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
|
| dtimer.h文件
#ifndef _DTIMER_H
#define _DTIMER_H
//軟件定時器結構
typedef struct
{
uint32_t SetValue;
uint32_t Target_Ticks;
uint8_t Run_Step;
} Dtimer_Typedef;
//設置軟件定時器的延時值函數，這個目的是在其他地方可以修改更新延時值
void dtimer_set(Dtimer_Typedef *dtimer, uint32_t delayvalue);
//設置軟件定時器延時值并開始計時函數
void dtimer_en(Dtimer_Typedef *dtimer, uint32_t delayvalue);
//設置軟件定時器復位函數
void dtimer_reset(Dtimer_Typedef *dtimer);
//判斷軟件定時器是否剛到（到定時值時第一次會返回true,第2次返回false,相當于上升沿，只執行一次）
bool dtimer_reaching(Dtimer_Typedef *dtimer);
//判斷軟件定時器是否已到（已到定時值時，如果沒有復位會一直返回true）
bool dtimer_reached(Dtimer_Typedef *dtimer);
#endif
dtimer.c文件
#include "main.h"
#include "dtimer.h"
//設置軟件定時器的延時值函數，這個目的是在其他地方可以修改更新延時值
void dtimer_set(Dtimer_Typedef *dtimer, uint32_t delayvalue)
{
if ((*dtimer).Run_Step != 1)
{
(*dtimer).SetValue = delayvalue;
}
}
//設置軟件定時器延時值并開始計時函數,定時值到后，必須dtimer_reset后才會再次執行
void dtimer_en(Dtimer_Typedef *dtimer, uint32_t delayvalue)
{
if ((*dtimer).Run_Step == 0)
{
if(delayvalue>0)
{
(*dtimer).SetValue = delayvalue;
}
(*dtimer).Target_Ticks = millis() + (*dtimer).SetValue;
(*dtimer).Run_Step = 1;
}
}
//設置軟件定時器復位，復位后，遇到dtimer_en才會啟用軟件定時器
void dtimer_reset(Dtimer_Typedef *dtimer)
{
if ((*dtimer).Run_Step != 0)
{
(*dtimer).Run_Step = 0;
}
}
//判斷軟件定時器是否剛到（到定時值時第一次會返回true,第2次返回false,相當于上升沿，只執行一次）
bool dtimer_reaching(Dtimer_Typedef *dtimer)
{
if ((*dtimer).Run_Step == 1)
{
if (millis() > (*dtimer).Target_Ticks)
{
(*dtimer).Run_Step = 2;
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
//判斷軟件定時器是否已到（已到定時值時，如果沒有復位會一直返回true）
bool dtimer_reached(Dtimer_Typedef *dtimer)
{
if (millis() > (*dtimer).Target_Ticks)
{
return true;
}
else
{
return false;
}
}
文件中millis() 為 其他c文件實現的系統毫秒計時返回值，類似于Arduino的中millis()作用，其他單片機可以用定時中斷計數累加，如
volatile static uint32_t MILLIS_CNT = 0;
volatile static uint32_t TEMPMS_CNT = 0;
volatile static uint32_t SECOND_CNT = 0;
void SysTick_Handler(void) //定時器1毫秒中斷調用
{
MILLIS_CNT++;
TEMPMS_CNT++;
if(TEMPMS_CNT==60)
{
SECOND_CNT++;
TEMPMS_CNT = 0;
}
}
uint32_t seconds(void) //獲取系統運行當前秒
{
return SECOND_CNT;
}
uint32_t millis() //獲取系統運行當前毫秒
{
return MILLIS_CNT;
}
void delay(uint32_t time) //傳統的阻塞式毫秒延時函數
{
uint32_t m_times=millis()+time;
while(millis()<m_times);
}
void delayus(uint32_t time) //傳統的阻塞式微秒延時函數
{
uint32_t m_times=micros()+time;
while(micros()<m_times);
}
uint32_t micros(void) //獲取系統運行當前微秒
{
uint32_t ms = millis();
uint32_t systick_value = SysTick->VAL;
uint32_t systick_load = SysTick->LOAD + 1;
uint32_t us = ((systick_load - systick_value) * 1000) / systick_load;
return (ms * 1000 + us);
}
使用方法：比如P01 高電平-亮100ms，然后低電平-滅300ms
一般的方法：延時過程，其他代碼被阻塞，無法執行
int main(void)
{
while(1)
{
P01=1;
delay(100);
P01=0;
delay(300);
其它代碼....
}
}
非阻塞的方法：延時過程，其他代碼正常執行，但P01的延時效果跟傳統一樣
#include "dtimer.h"
static Dtimer_Typedef DT[2]
int main(void)
{
while(1)
{
dtimer_en(&DT[0],100); //軟件定時器0啟用，計時100毫秒
if(dtimer_reaching(&DT[0])) //軟件定時器0延時到，執行一次
{
P01=0; //P01滅
dtimer_reset(&DT[1]); //復位軟件定時器1，避免第二次執行時，下面的dtimer_en不起作用
dtimer_en(&DT[1],300); //軟件定時器1啟用，計時300毫秒
}
else //軟件定時器0延時未到
{
P01=1; //P01亮
}
if(dtimer_reaching(&DT[1])) //軟件定時器1延時到，執行一次
{
dtimer_reset(&DT[0]); //復位軟件定時器0
}
其他代碼...
}
}
while的常規代碼，遇到fun_1 while時，fun_2就會因為阻塞沒有運行到
如：
int i=0;
int main(void)
{
while(1)
{
fun_1();
fun_2();
}
}
void fun_1()
{
代碼1
...
while(i<100)
{
代碼2
...
i++;
}
代碼3
...
}
void fun_2()
{
代碼4
...
}
while的非阻塞式轉換，fun_1()和傳統while一樣，i<100時，會不斷執行條件里面的代碼2.. ,但此時fun_2()并沒有被阻塞
int i=0;
static index=0;
int main(void)
{
while(1)
{
fun_1();
fun_2();
}
}
void fun_1()
{
switch(index)
{
case 0:
代碼1
...
index=1;
break;
case 1:
if(i<100)
{
代碼2
...
i++;
}
else
{
index=2;
}
break;
case 3:
代碼3
...
index=0;
break;
}
}
void fun_2()
{
代碼4
...
}
|
