1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
|
/**
*********************************************************************************************************
* Copyright(c) 2020, Realtek Semiconductor Corporation. All rights reserved.
**********************************************************************************************************
* @file rtl876x_rtc.c
* @brief This file provides all the RTC firmware functions.
* @details
* @author yuan
* @date 2020-11-11
* @version v2.1.0
*********************************************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "rtl876x_rtc.h"
/* Internal defines ------------------------------------------------------------*/
#define REG_FAST_WRITE_BASE_ADDR (0x40000100UL)
#define REG_RTC_FAST_WDATA (0x400001F0UL)
#define REG_RTC_FAST_ADDR (0x400001F4UL)
#define REG_RTC_WR_STROBE (0x400001F8UL)
/**
* @brief Fast write RTC register.
* @param reg_address: the register address.
* @param data: data which write to register.
* @return None
*/
void RTC_WriteReg(uint32_t reg_address, uint32_t data)
{
static bool is_called = false;
if (is_called == false)
{
*((volatile uint32_t *)0x40000014) |= BIT(9);//no need run this every time
is_called = true;
}
/* Write data */
*((volatile uint32_t *)REG_RTC_FAST_WDATA) = data;
/* Write RTC register address. Only offset */
*((volatile uint32_t *)REG_RTC_FAST_ADDR) = reg_address - REG_FAST_WRITE_BASE_ADDR;
*((volatile uint32_t *)REG_RTC_WR_STROBE) = 1;
}
/**
* @brief Reset RTC.
* @param None
* @return None
*/
void RTC_DeInit(void)
{
/* Stop RTC counter */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & RTC_START_CLR));
/* Disable wakeup signal */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & RTC_NV_EN_CLR));
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & RTC_WAKEUP_EN_CLR));
/* Clear all RTC interrupt & wakeup */
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), RTC_ALL_INT_CLR_SET | RTC_ALL_WAKEUP_CLR_SET);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), 0);
/* Clear prescale register */
RTC_WriteReg((uint32_t)(&(RTC->PRESCALER)), 0);
/* Clear all comparator register */
RTC_WriteReg((uint32_t)(&(RTC->COMP0)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP1)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP2)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP3)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP0GT)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP1GT)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP2GT)), 0);
RTC_WriteReg((uint32_t)(&(RTC->COMP3GT)), 0);
RTC_WriteReg((uint32_t)(&(RTC->PRE_COMP)), 0);
/* Reset prescale counter and counter */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), RTC_PRE_COUNTER_RST_Msk | RTC_COUNTER_RST_Msk);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->CR0)), 0x0);
}
/**
* @brief Set RTC prescaler value.
* @param value: the prescaler value to be set.Should be no more than 12 bits!
* @return None
*/
void RTC_SetPrescaler(uint16_t value)
{
RTC_WriteReg((uint32_t)(&(RTC->PRESCALER)), value & 0xFFF);
}
/**
* @brief Start or stop RTC peripheral.
* @param NewState: new state of RTC peripheral.
* This parameter can be the following values:
* @arg ENABLE: start RTC.
* @arg DISABLE: stop RTC.
* @return None
*/
void RTC_Cmd(FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState == ENABLE)
{
/* Start RTC */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), RTC->CR0 | RTC_START_Msk);
}
else
{
/* Stop RTC */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), RTC->CR0 & RTC_START_CLR);
}
}
/**
* @brief Enable or disable the specified RTC interrupts.
* @param RTC_INT: specifies the RTC interrupt source to be enabled or disabled.
* This parameter can be any combination of the following values:
* @arg RTC_INT_TICK: tick interrupt
* @arg RTC_INT_OVF: counter overflow interrupt
* @arg RTC_INT_PRE_CMP: prescale compare interrupt
* @arg RTC_INT_PRE_CMP3: prescale & compare 3 interrupt
* @arg RTC_INT_CMP0: compare 0 interrupt
* @arg RTC_INT_CMP1: compare 1 interrupt
* @arg RTC_INT_CMP2: compare 2 interrupt
* @arg RTC_INT_CMP3: compare 3 interrupt
* @param NewState: new state of the specified RTC interrupt.
* This parameter can be: ENABLE or DISABLE.
* @return None.
*/
void RTC_INTConfig(E_RTC_INT RTC_INT, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_RTC_INT(RTC_INT));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState == ENABLE)
{
/* Enable the selected RTC comparator interrupt */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 | RTC_INT));
}
else
{
/* Disable the selected RTC comparator interrupt */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & (~RTC_INT)));
}
}
/**
* @brief Enable or disable the specified RTC wakeup function.
* @param RTC_WK: specifies the RTC wakeup function to be enabled or disabled.
* This parameter can be any combination of the following values:
* @arg RTC_WK_TICK: tick wakeup function
* @arg RTC_WK_OVF: tick wakeup function
* @arg RTC_WK_PRE_CMP: prescale compare wakeup function
* @arg RTC_WK_PRE_CMP3: prescale & compare 3 wakeup function
* @arg RTC_WK_COMP0GT: compare 0 gt wakeup function
* @arg RTC_WK_COMP1GT: compare 1 gt wakeup function
* @arg RTC_WK_COMP2GT: compare 2 gt wakeup function
* @arg RTC_WK_COMP3GT: compare 3 gt wakeup function
* @arg RTC_WK_CMP0: compare 0 wakeup function
* @arg RTC_WK_CMP1: compare 1 wakeup function
* @arg RTC_WK_CMP2: compare 2 wakeup function
* @arg RTC_WK_CMP3: compare 3 wakeup function
* @param NewState: new state of the specified RTC wakeup function.
* This parameter can be: ENABLE or DISABLE.
* @return None.
*/
void RTC_WKConfig(E_RTC_WK RTC_WK, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_RTC_WK(RTC_WK));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState == ENABLE)
{
/* Enable the selected RTC comparator interrupt */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 | RTC_WK));
}
else
{
/* Disable the selected RTC comparator interrupt */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & (~RTC_WK)));
}
}
/**
* @brief Enable interrupt signal to CPU NVIC.
* @param This parameter can be: ENABLE or DISABLE.
* @return None.
*/
void RTC_NvCmd(FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 | RTC_NV_EN_Msk));
}
else
{
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & RTC_NV_EN_CLR));
}
}
/**
* @brief Enable or disable system wake up of RTC.
* @param NewState: new state of the wake up function.
* This parameter can be: ENABLE or DISABLE.
* @return None
*/
void RTC_SystemWakeupConfig(FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState == ENABLE)
{
/* Enable system wake up */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 | RTC_WAKEUP_EN_Msk));
}
else
{
/* Disable system wake up */
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0 & RTC_WAKEUP_EN_CLR));
}
}
/**
* @brief Reset counter value of RTC.
* @param None
* @return None
*/
void RTC_ResetCounter(void)
{
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0) | RTC_COUNTER_RST_Msk);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0) & RTC_COUNTER_RST_CLR);
}
/**
* @brief Reset prescaler counter value of RTC.
* @param None
* @return None
*/
void RTC_ResetPrescalerCounter(void)
{
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0) | RTC_PRE_COUNTER_RST_Msk);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->CR0)), (RTC->CR0) & RTC_PRE_COUNTER_RST_CLR);
}
/**
* @brief Checks whether the specified RTC interrupt is set or not.
* @param RTC_INT: specifies the RTC interrupt source to be enabled or disabled.
* This parameter can be any combination of the following values:
* @arg RTC_INT_TICK: RTC tick interrupt source
* @arg RTC_INT_PRE_COMP: prescale compare interrupt source
* @arg RTC_INT_PRE_COMP3: prescale & compare 3 interrupt source
* @arg RTC_INT_COMP0: compare 0 interrupt source
* @arg RTC_INT_COMP1: compare 1 interrupt source
* @arg RTC_INT_COMP2: compare 2 interrupt source
* @arg RTC_INT_COMP3: compare 3 interrupt source
* @return The new state of RTC_INT (SET or RESET).
*/
ITStatus RTC_GetINTStatus(E_RTC_INT RTC_INT)
{
/* Check the parameters */
assert_param(IS_RTC_CONFIG_INT(RTC_INT));
ITStatus int_status = RESET;
if ((RTC->INT_SR & ((uint32_t)RTC_INT >> 8)) != (uint32_t)RESET)
{
int_status = SET;
}
/* Return the RTC_INT status */
return int_status;
}
/**
* @brief Clear the interrupt pending bits of RTC.
* @param RTC_INT: specifies the RTC interrupt flag to clear.
* This parameter can be any combination of the following values:
* @arg RTC_INT_TICK: RTC tick interrupt source
* @arg RTC_INT_OVF: RTC counter overflow interrupt source
* @arg RTC_INT_PRE_COMP: prescale compare interrupt source
* @arg RTC_INT_PRE_COMP3: prescale & compare 3 interrupt source
* @arg RTC_INT_COMP0: compare 0 interrupt source
* @arg RTC_INT_COMP1: compare 1 interrupt source
* @arg RTC_INT_COMP2: compare 2 interrupt source
* @arg RTC_INT_COMP3: compare 3 interrupt source
* @return None
*/
void RTC_ClearINTPendingBit(E_RTC_INT RTC_INT)
{
/* Check the parameters */
assert_param(IS_RTC_INT(RTC_INT));
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), (uint32_t)RTC_INT >> 8);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), 0);
}
/**
* @brief Checks whether the specified RTC wakeup state is set or not.
* @param RTC_WK: specifies the RTC interrupt source to be enabled or disabled.
* This parameter can be any combination of the following values:
* @arg RTC_WK_TICK: tick wakeup function
* @arg RTC_WK_OVF: tick wakeup function
* @arg RTC_WK_PRE_CMP: prescale compare wakeup function
* @arg RTC_WK_PRE_CMP3: prescale & compare 3 wakeup function
* @arg RTC_WK_COMP0GT: compare 0 gt wakeup function
* @arg RTC_WK_COMP1GT: compare 1 gt wakeup function
* @arg RTC_WK_COMP2GT: compare 2 gt wakeup function
* @arg RTC_WK_COMP3GT: compare 3 gt wakeup function
* @arg RTC_WK_CMP0: compare 0 wakeup function
* @arg RTC_WK_CMP1: compare 1 wakeup function
* @arg RTC_WK_CMP2: compare 2 wakeup function
* @arg RTC_WK_CMP3: compare 3 wakeup function
* @return The new state of RTC_INT (SET or RESET).
*/
ITStatus RTC_GetWakeupStatus(E_RTC_WK RTC_WK)
{
/* Check the parameters */
assert_param(IS_RTC_CONFIG_INT(RTC_WK));
ITStatus wakeup_status = RESET;
if ((RTC->INT_SR & ((uint32_t)RTC_WK >> 8)) != (uint32_t)RESET)
{
wakeup_status = SET;
}
/* Return the RTC_INT status */
return wakeup_status;
}
/**
* @brief Clear the wakeup status bits of RTC.
* @param RTC_WK: specifies the RTC wakeup flag to clear.
* This parameter can be any combination of the following values:
* @arg RTC_WK_TICK: tick wakeup function
* @arg RTC_WK_OVF: tick wakeup function
* @arg RTC_WK_PRE_CMP: prescale compare wakeup function
* @arg RTC_WK_PRE_CMP3: prescale & compare 3 wakeup function
* @arg RTC_WK_COMP0GT: compare 0 gt wakeup function
* @arg RTC_WK_COMP1GT: compare 1 gt wakeup function
* @arg RTC_WK_COMP2GT: compare 2 gt wakeup function
* @arg RTC_WK_COMP3GT: compare 3 gt wakeup function
* @arg RTC_WK_CMP0: compare 0 wakeup function
* @arg RTC_WK_CMP1: compare 1 wakeup function
* @arg RTC_WK_CMP2: compare 2 wakeup function
* @arg RTC_WK_CMP3: compare 3 wakeup function
* @return None
*/
void RTC_ClearWakeupStatusBit(E_RTC_WK RTC_WK)
{
/* Check the parameters */
assert_param(IS_RTC_WK(RTC_WK));
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), (uint32_t)RTC_WK >> 8);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), 0);
}
/**
* @brief Clear the interrupt pending bit of the select comparator of RTC.
* @param index: the comparator number 0~3.
* @return None
*/
void RTC_ClearCompINT(E_RTC_COMP_INDEX index)
{
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), BIT(RTC_COMP0_CLR_Pos + index));
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), 0);
}
/**
* @brief Clear the overflow interrupt pending bit of RTC.
* @param None
* @return None
*/
void RTC_ClearOverFlowINT(void)
{
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), RTC_OVERFLOW_CLR_SET);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), 0);
}
/**
* @brief Clear the tick interrupt pending bit of RTC.
* @param None
* @return None
*/
void RTC_ClearTickINT(void)
{
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), RTC_TICK_CLR_SET);
__NOP();
__NOP();
RTC_WriteReg((uint32_t)(&(RTC->INT_CLR)), 0);
}
/******************* (C) COPYRIGHT 2020 Realtek Semiconductor Corporation *****END OF FILE****/
|
