Mercurial > public > ostc4
comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Src/stm32f4xx_hal_crc.c @ 38:5f11787b4f42
include in ostc4 repository
author | heinrichsweikamp |
---|---|
date | Sat, 28 Apr 2018 11:52:34 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
37:ccc45c0e1ea2 | 38:5f11787b4f42 |
---|---|
1 /** | |
2 ****************************************************************************** | |
3 * @file stm32f4xx_hal_crc.c | |
4 * @author MCD Application Team | |
5 * @version V1.2.0 | |
6 * @date 26-December-2014 | |
7 * @brief CRC HAL module driver. | |
8 * This file provides firmware functions to manage the following | |
9 * functionalities of the Cyclic Redundancy Check (CRC) peripheral: | |
10 * + Initialization and de-initialization functions | |
11 * + Peripheral Control functions | |
12 * + Peripheral State functions | |
13 * | |
14 @verbatim | |
15 ============================================================================== | |
16 ##### How to use this driver ##### | |
17 ============================================================================== | |
18 [..] | |
19 The CRC HAL driver can be used as follows: | |
20 | |
21 (#) Enable CRC AHB clock using __HAL_RCC_CRC_CLK_ENABLE(); | |
22 | |
23 (#) Use HAL_CRC_Accumulate() function to compute the CRC value of | |
24 a 32-bit data buffer using combination of the previous CRC value | |
25 and the new one. | |
26 | |
27 (#) Use HAL_CRC_Calculate() function to compute the CRC Value of | |
28 a new 32-bit data buffer. This function resets the CRC computation | |
29 unit before starting the computation to avoid getting wrong CRC values. | |
30 | |
31 @endverbatim | |
32 ****************************************************************************** | |
33 * @attention | |
34 * | |
35 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> | |
36 * | |
37 * Redistribution and use in source and binary forms, with or without modification, | |
38 * are permitted provided that the following conditions are met: | |
39 * 1. Redistributions of source code must retain the above copyright notice, | |
40 * this list of conditions and the following disclaimer. | |
41 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
42 * this list of conditions and the following disclaimer in the documentation | |
43 * and/or other materials provided with the distribution. | |
44 * 3. Neither the name of STMicroelectronics nor the names of its contributors | |
45 * may be used to endorse or promote products derived from this software | |
46 * without specific prior written permission. | |
47 * | |
48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
49 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
51 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
54 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
55 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
56 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
57 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
58 * | |
59 ****************************************************************************** | |
60 */ | |
61 | |
62 /* Includes ------------------------------------------------------------------*/ | |
63 #include "stm32f4xx_hal.h" | |
64 | |
65 /** @addtogroup STM32F4xx_HAL_Driver | |
66 * @{ | |
67 */ | |
68 | |
69 /** @addtogroup CRC | |
70 * @{ | |
71 */ | |
72 | |
73 #ifdef HAL_CRC_MODULE_ENABLED | |
74 | |
75 /* Private typedef -----------------------------------------------------------*/ | |
76 /* Private define ------------------------------------------------------------*/ | |
77 /* Private macro -------------------------------------------------------------*/ | |
78 /* Private variables ---------------------------------------------------------*/ | |
79 /* Private function prototypes -----------------------------------------------*/ | |
80 /* Private functions ---------------------------------------------------------*/ | |
81 /* Exported functions --------------------------------------------------------*/ | |
82 | |
83 /** @addtogroup CRC_Exported_Functions | |
84 * @{ | |
85 */ | |
86 | |
87 /** @addtogroup CRC_Exported_Functions_Group1 | |
88 * @brief Initialization and de-initialization functions | |
89 * | |
90 @verbatim | |
91 ============================================================================== | |
92 ##### Initialization and de-initialization functions ##### | |
93 ============================================================================== | |
94 [..] This section provides functions allowing to: | |
95 (+) Initialize the CRC according to the specified parameters | |
96 in the CRC_InitTypeDef and create the associated handle | |
97 (+) DeInitialize the CRC peripheral | |
98 (+) Initialize the CRC MSP | |
99 (+) DeInitialize CRC MSP | |
100 | |
101 @endverbatim | |
102 * @{ | |
103 */ | |
104 | |
105 /** | |
106 * @brief Initializes the CRC according to the specified | |
107 * parameters in the CRC_InitTypeDef and creates the associated handle. | |
108 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
109 * the configuration information for CRC | |
110 * @retval HAL status | |
111 */ | |
112 HAL_StatusTypeDef HAL_CRC_Init(CRC_HandleTypeDef *hcrc) | |
113 { | |
114 /* Check the CRC handle allocation */ | |
115 if(hcrc == NULL) | |
116 { | |
117 return HAL_ERROR; | |
118 } | |
119 | |
120 /* Check the parameters */ | |
121 assert_param(IS_CRC_ALL_INSTANCE(hcrc->Instance)); | |
122 | |
123 if(hcrc->State == HAL_CRC_STATE_RESET) | |
124 { | |
125 /* Init the low level hardware */ | |
126 HAL_CRC_MspInit(hcrc); | |
127 } | |
128 | |
129 /* Change CRC peripheral state */ | |
130 hcrc->State = HAL_CRC_STATE_BUSY; | |
131 | |
132 /* Change CRC peripheral state */ | |
133 hcrc->State = HAL_CRC_STATE_READY; | |
134 | |
135 /* Return function status */ | |
136 return HAL_OK; | |
137 } | |
138 | |
139 /** | |
140 * @brief DeInitializes the CRC peripheral. | |
141 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
142 * the configuration information for CRC | |
143 * @retval HAL status | |
144 */ | |
145 HAL_StatusTypeDef HAL_CRC_DeInit(CRC_HandleTypeDef *hcrc) | |
146 { | |
147 /* Check the CRC handle allocation */ | |
148 if(hcrc == NULL) | |
149 { | |
150 return HAL_ERROR; | |
151 } | |
152 | |
153 /* Check the parameters */ | |
154 assert_param(IS_CRC_ALL_INSTANCE(hcrc->Instance)); | |
155 | |
156 /* Change CRC peripheral state */ | |
157 hcrc->State = HAL_CRC_STATE_BUSY; | |
158 | |
159 /* DeInit the low level hardware */ | |
160 HAL_CRC_MspDeInit(hcrc); | |
161 | |
162 /* Change CRC peripheral state */ | |
163 hcrc->State = HAL_CRC_STATE_RESET; | |
164 | |
165 /* Release Lock */ | |
166 __HAL_UNLOCK(hcrc); | |
167 | |
168 /* Return function status */ | |
169 return HAL_OK; | |
170 } | |
171 | |
172 /** | |
173 * @brief Initializes the CRC MSP. | |
174 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
175 * the configuration information for CRC | |
176 * @retval None | |
177 */ | |
178 __weak void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc) | |
179 { | |
180 /* NOTE : This function Should not be modified, when the callback is needed, | |
181 the HAL_CRC_MspInit could be implemented in the user file | |
182 */ | |
183 } | |
184 | |
185 /** | |
186 * @brief DeInitializes the CRC MSP. | |
187 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
188 * the configuration information for CRC | |
189 * @retval None | |
190 */ | |
191 __weak void HAL_CRC_MspDeInit(CRC_HandleTypeDef *hcrc) | |
192 { | |
193 /* NOTE : This function Should not be modified, when the callback is needed, | |
194 the HAL_CRC_MspDeInit could be implemented in the user file | |
195 */ | |
196 } | |
197 | |
198 /** | |
199 * @} | |
200 */ | |
201 | |
202 /** @addtogroup CRC_Exported_Functions_Group2 | |
203 * @brief Peripheral Control functions | |
204 * | |
205 @verbatim | |
206 ============================================================================== | |
207 ##### Peripheral Control functions ##### | |
208 ============================================================================== | |
209 [..] This section provides functions allowing to: | |
210 (+) Compute the 32-bit CRC value of 32-bit data buffer, | |
211 using combination of the previous CRC value and the new one. | |
212 (+) Compute the 32-bit CRC value of 32-bit data buffer, | |
213 independently of the previous CRC value. | |
214 | |
215 @endverbatim | |
216 * @{ | |
217 */ | |
218 | |
219 /** | |
220 * @brief Computes the 32-bit CRC of 32-bit data buffer using combination | |
221 * of the previous CRC value and the new one. | |
222 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
223 * the configuration information for CRC | |
224 * @param pBuffer: pointer to the buffer containing the data to be computed | |
225 * @param BufferLength: length of the buffer to be computed | |
226 * @retval 32-bit CRC | |
227 */ | |
228 uint32_t HAL_CRC_Accumulate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength) | |
229 { | |
230 uint32_t index = 0; | |
231 | |
232 /* Process Locked */ | |
233 __HAL_LOCK(hcrc); | |
234 | |
235 /* Change CRC peripheral state */ | |
236 hcrc->State = HAL_CRC_STATE_BUSY; | |
237 | |
238 /* Enter Data to the CRC calculator */ | |
239 for(index = 0; index < BufferLength; index++) | |
240 { | |
241 hcrc->Instance->DR = pBuffer[index]; | |
242 } | |
243 | |
244 /* Change CRC peripheral state */ | |
245 hcrc->State = HAL_CRC_STATE_READY; | |
246 | |
247 /* Process Unlocked */ | |
248 __HAL_UNLOCK(hcrc); | |
249 | |
250 /* Return the CRC computed value */ | |
251 return hcrc->Instance->DR; | |
252 } | |
253 | |
254 /** | |
255 * @brief Computes the 32-bit CRC of 32-bit data buffer independently | |
256 * of the previous CRC value. | |
257 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
258 * the configuration information for CRC | |
259 * @param pBuffer: Pointer to the buffer containing the data to be computed | |
260 * @param BufferLength: Length of the buffer to be computed | |
261 * @retval 32-bit CRC | |
262 */ | |
263 uint32_t HAL_CRC_Calculate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength) | |
264 { | |
265 uint32_t index = 0; | |
266 | |
267 /* Process Locked */ | |
268 __HAL_LOCK(hcrc); | |
269 | |
270 /* Change CRC peripheral state */ | |
271 hcrc->State = HAL_CRC_STATE_BUSY; | |
272 | |
273 /* Reset CRC Calculation Unit */ | |
274 __HAL_CRC_DR_RESET(hcrc); | |
275 | |
276 /* Enter Data to the CRC calculator */ | |
277 for(index = 0; index < BufferLength; index++) | |
278 { | |
279 hcrc->Instance->DR = pBuffer[index]; | |
280 } | |
281 | |
282 /* Change CRC peripheral state */ | |
283 hcrc->State = HAL_CRC_STATE_READY; | |
284 | |
285 /* Process Unlocked */ | |
286 __HAL_UNLOCK(hcrc); | |
287 | |
288 /* Return the CRC computed value */ | |
289 return hcrc->Instance->DR; | |
290 } | |
291 | |
292 /** | |
293 * @} | |
294 */ | |
295 | |
296 | |
297 /** @addtogroup CRC_Exported_Functions_Group3 | |
298 * @brief Peripheral State functions | |
299 * | |
300 @verbatim | |
301 ============================================================================== | |
302 ##### Peripheral State functions ##### | |
303 ============================================================================== | |
304 [..] | |
305 This subsection permits to get in run-time the status of the peripheral | |
306 and the data flow. | |
307 | |
308 @endverbatim | |
309 * @{ | |
310 */ | |
311 | |
312 /** | |
313 * @brief Returns the CRC state. | |
314 * @param hcrc: pointer to a CRC_HandleTypeDef structure that contains | |
315 * the configuration information for CRC | |
316 * @retval HAL state | |
317 */ | |
318 HAL_CRC_StateTypeDef HAL_CRC_GetState(CRC_HandleTypeDef *hcrc) | |
319 { | |
320 return hcrc->State; | |
321 } | |
322 | |
323 /** | |
324 * @} | |
325 */ | |
326 | |
327 /** | |
328 * @} | |
329 */ | |
330 | |
331 #endif /* HAL_CRC_MODULE_ENABLED */ | |
332 /** | |
333 * @} | |
334 */ | |
335 | |
336 /** | |
337 * @} | |
338 */ | |
339 | |
340 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |