1 /*
2 ******************************************************************************
3 * @file HAL_OPA.c
4 * @version V1.0.0
5 * @date 2020
6 * @brief OPA HAL module driver.
7 * This file provides firmware functions to manage the following
8 * functionalities of the Operational Amplifier (OPA).
9 * @ Initialization and de-initialization functions
10 * @ IO operation functions
11 * @ Peripheral Control functions
12 ******************************************************************************
13 */
14 #include "ACM32Fxx_HAL.h"
15
16 /************************************************************************
17 * function : HAL_OPA_MspInit
18 * Description: OPA MCU specific initiation, such as IO share, module clock, ...
19 * input :
20 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
21 * return: none
22 ************************************************************************/
HAL_OPA_MspInit(OPA_HandleTypeDef * hopa)23 __weak void HAL_OPA_MspInit(OPA_HandleTypeDef* hopa)
24 {
25 /*
26 NOTE : This function should be modified by the user.
27 */
28
29 /* For Example */
30 GPIO_InitTypeDef GPIO_OPA;
31
32 /* Enable Clock */
33 System_Module_Enable(EN_OPA);
34
35 if(hopa->Init.OpaX == OPA1)
36 {
37 /* OPA1 GPIO inition VINP:PC4*/
38 /* OPA1 GPIO inition VINM:PA3*/
39 /* OPA1 GPIO inition OPA1_VOUT:PA2*/
40 GPIO_OPA.Pin = GPIO_PIN_2 | GPIO_PIN_3;
41 GPIO_OPA.Mode = GPIO_MODE_ANALOG;
42 GPIO_OPA.Pull = GPIO_NOPULL;
43 HAL_GPIO_Init(GPIOA, &GPIO_OPA);
44
45 GPIO_OPA.Pin = GPIO_PIN_4;
46 GPIO_OPA.Mode = GPIO_MODE_ANALOG;
47 GPIO_OPA.Pull = GPIO_NOPULL;
48 HAL_GPIO_Init(GPIOC, &GPIO_OPA);
49 }
50
51 else if(hopa->Init.OpaX == OPA2)
52 {
53 /* OPA2 GPIO inition VINP:PA7*/
54 /* OPA2 GPIO inition VINM:PC5*/
55 /* OPA2 GPIO inition OPA2_VOUT:PA6*/
56 GPIO_OPA.Pin = GPIO_PIN_6 | GPIO_PIN_7;
57 GPIO_OPA.Mode = GPIO_MODE_ANALOG;
58 GPIO_OPA.Pull = GPIO_NOPULL;
59 HAL_GPIO_Init(GPIOA, &GPIO_OPA);
60
61 GPIO_OPA.Pin = GPIO_PIN_5;
62 GPIO_OPA.Mode = GPIO_MODE_ANALOG;
63 GPIO_OPA.Pull = GPIO_NOPULL;
64 HAL_GPIO_Init(GPIOC, &GPIO_OPA);
65
66 }
67 else if(hopa->Init.OpaX == OPA3)
68 {
69 /* OPA3 GPIO inition VINP:PA4*/
70 /* OPA3 GPIO inition VINM:PB10*/
71 /* OPA3 GPIO inition OPA2_VOUT:PB1*/
72 GPIO_OPA.Pin = GPIO_PIN_4;
73 GPIO_OPA.Mode = GPIO_MODE_ANALOG;
74 GPIO_OPA.Pull = GPIO_NOPULL;
75 HAL_GPIO_Init(GPIOA, &GPIO_OPA);
76
77 GPIO_OPA.Pin = GPIO_PIN_1 | GPIO_PIN_10;
78 GPIO_OPA.Mode = GPIO_MODE_ANALOG;
79 GPIO_OPA.Pull = GPIO_NOPULL;
80 HAL_GPIO_Init(GPIOB, &GPIO_OPA);
81 }
82 }
83
84 /************************************************************************
85 * function : HAL_OPA_MspDeInit
86 * Description: OPA MCU De-initiation, such as IO share, module clock, ...
87 * input :
88 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
89 * return: none
90 ************************************************************************/
HAL_OPA_MspDeInit(OPA_HandleTypeDef * hopa)91 __weak void HAL_OPA_MspDeInit(OPA_HandleTypeDef* hopa)
92 {
93 /*
94 NOTE : This function should be modified by the user.
95 */
96
97 /* For Example */
98
99 /* Reset the OPA */
100 System_Module_Reset(RST_OPA);
101 /* Disable Clock */
102 System_Module_Disable(EN_OPA);
103
104 }
105
106 /************************************************************************
107 * function : HAL_OPA_Init
108 * Description: opa initial with parameters.
109 * input :
110 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
111 ************************************************************************/
HAL_OPA_Init(OPA_HandleTypeDef * hopa)112 HAL_StatusTypeDef HAL_OPA_Init(OPA_HandleTypeDef* hopa)
113 {
114 uint32_t u32RegTemp, u32NvrTrimValue;
115 __IO uint32_t *gu32RegCrx;
116 uint8_t trim_value;
117
118 /* Check the OPA handle allocation */
119 if (hopa == NULL)
120 {
121 return HAL_ERROR;
122 }
123
124 /* Check the parameters */
125 if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
126 if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
127 if(!IS_OPA_ALL_HSM(hopa->Init.Hsm)) return HAL_ERROR;
128 if(!IS_OPA_ALL_GAIN(hopa->Init.Gain)) return HAL_ERROR;
129 if(!IS_OPA_ALL_POL(hopa->Init.PolSel)) return HAL_ERROR;
130 if(!IS_OPA_ALL_MODE(hopa->Init.OpaMode)) return HAL_ERROR;
131 if(!IS_OPA_ALL_VINP(hopa->Init.VinPSel)) return HAL_ERROR;
132 if(!IS_OPA_ALL_OUT(hopa->Init.OutSel)) return HAL_ERROR;
133 if(!IS_OPA_ALL_VINM0(hopa->Init.VinM0En)) return HAL_ERROR;
134 if(!IS_OPA_ALL_TRIM(hopa->Init.TrimEn)) return HAL_ERROR;
135
136 if(hopa->Init.OpaX == OPA1)
137 gu32RegCrx = &hopa->Instance->OPA1_CSR;
138 else if(hopa->Init.OpaX == OPA2)
139 gu32RegCrx = &hopa->Instance->OPA2_CSR;
140 else if(hopa->Init.OpaX == OPA3)
141 gu32RegCrx = &hopa->Instance->OPA3_CSR;
142
143 /* Init the low level hardware : GPIO, CLOCK */
144 HAL_OPA_MspInit(hopa);
145
146 if(READ_BIT(*gu32RegCrx, OPA_CSR_LOCK))
147 {
148 System_Module_Reset(RST_OPA);
149 }
150
151 u32RegTemp = *gu32RegCrx;
152
153 u32RegTemp = ((hopa->Init.Hsm << 28) & OPA_CSR_HSM) | \
154 ((hopa->Init.Gain << OPA_CSR_GAIN_SEL_POS) & OPA_CSR_GAIN_SEL_MASK) | \
155 ((hopa->Init.PolSel << OPA_CSR_POL_SEL_POS) & OPA_CSR_POL_SEL_MASK) | \
156 ((hopa->Init.VinM0En << 20) & OPA_CSR_VINM0_SEL_POS) | \
157 ((hopa->Init.OpaMode << OPA_CSR_MODE_SEL_POS) & OPA_CSR_MODE_SEL_MASK) | \
158 ((hopa->Init.VinPSel << OPA_CSR_VINP_SEL_POS) & OPA_CSR_VINP_SEL_MASK) | \
159 ((hopa->Init.OutSel << OPA_CSR_OUT_SEL_POS) & OPA_CSR_OUT_SEL_MASK);
160
161 *gu32RegCrx = u32RegTemp;
162
163 /* Enable the opa */
164 SET_BIT(*gu32RegCrx, OPA_CSR_EN);
165
166 if(hopa->Init.TrimEn == OPA_CSR_TRIM_ENABLE)
167 {
168 /* Trim the OPA_CSR_CAL_H N channel */
169 SET_BIT(*gu32RegCrx, OPA_CSR_CAL_NEN);
170 CLEAR_BIT(*gu32RegCrx, OPA_CSR_CAL_PEN);
171
172 for(trim_value=0;trim_value<31;trim_value++)
173 {
174 MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSN_MASK,(trim_value)<<OPA_CSR_TRIM_OSN_POS);
175 System_Delay(1000);
176 if(READ_BIT(*gu32RegCrx,OPA_CSR_CAL_OUT)) break;
177 }
178 /* Trim the OPA_CSR_CAL_L P channel */
179 SET_BIT(*gu32RegCrx, OPA_CSR_CAL_PEN);
180 CLEAR_BIT(*gu32RegCrx, OPA_CSR_CAL_NEN);
181
182 for(trim_value=0;trim_value<31;trim_value++)
183 {
184 MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSP_MASK,(trim_value)<<OPA_CSR_TRIM_OSP_POS);
185 System_Delay(1000);
186 if(READ_BIT(*gu32RegCrx,OPA_CSR_CAL_OUT)) break;
187 }
188 }
189 else
190 {
191 /* Use the Trim value */
192 u32NvrTrimValue = *(volatile uint32_t*)(0x0008024C+(hopa->Init.OpaX-1)*4); //Read the OPA trim value;
193 if(((~(u32NvrTrimValue>>16))&0xFFFF) != (u32NvrTrimValue&0xFFFF)) return HAL_ERROR;
194
195 u32NvrTrimValue = u32NvrTrimValue & 0xFFFF;
196
197 MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSN_MASK,((u32NvrTrimValue&0x1F)<<OPA_CSR_TRIM_OSN_POS));
198
199 MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSP_MASK,(((u32NvrTrimValue>>5)&0x1F)<<OPA_CSR_TRIM_OSP_POS));
200 }
201
202 /* enable the trim*/
203 SET_BIT(*gu32RegCrx, OPA_CSR_CAL_PEN);
204 SET_BIT(*gu32RegCrx, OPA_CSR_CAL_NEN);
205
206 return HAL_OK;
207 }
208
209 /************************************************************************
210 * function : HAL_OPA_DeInit
211 * Description: opa De-initial with parameters.
212 * input :
213 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
214 ************************************************************************/
HAL_OPA_DeInit(OPA_HandleTypeDef * hopa)215 HAL_StatusTypeDef HAL_OPA_DeInit(OPA_HandleTypeDef* hopa)
216 {
217 /* Check the OPA handle allocation */
218 if (hopa == NULL)
219 {
220 return HAL_ERROR;
221 }
222
223 HAL_OPA_MspDeInit(hopa);
224
225 memset(&hopa->Init, 0, sizeof(hopa->Init));
226
227 return HAL_OK;
228 }
229 /************************************************************************
230 * function : HAL_OPA_Enable
231 * Description: opa enable.
232 * input :
233 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
234 ************************************************************************/
HAL_OPA_Enable(OPA_HandleTypeDef * hopa)235 HAL_StatusTypeDef HAL_OPA_Enable(OPA_HandleTypeDef* hopa)
236 {
237 uint32_t u32RegTemp;
238 __IO uint32_t *gu32RegCrx;
239
240 /* Check the OPA handle allocation */
241 if (hopa == NULL)
242 {
243 return HAL_ERROR;
244 }
245
246 /* Check the parameters */
247 if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
248 if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
249
250 if(hopa->Init.OpaX == OPA1)
251 gu32RegCrx = &hopa->Instance->OPA1_CSR;
252 else if(hopa->Init.OpaX == OPA2)
253 gu32RegCrx = &hopa->Instance->OPA2_CSR;
254 else if(hopa->Init.OpaX == OPA3)
255 gu32RegCrx = &hopa->Instance->OPA3_CSR;
256
257 /* Enable the opa */
258 SET_BIT(*gu32RegCrx, OPA_CSR_EN);
259
260 return HAL_OK;
261 }
262
263 /************************************************************************
264 * function : HAL_OPA_Disable
265 * Description: opa disable.
266 * input :
267 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
268 ************************************************************************/
HAL_OPA_Disable(OPA_HandleTypeDef * hopa)269 HAL_StatusTypeDef HAL_OPA_Disable(OPA_HandleTypeDef* hopa)
270 {
271 uint32_t u32RegTemp;
272 __IO uint32_t *gu32RegCrx;
273
274 /* Check the OPA handle allocation */
275 if (hopa == NULL)
276 {
277 return HAL_ERROR;
278 }
279
280 /* Check the parameters */
281 if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
282 if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
283
284 if(hopa->Init.OpaX == OPA1)
285 gu32RegCrx = &hopa->Instance->OPA1_CSR;
286 else if(hopa->Init.OpaX == OPA2)
287 gu32RegCrx = &hopa->Instance->OPA2_CSR;
288 else if(hopa->Init.OpaX == OPA3)
289 gu32RegCrx = &hopa->Instance->OPA3_CSR;
290
291 /* Disable the opa */
292 CLEAR_BIT(*gu32RegCrx, OPA_CSR_EN);
293
294 return HAL_OK;
295 }
296
297 /************************************************************************
298 * function : HAL_OPA_Lock
299 * Description: opa lock.
300 * input :
301 * OPA_HandleTypeDef *hopa: pointer to opa handle structure
302 ************************************************************************/
HAL_OPA_Lock(OPA_HandleTypeDef * hopa)303 HAL_StatusTypeDef HAL_OPA_Lock(OPA_HandleTypeDef* hopa)
304 {
305 uint32_t u32RegTemp;
306 __IO uint32_t *gu32RegCrx;
307
308 /* Check the OPA handle allocation */
309 if (hopa == NULL)
310 {
311 return HAL_ERROR;
312 }
313
314 /* Check the parameters */
315 if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
316 if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
317
318 if(hopa->Init.OpaX == OPA1)
319 gu32RegCrx = &hopa->Instance->OPA1_CSR;
320 else if(hopa->Init.OpaX == OPA2)
321 gu32RegCrx = &hopa->Instance->OPA2_CSR;
322 else if(hopa->Init.OpaX == OPA3)
323 gu32RegCrx = &hopa->Instance->OPA3_CSR;
324
325 /* Lock the opa */
326 SET_BIT(*gu32RegCrx, OPA_CSR_LOCK);
327
328 return HAL_OK;
329 }
330