Note_20140805——Memory Read/Write timing cycles

内存读写周期解析
本文主要探讨了内存读写周期中的关键参数,如访问时间、读恢复时间和写恢复时间。内存读周期开始于地址输入,期间地址必须保持稳定,数据输出在一定延迟后变为有效。读写周期时间由访问时间、读恢复时间和写恢复时间组成。写周期则涉及到地址设置时间、写脉冲宽度等,整个过程中数据输入需保持稳定。需要注意的是,这些时间是设备本身的最小要求,实际系统的访问和周期时间会因I/O控制逻辑、系统总线逻辑和内存接口逻辑的延迟而变得更长。

OK. As you have know, all the materials is just my own note. Hopefully, you could find something interesting to you.



好的模块划分可以使得设计优化更加容易,调试的时候也更加哟利于问题的定位。



Memory Read/Write timing cycles 

The most important timing parameter to be considered in choosing a memory device is the access time. The maximum time delay from an address input to a data output is longer than the delay between a chip enable and a data output, and consequently the former timing figure is normally considered to be the access time. The access time for commonly used  RAMs varies from 50 to 500 ns.

For a read operation, once the output data are valid, the address input cannot be changed immediately to start another read operation. This is because the device needs a certain amount of time, called read recovery time, to complete its internal operations before the next memory operation. The sum of the access time and read recovery time is the memory read cycle time. This is the time needed between the start of a read operation and the start of the next memory cycle. 

The memory write cycle time can be similarly defined and may be different from the read cycle time. The Figure below illustrates the timing of a memory read cycle. The address is applied at point A, which is the beginning of the read cycle, and must be held stable during the entire cycle. In order to reduce the access time, the chip enable input should be applied before point B. The data output becomes valid after point C and remains valid as long as the address and chip enable inputs hold. 

The R/W control input is not shown in the timing diagram for the read cycle, but should remain high throughout the entire cycle.




A typical write cycle is shown in Figure above. In addition to the address and chip enable inputs, an active low write pulse on the R/W line and the data to be stored must be applied during the write cvcle. The timing of data input is less restrictive and can be satisfied simply by holding the data input stable during the entire cycle. However, the application of the write pulse has two critical timing parameters: the address setup time and the write pulse width. The address setup time is the time required for the address to stabilize and is the time that must elapse before the write pulse can be applied. 

In the Figure above, the address setup time is the time interval between points A and B. The write pulse width defines the amount of time that the write input must remain active low. The write cycle time is the time interval between points A and D and is the sum of address setup time, write pulse width, and write recovery time. 

It is important to note that the access time and cycle time discussed in this section are the minimum timing requirements for the memory devices themselves. The access time and cycle time for the memory system as a whole are considerably longer because of the delays resulting from the I/O control logic, system bus logic, and memory interface logic.


/** ****************************************************************************** * @file stm32f1xx_ll_fsmc.h * @author MCD Application Team * @version V1.1.1 * @date 12-May-2017 * @brief Header file of FSMC HAL module. ****************************************************************************** * @attention * * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. Neither the name of STMicroelectronics nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************** */ /* Define to prevent recursive inclusion -------------------------------------*/ #ifndef __STM32F1xx_LL_FSMC_H #define __STM32F1xx_LL_FSMC_H #ifdef __cplusplus extern "C" { #endif /* Includes ------------------------------------------------------------------*/ #include "stm32f1xx_hal_def.h" /** @addtogroup STM32F1xx_HAL_Driver * @{ */ #if defined(FSMC_BANK1) /** @addtogroup FSMC_LL * @{ */ /* Exported typedef ----------------------------------------------------------*/ /** @defgroup FSMC_NORSRAM_Exported_typedef FSMC Low Layer Exported Types * @{ */ /** * @brief FSMC NORSRAM Configuration Structure definition */ typedef struct { uint32_t NSBank; /*!< Specifies the NORSRAM memory device that will be used. This parameter can be a value of @ref FSMC_NORSRAM_Bank */ uint32_t DataAddressMux; /*!< Specifies whether the address and data values are multiplexed on the data bus or not. This parameter can be a value of @ref FSMC_Data_Address_Bus_Multiplexing */ uint32_t MemoryType; /*!< Specifies the type of external memory attached to the corresponding memory device. This parameter can be a value of @ref FSMC_Memory_Type */ uint32_t MemoryDataWidth; /*!< Specifies the external memory device width. This parameter can be a value of @ref FSMC_NORSRAM_Data_Width */ uint32_t BurstAccessMode; /*!< Enables or disables the burst access mode for Flash memory, valid only with synchronous burst Flash memories. This parameter can be a value of @ref FSMC_Burst_Access_Mode */ uint32_t WaitSignalPolarity; /*!< Specifies the wait signal polarity, valid only when accessing the Flash memory in burst mode. This parameter can be a value of @ref FSMC_Wait_Signal_Polarity */ uint32_t WrapMode; /*!< Enables or disables the Wrapped burst access mode for Flash memory, valid only when accessing Flash memories in burst mode. This parameter can be a value of @ref FSMC_Wrap_Mode */ uint32_t WaitSignalActive; /*!< Specifies if the wait signal is asserted by the memory one clock cycle before the wait state or during the wait state, valid only when accessing memories in burst mode. This parameter can be a value of @ref FSMC_Wait_Timing */ uint32_t WriteOperation; /*!< Enables or disables the write operation in the selected device by the FSMC. This parameter can be a value of @ref FSMC_Write_Operation */ uint32_t WaitSignal; /*!< Enables or disables the wait state insertion via wait signal, valid for Flash memory access in burst mode. This parameter can be a value of @ref FSMC_Wait_Signal */ uint32_t ExtendedMode; /*!< Enables or disables the extended mode. This parameter can be a value of @ref FSMC_Extended_Mode */ uint32_t AsynchronousWait; /*!< Enables or disables wait signal during asynchronous transfers, valid only with asynchronous Flash memories. This parameter can be a value of @ref FSMC_AsynchronousWait */ uint32_t WriteBurst; /*!< Enables or disables the write burst operation. This parameter can be a value of @ref FSMC_Write_Burst */ }FSMC_NORSRAM_InitTypeDef; /** * @brief FSMC NORSRAM Timing parameters structure definition */ typedef struct { uint32_t AddressSetupTime; /*!< Defines the number of HCLK cycles to configure the duration of the address setup time. This parameter can be a value between Min_Data = 0 and Max_Data = 15. @note This parameter is not used with synchronous NOR Flash memories. */ uint32_t AddressHoldTime; /*!< Defines the number of HCLK cycles to configure the duration of the address hold time. This parameter can be a value between Min_Data = 1 and Max_Data = 15. @note This parameter is not used with synchronous NOR Flash memories. */ uint32_t DataSetupTime; /*!< Defines the number of HCLK cycles to configure the duration of the data setup time. This parameter can be a value between Min_Data = 1 and Max_Data = 255. @note This parameter is used for SRAMs, ROMs and asynchronous multiplexed NOR Flash memories. */ uint32_t BusTurnAroundDuration; /*!< Defines the number of HCLK cycles to configure the duration of the bus turnaround. This parameter can be a value between Min_Data = 0 and Max_Data = 15. @note This parameter is only used for multiplexed NOR Flash memories. */ uint32_t CLKDivision; /*!< Defines the period of CLK clock output signal, expressed in number of HCLK cycles. This parameter can be a value between Min_Data = 2 and Max_Data = 16. @note This parameter is not used for asynchronous NOR Flash, SRAM or ROM accesses. */ uint32_t DataLatency; /*!< Defines the number of memory clock cycles to issue to the memory before getting the first data. The parameter value depends on the memory type as shown below: - It must be set to 0 in case of a CRAM - It is don't care in asynchronous NOR, SRAM or ROM accesses - It may assume a value between Min_Data = 2 and Max_Data = 17 in NOR Flash memories with synchronous burst mode enable */ uint32_t AccessMode; /*!< Specifies the asynchronous access mode. This parameter can be a value of @ref FSMC_Access_Mode */ }FSMC_NORSRAM_TimingTypeDef; #if (defined(STM32F101xE) || defined(STM32F103xE) || defined(STM32F101xG) || defined(STM32F103xG)) /** * @brief FSMC NAND Configuration Structure definition */ typedef struct { uint32_t NandBank; /*!< Specifies the NAND memory device that will be used. This parameter can be a value of @ref FSMC_NAND_Bank */ uint32_t Waitfeature; /*!< Enables or disables the Wait feature for the NAND Memory device. This parameter can be any value of @ref FSMC_Wait_feature */ uint32_t MemoryDataWidth; /*!< Specifies the external memory device width. This parameter can be any value of @ref FSMC_NAND_Data_Width */ uint32_t EccComputation; /*!< Enables or disables the ECC computation. This parameter can be any value of @ref FSMC_ECC */ uint32_t ECCPageSize; /*!< Defines the page size for the extended ECC. This parameter can be any value of @ref FSMC_ECC_Page_Size */ uint32_t TCLRSetupTime; /*!< Defines the number of HCLK cycles to configure the delay between CLE low and RE low. This parameter can be a value between Min_Data = 0 and Max_Data = 255 */ uint32_t TARSetupTime; /*!< Defines the number of HCLK cycles to configure the delay between ALE low and RE low. This parameter can be a number between Min_Data = 0 and Max_Data = 255 */ }FSMC_NAND_InitTypeDef; /** * @brief FSMC NAND/PCCARD Timing parameters structure definition */ typedef struct { uint32_t SetupTime; /*!< Defines the number of HCLK cycles to setup address before the command assertion for NAND-Flash read or write access to common/Attribute or I/O memory space (depending on the memory space timing to be configured). This parameter can be a value between Min_Data = 0 and Max_Data = 255 */ uint32_t WaitSetupTime; /*!< Defines the minimum number of HCLK cycles to assert the command for NAND-Flash read or write access to common/Attribute or I/O memory space (depending on the memory space timing to be configured). This parameter can be a number between Min_Data = 0 and Max_Data = 255 */ uint32_t HoldSetupTime; /*!< Defines the number of HCLK clock cycles to hold address (and data for write access) after the command de-assertion for NAND-Flash read or write access to common/Attribute or I/O memory space (depending on the memory space timing to be configured). This parameter can be a number between Min_Data = 0 and Max_Data = 255 */ uint32_t HiZSetupTime; /*!< Defines the number of HCLK clock cycles during which the data bus is kept in HiZ after the start of a NAND-Flash write access to common/Attribute or I/O memory space (depending on the memory space timing to be configured). This parameter can be a number between Min_Data = 0 and Max_Data = 255 */ }FSMC_NAND_PCC_TimingTypeDef; /** * @brief FSMC NAND Configuration Structure definition */ typedef struct { uint32_t Waitfeature; /*!< Enables or disables the Wait feature for the PCCARD Memory device. This parameter can be any value of @ref FSMC_Wait_feature */ uint32_t TCLRSetupTime; /*!< Defines the number of HCLK cycles to configure the delay between CLE low and RE low. This parameter can be a value between Min_Data = 0 and Max_Data = 255 */ uint32_t TARSetupTime; /*!< Defines the number of HCLK cycles to configure the delay between ALE low and RE low. This parameter can be a number between Min_Data = 0 and Max_Data = 255 */ }FSMC_PCCARD_InitTypeDef; #endif /* STM32F101xE || STM32F103xE || STM32F101xG || STM32F103xG */ /** * @} */ /* Exported constants --------------------------------------------------------*/ /** @defgroup FSMC_Exported_Constants FSMC Low Layer Exported Constants * @{ */ /** @defgroup FSMC_NORSRAM_Exported_constants FSMC NOR/SRAM Exported constants * @{ */ /** @defgroup FSMC_NORSRAM_Bank FSMC NOR/SRAM Bank * @{ */ #define FSMC_NORSRAM_BANK1 0x00000000U #define FSMC_NORSRAM_BANK2 0x00000002U #define FSMC_NORSRAM_BANK3 0x00000004U #define FSMC_NORSRAM_BANK4 0x00000006U /** * @} */ /** @defgroup FSMC_Data_Address_Bus_Multiplexing FSMC Data Address Bus Multiplexing * @{ */ #define FSMC_DATA_ADDRESS_MUX_DISABLE 0x00000000U #define FSMC_DATA_ADDRESS_MUX_ENABLE ((uint32_t)FSMC_BCRx_MUXEN) /** * @} */ /** @defgroup FSMC_Memory_Type FSMC Memory Type * @{ */ #define FSMC_MEMORY_TYPE_SRAM 0x00000000U #define FSMC_MEMORY_TYPE_PSRAM ((uint32_t)FSMC_BCRx_MTYP_0) #define FSMC_MEMORY_TYPE_NOR ((uint32_t)FSMC_BCRx_MTYP_1) /** * @} */ /** @defgroup FSMC_NORSRAM_Data_Width FSMC NOR/SRAM Data Width * @{ */ #define FSMC_NORSRAM_MEM_BUS_WIDTH_8 0x00000000U #define FSMC_NORSRAM_MEM_BUS_WIDTH_16 ((uint32_t)FSMC_BCRx_MWID_0) #define FSMC_NORSRAM_MEM_BUS_WIDTH_32 ((uint32_t)FSMC_BCRx_MWID_1) /** * @} */ /** @defgroup FSMC_NORSRAM_Flash_Access FSMC NOR/SRAM Flash Access * @{ */ #define FSMC_NORSRAM_FLASH_ACCESS_ENABLE ((uint32_t)FSMC_BCRx_FACCEN) #define FSMC_NORSRAM_FLASH_ACCESS_DISABLE 0x00000000U /** * @} */ /** @defgroup FSMC_Burst_Access_Mode FSMC Burst Access Mode * @{ */ #define FSMC_BURST_ACCESS_MODE_DISABLE 0x00000000U #define FSMC_BURST_ACCESS_MODE_ENABLE ((uint32_t)FSMC_BCRx_BURSTEN) /** * @} */ /** @defgroup FSMC_Wait_Signal_Polarity FSMC Wait Signal Polarity * @{ */ #define FSMC_WAIT_SIGNAL_POLARITY_LOW 0x00000000U #define FSMC_WAIT_SIGNAL_POLARITY_HIGH ((uint32_t)FSMC_BCRx_WAITPOL) /** * @} */ /** @defgroup FSMC_Wrap_Mode FSMC Wrap Mode * @{ */ #define FSMC_WRAP_MODE_DISABLE 0x00000000U #define FSMC_WRAP_MODE_ENABLE ((uint32_t)FSMC_BCRx_WRAPMOD) /** * @} */ /** @defgroup FSMC_Wait_Timing FSMC Wait Timing * @{ */ #define FSMC_WAIT_TIMING_BEFORE_WS 0x00000000U #define FSMC_WAIT_TIMING_DURING_WS ((uint32_t)FSMC_BCRx_WAITCFG) /** * @} */ /** @defgroup FSMC_Write_Operation FSMC Write Operation * @{ */ #define FSMC_WRITE_OPERATION_DISABLE 0x00000000U #define FSMC_WRITE_OPERATION_ENABLE ((uint32_t)FSMC_BCRx_WREN) /** * @} */ /** @defgroup FSMC_Wait_Signal FSMC Wait Signal * @{ */ #define FSMC_WAIT_SIGNAL_DISABLE 0x00000000U #define FSMC_WAIT_SIGNAL_ENABLE ((uint32_t)FSMC_BCRx_WAITEN) /** * @} */ /** @defgroup FSMC_Extended_Mode FSMC Extended Mode * @{ */ #define FSMC_EXTENDED_MODE_DISABLE 0x00000000U #define FSMC_EXTENDED_MODE_ENABLE ((uint32_t)FSMC_BCRx_EXTMOD) /** * @} */ /** @defgroup FSMC_AsynchronousWait FSMC Asynchronous Wait * @{ */ #define FSMC_ASYNCHRONOUS_WAIT_DISABLE 0x00000000U #define FSMC_ASYNCHRONOUS_WAIT_ENABLE ((uint32_t)FSMC_BCRx_ASYNCWAIT) /** * @} */ /** @defgroup FSMC_Write_Burst FSMC Write Burst * @{ */ #define FSMC_WRITE_BURST_DISABLE 0x00000000U #define FSMC_WRITE_BURST_ENABLE ((uint32_t)FSMC_BCRx_CBURSTRW) /** * @} */ /** @defgroup FSMC_Access_Mode FSMC Access Mode * @{ */ #define FSMC_ACCESS_MODE_A 0x00000000U #define FSMC_ACCESS_MODE_B ((uint32_t)FSMC_BTRx_ACCMOD_0) #define FSMC_ACCESS_MODE_C ((uint32_t)FSMC_BTRx_ACCMOD_1) #define FSMC_ACCESS_MODE_D ((uint32_t)(FSMC_BTRx_ACCMOD_0 | FSMC_BTRx_ACCMOD_1)) /** * @} */ /** * @} */ #if (defined(STM32F101xE) || defined(STM32F103xE) || defined(STM32F101xG) || defined(STM32F103xG)) /** @defgroup FSMC_NAND_Controller FSMC NAND and PCCARD Controller * @{ */ /** @defgroup FSMC_NAND_Bank FSMC NAND Bank * @{ */ #define FSMC_NAND_BANK2 0x00000010U #define FSMC_NAND_BANK3 0x00000100U /** * @} */ /** @defgroup FSMC_Wait_feature FSMC Wait feature * @{ */ #define FSMC_NAND_PCC_WAIT_FEATURE_DISABLE 0x00000000U #define FSMC_NAND_PCC_WAIT_FEATURE_ENABLE ((uint32_t)FSMC_PCRx_PWAITEN) /** * @} */ /** @defgroup FSMC_PCR_Memory_Type FSMC PCR Memory Type * @{ */ #define FSMC_PCR_MEMORY_TYPE_PCCARD 0x00000000U #define FSMC_PCR_MEMORY_TYPE_NAND ((uint32_t)FSMC_PCRx_PTYP) /** * @} */ /** @defgroup FSMC_NAND_Data_Width FSMC NAND Data Width * @{ */ #define FSMC_NAND_PCC_MEM_BUS_WIDTH_8 0x00000000U #define FSMC_NAND_PCC_MEM_BUS_WIDTH_16 ((uint32_t)FSMC_PCRx_PWID_0) /** * @} */ /** @defgroup FSMC_ECC FSMC NAND ECC * @{ */ #define FSMC_NAND_ECC_DISABLE 0x00000000U #define FSMC_NAND_ECC_ENABLE ((uint32_t)FSMC_PCRx_ECCEN) /** * @} */ /** @defgroup FSMC_ECC_Page_Size FSMC ECC Page Size * @{ */ #define FSMC_NAND_ECC_PAGE_SIZE_256BYTE 0x00000000U #define FSMC_NAND_ECC_PAGE_SIZE_512BYTE ((uint32_t)FSMC_PCRx_ECCPS_0) #define FSMC_NAND_ECC_PAGE_SIZE_1024BYTE ((uint32_t)FSMC_PCRx_ECCPS_1) #define FSMC_NAND_ECC_PAGE_SIZE_2048BYTE ((uint32_t)FSMC_PCRx_ECCPS_0|FSMC_PCRx_ECCPS_1) #define FSMC_NAND_ECC_PAGE_SIZE_4096BYTE ((uint32_t)FSMC_PCRx_ECCPS_2) #define FSMC_NAND_ECC_PAGE_SIZE_8192BYTE ((uint32_t)FSMC_PCRx_ECCPS_0|FSMC_PCRx_ECCPS_2) /** * @} */ /** * @} */ #endif /* STM32F101xE || STM32F103xE || STM32F101xG || STM32F103xG */ /** @defgroup FSMC_LL_Interrupt_definition FSMC Interrupt definition * @brief FSMC Interrupt definition * @{ */ #define FSMC_IT_RISING_EDGE ((uint32_t)FSMC_SRx_IREN) #define FSMC_IT_LEVEL ((uint32_t)FSMC_SRx_ILEN) #define FSMC_IT_FALLING_EDGE ((uint32_t)FSMC_SRx_IFEN) /** * @} */ /** @defgroup FSMC_LL_Flag_definition FSMC Flag definition * @brief FSMC Flag definition * @{ */ #define FSMC_FLAG_RISING_EDGE ((uint32_t)FSMC_SRx_IRS) #define FSMC_FLAG_LEVEL ((uint32_t)FSMC_SRx_ILS) #define FSMC_FLAG_FALLING_EDGE ((uint32_t)FSMC_SRx_IFS) #define FSMC_FLAG_FEMPT ((uint32_t)FSMC_SRx_FEMPT) /** * @} */ /** @defgroup FSMC_LL_Alias_definition FSMC Alias definition * @{ */ #define FSMC_NORSRAM_TypeDef FSMC_Bank1_TypeDef #define FSMC_NORSRAM_EXTENDED_TypeDef FSMC_Bank1E_TypeDef #define FSMC_NAND_TypeDef FSMC_Bank2_3_TypeDef #define FSMC_PCCARD_TypeDef FSMC_Bank4_TypeDef #define FSMC_NORSRAM_DEVICE FSMC_Bank1 #define FSMC_NORSRAM_EXTENDED_DEVICE FSMC_Bank1E #define FSMC_NAND_DEVICE FSMC_Bank2_3 #define FSMC_PCCARD_DEVICE FSMC_Bank4 /** * @} */ /** * @} */ /* Exported macro ------------------------------------------------------------*/ /** @defgroup FSMC_Exported_Macros FSMC Low Layer Exported Macros * @{ */ /** @defgroup FSMC_LL_NOR_Macros FSMC NOR/SRAM Exported Macros * @brief macros to handle NOR device enable/disable and read/write operations * @{ */ /** * @brief Enable the NORSRAM device access. * @param __INSTANCE__: FSMC_NORSRAM Instance * @param __BANK__: FSMC_NORSRAM Bank * @retval none */ #define __FSMC_NORSRAM_ENABLE(__INSTANCE__, __BANK__) SET_BIT((__INSTANCE__)->BTCR[(__BANK__)], FSMC_BCRx_MBKEN) /** * @brief Disable the NORSRAM device access. * @param __INSTANCE__: FSMC_NORSRAM Instance * @param __BANK__: FSMC_NORSRAM Bank * @retval none */ #define __FSMC_NORSRAM_DISABLE(__INSTANCE__, __BANK__) CLEAR_BIT((__INSTANCE__)->BTCR[(__BANK__)], FSMC_BCRx_MBKEN) /** * @} */ #if (defined(STM32F101xE) || defined(STM32F103xE) || defined(STM32F101xG) || defined(STM32F103xG)) /** @defgroup FSMC_LL_NAND_Macros FSMC NAND Macros * @brief macros to handle NAND device enable/disable * @{ */ /** * @brief Enable the NAND device access. * @param __INSTANCE__: FSMC_NAND Instance * @param __BANK__: FSMC_NAND Bank * @retval None */ #define __FSMC_NAND_ENABLE(__INSTANCE__, __BANK__) (((__BANK__) == FSMC_NAND_BANK2)? SET_BIT((__INSTANCE__)->PCR2, FSMC_PCRx_PBKEN): \ SET_BIT((__INSTANCE__)->PCR3, FSMC_PCRx_PBKEN)) /** * @brief Disable the NAND device access. * @param __INSTANCE__: FSMC_NAND Instance * @param __BANK__: FSMC_NAND Bank * @retval None */ #define __FSMC_NAND_DISABLE(__INSTANCE__, __BANK__) (((__BANK__) == FSMC_NAND_BANK2)? CLEAR_BIT((__INSTANCE__)->PCR2, FSMC_PCRx_PBKEN): \ CLEAR_BIT((__INSTANCE__)->PCR3, FSMC_PCRx_PBKEN)) /** * @} */ /** @defgroup FSMC_LL_PCCARD_Macros FSMC PCCARD Macros * @brief macros to handle PCCARD read/write operations * @{ */ /** * @brief Enable the PCCARD device access. * @param __INSTANCE__: FSMC_PCCARD Instance * @retval None */ #define __FSMC_PCCARD_ENABLE(__INSTANCE__) SET_BIT((__INSTANCE__)->PCR4, FSMC_PCRx_PBKEN) /** * @brief Disable the PCCARD device access. * @param __INSTANCE__: FSMC_PCCARD Instance * @retval None */ #define __FSMC_PCCARD_DISABLE(__INSTANCE__) CLEAR_BIT((__INSTANCE__)->PCR4, FSMC_PCRx_PBKEN) /** * @} */ /** @defgroup FSMC_LL_Flag_Interrupt_Macros FSMC Flag&Interrupt Macros * @brief macros to handle FSMC flags and interrupts * @{ */ /** * @brief Enable the NAND device interrupt. * @param __INSTANCE__: FSMC_NAND Instance * @param __BANK__: FSMC_NAND Bank * @param __INTERRUPT__: FSMC_NAND interrupt * This parameter can be any combination of the following values: * @arg FSMC_IT_RISING_EDGE: Interrupt rising edge. * @arg FSMC_IT_LEVEL: Interrupt level. * @arg FSMC_IT_FALLING_EDGE: Interrupt falling edge. * @retval None */ #define __FSMC_NAND_ENABLE_IT(__INSTANCE__, __BANK__, __INTERRUPT__) (((__BANK__) == FSMC_NAND_BANK2)? SET_BIT((__INSTANCE__)->SR2, (__INTERRUPT__)): \ SET_BIT((__INSTANCE__)->SR3, (__INTERRUPT__))) /** * @brief Disable the NAND device interrupt. * @param __INSTANCE__: FSMC_NAND Instance * @param __BANK__: FSMC_NAND Bank * @param __INTERRUPT__: FSMC_NAND interrupt * This parameter can be any combination of the following values: * @arg FSMC_IT_RISING_EDGE: Interrupt rising edge. * @arg FSMC_IT_LEVEL: Interrupt level. * @arg FSMC_IT_FALLING_EDGE: Interrupt falling edge. * @retval None */ #define __FSMC_NAND_DISABLE_IT(__INSTANCE__, __BANK__, __INTERRUPT__) (((__BANK__) == FSMC_NAND_BANK2)? CLEAR_BIT((__INSTANCE__)->SR2, (__INTERRUPT__)): \ CLEAR_BIT((__INSTANCE__)->SR3, (__INTERRUPT__))) /** * @brief Get flag status of the NAND device. * @param __INSTANCE__: FSMC_NAND Instance * @param __BANK__ : FSMC_NAND Bank * @param __FLAG__ : FSMC_NAND flag * This parameter can be any combination of the following values: * @arg FSMC_FLAG_RISING_EDGE: Interrupt rising edge flag. * @arg FSMC_FLAG_LEVEL: Interrupt level edge flag. * @arg FSMC_FLAG_FALLING_EDGE: Interrupt falling edge flag. * @arg FSMC_FLAG_FEMPT: FIFO empty flag. * @retval The state of FLAG (SET or RESET). */ #define __FSMC_NAND_GET_FLAG(__INSTANCE__, __BANK__, __FLAG__) (((__BANK__) == FSMC_NAND_BANK2)? (((__INSTANCE__)->SR2 &(__FLAG__)) == (__FLAG__)): \ (((__INSTANCE__)->SR3 &(__FLAG__)) == (__FLAG__))) /** * @brief Clear flag status of the NAND device. * @param __INSTANCE__: FSMC_NAND Instance * @param __BANK__: FSMC_NAND Bank * @param __FLAG__: FSMC_NAND flag * This parameter can be any combination of the following values: * @arg FSMC_FLAG_RISING_EDGE: Interrupt rising edge flag. * @arg FSMC_FLAG_LEVEL: Interrupt level edge flag. * @arg FSMC_FLAG_FALLING_EDGE: Interrupt falling edge flag. * @arg FSMC_FLAG_FEMPT: FIFO empty flag. * @retval None */ #define __FSMC_NAND_CLEAR_FLAG(__INSTANCE__, __BANK__, __FLAG__) (((__BANK__) == FSMC_NAND_BANK2)? CLEAR_BIT((__INSTANCE__)->SR2, (__FLAG__)): \ CLEAR_BIT((__INSTANCE__)->SR3, (__FLAG__))) /** * @brief Enable the PCCARD device interrupt. * @param __INSTANCE__: FSMC_PCCARD Instance * @param __INTERRUPT__: FSMC_PCCARD interrupt * This parameter can be any combination of the following values: * @arg FSMC_IT_RISING_EDGE: Interrupt rising edge. * @arg FSMC_IT_LEVEL: Interrupt level. * @arg FSMC_IT_FALLING_EDGE: Interrupt falling edge. * @retval None */ #define __FSMC_PCCARD_ENABLE_IT(__INSTANCE__, __INTERRUPT__) SET_BIT((__INSTANCE__)->SR4, (__INTERRUPT__)) /** * @brief Disable the PCCARD device interrupt. * @param __INSTANCE__: FSMC_PCCARD Instance * @param __INTERRUPT__: FSMC_PCCARD interrupt * This parameter can be any combination of the following values: * @arg FSMC_IT_RISING_EDGE: Interrupt rising edge. * @arg FSMC_IT_LEVEL: Interrupt level. * @arg FSMC_IT_FALLING_EDGE: Interrupt falling edge. * @retval None */ #define __FSMC_PCCARD_DISABLE_IT(__INSTANCE__, __INTERRUPT__) CLEAR_BIT((__INSTANCE__)->SR4, (__INTERRUPT__)) /** * @brief Get flag status of the PCCARD device. * @param __INSTANCE__: FSMC_PCCARD Instance * @param __FLAG__: FSMC_PCCARD flag * This parameter can be any combination of the following values: * @arg FSMC_FLAG_RISING_EDGE: Interrupt rising edge flag. * @arg FSMC_FLAG_LEVEL: Interrupt level edge flag. * @arg FSMC_FLAG_FALLING_EDGE: Interrupt falling edge flag. * @arg FSMC_FLAG_FEMPT: FIFO empty flag. * @retval The state of FLAG (SET or RESET). */ #define __FSMC_PCCARD_GET_FLAG(__INSTANCE__, __FLAG__) (((__INSTANCE__)->SR4 &(__FLAG__)) == (__FLAG__)) /** * @brief Clear flag status of the PCCARD device. * @param __INSTANCE__: FSMC_PCCARD Instance * @param __FLAG__: FSMC_PCCARD flag * This parameter can be any combination of the following values: * @arg FSMC_FLAG_RISING_EDGE: Interrupt rising edge flag. * @arg FSMC_FLAG_LEVEL: Interrupt level edge flag. * @arg FSMC_FLAG_FALLING_EDGE: Interrupt falling edge flag. * @arg FSMC_FLAG_FEMPT: FIFO empty flag. * @retval None */ #define __FSMC_PCCARD_CLEAR_FLAG(__INSTANCE__, __FLAG__) CLEAR_BIT((__INSTANCE__)->SR4, (__FLAG__)) /** * @} */ #endif /* STM32F101xE || STM32F103xE || STM32F101xG || STM32F103xG */ /** * @} */ /** @defgroup FSMC_LL_Private_Macros FSMC Low Layer Private Macros * @{ */ #define IS_FSMC_NORSRAM_BANK(__BANK__) (((__BANK__) == FSMC_NORSRAM_BANK1) || \ ((__BANK__) == FSMC_NORSRAM_BANK2) || \ ((__BANK__) == FSMC_NORSRAM_BANK3) || \ ((__BANK__) == FSMC_NORSRAM_BANK4)) #define IS_FSMC_MUX(__MUX__) (((__MUX__) == FSMC_DATA_ADDRESS_MUX_DISABLE) || \ ((__MUX__) == FSMC_DATA_ADDRESS_MUX_ENABLE)) #define IS_FSMC_MEMORY(__MEMORY__) (((__MEMORY__) == FSMC_MEMORY_TYPE_SRAM) || \ ((__MEMORY__) == FSMC_MEMORY_TYPE_PSRAM)|| \ ((__MEMORY__) == FSMC_MEMORY_TYPE_NOR)) #define IS_FSMC_NORSRAM_MEMORY_WIDTH(__WIDTH__) (((__WIDTH__) == FSMC_NORSRAM_MEM_BUS_WIDTH_8) || \ ((__WIDTH__) == FSMC_NORSRAM_MEM_BUS_WIDTH_16) || \ ((__WIDTH__) == FSMC_NORSRAM_MEM_BUS_WIDTH_32)) #define IS_FSMC_WRITE_BURST(__BURST__) (((__BURST__) == FSMC_WRITE_BURST_DISABLE) || \ ((__BURST__) == FSMC_WRITE_BURST_ENABLE)) #define IS_FSMC_ACCESS_MODE(__MODE__) (((__MODE__) == FSMC_ACCESS_MODE_A) || \ ((__MODE__) == FSMC_ACCESS_MODE_B) || \ ((__MODE__) == FSMC_ACCESS_MODE_C) || \ ((__MODE__) == FSMC_ACCESS_MODE_D)) #define IS_FSMC_NAND_BANK(__BANK__) (((__BANK__) == FSMC_NAND_BANK2) || \ ((__BANK__) == FSMC_NAND_BANK3)) #define IS_FSMC_WAIT_FEATURE(__FEATURE__) (((__FEATURE__) == FSMC_NAND_PCC_WAIT_FEATURE_DISABLE) || \ ((__FEATURE__) == FSMC_NAND_PCC_WAIT_FEATURE_ENABLE)) #define IS_FSMC_NAND_MEMORY_WIDTH(__WIDTH__) (((__WIDTH__) == FSMC_NAND_PCC_MEM_BUS_WIDTH_8) || \ ((__WIDTH__) == FSMC_NAND_PCC_MEM_BUS_WIDTH_16)) #define IS_FSMC_ECC_STATE(__STATE__) (((__STATE__) == FSMC_NAND_ECC_DISABLE) || \ ((__STATE__) == FSMC_NAND_ECC_ENABLE)) #define IS_FSMC_ECCPAGE_SIZE(__SIZE__) (((__SIZE__) == FSMC_NAND_ECC_PAGE_SIZE_256BYTE) || \ ((__SIZE__) == FSMC_NAND_ECC_PAGE_SIZE_512BYTE) || \ ((__SIZE__) == FSMC_NAND_ECC_PAGE_SIZE_1024BYTE) || \ ((__SIZE__) == FSMC_NAND_ECC_PAGE_SIZE_2048BYTE) || \ ((__SIZE__) == FSMC_NAND_ECC_PAGE_SIZE_4096BYTE) || \ ((__SIZE__) == FSMC_NAND_ECC_PAGE_SIZE_8192BYTE)) /** @defgroup FSMC_TCLR_Setup_Time FSMC_TCLR_Setup_Time * @{ */ #define IS_FSMC_TCLR_TIME(__TIME__) ((__TIME__) <= 255U) /** * @} */ /** @defgroup FSMC_TAR_Setup_Time FSMC_TAR_Setup_Time * @{ */ #define IS_FSMC_TAR_TIME(__TIME__) ((__TIME__) <= 255U) /** * @} */ /** @defgroup FSMC_Setup_Time FSMC_Setup_Time * @{ */ #define IS_FSMC_SETUP_TIME(__TIME__) ((__TIME__) <= 255U) /** * @} */ /** @defgroup FSMC_Wait_Setup_Time FSMC_Wait_Setup_Time * @{ */ #define IS_FSMC_WAIT_TIME(__TIME__) ((__TIME__) <= 255U) /** * @} */ /** @defgroup FSMC_Hold_Setup_Time FSMC_Hold_Setup_Time * @{ */ #define IS_FSMC_HOLD_TIME(__TIME__) ((__TIME__) <= 255U) /** * @} */ /** @defgroup FSMC_HiZ_Setup_Time FSMC_HiZ_Setup_Time * @{ */ #define IS_FSMC_HIZ_TIME(__TIME__) ((__TIME__) <= 255U) /** * @} */ /** @defgroup FSMC_NORSRAM_Device_Instance FSMC NOR/SRAM Device Instance * @{ */ #define IS_FSMC_NORSRAM_DEVICE(__INSTANCE__) ((__INSTANCE__) == FSMC_NORSRAM_DEVICE) /** * @} */ /** @defgroup FSMC_NORSRAM_EXTENDED_Device_Instance FSMC NOR/SRAM EXTENDED Device Instance * @{ */ #define IS_FSMC_NORSRAM_EXTENDED_DEVICE(__INSTANCE__) ((__INSTANCE__) == FSMC_NORSRAM_EXTENDED_DEVICE) /** * @} */ /** @defgroup FSMC_NAND_Device_Instance FSMC NAND Device Instance * @{ */ #define IS_FSMC_NAND_DEVICE(__INSTANCE__) ((__INSTANCE__) == FSMC_NAND_DEVICE) /** * @} */ /** @defgroup FSMC_PCCARD_Device_Instance FSMC PCCARD Device Instance * @{ */ #define IS_FSMC_PCCARD_DEVICE(__INSTANCE__) ((__INSTANCE__) == FSMC_PCCARD_DEVICE) /** * @} */ #define IS_FSMC_BURSTMODE(__STATE__) (((__STATE__) == FSMC_BURST_ACCESS_MODE_DISABLE) || \ ((__STATE__) == FSMC_BURST_ACCESS_MODE_ENABLE)) #define IS_FSMC_WAIT_POLARITY(__POLARITY__) (((__POLARITY__) == FSMC_WAIT_SIGNAL_POLARITY_LOW) || \ ((__POLARITY__) == FSMC_WAIT_SIGNAL_POLARITY_HIGH)) #define IS_FSMC_WRAP_MODE(__MODE__) (((__MODE__) == FSMC_WRAP_MODE_DISABLE) || \ ((__MODE__) == FSMC_WRAP_MODE_ENABLE)) #define IS_FSMC_WAIT_SIGNAL_ACTIVE(__ACTIVE__) (((__ACTIVE__) == FSMC_WAIT_TIMING_BEFORE_WS) || \ ((__ACTIVE__) == FSMC_WAIT_TIMING_DURING_WS)) #define IS_FSMC_WRITE_OPERATION(__OPERATION__) (((__OPERATION__) == FSMC_WRITE_OPERATION_DISABLE) || \ ((__OPERATION__) == FSMC_WRITE_OPERATION_ENABLE)) #define IS_FSMC_WAITE_SIGNAL(__SIGNAL__) (((__SIGNAL__) == FSMC_WAIT_SIGNAL_DISABLE) || \ ((__SIGNAL__) == FSMC_WAIT_SIGNAL_ENABLE)) #define IS_FSMC_EXTENDED_MODE(__MODE__) (((__MODE__) == FSMC_EXTENDED_MODE_DISABLE) || \ ((__MODE__) == FSMC_EXTENDED_MODE_ENABLE)) #define IS_FSMC_ASYNWAIT(__STATE__) (((__STATE__) == FSMC_ASYNCHRONOUS_WAIT_DISABLE) || \ ((__STATE__) == FSMC_ASYNCHRONOUS_WAIT_ENABLE)) #define IS_FSMC_CLK_DIV(__DIV__) (((__DIV__) > 1U) && ((__DIV__) <= 16U)) /** @defgroup FSMC_Data_Latency FSMC Data Latency * @{ */ #define IS_FSMC_DATA_LATENCY(__LATENCY__) (((__LATENCY__) > 1U) && ((__LATENCY__) <= 17U)) /** * @} */ /** @defgroup FSMC_Address_Setup_Time FSMC Address Setup Time * @{ */ #define IS_FSMC_ADDRESS_SETUP_TIME(__TIME__) ((__TIME__) <= 15U) /** * @} */ /** @defgroup FSMC_Address_Hold_Time FSMC Address Hold Time * @{ */ #define IS_FSMC_ADDRESS_HOLD_TIME(__TIME__) (((__TIME__) > 0U) && ((__TIME__) <= 15U)) /** * @} */ /** @defgroup FSMC_Data_Setup_Time FSMC Data Setup Time * @{ */ #define IS_FSMC_DATASETUP_TIME(__TIME__) (((__TIME__) > 0U) && ((__TIME__) <= 255U)) /** * @} */ /** @defgroup FSMC_Bus_Turn_around_Duration FSMC Bus Turn around Duration * @{ */ #define IS_FSMC_TURNAROUND_TIME(__TIME__) ((__TIME__) <= 15U) /** * @} */ /** * @} */ /** @defgroup FSMC_LL_Private_Constants FSMC Low Layer Private Constants * @{ */ /* ----------------------- FSMC registers bit mask --------------------------- */ #if (defined (STM32F101xE) || defined(STM32F103xE) || defined(STM32F101xG) || defined(STM32F103xG)) /* --- PCR Register ---*/ /* PCR register clear mask */ #define PCR_CLEAR_MASK ((uint32_t)(FSMC_PCRx_PWAITEN | FSMC_PCRx_PBKEN | \ FSMC_PCRx_PTYP | FSMC_PCRx_PWID | \ FSMC_PCRx_ECCEN | FSMC_PCRx_TCLR | \ FSMC_PCRx_TAR | FSMC_PCRx_ECCPS)) /* --- PMEM Register ---*/ /* PMEM register clear mask */ #define PMEM_CLEAR_MASK ((uint32_t)(FSMC_PMEMx_MEMSETx | FSMC_PMEMx_MEMWAITx |\ FSMC_PMEMx_MEMHOLDx | FSMC_PMEMx_MEMHIZx)) /* --- PATT Register ---*/ /* PATT register clear mask */ #define PATT_CLEAR_MASK ((uint32_t)(FSMC_PATTx_ATTSETx | FSMC_PATTx_ATTWAITx |\ FSMC_PATTx_ATTHOLDx | FSMC_PATTx_ATTHIZx)) #endif /* STM32F101xE || STM32F103xE || STM32F101xG || STM32F103xG */ /* --- BCR Register ---*/ /* BCR register clear mask */ #define BCR_CLEAR_MASK ((uint32_t)(FSMC_BCRx_FACCEN | FSMC_BCRx_MUXEN | \ FSMC_BCRx_MTYP | FSMC_BCRx_MWID | \ FSMC_BCRx_BURSTEN | FSMC_BCRx_WAITPOL | \ FSMC_BCRx_WRAPMOD | FSMC_BCRx_WAITCFG | \ FSMC_BCRx_WREN | FSMC_BCRx_WAITEN | \ FSMC_BCRx_EXTMOD | FSMC_BCRx_ASYNCWAIT | \ FSMC_BCRx_CBURSTRW)) /* --- BTR Register ---*/ /* BTR register clear mask */ #define BTR_CLEAR_MASK ((uint32_t)(FSMC_BTRx_ADDSET | FSMC_BTRx_ADDHLD |\ FSMC_BTRx_DATAST | FSMC_BTRx_BUSTURN |\ FSMC_BTRx_CLKDIV | FSMC_BTRx_DATLAT |\ FSMC_BTRx_ACCMOD)) /* --- BWTR Register ---*/ /* BWTR register clear mask */ #if (defined(STM32F101xE) || defined(STM32F103xE) || defined(STM32F101xG) || defined(STM32F103xG)) #define BWTR_CLEAR_MASK ((uint32_t)(FSMC_BWTRx_ADDSET | FSMC_BWTRx_ADDHLD | \ FSMC_BWTRx_DATAST | FSMC_BWTRx_ACCMOD | \ FSMC_BWTRx_BUSTURN)) #else #define BWTR_CLEAR_MASK ((uint32_t)(FSMC_BWTRx_ADDSET | FSMC_BWTRx_ADDHLD | \ FSMC_BWTRx_DATAST | FSMC_BWTRx_ACCMOD | \ FSMC_BWTRx_CLKDIV | FSMC_BWTRx_DATLAT)) #endif /* STM32F101xE || STM32F103xE || STM32F101xG || STM32F103xG */ /* --- PIO4 Register ---*/ /* PIO4 register clear mask */ #define PIO4_CLEAR_MASK ((uint32_t)(FSMC_PIO4_IOSET4 | FSMC_PIO4_IOWAIT4 | \ FSMC_PIO4_IOHOLD4 | FSMC_PIO4_IOHIZ4)) /** * @} */ /* Exported functions --------------------------------------------------------*/ /** @addtogroup FSMC_LL_Exported_Functions * @{ */ /** @addtogroup FSMC_NORSRAM * @{ */ /** @addtogroup FSMC_NORSRAM_Group1 * @{ */ /* FSMC_NORSRAM Controller functions ******************************************/ /* Initialization/de-initialization functions */ HAL_StatusTypeDef FSMC_NORSRAM_Init(FSMC_NORSRAM_TypeDef *Device, FSMC_NORSRAM_InitTypeDef *Init); HAL_StatusTypeDef FSMC_NORSRAM_Timing_Init(FSMC_NORSRAM_TypeDef *Device, FSMC_NORSRAM_TimingTypeDef *Timing, uint32_t Bank); HAL_StatusTypeDef FSMC_NORSRAM_Extended_Timing_Init(FSMC_NORSRAM_EXTENDED_TypeDef *Device, FSMC_NORSRAM_TimingTypeDef *Timing, uint32_t Bank, uint32_t ExtendedMode); HAL_StatusTypeDef FSMC_NORSRAM_DeInit(FSMC_NORSRAM_TypeDef *Device, FSMC_NORSRAM_EXTENDED_TypeDef *ExDevice, uint32_t Bank); /** * @} */ /** @addtogroup FSMC_NORSRAM_Group2 * @{ */ /* FSMC_NORSRAM Control functions */ HAL_StatusTypeDef FSMC_NORSRAM_WriteOperation_Enable(FSMC_NORSRAM_TypeDef *Device, uint32_t Bank); HAL_StatusTypeDef FSMC_NORSRAM_WriteOperation_Disable(FSMC_NORSRAM_TypeDef *Device, uint32_t Bank); /** * @} */ /** * @} */ #if (defined(STM32F101xE) || defined(STM32F103xE) || defined(STM32F101xG) || defined(STM32F103xG)) /** @addtogroup FSMC_NAND * @{ */ /* FSMC_NAND Controller functions **********************************************/ /* Initialization/de-initialization functions */ /** @addtogroup FSMC_NAND_Exported_Functions_Group1 * @{ */ HAL_StatusTypeDef FSMC_NAND_Init(FSMC_NAND_TypeDef *Device, FSMC_NAND_InitTypeDef *Init); HAL_StatusTypeDef FSMC_NAND_CommonSpace_Timing_Init(FSMC_NAND_TypeDef *Device, FSMC_NAND_PCC_TimingTypeDef *Timing, uint32_t Bank); HAL_StatusTypeDef FSMC_NAND_AttributeSpace_Timing_Init(FSMC_NAND_TypeDef *Device, FSMC_NAND_PCC_TimingTypeDef *Timing, uint32_t Bank); HAL_StatusTypeDef FSMC_NAND_DeInit(FSMC_NAND_TypeDef *Device, uint32_t Bank); /** * @} */ /* FSMC_NAND Control functions */ /** @addtogroup FSMC_NAND_Exported_Functions_Group2 * @{ */ HAL_StatusTypeDef FSMC_NAND_ECC_Enable(FSMC_NAND_TypeDef *Device, uint32_t Bank); HAL_StatusTypeDef FSMC_NAND_ECC_Disable(FSMC_NAND_TypeDef *Device, uint32_t Bank); HAL_StatusTypeDef FSMC_NAND_GetECC(FSMC_NAND_TypeDef *Device, uint32_t *ECCval, uint32_t Bank, uint32_t Timeout); /** * @} */ /** * @} */ /** @addtogroup FSMC_PCCARD * @{ */ /* FSMC_PCCARD Controller functions ********************************************/ /* Initialization/de-initialization functions */ /** @addtogroup FSMC_PCCARD_Exported_Functions_Group1 * @{ */ HAL_StatusTypeDef FSMC_PCCARD_Init(FSMC_PCCARD_TypeDef *Device, FSMC_PCCARD_InitTypeDef *Init); HAL_StatusTypeDef FSMC_PCCARD_CommonSpace_Timing_Init(FSMC_PCCARD_TypeDef *Device, FSMC_NAND_PCC_TimingTypeDef *Timing); HAL_StatusTypeDef FSMC_PCCARD_AttributeSpace_Timing_Init(FSMC_PCCARD_TypeDef *Device, FSMC_NAND_PCC_TimingTypeDef *Timing); HAL_StatusTypeDef FSMC_PCCARD_IOSpace_Timing_Init(FSMC_PCCARD_TypeDef *Device, FSMC_NAND_PCC_TimingTypeDef *Timing); HAL_StatusTypeDef FSMC_PCCARD_DeInit(FSMC_PCCARD_TypeDef *Device); /** * @} */ /** * @} */ #endif /* STM32F101xE || STM32F103xE || STM32F101xG || STM32F103xG */ /** * @} */ /** * @} */ #endif /* FSMC_BANK1 */ /** * @} */ #ifdef __cplusplus } #endif #endif /* __STM32F1xx_LL_FSMC_H */ /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ 帮我提取一下代码中的FSMC配置信息,在stm32cubemx中是什么样的配置
09-07
//########################################################################### // // FILE: can.h // // TITLE: C28x CAN driver. // //########################################################################### // $Copyright: // Copyright (C) 2022 Texas Instruments Incorporated - http://www.ti.com // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // // Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // // Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the // distribution. // // Neither the name of Texas Instruments Incorporated nor the names of // its contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // $ //########################################################################### #ifndef CAN_H #define CAN_H //***************************************************************************** // // If building with a C++ compiler, make all of the definitions in this header // have a C binding. // //***************************************************************************** #ifdef __cplusplus extern "C" { #endif #ifdef __TMS320C28XX__ //***************************************************************************** // //! \addtogroup can_api CAN //! @{ // //***************************************************************************** #include <stdint.h> #include <stdbool.h> #include "inc/hw_memmap.h" #include "inc/hw_types.h" #include "inc/hw_can.h" #include "debug.h" #include "sysctl.h" // // The key value for RAM initialization // #define CAN_RAM_INIT_KEY (0xAU) // // RAM Initialization Register Mask // #define CAN_RAM_INIT_MASK (0x003FU) // // The Parity disable key value // #define CAN_INIT_PARITY_DISABLE (0x1400U) #ifndef DOXYGEN_PDF_IGNORE //***************************************************************************** // // Miscellaneous defines for Message ID Types // //***************************************************************************** //***************************************************************************** // // These are the flags used by the flags parameter when calling // the CAN_setupMessageObject() function. // //***************************************************************************** //! This indicates that transmit interrupts should be enabled, or are enabled. #define CAN_MSG_OBJ_TX_INT_ENABLE CAN_IF1MCTL_TXIE //! This indicates that receive interrupts should be enabled, or are //! enabled. #define CAN_MSG_OBJ_RX_INT_ENABLE CAN_IF1MCTL_RXIE //! This indicates that a message object will use or is using filtering //! based on the object's message identifier. #define CAN_MSG_OBJ_USE_ID_FILTER (0x00000001U) //! This indicates that a message object will use or is using filtering //! based on the direction of the transfer. #define CAN_MSG_OBJ_USE_DIR_FILTER CAN_IF1MSK_MDIR //! This indicates that a message object will use or is using message //! identifier filtering based on the extended identifier. #define CAN_MSG_OBJ_USE_EXT_FILTER CAN_IF1MSK_MXTD //! This indicates that this message object is part of a FIFO structure and //! not the final message object in a FIFO. #define CAN_MSG_OBJ_FIFO (0x00000002U) //! This indicates that a message object has no flags set. #define CAN_MSG_OBJ_NO_FLAGS (0x00000000U) //***************************************************************************** // // These definitions are used to specify interrupt sources to // CAN_enableInterrupt() and CAN_disableInterrupt(). // //***************************************************************************** //! This flag is used to allow a CAN controller to generate error //! interrupts. #define CAN_INT_ERROR (0x00000008UL) //! This flag is used to allow a CAN controller to generate status //! interrupts. #define CAN_INT_STATUS (0x00000004UL) //! This flag is used to allow a CAN controller to generate interrupts //! on interrupt line 0 #define CAN_INT_IE0 (0x00000002UL) //! This flag is used to allow a CAN controller to generate interrupts //! on interrupt line 1 #define CAN_INT_IE1 (0x00020000UL) //***************************************************************************** // // The following definitions contain all error or status indicators that can // be returned when calling the CAN_getStatus() function. // //***************************************************************************** //! CAN controller has detected a parity error. #define CAN_STATUS_PERR (0x00000100U) //! CAN controller has entered a Bus Off state. #define CAN_STATUS_BUS_OFF (0x00000080U) //! CAN controller error level has reached warning level. #define CAN_STATUS_EWARN (0x00000040U) //! CAN controller error level has reached error passive level. #define CAN_STATUS_EPASS (0x00000020U) //! A message was received successfully since the last read of this status. #define CAN_STATUS_RXOK (0x00000010U) //! A message was transmitted successfully since the last read of this //! status. #define CAN_STATUS_TXOK (0x00000008U) //! This is the mask for the last error code field. #define CAN_STATUS_LEC_MSK (0x00000007U) //! There was no error. #define CAN_STATUS_LEC_NONE (0x00000000U) //! A bit stuffing error has occurred. #define CAN_STATUS_LEC_STUFF (0x00000001U) //! A formatting error has occurred. #define CAN_STATUS_LEC_FORM (0x00000002U) //! An acknowledge error has occurred. #define CAN_STATUS_LEC_ACK (0x00000003U) //! The bus remained a bit level of 1 for longer than is allowed. #define CAN_STATUS_LEC_BIT1 (0x00000004U) //! The bus remained a bit level of 0 for longer than is allowed. #define CAN_STATUS_LEC_BIT0 (0x00000005U) //! A CRC error has occurred. #define CAN_STATUS_LEC_CRC (0x00000006U) //***************************************************************************** // // The following macros are added for the Global Interrupt EN/FLG/CLR // register // //***************************************************************************** //! CANINT0 global interrupt bit #define CAN_GLOBAL_INT_CANINT0 (0x00000001U) //! CANINT1 global interrupt bit #define CAN_GLOBAL_INT_CANINT1 (0x00000002U) //***************************************************************************** // // The following macros are added for accessing the interrupt register and // the standard arbitration ID in the interface registers. // //***************************************************************************** //! Status of INT0ID #define CAN_INT_INT0ID_STATUS (0x8000U) //! IF1 Arbitration Standard ID Shift Offset #define CAN_IF1ARB_STD_ID_S (18U) //! IF1 Arbitration Standard ID Mask #define CAN_IF1ARB_STD_ID_M (0x1FFC0000U) //! IF2 Arbitration Standard ID Shift Offset #define CAN_IF2ARB_STD_ID_S (18U) //! IF2 Arbitration Standard ID Mask #define CAN_IF2ARB_STD_ID_M (0x1FFC0000U) #endif // DOXYGEN_PDF_IGNORE //***************************************************************************** // //! This data type is used to decide between STD_ID or EXT_ID for a mailbox. //! This is used when calling the CAN_setupMessageObject() function. // //***************************************************************************** typedef enum { //! Set the message ID frame to standard. CAN_MSG_FRAME_STD, //! Set the message ID frame to extended. CAN_MSG_FRAME_EXT } CAN_MsgFrameType; //***************************************************************************** // //! This definition is used to determine the type of message object that will //! be set up via a call to the CAN_setupMessageObject() API. // //***************************************************************************** typedef enum { //! Transmit message object. CAN_MSG_OBJ_TYPE_TX, //! Transmit remote request message object CAN_MSG_OBJ_TYPE_TX_REMOTE, //! Receive message object. CAN_MSG_OBJ_TYPE_RX, //! Remote frame receive remote, with auto-transmit message object. CAN_MSG_OBJ_TYPE_RXTX_REMOTE } CAN_MsgObjType; //***************************************************************************** // //! This definition is used to determine the clock source that will //! be set up via a call to the CAN_selectClockSource() API. // //***************************************************************************** typedef enum { //! Peripheral System Clock Source CAN_CLOCK_SOURCE_SYS = 0x0, //! External Oscillator Clock Source CAN_CLOCK_SOURCE_XTAL = 0x1, //! Auxiliary Clock Input Source CAN_CLOCK_SOURCE_AUX = 0x2 } CAN_ClockSource; //***************************************************************************** // // Prototypes for the APIs. // //***************************************************************************** //***************************************************************************** // //! \internal //! //! Checks a CAN base address. //! //! \param base is the base address of the CAN controller. //! //! This function determines if a CAN controller base address is valid. //! //! \return Returns \b true if the base address is valid and \b false //! otherwise. // //***************************************************************************** #ifdef DEBUG static inline bool CAN_isBaseValid(uint32_t base) { return( (base == CANA_BASE) || (base == CANB_BASE) ); } #endif //***************************************************************************** // //! \internal //! //! Copies data from a buffer to the CAN Data registers. //! //! \param data is a pointer to the data to be written out to the CAN //! controller's data registers. //! \param address is a uint32_t value for the first register of the //! CAN controller's data registers. For example, in order to use the IF1 //! register set on CAN controller 0, the value would be: \b CANA_BASE \b + //! \b CAN_O_IF1DATA. //! \param size is the number of bytes to copy into the CAN controller. //! //! This function takes the steps necessary to copy data from a contiguous //! buffer in memory into the non-contiguous data registers used by the CAN //! controller. //! //! \return None. // //***************************************************************************** static inline void CAN_writeDataReg(const uint16_t *const data, uint32_t address, uint32_t size) { uint32_t idx; uint32_t dataReg = address; // // Check the dataReg. // ASSERT(dataReg != 0U); // // Loop always copies 1 byte per iteration. // for(idx = 0U; idx < size; idx++) { // // Write out the data 8 bits at a time. // HWREGB(dataReg) = data[idx]; dataReg++; } } //***************************************************************************** // //! \internal //! //! Copies data (all 16bits) from a buffer to the CAN Data registers. //! //! \param data is a pointer to the data to be written out to the CAN //! controller's data registers. //! \param address is a uint32_t value for the first register of the //! CAN controller's data registers. For example, in order to use the IF1 //! register set on CAN controller 0, the value would be: \b CANA_BASE \b + //! \b CAN_O_IF1DATA. //! \param size is the number of bytes to copy into the CAN controller. //! //! This function takes the steps necessary to copy data from a contiguous //! buffer in memory into the non-contiguous data registers used by the CAN //! controller. //! //! \return None. // //***************************************************************************** static inline void CAN_writeDataReg_16bit(const uint16_t *const data, uint32_t address, uint32_t size) { uint32_t idx; uint32_t dataReg = address; // // Check the dataReg. // ASSERT(dataReg != 0U); // // Loop always copies 1 byte per iteration. // for(idx = 0U; idx < size; idx++) { // // Write out the data 8 bits at a time. // HWREGB(dataReg) = (uint32_t)((data[idx / 2UL]) >> ((idx % 2UL) * 8UL)); dataReg++; } } //***************************************************************************** // //! \internal //! //! Copies data (all 32bits) from a buffer to the CAN Data registers. //! //! \param data is a pointer to the data to be written out to the CAN //! controller's data registers. //! \param address is a uint32_t value for the first register of the //! CAN controller's data registers. For example, in order to use the IF1 //! register set on CAN controller 0, the value would be: \b CANA_BASE \b + //! \b CAN_O_IF1DATA. //! \param size is the number of bytes to copy into the CAN controller. //! //! This function takes the steps necessary to copy data from a contiguous //! buffer in memory into the non-contiguous data registers used by the CAN //! controller. //! //! \return None. // //***************************************************************************** static inline void CAN_writeDataReg_32bit(const uint32_t *const data, uint32_t address, uint32_t size) { uint32_t idx; uint32_t dataReg = address; // // Check the dataReg. // ASSERT(dataReg != 0U); // // Loop always copies 1 byte per iteration. // for(idx = 0U; idx < size; idx++) { // // Write out the data 8 bits at a time. // HWREGB(dataReg) = ((data[idx / 4UL]) >> ((idx % 4UL) * 8UL)); dataReg++; } } //***************************************************************************** // //! \internal //! //! Copies data from the CAN Data registers to a buffer. //! //! \param data is a pointer to the location to store the data read from the //! CAN controller's data registers. //! \param address is a uint32_t value for the first register of the //! CAN controller's data registers. For example, in order to use the IF1 //! register set on CAN controller 1, the value would be: \b CANA_BASE \b + //! \b CAN_O_IF1DATA. //! \param size is the number of bytes to copy from the CAN controller. //! //! This function takes the steps necessary to copy data to a contiguous buffer //! in memory from the non-contiguous data registers used by the CAN //! controller. //! //! \return None. // //***************************************************************************** static inline void CAN_readDataReg(uint16_t *data, const uint32_t address, uint32_t size) { uint32_t idx; uint32_t dataReg = address; // // Loop always copies 1 byte per iteration. // for(idx = 0U; idx < size; idx++) { // // Read out the data // data[idx] = HWREGB(dataReg); dataReg++; } } //***************************************************************************** // //! Initializes the CAN controller's RAM. //! //! \param base is the base address of the CAN controller. //! //! Performs the initialization of the RAM used for the CAN message objects. //! //! \return None. // //***************************************************************************** static inline void CAN_initRAM(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); HWREGH(base + CAN_O_RAM_INIT) = CAN_RAM_INIT_CAN_RAM_INIT | CAN_RAM_INIT_KEY; while(!((HWREGH(base + CAN_O_RAM_INIT) & CAN_RAM_INIT_MASK) == (CAN_RAM_INIT_RAM_INIT_DONE | CAN_RAM_INIT_KEY2 | CAN_RAM_INIT_KEY0))) { // // Wait until RAM Init is complete // } } //***************************************************************************** // //! Select CAN Clock Source //! //! \param base is the base address of the CAN controller. //! \param source is the clock source to use for the CAN controller. //! //! This function selects the specified clock source for the CAN controller. //! //! The \e source parameter can be any one of the following: //! - \b CAN_CLOCK_SOURCE_SYS - Peripheral System Clock //! - \b CAN_CLOCK_SOURCE_XTAL - External Oscillator //! - \b CAN_CLOCK_SOURCE_AUX - Auxiliary Clock Input from GPIO //! //! \return None. // //***************************************************************************** static inline void CAN_selectClockSource(uint32_t base, CAN_ClockSource source) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Determine the CAN controller and set specified clock source // EALLOW; switch(base) { case CANA_BASE: HWREGH(CLKCFG_BASE + SYSCTL_O_CLKSRCCTL2) &= ~SYSCTL_CLKSRCCTL2_CANABCLKSEL_M; HWREGH(CLKCFG_BASE + SYSCTL_O_CLKSRCCTL2) |= ((uint16_t)source << SYSCTL_CLKSRCCTL2_CANABCLKSEL_S); break; case CANB_BASE: HWREGH(CLKCFG_BASE + SYSCTL_O_CLKSRCCTL2) &= ~SYSCTL_CLKSRCCTL2_CANBBCLKSEL_M; HWREGH(CLKCFG_BASE + SYSCTL_O_CLKSRCCTL2) |= ((uint16_t)source << SYSCTL_CLKSRCCTL2_CANBBCLKSEL_S); break; default: // // Do nothing. Not a valid mode value. // break; } EDIS; } //***************************************************************************** // //! Starts the CAN Module's Operations //! //! \param base is the base address of the CAN controller. //! //! This function starts the CAN module's operations after initialization, //! which includes the CAN protocol controller state machine of the CAN core //! and the message handler state machine to begin controlling the CAN's //! internal data flow. //! //! \return None. // //***************************************************************************** static inline void CAN_startModule(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Clear Init and CCE bits // HWREGH(base + CAN_O_CTL) &= ~(CAN_CTL_INIT | CAN_CTL_CCE); } //***************************************************************************** // //! Enables the CAN controller. //! //! \param base is the base address of the CAN controller to enable. //! //! Enables the CAN controller for message processing. Once enabled, the //! controller will automatically transmit any pending frames, and process any //! received frames. The controller can be stopped by calling //! CAN_disableController(). //! //! \return None. // //***************************************************************************** static inline void CAN_enableController(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Clear the init bit in the control register. // HWREGH(base + CAN_O_CTL) &= ~CAN_CTL_INIT; } //***************************************************************************** // //! Disables the CAN controller. //! //! \param base is the base address of the CAN controller to disable. //! //! Disables the CAN controller for message processing. When disabled, the //! controller will no longer automatically process data on the CAN bus. The //! controller can be restarted by calling CAN_enableController(). The state //! of the CAN controller and the message objects in the controller are left as //! they were before this call was made. //! //! \return None. // //***************************************************************************** static inline void CAN_disableController(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Set the init bit in the control register. // HWREGH(base + CAN_O_CTL) |= CAN_CTL_INIT; } //***************************************************************************** // //! Enables the test modes of the CAN controller. //! //! \param base is the base address of the CAN controller. //! \param mode are the the test modes to enable. //! //! Enables test modes within the controller. The following valid options for //! \e mode can be OR'ed together: //! - \b CAN_TEST_SILENT - Silent Mode //! - \b CAN_TEST_LBACK - Loopback Mode //! - \b CAN_TEST_EXL - External Loopback Mode //! //! \note Loopback mode and external loopback mode \b can \b not be //! enabled at the same time. //! //! \return None. // //***************************************************************************** static inline void CAN_enableTestMode(uint32_t base, uint16_t mode) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((mode & (CAN_TEST_LBACK | CAN_TEST_EXL)) != (CAN_TEST_LBACK | CAN_TEST_EXL)); // // Clear the bits in the test register. // HWREGH(base + CAN_O_TEST) &= ~((uint16_t)CAN_TEST_SILENT | (uint16_t)CAN_TEST_LBACK | (uint16_t)CAN_TEST_EXL); // // Enable test mode and set the bits in the test register. // HWREGH(base + CAN_O_CTL) |= CAN_CTL_TEST; HWREGH(base + CAN_O_TEST) |= mode; } //***************************************************************************** // //! Disables the test modes of the CAN controller. //! //! \param base is the base address of the CAN controller. //! //! Disables test modes within the controller and clears the test bits. //! //! \return None. // //***************************************************************************** static inline void CAN_disableTestMode(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Clear the bits in the test register. // HWREGH(base + CAN_O_TEST) &= ~((uint16_t)CAN_TEST_SILENT | (uint16_t)CAN_TEST_LBACK | (uint16_t)CAN_TEST_EXL); // // Clear the test mode enable bit // HWREGH(base + CAN_O_CTL) &= ~CAN_CTL_TEST; } //***************************************************************************** // //! Get the current settings for the CAN controller bit timing. //! //! \param base is the base address of the CAN controller. //! //! This function reads the current configuration of the CAN controller bit //! clock timing. //! //! \return Returns the value of the bit timing register. // //***************************************************************************** static inline uint32_t CAN_getBitTiming(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Read and return BTR register // return(HWREG_BP(base + CAN_O_BTR)); } //***************************************************************************** // //! Enables direct access to the RAM. //! //! \param base is the base address of the CAN controller. //! //! Enables direct access to the RAM while in Test mode. //! //! \note Test Mode must first be enabled to use this function. //! //! \return None. // //***************************************************************************** static inline void CAN_enableMemoryAccessMode(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Set the RAM direct access bit // HWREGH(base + CAN_O_TEST) |= CAN_TEST_RDA; } //***************************************************************************** // //! Disables direct access to the RAM. //! //! \param base is the base address of the CAN controller. //! //! Disables direct access to the RAM while in Test mode. //! //! \return None. // //***************************************************************************** static inline void CAN_disableMemoryAccessMode(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Clear the RAM direct access bit // HWREGH(base + CAN_O_TEST) &= ~CAN_TEST_RDA; } //***************************************************************************** // //! Sets the interruption debug mode of the CAN controller. //! //! \param base is the base address of the CAN controller. //! \param enable is a flag to enable or disable the interruption debug mode. //! //! This function sets the interruption debug mode of the CAN controller. When //! the \e enable parameter is \b true, CAN will be configured to interrupt any //! transmission or reception and enter debug mode immediately after it is //! requested. When \b false, CAN will wait for a started transmission or //! reception to be completed before entering debug mode. //! //! \return None. // //***************************************************************************** static inline void CAN_setInterruptionDebugMode(uint32_t base, bool enable) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); if(enable) { // // Enable interrupt debug support // HWREGH(base + CAN_O_CTL) |= CAN_CTL_IDS; } else { // // Disable interrupt debug support // HWREGH(base + CAN_O_CTL) &= ~CAN_CTL_IDS; } } //***************************************************************************** // //! Disables Auto-Bus-On. //! //! \param base is the base address of the CAN controller. //! //! Disables the Auto-Bus-On feature of the CAN controller. //! //! \return None. // //***************************************************************************** static inline void CAN_disableAutoBusOn(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Clear the ABO bit in the control register. // HWREGH(base + CAN_O_CTL) &= ~CAN_CTL_ABO; } //***************************************************************************** // //! Enables Auto-Bus-On. //! //! \param base is the base address of the CAN controller. //! //! Enables the Auto-Bus-On feature of the CAN controller. Be sure to also //! configure the Auto-Bus-On time using the CAN_setAutoBusOnTime function. //! //! \return None. // //***************************************************************************** static inline void CAN_enableAutoBusOn(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Set the ABO bit in the control register. // HWREGH(base + CAN_O_CTL) |= CAN_CTL_ABO; } //***************************************************************************** // //! Sets the time before a Bus-Off recovery sequence is started. //! //! \param base is the base address of the CAN controller. //! \param onTime is number of clock cycles before a Bus-Off recovery sequence //! is started. //! //! This function sets the number of clock cycles before a Bus-Off recovery //! sequence is started by clearing the Init bit. //! //! \note To enable this functionality, use CAN_enableAutoBusOn(). //! //! \return None. // //***************************************************************************** static inline void CAN_setAutoBusOnTime(uint32_t base, uint32_t onTime) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Set bus-off timer value // HWREG_BP(base + CAN_O_ABOTR) = onTime; } //***************************************************************************** // //! Enables individual CAN controller interrupt sources. //! //! \param base is the base address of the CAN controller. //! \param intFlags is the bit mask of the interrupt sources to be enabled. //! //! Enables specific interrupt sources of the CAN controller. Only enabled //! sources will cause a processor interrupt. //! //! The \e intFlags parameter is the logical OR of any of the following: //! - \b CAN_INT_ERROR - a controller error condition has occurred //! - \b CAN_INT_STATUS - a message transfer has completed, or a bus error has //! been detected //! - \b CAN_INT_IE0 - allow CAN controller to generate interrupts on interrupt //! line 0 //! - \b CAN_INT_IE1 - allow CAN controller to generate interrupts on interrupt //! line 1 //! //! \return None. // //***************************************************************************** static inline void CAN_enableInterrupt(uint32_t base, uint32_t intFlags) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((intFlags & ~(CAN_INT_ERROR | CAN_INT_STATUS | CAN_INT_IE0 | CAN_INT_IE1)) == 0U); // // Enable the specified interrupts. // HWREG_BP(base + CAN_O_CTL) |= intFlags; } //***************************************************************************** // //! Disables individual CAN controller interrupt sources. //! //! \param base is the base address of the CAN controller. //! \param intFlags is the bit mask of the interrupt sources to be disabled. //! //! Disables the specified CAN controller interrupt sources. Only enabled //! interrupt sources can cause a processor interrupt. //! //! The \e intFlags parameter has the same definition as in the //! CAN_enableInterrupt() function. //! //! \return None. // //***************************************************************************** static inline void CAN_disableInterrupt(uint32_t base, uint32_t intFlags) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((intFlags & ~(CAN_INT_ERROR | CAN_INT_STATUS | CAN_INT_IE0 | CAN_INT_IE1)) == 0U); // // Disable the specified interrupts. // HWREG_BP(base + CAN_O_CTL) &= ~(intFlags); } //***************************************************************************** // //! Get the CAN controller Interrupt Line set for each mailbox //! //! \param base is the base address of the CAN controller. //! //! Gets which interrupt line each message object should assert when an //! interrupt occurs. Bit 0 corresponds to message object 32 and then bits //! 1 to 31 correspond to message object 1 through 31 respectively. Bits that //! are asserted indicate the message object should generate an interrupt on //! interrupt line 1, while bits that are not asserted indicate the message //! object should generate an interrupt on line 0. //! //! \return Returns the value of the interrupt muxing register. // //***************************************************************************** static inline uint32_t CAN_getInterruptMux(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Get the interrupt muxing for the CAN peripheral // return(HWREG_BP(base + CAN_O_IP_MUX21)); } //***************************************************************************** // //! Set the CAN controller Interrupt Line for each mailbox //! //! \param base is the base address of the CAN controller. //! \param mux bit packed representation of which message objects should //! generate an interrupt on a given interrupt line. //! //! Selects which interrupt line each message object should assert when an //! interrupt occurs. Bit 0 corresponds to message object 32 and then bits //! 1 to 31 correspond to message object 1 through 31 respectively. Bits that //! are asserted indicate the message object should generate an interrupt on //! interrupt line 1, while bits that are not asserted indicate the message //! object should generate an interrupt on line 0. //! //! \return None. // //***************************************************************************** static inline void CAN_setInterruptMux(uint32_t base, uint32_t mux) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Set the interrupt muxing for the CAN peripheral // HWREG_BP(base + CAN_O_IP_MUX21) = mux; } //***************************************************************************** // //! Enables the CAN controller automatic retransmission behavior. //! //! \param base is the base address of the CAN controller. //! //! Enables the automatic retransmission of messages with detected errors. //! //! \return None. // //***************************************************************************** static inline void CAN_enableRetry(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Clearing the DAR bit tells the controller to not disable the // auto-retry of messages which were not transmitted or received // correctly. // HWREGH(base + CAN_O_CTL) &= ~CAN_CTL_DAR; } //***************************************************************************** // //! Disables the CAN controller automatic retransmission behavior. //! //! \param base is the base address of the CAN controller. //! //! Disables the automatic retransmission of messages with detected errors. //! //! \return None. // //***************************************************************************** static inline void CAN_disableRetry(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Setting the DAR bit tells the controller to disable the auto-retry // of messages which were not transmitted or received correctly. // HWREGH(base + CAN_O_CTL) |= CAN_CTL_DAR; } //***************************************************************************** // //! Returns the current setting for automatic retransmission. //! //! \param base is the base address of the CAN controller. //! //! Reads the current setting for the automatic retransmission in the CAN //! controller and returns it to the caller. //! //! \return Returns \b true if automatic retransmission is enabled, \b false //! otherwise. // //***************************************************************************** static inline bool CAN_isRetryEnabled(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Read the disable automatic retry setting from the CAN controller. // return((bool)((HWREGH(base + CAN_O_CTL) & CAN_CTL_DAR) != CAN_CTL_DAR)); } //***************************************************************************** // //! Reads the CAN controller error counter register. //! //! \param base is the base address of the CAN controller. //! \param rxCount is a pointer to storage for the receive error counter. //! \param txCount is a pointer to storage for the transmit error counter. //! //! Reads the error counter register and returns the transmit and receive error //! counts to the caller along with a flag indicating if the controller receive //! counter has reached the error passive limit. The values of the receive and //! transmit error counters are returned through the pointers provided as //! parameters. //! //! After this call, \e rxCount will hold the current receive error count //! and \e txCount will hold the current transmit error count. //! //! \return Returns \b true if the receive error count has reached the error //! passive limit, and \b false if the error count is below the error passive //! limit. // //***************************************************************************** static inline bool CAN_getErrorCount(uint32_t base, uint32_t *rxCount, uint32_t *txCount) { uint32_t canError = 0U; // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Read the current count of transmit/receive errors. // canError = HWREG_BP(base + CAN_O_ERRC); // // Extract the error numbers from the register value. // *rxCount = (canError & CAN_ERRC_REC_M) >> CAN_ERRC_REC_S; *txCount = (canError & CAN_ERRC_TEC_M) >> CAN_ERRC_TEC_S; return((bool)((canError & CAN_ERRC_RP) != 0U)); } //***************************************************************************** // //! Reads the CAN controller error and status register. //! //! \param base is the base address of the CAN controller. //! //! Reads the error and status register of the CAN controller. //! //! \return Returns the value of the register. // //***************************************************************************** static inline uint16_t CAN_getStatus(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Return error and status register value // return(HWREGH(base + CAN_O_ES)); } //***************************************************************************** // //! Reads the CAN controller TX request register. //! //! \param base is the base address of the CAN controller. //! //! Reads the TX request register of the CAN controller. //! //! \return Returns the value of the register. // //***************************************************************************** static inline uint32_t CAN_getTxRequests(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Return Tx requests register value // return(HWREG_BP(base + CAN_O_TXRQ_21)); } //***************************************************************************** // //! Reads the CAN controller new data status register. //! //! \param base is the base address of the CAN controller. //! //! Reads the new data status register of the CAN controller for all message //! objects. //! //! \return Returns the value of the register. // //***************************************************************************** static inline uint32_t CAN_getNewDataFlags(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Return new data register value // return(HWREG_BP(base + CAN_O_NDAT_21)); } //***************************************************************************** // //! Reads the CAN controller valid message object register. //! //! \param base is the base address of the CAN controller. //! //! Reads the valid message object register of the CAN controller. //! //! \return Returns the value of the register. // //***************************************************************************** static inline uint32_t CAN_getValidMessageObjects(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Return the valid message register value // return(HWREG_BP(base + CAN_O_MVAL_21)); } //***************************************************************************** // //! Get the CAN controller interrupt cause. //! //! \param base is the base address of the CAN controller. //! //! This function returns the value of the interrupt register that indicates //! the cause of the interrupt. //! //! \return Returns the value of the interrupt register. // //***************************************************************************** static inline uint32_t CAN_getInterruptCause(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Read interrupt identifier status // return(HWREG_BP(base + CAN_O_INT)); } //***************************************************************************** // //! Get the CAN controller pending interrupt message source. //! //! \param base is the base address of the CAN controller. //! //! Returns the value of the pending interrupts register that indicates //! which messages are the source of pending interrupts. //! //! \return Returns the value of the pending interrupts register. // //***************************************************************************** static inline uint32_t CAN_getInterruptMessageSource(uint32_t base) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); // // Read message object interrupt status // return(HWREG_BP(base + CAN_O_IPEN_21)); } //***************************************************************************** // //! CAN Global interrupt Enable function. //! //! \param base is the base address of the CAN controller. //! \param intFlags is the bit mask of the interrupt sources to be enabled. //! //! Enables specific CAN interrupt in the global interrupt enable register //! //! The \e intFlags parameter is the logical OR of any of the following: //! - \b CAN_GLOBAL_INT_CANINT0 - Global Interrupt Enable bit for CAN INT0 //! - \b CAN_GLOBAL_INT_CANINT1 - Global Interrupt Enable bit for CAN INT1 //! //! \return None. // //***************************************************************************** static inline void CAN_enableGlobalInterrupt(uint32_t base, uint16_t intFlags) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((intFlags & ~(CAN_GLOBAL_INT_CANINT0 | CAN_GLOBAL_INT_CANINT1)) == 0U); // // Enable the requested interrupts // HWREGH(base + CAN_O_GLB_INT_EN) |= intFlags; } //***************************************************************************** // //! CAN Global interrupt Disable function. //! //! \param base is the base address of the CAN controller. //! \param intFlags is the bit mask of the interrupt sources to be disabled. //! //! Disables the specific CAN interrupt in the global interrupt enable register //! //! The \e intFlags parameter is the logical OR of any of the following: //! - \b CAN_GLOBAL_INT_CANINT0 - Global Interrupt bit for CAN INT0 //! - \b CAN_GLOBAL_INT_CANINT1 - Global Interrupt bit for CAN INT1 //! //! \return None. // //***************************************************************************** static inline void CAN_disableGlobalInterrupt(uint32_t base, uint16_t intFlags) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((intFlags & ~(CAN_GLOBAL_INT_CANINT0 | CAN_GLOBAL_INT_CANINT1)) == 0U); // // Disable the requested interrupts // HWREGH(base + CAN_O_GLB_INT_EN) &= ~intFlags; } //***************************************************************************** // //! CAN Global interrupt Clear function. //! //! \param base is the base address of the CAN controller. //! \param intFlags is the bit mask of the interrupt sources to be cleared. //! //! Clear the specific CAN interrupt bit in the global interrupt flag register. //! //! The \e intFlags parameter is the logical OR of any of the following: //! - \b CAN_GLOBAL_INT_CANINT0 - Global Interrupt bit for CAN INT0 //! - \b CAN_GLOBAL_INT_CANINT1 - Global Interrupt bit for CAN INT1 //! //! \return None. // //***************************************************************************** static inline void CAN_clearGlobalInterruptStatus(uint32_t base, uint16_t intFlags) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((intFlags & ~(CAN_GLOBAL_INT_CANINT0 | CAN_GLOBAL_INT_CANINT1)) == 0U); // // Clear the requested interrupts // HWREGH(base + CAN_O_GLB_INT_CLR) |= intFlags; } //***************************************************************************** // //! Get the CAN Global Interrupt status. //! //! \param base is the base address of the CAN controller. //! \param intFlags is the bit mask of the interrupt sources to be enabled. //! //! Check if any interrupt bit is set in the global interrupt flag register. //! //! The \e intFlags parameter is the logical OR of any of the following: //! - \b CAN_GLOBAL_INT_CANINT0 - Global Interrupt bit for CAN INT0 //! - \b CAN_GLOBAL_INT_CANINT1 - Global Interrupt bit for CAN INT1 //! //! \return True if any of the requested interrupt bits are set. False, if //! none of the requested bits are set. // //***************************************************************************** static inline bool CAN_getGlobalInterruptStatus(uint32_t base, uint16_t intFlags) { // // Check the arguments. // ASSERT(CAN_isBaseValid(base)); ASSERT((intFlags & ~(CAN_GLOBAL_INT_CANINT0 | CAN_GLOBAL_INT_CANINT1)) == 0U); // // Read and return the global interrupt flag register // return((bool)((HWREGH(base + CAN_O_GLB_INT_FLG) & intFlags) != 0U)); } //***************************************************************************** // //! Initializes the CAN controller //! //! \param base is the base address of the CAN controller. //! //! This function initializes the message RAM, which also clears all the //! message objects, and places the CAN controller in an init state. Write //! access to the configuration registers is available as a result, allowing //! the bit timing and message objects to be setup. //! //! \note To exit the initialization mode and start the CAN module, use the //! CAN_startModule() function. //! //! \return None. // //***************************************************************************** extern void CAN_initModule(uint32_t base); //***************************************************************************** // //! Sets the CAN Bit Timing based on requested Bit Rate. //! //! \param base is the base address of the CAN controller. //! \param clockFreq is the CAN module clock frequency before the bit rate //! prescaler (Hertz) //! \param bitRate is the desired bit rate (bits/sec) //! \param bitTime is the number of time quanta per bit required for desired //! bit time (Tq) and must be in the range from 8 to 25 //! //! This function sets the CAN bit timing values for the bit rate passed in the //! \e bitRate and \e bitTime parameters based on the \e clockFreq parameter. The //! CAN bit clock is calculated to be an average timing value that should work //! for most systems. If tighter timing requirements are needed, then the //! CAN_setBitTiming() function is available for full customization of all of //! the CAN bit timing values. //! //! \note Not all bit-rate and bit-time combinations are valid. //! For combinations that would yield the correct bit-rate, //! refer to the DCAN_CANBTR_values.xlsx file in the "docs" directory. //! The CANBTR register values calculated by the function CAN_setBitRate //! may not be suitable for your network parameters. If this is the case //! and you have computed the correct values for your network, you could //! directly write those parameters in CANBTR register using the //! function CAN_setBitTiming. //! //! \return None. // //***************************************************************************** extern void CAN_setBitRate(uint32_t base, uint32_t clockFreq, uint32_t bitRate, uint16_t bitTime); //***************************************************************************** // //! Manually set the CAN controller bit timing. //! //! \param base is the base address of the CAN controller. //! \param prescaler is the baud rate prescaler //! \param prescalerExtension is the baud rate prescaler extension //! \param tSeg1 is the time segment 1 //! \param tSeg2 is the time segment 2 //! \param sjw is the synchronization jump width //! //! This function sets the various timing parameters for the CAN bus bit //! timing: baud rate prescaler, prescaler extension, time segment 1, //! time segment 2, and the Synchronization Jump Width. //! //! \return None. // //***************************************************************************** extern void CAN_setBitTiming(uint32_t base, uint16_t prescaler, uint16_t prescalerExtension, uint16_t tSeg1, uint16_t tSeg2, uint16_t sjw); //***************************************************************************** // //! Clears a CAN interrupt source. //! //! \param base is the base address of the CAN controller. //! \param intClr is a value indicating which interrupt source to clear. //! //! This function can be used to clear a specific interrupt source. The //! \e intClr parameter should be either a number from 1 to 32 to clear a //! specific message object interrupt or can be the following: //! - \b CAN_INT_INT0ID_STATUS - Clears a status interrupt. //! //! It is not necessary to use this function to clear an interrupt. This //! should only be used if the application wants to clear an interrupt source //! without taking the normal interrupt action. //! //! \return None. // //***************************************************************************** extern void CAN_clearInterruptStatus(uint32_t base, uint32_t intClr); //***************************************************************************** // //! Setup a Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the message object number to configure (1-32). //! \param msgID is the CAN message identifier used for the 11 or 29 bit //! identifiers //! \param frame is the CAN ID frame type //! \param msgType is the message object type //! \param msgIDMask is the CAN message identifier mask used when identifier //! filtering is enabled //! \param flags is the various flags and settings to be set for the message //! object //! \param msgLen is the number of bytes of data in the message object (0-8) //! //! This function sets the various values required for a message object. //! //! The \e frame parameter can be one of the following values: //! - \b CAN_MSG_FRAME_STD - Standard 11 bit identifier //! - \b CAN_MSG_FRAME_EXT - Extended 29 bit identifier //! //! The \e msgType parameter can be one of the following values: //! - \b CAN_MSG_OBJ_TYPE_TX - Transmit Message //! - \b CAN_MSG_OBJ_TYPE_TX_REMOTE - Transmit Remote Message //! - \b CAN_MSG_OBJ_TYPE_RX - Receive Message //! - \b CAN_MSG_OBJ_TYPE_RXTX_REMOTE - Receive Remote message with //! auto-transmit //! //! The \e flags parameter can be set as \b CAN_MSG_OBJ_NO_FLAGS if no flags //! are required or the parameter can be a logical OR of any of the following //! values: //! - \b CAN_MSG_OBJ_TX_INT_ENABLE - Enable Transmit Interrupts //! - \b CAN_MSG_OBJ_RX_INT_ENABLE - Enable Receive Interrupts //! - \b CAN_MSG_OBJ_USE_ID_FILTER - Use filtering based on the Message ID //! (Standard or Extended) //! - \b CAN_MSG_OBJ_USE_EXT_FILTER - Use Extended Identifier Bit for filtering //! (Only among Extended IDs will be accepted) //! - \b CAN_MSG_OBJ_USE_DIR_FILTER - Use filtering based on the direction of //! the transfer //! - \b CAN_MSG_OBJ_FIFO - Message object is part of a FIFO //! structure and isn't the final message //! object in FIFO //! //! If filtering is based on message identifier (for Standard or Extended IDs) //! specified by the \e msgIDMask parameter, the value \b CAN_MSG_OBJ_USE_ID_FILTER //! has to be logically ORed with the \e flag parameter. //! If \b CAN_MSG_OBJ_USE_EXT_FILTER is ORed with the \e flag parameter, //! only extended identifier frames are accepted which can further be masked //! by using the flag above. //! //! \note The \b msgLen Parameter for the Receive Message Object is a "don't //! care" but its value should be between 0-8 due to the assert. //! //! \return None. // //***************************************************************************** extern void CAN_setupMessageObject(uint32_t base, uint32_t objID, uint32_t msgID, CAN_MsgFrameType frame, CAN_MsgObjType msgType, uint32_t msgIDMask, uint32_t flags, uint16_t msgLen); //***************************************************************************** // //! Sends a Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to configure (1-32). //! \param msgLen is the number of bytes of data in the message object (0-8) //! \param msgData is a pointer to the message object's data //! //! This function is used to transmit a message object and the message data, //! if applicable. //! //! \note The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function. //! //! \return None. // //***************************************************************************** extern void CAN_sendMessage(uint32_t base, uint32_t objID, uint16_t msgLen, const uint16_t *msgData); //***************************************************************************** // //! Sends a Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to configure (1-32). //! \param msgLen is the number of bytes of data in the message object (0-8) //! \param msgData is a pointer to the message object's data (all 16 bits are sent) //! //! This function is used to transmit a message object and the message data, //! if applicable. //! //! \note The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function. //! //! \return None. // //***************************************************************************** extern void CAN_sendMessage_16bit(uint32_t base, uint32_t objID, uint16_t msgLen, const uint16_t *msgData); //***************************************************************************** // //! Sends a Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to configure (1-32). //! \param msgLen is the number of bytes of data in the message object (0-8) //! \param msgData is a pointer to the message object's data (all 32 bits are sent) //! //! This function is used to transmit a message object and the message data, //! if applicable. //! //! \note The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function. //! //! \return None. // //***************************************************************************** extern void CAN_sendMessage_32bit(uint32_t base, uint32_t objID, uint16_t msgLen, const uint32_t *msgData); //***************************************************************************** // //! Sends a Message Object while dynamically updating data length //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to configure (1-32). //! \param msgLen is the number of bytes of data in the message object (0-8) //! \param msgData is a pointer to the message object's data //! //! This function is used to transmit a message object and the message data, //! if applicable and can be used to dynamically update the data length //! for every subsequent call of this function. //! //! \note The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function. //! //! \return None. // //***************************************************************************** extern void CAN_sendMessage_updateDLC(uint32_t base, uint32_t objID, uint16_t msgLen, const uint16_t *msgData); //***************************************************************************** // //! Sends a Remote Request Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to configure (1-32). //! //! This function is used to transmit a remote request message object. //! //! \note The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function with CAN_MSG_OBJ_TYPE_TX_REMOTE //! as msgType flag. //! //! \return None. // //***************************************************************************** extern void CAN_sendRemoteRequestMessage(uint32_t base, uint32_t objID); //***************************************************************************** // //! Reads the data in a Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to read (1-32). //! \param msgData is a pointer to the array to store the message data //! //! This function is used to read the data contents of the specified message //! object in the CAN controller. The data returned is stored in the //! \e msgData parameter. //! //! \note //! -# The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function. //! -# If the DLC of the received message is larger than the \e msgData //! buffer provided, then it is possible for a buffer overflow to occur. //! //! \return Returns \b true if new data was retrieved, else returns //! \b false to indicate no new data was retrieved. // //***************************************************************************** extern bool CAN_readMessage(uint32_t base, uint32_t objID, uint16_t *msgData); //***************************************************************************** // //! Reads the data and Message ID in a Message Object //! //! \param base is the base address of the CAN controller. //! \param objID is the object number to read (1-32). //! \param frameType is a pointer to the CAN_MsgFrameType to store the message //! type that has been received in the mailbox //! The \e frameType parameter shall be filled as of the following values: //! - \b CAN_MSG_FRAME_STD - Standard 11 bit identifier //! - \b CAN_MSG_FRAME_EXT - Extended 29 bit identifier //! This parameter is filled when return value is true for this function. //! \param msgID is a pointer to storage for the received Message ID //! Filled when the return value is true for this function. //! \param msgData is a pointer to the array to store the message data //! Filled with read Data when the return value is true for this function. //! //! This function is used to read the data contents and the Message ID //! of the specified message object in the CAN controller.The Message ID returned //! is stored in the \e msgID parameter and its type in \e frameType parameter. //! The data returned is stored in the \e msgData parameter. //! //! \note //! -# The message object requested by the \e objID must first be setup //! using the CAN_setupMessageObject() function. //! //! \return Returns \b true if new data was retrieved, else returns //! \b false to indicate no new data was retrieved. // //***************************************************************************** extern bool CAN_readMessageWithID(uint32_t base, uint32_t objID, CAN_MsgFrameType *frameType, uint32_t *msgID, uint16_t *msgData); //***************************************************************************** // //! Transfers a CAN message between the IF registers and Message RAM. //! //! \param base is the base address of the CAN controller. //! \param interface is the interface to use for the transfer. Valid value are //! 1 or 2. //! \param objID is the object number to transfer (1-32). //! \param direction is the direction of data transfer. False is Message RAM //! to IF, True is IF to Message RAM. //! //! This function transfers the contents of the interface registers to message //! RAM or vice versa depending on the value passed to direction. //! //! \return None. // //***************************************************************************** extern void CAN_transferMessage(uint32_t base, uint16_t interface, uint32_t objID, bool direction); //***************************************************************************** // //! Clears a message object so that it is no longer used. //! //! \param base is the base address of the CAN controller. //! \param objID is the message object number to disable (1-32). //! //! This function frees(disables) the specified message object from use. Once //! a message object has been cleared, it will no longer automatically send or //! receive messages, or generate interrupts. //! //! \return None. // //***************************************************************************** extern void CAN_clearMessage(uint32_t base, uint32_t objID); //***************************************************************************** // //! Disables specific message object //! //! \param base is the base address of the CAN controller. //! \param objID is the message object number to disable (1-32). //! //! This function disables the specific message object. Once the message object //! has been disabled it will be ignored by the message handler until it //! is configured again. //! //! \return None. // //***************************************************************************** extern void CAN_disableMessageObject(uint32_t base, uint32_t objID); //***************************************************************************** // //! Disables all message objects //! //! \param base is the base address of the CAN controller. //! //! This function disables all message objects. Once a message object //! has been disabled it will be ignored by the message handler until it //! is configured again. All message objects are disabled automatically on //! reset, however this function can be used to restart CAN operations //! without an external reset. //! //! \return None. // //***************************************************************************** extern void CAN_disableAllMessageObjects(uint32_t base); //***************************************************************************** // // Close the Doxygen group. //! @} // //***************************************************************************** #endif // #ifdef __TMS320C28XX__ //***************************************************************************** // // Mark the end of the C bindings section for C++ compilers. // //***************************************************************************** #ifdef __cplusplus } #endif #endif // CAN_H 这个是can.h文件
最新发布
10-18
/** * @file ADC/ADC_Temperature/main.h * @brief Header for main.c module * @author ChipSea MCU Group * @version V1.0.0 * @date * @copyright CHIPSEA TECHNOLOGIES (SHENZHEN) CORP. * @note * <h2><center>© COPYRIGHT 2022 ChipSea</center></h2> * * * @verbatim ----------------------- How to used this project--------------------------- * @par Example Description This example shows how to configure ADC for temperature detect. User should combine manual to learn how to calculate actual voltage. - Test steps a. Rebuild the project and load the image into target memory. b. Connect harware to the target board. c. Run the example, SDADC start sample every 1000ms. * @endverbatim * */ /***************************************************************************** * @includes *****************************************************************************/ #include "main.h" /***************************************************************************** * @definitions *****************************************************************************/ #define T0K_FLASH_BASE 0x1FFFFC34 #define DATAT0_HIGH_FLASH_BASE 0x1FFFFC3C #define DATAT0_LOW_FLASH_BASE 0x1FFFFC38 /***************************************************************************** * @variables *****************************************************************************/ extern uint32_t SystemCoreClock; static volatile uint32_t timing_delay; volatile uint32_t data_symbol = 0; /***************************************************************************** * @functions *****************************************************************************/ void delay(volatile uint32_t value); uint32_t adc_data_convert(uint32_t data); /**@brief Main program. * * @param[in] None. * * @return None. */ int main(void) { uint32_t data_T0 = 0; uint32_t T0_K = 0; uint32_t adc_data = 0; double adc_temp = 0; adc_config_t adc_config; pga_config_t pga_config; vref_config_t vref_config; /* Init USART1 */ cs_eval_com_init(); printf("ADC temperature example!\r\n"); /* Interrupt every 1ms */ SysTick_Config(SystemCoreClock / 1000); /* Clock enable */ __RCU_AHB_CLK_ENABLE(RCU_AHB_PERI_GPIOA); __RCU_APB1_CLK_ENABLE(RCU_APB1_PERI_ADADC); __RCU_FUNC_ENABLE(LRC2_CLK); /* adc clock = LRC2(1.024MHz) */ rcu_adcclk_config(RCU_ADCLK_CFG_LRC2); if(rcu_lrc2_stabilization_wait() == ERROR) { printf("LRC2 not ready\r\n"); /* Stop here */ while(1); } else { printf("LRC2 ready\r\n"); } adc_def_init(ADC1); /* Step1:Inner-vref must soft start */ adc_vref_soft_start(ADC1); /* Step2:Config AD-ADC */ adc_config_struct_init(&adc_config); adc_config.abandont_num = ADC_ABANDONT_DATA_4; adc_config.average_num = ADC_AVERAGE_NUM_16; adc_config.convert_mode = ADC_SINGLE_CONVERT_MODE; adc_config.data_rate = ADC_DATARATE_MODE_7; adc_config.gain_select = ADC_GAIN_2; adc_config.ovrwr_mode = ADC_DATA_OVER_WRITE_NONE; adc_config.power_mode = ADC_HIGH_POWER_MODE; adc_config.rst_num = ADC_RST_CYCLE_4; adc_config.setup_time = ADC_SETUP_TIME_CYCLE_2048; adc_init(ADC1, &adc_config); /* Step3:Config PGA */ pga_config.din_select = PGA_PMOS; pga_config.pga1_enable = DISABLE; pga_config.pga_chop = PGA_CHOP_DIV_256; pga_config.pga_gain = ADC_PGA_GAIN_1; adc_pga_init(&pga_config); /* Step4:Config VREF */ vref_config.buffer_enable = ENABLE; vref_config.driver = ADC_VREF_DRV_MAX_5MA; vref_config.ref_select = ADC_REF_SELECT_INNER_2P048V; vref_config.vref_enable = ENABLE; adc_vref_init(&vref_config); /* Step5:Filter select */ adc_digital_filter_select(ADC1, ADC_FILTER_LOW_LATENCY); /* Step6:trigger config -- soft */ adc_trigger_config(ADC1, ADC_TRIGGER_MODE_SOFT, ADC_TRIGGER_SRC_RTC); adc_chop_freq_set(ADC1,ADC_CHOP_DIV_256); adc_channel_config(ADC1, ADC_INPUT_CHANNEL_8, ADC_INPUT_CHANNEL_8); /* FLASH data code handle */ T0_K = *(__IO uint32_t *)T0K_FLASH_BASE; T0_K = (T0_K & 0x000000FF) | ((T0_K & 0x00FF0000)>>8); T0_K = (T0_K - 27315); data_T0 = (((*(__IO uint32_t *)DATAT0_HIGH_FLASH_BASE) & 0x000000FF) <<16) | \ ((*(__IO uint32_t *)DATAT0_LOW_FLASH_BASE) & 0x000000FF) | \ (((*(__IO uint32_t *)DATAT0_LOW_FLASH_BASE) & 0x00FF0000 )>>8); while(1) { adc_conversion_start(ADC1); while(!__ADC_FLAG_STATUS_GET(ADC1, ADC_FLAG_DATA_EOCH)); adc_data = adc_data_convert(__ADC_CONV_VALUE_GET(ADC1)); printf("ADC temp testúAdc value is %06x\r\n",adc_data); if(adc_data >= data_T0) { adc_temp = (double)(adc_data - data_T0) * 2048 / 8388608 + (double)T0_K/100; } else { adc_temp = (double)T0_K/100 - (double)(data_T0 - adc_data) * 2048 / 8388608; } printf("tempertureúAdc value is %f\r\n",adc_temp); printf("\r\n\n\n"); delay(1000); } } uint32_t adc_data_convert(uint32_t adc_data) { if(adc_data & 0x800000) { adc_data = (~(adc_data & 0xFFFFFF))+1; adc_data &= 0x00FFFFFF; } else { adc_data &= 0x00FFFFFF; } return adc_data; } /**@brief Inserts a delay time. * * @param[in] nTime: specifies the delay time length, in milliseconds. * * @return None. */ void delay(volatile uint32_t value) { timing_delay = value; while(timing_delay != 0); } /**@brief Decrements the timing_delay variable. * * @param[in] None. * * @return None. */ void timing_delay_decrement(void) { if (timing_delay != 0x00) { timing_delay--; } } #ifdef USE_FULL_ASSERT /**@brief Report the assert error. * * @param[in] file: pointer to the source file name. * * @param[in] line: error line source number. * * @return None. */ void assert_failed(uint8_t* file, uint32_t line) { while(1); } #endif
07-30
/** DSI Functional Configuration Selection This definition is used in dsi_set_config()/dsi_get_config() specify which of the dsi function is selected to assign new configurations. */ typedef enum { DSI_CONFIG_ID_MODE, ///< Configure DSI mode ///< @note for DSI_CFG_MODE_SEL ///< Context can be any of: ///< - @b DSI_MODE_MANUAL_MODE : Manual Commands Only: Send CMD(s) and auto clear DSI_TX_EN ///< - @b DSI_MODE_AUTO_MODE1 : Send single frame only and auto clear DSI_TX_EN at frame end (No commands) ///< - @b DSI_MODE_AUTO_MODE2 : Auto Mode 2: FRM1 + FRM2 + ... ///< - @b DSI_MODE_AUTO_MODE3 : Auto Mode 3: CMD(s) + FRM1 + CMD(s) + FRM2 + ... DSI_CONFIG_ID_PIXEL_FMT, ///< Configure DSI pinxel format. Use DSI_PIXEL_RGB_888/DSI_PIXEL_RGB_565/DSI_PIXEL_RGB_666_PACKETED/DSI_PIXEL_RGB_666_LOOSELY DSI_CONFIG_ID_PIXPKT_MODE, ///< Configure DSI pinxel mode. DSI_CONFIG_ID_VDOPKT_TYPE, ///< Configure DSI video packet type. DSI_CONFIG_ID_ECC_CHK_EN, ///< Configure DSI Ecc check enable/disable. DSI_CONFIG_ID_FRMEND_BTA_EN, ///< Configure DSI frameend BTA enable/disable. DSI_CONFIG_ID_EOT_PKT_EN, ///< Configure DSI EOT packet enable/disable DSI_CONFIG_ID_BLANK_CTRL, ///< Configure DSI blank control DSI_CONFIG_ID_INTER_PKT_LP, ///< Configure DSI inter-packet enter LP or not. DSI_CONFIG_ID_CLK_LP_CTRL, ///< Configure DSI clock enter LP or not. DSI_CONFIG_ID_SYNC_EN, ///< Configure DSI sync enable/disable. DSI_CONFIG_ID_SYNC_SRC, ///< Configure DSI sync source. DSI_CONFIG_ID_SYNC_WITH_SETTEON, ///< Configure DSI sync with set te on. DSI_CONFIG_ID_SYNC_WITH_SETTEON_RTY, ///< Configure DSI sync with set te on retry. DSI_CONFIG_ID_RGB_SWAP, ///< Configure DSI RGB swap DSI_CONFIG_ID_RGB_BITFLIP, ///< Configure DSI RGB bit swap DSI_CONFIG_ID_SYNC_WITH_SETTEON_RTY_TWICEBTA, ///< Configure DSI sync with set te on retry and BTA twice. DSI_CONFIG_ID_DATALANE_NO, ///< Configure DSI data lane number. DSI_CONFIG_ID_SRC, ///< Configure DSI souce from IDE or IDE2 DSI_CONFIG_ID_PIXPKT_PH_DT, ///< Configure DSI pixel Packet header DataType. DSI_CONFIG_ID_PIXPKT_PH_VC, ///< Configure DSI pixel Packet header VirtualChannel. DSI_CONFIG_ID_DCS_CT0, ///< Configure DSI DSC command, this field would be inserted in front of the first pixel packet. DSI_CONFIG_ID_DCS_CT1, ///< Configure DSI DSC command, this field would be inserted in front of the pixel packet except the first pixel packet. DSI_CONFIG_ID_SYNCEVT_SLICE_NO, ///< Configure DSI sync event slice number. DSI_CONFIG_ID_SYNCEVT_NULL_LEN, ///< Configure DSI sync even null length. (Byte count) DSI_CONFIG_ID_VSA, ///< Configure DSI vertical sync active timing. DSI_CONFIG_ID_VTOTAL, ///< Configure DSI vertical total timing. DSI_CONFIG_ID_VVALID_START, ///< Configure DSI vertical valid start timing. DSI_CONFIG_ID_VVALID_END, ///< Configure DSI vertical valid end timing. DSI_CONFIG_ID_HSA, ///< Configure DSI horizontal sync active timing. DSI_CONFIG_ID_BLLP, ///< Configure DSI BLLP period, this period can trasmit HS packets or entering LP11. DSI_CONFIG_ID_HBP, ///< Configure DSI horizontal back porch period. DSI_CONFIG_ID_HFP, ///< Configure DSI horizontal front porch period. DSI_CONFIG_ID_HACT, ///< Configure DSI horizontal active period. DSI_CONFIG_ID_TLPX, ///< Configure DSI LTPX timing. DSI_CONFIG_ID_BTA_TA_GO, ///< Configure DSI TA_GO timing. DSI_CONFIG_ID_BTA_TA_SURE, ///< Configure DSI TA_SURE timing. DSI_CONFIG_ID_BTA_TA_GET, ///< Configure DSI TA_GET timing. DSI_CONFIG_ID_THS_PREPARE, ///< Configure DSI THS_PREPARE timing. DSI_CONFIG_ID_THS_ZERO, ///< Configure DSI THS_ZERO timing. DSI_CONFIG_ID_THS_TRAIL, ///< Configure DSI THS_TRAIL timing. DSI_CONFIG_ID_THS_EXIT, ///< Configure DSI THS_EXIT timing. DSI_CONFIG_ID_TWAKEUP, ///< Configure DSI wakeup timing. DSI_CONFIG_ID_TCLK_PREPARE, ///< Configure DSI TCLK_PREPARE timing. DSI_CONFIG_ID_TCLK_ZERO, ///< Configure DSI TCLK_ZERO timing. DSI_CONFIG_ID_TCLK_POST, ///< Configure DSI TCLK_POST timing. DSI_CONFIG_ID_TCLK_PRE, ///< Configure DSI TCLK_PRE timing. DSI_CONFIG_ID_TCLK_TRAIL, ///< Configure DSI TCLK_TRAIL timing. DSI_CONFIG_ID_BTA_TMOUT_VAL, ///< Configure DSI BTA timeout. DSI_CONFIG_ID_BTA_HANDSK_TMOUT_VAL, ///< Configure DSI BTA handshake timeout. DSI_CONFIG_ID_SYNC_POL, ///< Configure DSI SYNC polarity. DSI_CONFIG_ID_SYNC_SEL, ///< Configure DSI SYNC faster or slower than peripheral selection. DSI_CONFIG_ID_SYNC_DLY_CNT, ///< Configure DSI SYNC delay count. DSI_CONFIG_ID_TE_BTA_INTERVAL, ///< Configure DSI TE BAT issue interval. DSI_CONFIG_ID_PHY_DRVING, ///< Configure DSI PHY driving DSI_CONFIG_ID_CLK_PHASE_OFS, ///< Configure DSI PHY clock phase offset. DSI_CONFIG_ID_DAT0_PHASE_OFS, ///< Configure DSI PHY data0 phase offset. DSI_CONFIG_ID_DAT1_PHASE_OFS, ///< Configure DSI PHY data1 phase offset. DSI_CONFIG_ID_DAT2_PHASE_OFS, ///< Configure DSI PHY data2 phase offset. DSI_CONFIG_ID_DAT3_PHASE_OFS, ///< Configure DSI PHY data3 phase offset. DSI_CONFIG_ID_PHASE_DELAY_ENABLE_OFS, ///< Configure DSI PHY phase delay enable. //DSI_CFG_ID_FREQ DSI_CONFIG_ID_FREQ, ///< DSI module target clock (Unit: Hz) DSI_CONFIG_ID_LPFREQ, ///< DSI module LP clock (Unit: Hz) DSI_CONFIG_ID_IDEHVALID, ///< DSI module of IDE HVALID setting DSI_CONFIG_ID_LANSEL_D0, ///< Configure DSI DAT0 Lane mapping DSI_CONFIG_ID_LANSEL_D1, ///< Configure DSI DAT1 Lane mapping DSI_CONFIG_ID_LANSEL_D2, ///< Configure DSI DAT2 Lane mapping DSI_CONFIG_ID_LANSEL_D3, ///< Configure DSI DAT3 Lane mapping DSI_CONFIG_ID_PHY_LP_RX_DAT0,///< Configure DSI LP RX DAT0 enable/disable DSI_CONFIG_ID_BTA_VALUE, ///< Read back SRAM value DSI_CONFIG_ID_CHIP_VER, ///< Get DSI chip version ENUM_DUMMY4WORD(DSI_CONFIG_ID) } DSI_CONFIG_ID;分析每个枚举值的用途
06-06
<think>嗯,用户这次问的是MIPI-DSI配置中一个特定枚举值DSI_CONFIG_ID的功能分析,看起来是在做底层驱动开发。从ta引用文档的细节程度看,应该是手机或嵌入式领域的工程师,正在调试显示模块。用户引用了三条重要信息:第一条详细描述了DSI时序参数的计算方法;第二条给出了视频模式数据速率公式;第三条提到高通的commandmode实现。这些引用很有价值,说明用户已经查阅过技术文档,但还需要更具体的寄存器级分析。注意到用户特别强调“不是真正需求”,可能之前沟通存在偏差。这次明确要枚举值功能分析,重点在DSI_CONFIG_ID这个特定参数。从专业角度看,这个枚举值在MIPI-DSI驱动架构中属于核心配置项,需要从硬件抽象层角度解释。准备从三个层面展开:首先是功能意义(物理/虚拟通道选择与同步),接着工作模式选择(视频/命令模式),最后介绍时钟源决策机制。由于涉及硬件寄存器操作,补充lane数量提示很重要——这直接关系到用户后续计算data_rate是否准确。用户没有问但可能需要的隐藏信息是:DSI_CONFIG_ID不同值对应的物理电路差异(比如电平转换器使能状态),这个放在衍生问题里作为第二点更合适。另外注意到用户引用[3]提到LK(LittleKernel)阶段实现,提示ta该参数需在bootloader初始化阶段配置完毕。技术上需要验证的是DSI-1规格书中关于CONFIG_TYPE寄存器的说明,确认bit3是否真如高通文档所述控制虚拟通道切换。稍后回复时在功能映射部分补充注释,避免与其他平台混淆。</think> MIPI-DSI协议中的`DSI_CONFIG_ID`枚举值主要用于**区分不同的DSI物理通道配置方案**,其核心功能是协调控制器与面板之间的物理层通信参数。具体功能分析如下: --- ### 一、功能作用分析 1. **物理/虚拟通道选择** `DSI_CONFIG_ID`指定控制器使用的DSI物理通道数量(如1/2/4条Lane)及虚拟通道分配方案。例如: - `DSI_CONFIG_1_LANE`:单通道传输,带宽较低 - `DSI_CONFIG_2_LANE_DUAL_VIRTUAL`:双物理通道,支持虚拟通道切换 2. **工作模式控制** 决定数据传输采用 **Command Mode** 或 **Video Mode**(引用[3]): ```c typedef enum { DSI_CONFIG_VIDEO_MODE, // 视频流模式(高速传输) DSI_CONFIG_COMMAND_MODE // 寄存器命令模式(低频配置) } dsi_config_type_t; ``` - **Command Mode**:通过寄存器配置面板参数(如引用[1]的时序数组配置) - **Video Mode**:持续传输像素数据流(依赖引用[2]的数据速率公式) 3. **时钟同步机制** 选择DSI时钟源(PLL分频策略)和同步信号极性(HSYNC/VSYNC极性),与引用[1]中的时序参数直接相关。 --- ### 二、底层配置映射(以高通平台为例) 在LK初始化阶段(引用[3]),枚举值被映射到硬件寄存器: ```c // 示例:配置双通道视频模式 static struct mipi_dsi_cmd_init dsi_config_table[] = { {DSI_CONFIG_ID, DSI_CONFIG_2_LANE_VIDEO}, {DSI_TIMING_ARRAY, 0x88, 0x1E, 0x12, ...} // 引用[1]的时序数据 }; ``` 硬件层将执行: 1. 设置PHY层Lane数量(PHY_CTRL寄存器) 2. 配置HS/LP传输速率(根据引用[2]公式计算) 3. 使能时钟同步(TIMING_CTRL寄存器) --- ### 三、关键设计逻辑 | 配置ID | 适用场景 | 带宽影响因子 | |------------------|------------------------|---------------------------| | `SINGLE_LANE_CMD`| 小分辨率Command屏 | 受限于LP模式速率(≤10Mbps)| | `DUAL_LANE_VIDEO`| 1080p@60fps屏 | 引用[2]公式:`Data rate = (H_total*V_total)*24*60/2` | | `QUAD_LANE_VIDEO`| 4K高刷新率屏 | 需匹配PHY最大带宽(如6Gbps)| --- ### 四、典型问题排查方向 1. **配置不匹配导致花屏** - 现象:配置`DSI_CONFIG_2_LANE_VIDEO`但面板仅支持单通道 - 方案:检查面板规格书匹配物理Lane数 2. **时钟同步失败** - 根因:`DSI_CONFIG_ID`选择的时钟源与时序参数冲突(引用[1]电子表格计算的参数需与所选ID一致) - 调试:验证PLL分频比 $$ PLL\_Div = \frac{RefClk \times Data\_Lane}{Pixel\_Clock} $$ ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值