├── LICENSE
├── Makefile
├── README.md
├── device
└── usb
│ ├── usb.c
│ ├── usb.h
│ ├── usb_rx.S
│ └── usb_tx.S
├── main.c
├── main.h
├── mcu
├── peripherals
│ └── mcu_gpio.h
├── std_lib
│ ├── Release_Notes.html
│ ├── inc
│ │ ├── stm8s.h
│ │ ├── stm8s_adc1.h
│ │ ├── stm8s_adc2.h
│ │ ├── stm8s_awu.h
│ │ ├── stm8s_beep.h
│ │ ├── stm8s_can.h
│ │ ├── stm8s_clk.h
│ │ ├── stm8s_exti.h
│ │ ├── stm8s_flash.h
│ │ ├── stm8s_gpio.h
│ │ ├── stm8s_i2c.h
│ │ ├── stm8s_itc.h
│ │ ├── stm8s_iwdg.h
│ │ ├── stm8s_rst.h
│ │ ├── stm8s_spi.h
│ │ ├── stm8s_tim1.h
│ │ ├── stm8s_tim2.h
│ │ ├── stm8s_tim3.h
│ │ ├── stm8s_tim4.h
│ │ ├── stm8s_tim5.h
│ │ ├── stm8s_tim6.h
│ │ ├── stm8s_uart1.h
│ │ ├── stm8s_uart2.h
│ │ ├── stm8s_uart3.h
│ │ └── stm8s_wwdg.h
│ └── src
│ │ ├── stm8s_adc1.c
│ │ ├── stm8s_adc2.c
│ │ ├── stm8s_awu.c
│ │ ├── stm8s_beep.c
│ │ ├── stm8s_can.c
│ │ ├── stm8s_clk.c
│ │ ├── stm8s_exti.c
│ │ ├── stm8s_flash.c
│ │ ├── stm8s_gpio.c
│ │ ├── stm8s_i2c.c
│ │ ├── stm8s_itc.c
│ │ ├── stm8s_iwdg.c
│ │ ├── stm8s_rst.c
│ │ ├── stm8s_spi.c
│ │ ├── stm8s_tim1.c
│ │ ├── stm8s_tim2.c
│ │ ├── stm8s_tim3.c
│ │ ├── stm8s_tim4.c
│ │ ├── stm8s_tim5.c
│ │ ├── stm8s_tim6.c
│ │ ├── stm8s_uart1.c
│ │ ├── stm8s_uart2.c
│ │ ├── stm8s_uart3.c
│ │ └── stm8s_wwdg.c
├── stm8_interrupt_vector.c
├── stm8s003f3.ini
├── stm8s003f3.lsf
├── stm8s_conf.h
├── stm8s_it.c
└── stm8s_it.h
├── target
└── target.s19
└── utility
├── macros.c
└── macros.h
/Makefile:
--------------------------------------------------------------------------------
1 | #==========================================================
2 | # Makefile for STM8
3 | # Denis Zheleznyakov aka ZiB @ http://ziblog.ru
4 | #==========================================================
5 |
6 | SRC_C = usb.c
7 | SRC_C += main.c
8 | SRC_C += macros.c
9 | SRC_C += stm8_interrupt_vector.c
10 | SRC_C += stm8s_it.c
11 | SRC_C += stm8s_clk.c
12 | SRC_C += stm8s_tim1.c
13 | SRC_C += stm8s_tim2.c
14 | SRC_C += stm8s_tim4.c
15 | SRC_C += stm8s_uart1.c
16 |
17 | SRC_S += usb_rx.S
18 | SRC_S += usb_tx.S
19 |
20 | CROSS_PATH = D:/Tools/Cosmic/
21 | CROSS = $(CROSS_PATH)/4.3.7/
22 |
23 | INCLUDES += -imcu
24 | INCLUDES += -imcu/peripherals
25 | INCLUDES += -imcu/startup
26 | INCLUDES += -imcu/std_lib/inc
27 | INCLUDES += -imcu/std_lib/src
28 | INCLUDES += -idevice
29 | INCLUDES += -idevice/usb
30 | INCLUDES += -iutility
31 |
32 | VPATH += mcu
33 | VPATH += mcu/peripherals
34 | VPATH += mcu/startup
35 | VPATH += mcu/std_lib/inc
36 | VPATH += mcu/std_lib/src
37 | VPATH += device
38 | VPATH += device/usb
39 | VPATH += utility
40 |
41 | FLAGS_C = +debug +warn +modsl0 -pxp -pp +fast +split -l -gge -pge
42 |
43 | all: clean
44 | @make -s -j job
45 | @echo '-----------------------------------------------------------'
46 | @$(CROSS)cobj -n target/target.sm8 | $(CROSS_PATH)cosmic_format 'mcu/stm8s003f3.lsf'
47 | @make -s mcu_program
48 |
49 | job: target.elf
50 |
51 | git:
52 | @C:/Tools/git/extensions/gitex browse .
53 |
54 | git_commit:
55 | @C:/Tools/git/extensions/gitex commit .
56 |
57 | mcu_all: all
58 | @make -s mcu_program
59 |
60 | %.elf: $(SRC_C:%.c=target/%.o) $(SRC_S:%.S=target/%.o)
61 | @echo '-----------------------------------------------------------'
62 | @echo linking: $@
63 | @$(CROSS)clnk -l'$(CROSS)/Lib' -o'target/target.sm8' -m'target/target.map' -sa 'mcu/*.lsf'
64 | @$(CROSS)cvdwarf target/target.sm8
65 | @$(CROSS)chex -o target/target.s19 target/target.sm8
66 | @rm -f target/*.o
67 |
68 | $(SRC_C:%.c=target/%.o): target/%.o: %.c
69 | @$(CROSS)cxstm8 $(FLAGS_C) $(INCLUDES) -i. -i$(CROSS)/Hstm8 -cl'target' -co'target' $<
70 |
71 | $(SRC_S:%.S=target/%.o): target/%.o: %.S
72 | @$(CROSS)cxstm8 +debug +warn -l -no $(INCLUDES) -i. -i$(CROSS)/Hstm8 -cl'target' -co'target' $<
73 |
74 | size:
75 | @echo '-----------------------------------------------------------'
76 | @$(CROSS)cobj -n target/target.sm8 | $(CROSS_PATH)cosmic_format 'mcu/stm8s003f3.lsf'
77 |
78 | clean:
79 | @echo '-----------------------------------------------------------'
80 | @mkdir -p target
81 | @rm -f target/*.*
82 |
83 | mcu_program:
84 | @D:/Tools/STMicroelectronics/toolset/stvp/STVP_CmdLine.exe -BoardName=ST-LINK -Device=STM8S003F3 -Port=USB -ProgMode=SWIM -no_loop -no_log -FileProg=target/target.s19
85 |
86 | mcu_restart:
87 | @D:/Tools/STMicroelectronics/toolset/stvd/gdb7.exe --quiet --command=mcu/stm8s003f3.ini
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 2014-02-STM8S-USB
2 | =================
3 |
4 | Sowftware USB on STM8S
5 |
--------------------------------------------------------------------------------
/device/usb/usb.c:
--------------------------------------------------------------------------------
1 | /*
2 | * File: usb.c
3 | * Date: 07.02.2014
4 | * Denis Zheleznyakov aka ZiB @ http://ziblog.ru
5 | */
6 |
7 | #include "main.h"
8 |
9 | extern void usb_tx(void);
10 |
11 | uint8_t usb_rx_buffer[16];
12 |
13 | uint8_t * usb_tx_buffer_pointer;
14 |
15 | uint8_t usb_tx_count;
16 | uint8_t usb_rx_count;
17 |
18 | enum usb_settings
19 | {
20 | USB_VENDOR_ID_LOW = 0x11, //
21 | USB_VENDOR_ID_HIGH = 0x22,
22 | USB_DEVICE_ID_LOW = 0x33, //
23 | USB_DEVICE_ID_HIGH = 0x44,
24 | USB_DEVICE_VERSION_LOW = 0x55, //
25 | USB_DEVICE_VERSION_HIGH = 0x66
26 | };
27 |
28 | const uint8_t usb_device_descriptor[] = { 18, // размер дескриптора (байт)
29 | 1, // тип дескриптора - устройство = 1
30 | 0x00, 0x01, // номер спецификации USB (USB 1.1 как 0x0110 и USB 1.0 как 0x0100)
31 | 0xFF, // код класса назначен вендором !
32 | 0x00, // код подкласса
33 | 0, // код протокола
34 | 8, // максимальный размер пакета, для LS 8 байт
35 | USB_VENDOR_ID_LOW, USB_VENDOR_ID_HIGH, // VID
36 | USB_DEVICE_ID_LOW, USB_DEVICE_ID_HIGH,// PID
37 | USB_DEVICE_VERSION_LOW, USB_DEVICE_VERSION_HIGH, // версия устройства
38 | 0, // индекс строки описания производителя
39 | 0, // индекс строки описания продукта
40 | 0, // индекс строки серийного номера
41 | 1, // кол-во конфигураций
42 | };
43 |
44 | const uint8_t usb_configuration_descriptor[] = { 9, // размер дескриптора (байт)
45 | 2, // тип дескриптора - конфигурация = 2
46 | 18, 0, // полная длина возвращаемых данных в байтах
47 | 1, // количество интерфейсов
48 | 1, // номер конфигурации
49 | 0, // индекс строки описания конфигурации
50 | 0x80, // аттрибуты (D7 всегда 1, D6 - питание не от USB, D5 - пробуждение)
51 | 50, // максимальный ток потребления в мА деленный на 2
52 | };
53 |
54 | const uint8_t usb_interface_descriptor[] = { 9, // размер дескриптора (байт)
55 | 4, // тип дескриптора - интерфейс = 4
56 | 1, // количество интерфейсов
57 | 0, // альтернативная установка (не понял для чего)
58 | 1, // кол-во точек используемых интерфейсом
59 | 0, // код класса
60 | 0, // код подкласса
61 | 0, // код протокола
62 | 0, // индекс строки описания интерфейса
63 | };
64 |
65 | const uint8_t usb_endpoint_descriptor[] = { 7, // размер дескриптора (байт)
66 | 5, // тип дескриптора - конечная точка = 5
67 | 0x81, // адрес и направление конечной точки (IN 0x81)
68 | 0x03, // аттрибут - тип передач прерывание
69 | 8, 0, // максимальный размер пакета, для LS 8 байт
70 | 10 // интервал опроса конечной точки в фреймах (для LS - 1 мс)
71 | };
72 |
73 | enum usb_events_list
74 | {
75 | USB_EVENT_NO = 0, //
76 | USB_EVENT_RECEIVE_SETUP_DATA = 1, // приняты данные токена SETUP
77 | USB_EVENT_READY_DATA_IN = 2, // готовы данные для передачи в ПК
78 | USB_EVENT_WAIT_DATA_IN = 3, // ожидание готовности данных для передачи в ПК
79 | USB_EVENT
80 | };
81 |
82 | enum usb_states_list
83 | {
84 | USB_STATE_IDLE = 0, //
85 | USB_STATE_SETUP = 1,
86 | USB_STATE_IN = 2,
87 | USB_STATE_OUT = 3,
88 | USB_STATE_DATA = 4,
89 | USB_STATE_ADDRESS_CHANGE = 5
90 | };
91 |
92 | enum usb_packets_id_list
93 | {
94 | USB_PID_SETUP = 0x2D, //
95 | USB_PID_DATA0 = 0xC3,
96 | USB_PID_DATA1 = 0x4B,
97 | USB_PID_IN = 0x69, // данные для ПК
98 | USB_PID_OUT = 0xE1, // данные от ПК
99 | USB_PID_ACK = 0xD2,
100 | USB_PID_NACK = 0x5A,
101 | USB_PID_STALL = 0x1E
102 | };
103 |
104 | enum usb_request_standart_type_list
105 | {
106 | USB_REQUEST_TYPE_TO_DEVICE = 0x00, //
107 | USB_REQUEST_TYPE_TO_INTERFACE = 0x01, //
108 | USB_REQUEST_TYPE_TO_ENDPOINT = 0x02, //
109 | USB_REQUEST_TYPE_FROM_DEVICE = 0x80, //
110 | USB_REQUEST_TYPE_FROM_INTERFACE = 0x81, //
111 | USB_REQUEST_TYPE_FROM_ENDPOINT = 0x82
112 | };
113 |
114 | enum usb_request_list
115 | {
116 | USB_REQUEST_GET_STATUS = 0x00, //
117 | USB_REQUEST_SET_ADDRESS = 0x05,
118 | USB_REQUEST_GET_DESCRIPTOR = 0x06,
119 | USB_REQUEST_SET_DESCRIPTOR = 0x07,
120 | USB_REQUEST_GET_CONFIGURATION = 0x08,
121 | USB_REQUEST_SET_CONFIGURATION = 0x09
122 | };
123 |
124 | struct usb_type
125 | {
126 | volatile uint8_t state;
127 | volatile uint8_t event;
128 | volatile uint8_t device_address;
129 |
130 | uint8_t endpoint_number;
131 | uint8_t setup_address;
132 | uint8_t setup_endpoint;
133 |
134 | uint8_t rx_buffer[16];
135 | uint8_t rx_lenght;
136 |
137 | uint8_t tx_buffer[16];
138 | uint8_t tx_lenght;
139 | uint8_t tx_is_all;
140 | } usb;
141 |
142 | void usb_init(void)
143 | {
144 | usb.state = USB_STATE_IDLE;
145 | usb.event = USB_EVENT_NO;
146 | usb.device_address = 0;
147 | usb.tx_is_all = TRUE;
148 | }
149 |
150 | void usb_send_nack(void)
151 | {
152 | uint8_t data[2];
153 |
154 | GPIOC->ODR = 0x40;
155 | GPIOC->CR1 = 0xFF;
156 | GPIOC->CR2 = 0xFF;
157 | GPIOC->DDR = 0xFF;
158 |
159 | data[0] = 0x80;
160 | data[1] = USB_PID_NACK;
161 |
162 | usb_tx_count = 2;
163 | usb_tx_buffer_pointer = &data[0];
164 |
165 | usb_tx();
166 |
167 | nop();
168 | nop();
169 | nop();
170 | nop();
171 | nop();
172 | nop();
173 |
174 | GPIOC->CR2 = 0x00;
175 | GPIOC->CR1 = 0x00;
176 | GPIOC->DDR = 0x3F;
177 | }
178 |
179 | void usb_send_ack(void)
180 | {
181 | uint8_t data[2];
182 |
183 | GPIOC->ODR = 0x40;
184 | GPIOC->CR1 = 0xFF;
185 | GPIOC->CR2 = 0xFF;
186 | GPIOC->DDR = 0xFF;
187 |
188 | data[0] = 0x80;
189 | data[1] = USB_PID_ACK;
190 |
191 | usb_tx_count = 2;
192 | usb_tx_buffer_pointer = &data[0];
193 |
194 | usb_tx();
195 |
196 | nop();
197 | nop();
198 | nop();
199 | nop();
200 | nop();
201 | nop();
202 |
203 | GPIOC->CR2 = 0x00;
204 | GPIOC->CR1 = 0x00;
205 | GPIOC->DDR = 0x3F;
206 | }
207 |
208 | uint8_t count = 0;
209 |
210 | @inline void usb_send_answer(void)
211 | {
212 | GPIOC->ODR = 0x40;
213 | GPIOC->CR1 = 0xFF;
214 | GPIOC->CR2 = 0xFF;
215 | GPIOC->DDR = 0xFF;
216 |
217 | usb_tx_count = usb.tx_lenght;
218 | usb_tx_buffer_pointer = &usb.tx_buffer[0];
219 |
220 | usb_tx();
221 |
222 | nop();
223 | nop();
224 | nop();
225 | nop();
226 | nop();
227 | nop();
228 |
229 | GPIOC->CR2 = 0x00;
230 | GPIOC->CR1 = 0x00;
231 | GPIOC->DDR = 0x3F;
232 | }
233 |
234 | void usb_rx_ok(void)
235 | {
236 | switch (usb_rx_buffer[1])
237 | {
238 | case (USB_PID_SETUP):
239 | {
240 | usb.state = USB_STATE_SETUP;
241 |
242 | break;
243 | }
244 | case (USB_PID_OUT):
245 | {
246 | usb.state = USB_STATE_OUT;
247 |
248 | break;
249 | }
250 | case (USB_PID_IN):
251 | {
252 | if (usb.event == USB_EVENT_READY_DATA_IN)
253 | {
254 | usb_send_answer();
255 |
256 | usb.event = USB_EVENT_WAIT_DATA_IN;
257 | }
258 | else
259 | {
260 | usb_send_nack();
261 | }
262 |
263 | usb.state = USB_STATE_IN;
264 |
265 | break;
266 | }
267 | case (USB_PID_DATA0):
268 | {
269 | if (usb.state == USB_STATE_SETUP)
270 | {
271 | usb.rx_buffer[0] = usb_rx_buffer[0];
272 | usb.rx_buffer[1] = usb_rx_buffer[1];
273 | usb.rx_buffer[2] = usb_rx_buffer[2];
274 | usb.rx_buffer[3] = usb_rx_buffer[3];
275 | usb.rx_buffer[4] = usb_rx_buffer[4];
276 | usb.rx_buffer[5] = usb_rx_buffer[5];
277 | usb.rx_buffer[6] = usb_rx_buffer[6];
278 | usb.rx_buffer[7] = usb_rx_buffer[7];
279 | usb.rx_buffer[8] = usb_rx_buffer[8];
280 | usb.rx_buffer[9] = usb_rx_buffer[9];
281 | usb.rx_buffer[10] = usb_rx_buffer[10];
282 | usb.rx_buffer[11] = usb_rx_buffer[11];
283 | usb.rx_buffer[12] = usb_rx_buffer[12];
284 | usb.rx_buffer[13] = usb_rx_buffer[13];
285 | usb.rx_buffer[14] = usb_rx_buffer[14];
286 | usb.rx_buffer[15] = usb_rx_buffer[15];
287 |
288 | usb_send_ack();
289 |
290 | usb.event = USB_EVENT_RECEIVE_SETUP_DATA;
291 | }
292 | else if (usb.state == USB_STATE_OUT)
293 | {
294 | usb_send_ack();
295 |
296 | usb.event == USB_EVENT_NO;
297 | }
298 |
299 | break;
300 | }
301 | case (USB_PID_DATA1):
302 | {
303 | if (usb.state == USB_STATE_OUT)
304 | {
305 | usb_send_ack();
306 |
307 | usb.event == USB_EVENT_NO;
308 | }
309 |
310 | break;
311 | }
312 | case (USB_PID_ACK):
313 | {
314 | break;
315 | }
316 | case (USB_PID_NACK):
317 | {
318 | break;
319 | }
320 | default:
321 | {
322 | usb.state = USB_STATE_IDLE;
323 |
324 | break;
325 | }
326 | }
327 | }
328 |
329 | void usb_calc_crc16(uint8_t * buffer, uint8_t lenght)
330 | {
331 | uint16_t crc = 0xFFFF;
332 | uint8_t index;
333 | uint8_t i;
334 |
335 | for (index = 0; index < lenght; index++)
336 | {
337 | crc ^= *buffer++;
338 |
339 | for (i = 8; i--;)
340 | {
341 | if ((crc & BIT(0)) != 0)
342 | {
343 | crc >>= 1;
344 | crc ^= 0xA001;
345 | }
346 | else
347 | {
348 | crc >>= 1;
349 | }
350 | }
351 | }
352 |
353 | crc = ~crc;
354 |
355 | *buffer++ = (uint8_t) crc;
356 | *buffer = (uint8_t) (crc >> 8);
357 | }
358 |
359 | void usb_send_data(uint8_t * buffer, uint8_t lenght)
360 | {
361 | uint8_t data_sync = USB_PID_DATA1;
362 | uint8_t index;
363 |
364 | while (lenght > 0)
365 | {
366 | if (lenght >= 8)
367 | {
368 | usb.tx_lenght = 12;
369 |
370 | usb.tx_buffer[0] = 0x80;
371 | usb.tx_buffer[1] = data_sync;
372 |
373 | for (index = 2; index < 10; index++)
374 | usb.tx_buffer[index] = *buffer++;
375 |
376 | lenght -= 8;
377 | }
378 | else
379 | {
380 | usb.tx_lenght = (uint8_t) (4 + lenght);
381 |
382 | usb.tx_buffer[0] = 0x80;
383 | usb.tx_buffer[1] = data_sync;
384 |
385 | for (index = 2; index < 2 + lenght; index++)
386 | usb.tx_buffer[index] = *buffer++;
387 |
388 | lenght = 0;
389 | }
390 |
391 | // расчитываем контрольную сумму пакета
392 | usb_calc_crc16(&usb.tx_buffer[2], (uint8_t) (usb.tx_lenght - 4));
393 |
394 | // обновляем пакет синхронизации
395 | if (data_sync == USB_PID_DATA1)
396 | data_sync = USB_PID_DATA0;
397 | else
398 | data_sync = USB_PID_DATA1;
399 |
400 | // сообщаем о готовности данных
401 | usb.event = USB_EVENT_READY_DATA_IN;
402 |
403 | while (usb.event == USB_EVENT_READY_DATA_IN)
404 | {
405 | if (usb.state != USB_STATE_IN)
406 | return;
407 | }
408 | }
409 | }
410 |
411 | uint8_t counter_a = 0;
412 | uint8_t counter_b = 0;
413 | uint8_t counter_all = 0;
414 |
415 | uint8_t tx_counter = 0;
416 |
417 | void usb_process(void)
418 | {
419 | if (usb.event == USB_EVENT_RECEIVE_SETUP_DATA)
420 | {
421 | switch (usb.rx_buffer[2])
422 | {
423 | case (USB_REQUEST_TYPE_FROM_DEVICE):
424 | {
425 | switch (usb.rx_buffer[3])
426 | {
427 | case (USB_REQUEST_GET_DESCRIPTOR):
428 | {
429 | if (usb.rx_buffer[5] == 1)
430 | usb_send_data(&usb_device_descriptor[0], ARRAY_LENGHT(usb_device_descriptor));
431 | else if (usb.rx_buffer[5] == 2)
432 | usb_send_data(&usb_configuration_descriptor[0], ARRAY_LENGHT(usb_configuration_descriptor));
433 |
434 | //if (usb.rx_buffer[5] == 0)
435 | // usb_send_data(&usb_device_descriptor[0], ARRAY_LENGHT(usb_device_descriptor));
436 |
437 | // else if (usb.rx_buffer[5] == 2)
438 | // usb_send_data(&usb_interface_descriptor[0], ARRAY_LENGHT(usb_interface_descriptor));
439 |
440 | break;
441 | }
442 | }
443 |
444 | break;
445 | }
446 | case (USB_REQUEST_TYPE_TO_DEVICE):
447 | {
448 | switch (usb.rx_buffer[3])
449 | {
450 | case (USB_REQUEST_SET_ADDRESS):
451 | {
452 | usb.device_address = usb.rx_buffer[4];
453 |
454 | usb.tx_lenght = 4;
455 | usb.tx_buffer[0] = 0x80;
456 | usb.tx_buffer[1] = USB_PID_DATA1;
457 | usb.tx_buffer[2] = 0;
458 | usb.tx_buffer[3] = 0;
459 |
460 | usb.event = USB_EVENT_READY_DATA_IN;
461 |
462 | break;
463 | }
464 | }
465 |
466 | break;
467 | }
468 | }
469 | }
470 | }
471 |
--------------------------------------------------------------------------------
/device/usb/usb.h:
--------------------------------------------------------------------------------
1 | /*
2 | * File: usb.h
3 | * Date: 07.02.2014
4 | * Denis Zheleznyakov aka ZiB @ http://ziblog.ru
5 | */
6 |
7 | #ifndef USB_H_
8 | #define USB_H_
9 |
10 | extern uint8_t usb_tx_count;
11 |
12 | extern uint8_t usb_tx_buffer[16];
13 |
14 | void usb_init(void);
15 | void usb_process(void);
16 |
17 | #endif /* USB_H_ */
18 |
--------------------------------------------------------------------------------
/device/usb/usb_rx.S:
--------------------------------------------------------------------------------
1 | xref _usb_rx_count, _usb_rx_buffer, _usb_rx_ok
2 |
3 | xdef _usb_rx
4 |
5 | L_Bit0_Begin:
6 | cpl ($14,y) ; сигнал синхронизации
7 | srl ($01, SP)
8 | ld a,(y)
9 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
10 | xor a, ($01, SP)
11 | ld ($01, SP),a
12 | nop
13 |
14 | L_Bit1_Begin:
15 | cpl ($14,y) ; сигнал синхронизации
16 | srl ($01, SP)
17 | ld a,(y)
18 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
19 | xor a, ($01, SP)
20 | ld ($01, SP),a
21 | incw x
22 | nop
23 |
24 | L_Bit2_Begin:
25 | cpl ($14,y) ; сигнал синхронизации
26 | srl ($01, SP)
27 | ld a,(y)
28 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
29 | xor a, ($01, SP)
30 | ld ($01, SP),a
31 | nop
32 | nop
33 |
34 | L_Bit3_Begin:
35 | cpl ($14,y) ; сигнал синхронизации
36 | srl ($01, SP)
37 | ld a,(y)
38 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
39 | xor a, ($01, SP)
40 | ld ($01, SP),a
41 | nop
42 |
43 | L_Bit4_Begin:
44 | cpl ($14,y) ; сигнал синхронизации
45 | srl ($01, SP)
46 | ld a,(y)
47 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
48 | xor a, ($01, SP)
49 | ld ($01, SP),a
50 | nop
51 |
52 | L_Bit5_Begin:
53 | cpl ($14,y) ; сигнал синхронизации
54 | srl ($01, SP)
55 | ld a,(y)
56 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
57 | xor a, ($01, SP)
58 | ld ($01, SP),a
59 | dec ($02,SP)
60 | jreq L_End_Rx
61 |
62 | L_Bit6_Begin:
63 | cpl ($14,y) ; сигнал синхронизации
64 | srl ($01, SP)
65 | ld a,(y)
66 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
67 | xor a, ($01, SP)
68 | ld ($01, SP),a
69 | nop
70 |
71 | L_Bit7_Begin:
72 | cpl ($14,y) ; сигнал синхронизации
73 | srl ($01, SP)
74 | ld a,(y)
75 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
76 | xor a, ($01, SP)
77 | ld ($01, SP),a
78 |
79 | ld (x),a ; сохраняем принятый байт
80 | rlc (x)
81 |
82 | cpl ($14,y) ; сигнал синхронизации
83 | srl ($01, SP)
84 | ld a,(y)
85 | jreq L_End_Rx ; выход, если input = 0 (конец пакета)
86 | xor a, ($01, SP)
87 | ld ($01, SP),a
88 |
89 | jra L_Bit1_Begin
90 |
91 | nop
92 | nop
93 | nop
94 |
95 | L_End_Rx:
96 |
97 | pop a
98 | pop a
99 | ld _usb_rx_count,a
100 |
101 | call _usb_rx_ok
102 |
103 | clr 20495
104 |
105 | mov 21077,#251 ; сброс флага прерывания таймера
106 |
107 | bres 21072,#0 ; стоп таймер
108 | clr 21086 ; сброс счетного регистра
109 | clr 21087 ;
110 |
111 | iret
112 |
113 | ;
114 | ;
115 | ;
116 |
117 | _usb_rx:
118 |
119 | ldw x, #L_Delay_Begin ; адрес начала таблицы задержек
120 | addw x, 21086 ; + смещение (значение таймера)
121 | cpw x, #L_Delay_End ; проверка выхода за границу таблицы (защита!)
122 | jruge L_Error
123 | jp (x) ; переход по таблице задержек
124 |
125 | L_Error:
126 |
127 | iret ; аврийный выход
128 |
129 | L_Delay_Begin:
130 | nop
131 | nop
132 | nop
133 | nop
134 | nop
135 | nop
136 | nop
137 | nop
138 | nop
139 | nop
140 | nop
141 | nop
142 | nop
143 | nop
144 | nop
145 | nop
146 | nop
147 | nop
148 | nop
149 | nop
150 | nop
151 | nop
152 | nop
153 | nop
154 | nop
155 | nop
156 | nop
157 | nop
158 | nop
159 | nop
160 | nop
161 | nop
162 | nop
163 | nop
164 |
165 | L_Delay_End:
166 |
167 | ldw x, #_usb_rx_buffer ; адрес начала буфера
168 | ldw y, #20491 ; адрес входного сигнала
169 | ld a, #$0E ; максимальное кол-во принимаемых байт (защита!)
170 | push a
171 | ld a, #$80
172 | push a
173 |
174 | jra L_Bit0_Begin
175 |
--------------------------------------------------------------------------------
/device/usb/usb_tx.S:
--------------------------------------------------------------------------------
1 | xref _usb_tx_count, _usb_tx_buffer_pointer
2 |
3 | xdef _usb_tx
4 |
5 | L_Bit0_Idle:
6 | nop
7 | nop
8 | dec a
9 | jrne L_Bit1_Begin
10 | nop
11 | nop
12 | nop
13 | cpl 20490
14 | nop
15 | nop
16 | ld a, #$06
17 | jra L_Bit1_Begin
18 | nop
19 | nop
20 |
21 | L_Bit1_Idle:
22 | nop
23 | nop
24 | dec a
25 | jrne L_Bit2_Begin
26 | nop
27 | nop
28 | nop
29 | cpl 20490
30 | nop
31 | nop
32 | ld a, #$06
33 | jra L_Bit2_Begin
34 | nop
35 | nop
36 |
37 | L_Bit2_Idle:
38 | nop
39 | dec a
40 | jrne L_Bit3_Begin
41 | nop
42 | nop
43 | nop
44 | nop
45 | cpl 20490
46 | nop
47 | ld a, #$06
48 | jra L_Bit3_Begin
49 | nop
50 | nop
51 |
52 | L_Bit3_Idle:
53 | nop
54 | nop
55 | nop
56 | dec a
57 | jrne L_Bit4_Begin
58 | nop;
59 | nop
60 | nop
61 | cpl 20490
62 | nop
63 | nop
64 | ld a, #$06
65 | jra L_Bit4_Begin
66 | nop
67 | nop
68 | ;nop
69 |
70 |
71 | L_Bit0_Begin:
72 | rrc (x) // бит 0 -> СC.C
73 | jrc L_Bit0_Idle // перейти, если равен CС.C = 1
74 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
75 | ld a, #$06 // если была инверсия, сбрасываем
76 | nop
77 | nop
78 | nop
79 | nop
80 |
81 | L_Bit1_Begin:
82 | rrc (x) // бит 0 -> СC.C
83 | jrc L_Bit1_Idle // перейти, если равен CС.C = 1
84 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
85 | ld a, #$06
86 | nop
87 | nop
88 | nop
89 | nop
90 |
91 | L_Bit2_Begin:
92 | rrc (x) // бит 0 -> СC.C
93 | jrc L_Bit2_Idle // перейти, если равен CС.C = 1
94 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
95 | ld a, #$06
96 | nop
97 | nop
98 | nop
99 | ;nop
100 |
101 | L_Bit3_Begin:
102 | rrc (x) // бит 0 -> СC.C
103 | jrc L_Bit3_Idle // перейти, если равен CС.C = 1
104 | nop;
105 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
106 | ld a, #$06
107 | nop
108 | nop
109 | nop
110 | nop
111 |
112 | L_Bit4_Begin:
113 | rrc (x) // бит 0 -> СC.C
114 | jrc L_Bit4_Idle // перейти, если равен CС.C = 1
115 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
116 | ld a, #$06
117 | nop
118 | nop
119 | nop
120 | nop
121 |
122 | L_Bit5_Begin:
123 | rrc (x) // бит 0 -> СC.C
124 | jrc L_Bit5_Idle // перейти, если равен CС.C = 1
125 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
126 | ld a, #$06
127 | nop
128 | nop
129 | nop
130 | nop
131 |
132 | L_Bit6_Begin:
133 | rrc (x) // бит 0 -> СC.C
134 | jrc L_Bit6_Idle // перейти, если равен CС.C = 1
135 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
136 | ld a, #$06
137 | nop
138 | nop
139 |
140 | L_Bit7_Begin:
141 | rrc (x) // бит 0 -> СC.C
142 | jrc L_Bit7_Idle // перейти, если равен CС.C = 1
143 | nop
144 | nop
145 | cpl 20490 // инверсия выходных сигналов [N,Z,C=1]
146 | ld a, #$06
147 |
148 | L_Check_End:
149 |
150 | incw x
151 | dec _usb_tx_count
152 | jrne L_Bit0_Begin
153 |
154 | nop
155 | L_Tx_End:
156 | nop
157 | nop
158 |
159 | clr 20490
160 |
161 | ret
162 |
163 | nop
164 | nop
165 | nop
166 | nop
167 |
168 | ;
169 | ;
170 | ;
171 | nop
172 |
173 | L_Bit4_Idle:
174 | nop
175 | nop
176 | dec a
177 | jrne L_Bit5_Begin
178 | nop
179 | nop
180 | nop
181 | cpl 20490
182 | nop
183 | nop
184 | ld a, #$06
185 | jra L_Bit5_Begin
186 | nop
187 |
188 | nop
189 | L_Bit5_Idle:
190 | nop
191 | nop
192 | dec a
193 | jrne L_Bit6_Begin
194 | nop
195 | nop
196 | nop
197 | cpl 20490
198 | nop
199 | nop
200 | ld a, #$06
201 | jra L_Bit6_Begin
202 | nop
203 | nop
204 |
205 | L_Bit6_Idle:
206 |
207 | dec a
208 | jrne L_Bit7_Begin
209 | nop
210 | nop
211 | nop
212 | nop
213 | nop
214 | cpl 20490
215 | ld a, #$06
216 | jra L_Bit7_Begin
217 | nop
218 | nop
219 | nop
220 |
221 | L_Bit7_Idle:
222 | dec a
223 | jrne L_Check_End
224 | dec _usb_tx_count
225 | nop
226 | incw x
227 | nop
228 | ld a, #$06
229 | nop
230 | cpl 20490
231 | nop
232 | tnz _usb_tx_count
233 | jrne L_Bit0_Begin
234 | jra L_Tx_End
235 |
236 | ;
237 | ; Точка входа
238 | ;
239 | _usb_tx:
240 |
241 | ldw x, _usb_tx_buffer_pointer
242 |
243 | ld a,#$40
244 | ld 20490,a
245 |
246 | ld a, #$06 ; счет
247 |
248 | jra L_Bit0_Begin
249 |
--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
1 | /*
2 | * File: main.c
3 | * Date: 02.01.2013
4 | * Denis Zheleznyakov aka ZiB @ http://ziblog.ru
5 | */
6 |
7 | #include "main.h"
8 |
9 | volatile uint32_t timer;
10 |
11 | @inline static void gpio_init(void)
12 | {
13 | // перевод всех линий на вход с подтяжкой к плюсу
14 | GPIOA->CR1 = 0xFF;
15 | GPIOB->CR1 = 0xFF;
16 | GPIOC->CR1 = 0xFF;
17 | GPIOD->CR1 = 0xFF;
18 | GPIOE->CR1 = 0xFF;
19 | GPIOF->CR1 = 0xFF;
20 |
21 | // Входные линии USB
22 | GPIOC->CR1 = 0;
23 | GPIOC->CR2 = 0;
24 | GPIOC->DDR = 0x3F;
25 | GPIOC->ODR = 0;
26 |
27 | // 1,5 kOm
28 | GPIOA->DDR = 0x00;
29 | GPIOA->ODR = 0x00;
30 | GPIOA->CR1 = 0x00;
31 | GPIOA->CR2 = 0x00;
32 | }
33 |
34 | @inline static void clock_init(void)
35 | {
36 | // после сброса микроконтроллер работает от встроенного HSI-генератора
37 | // с делителем по умолчанию 8, меняем его на 1
38 | CLK->CKDIVR = 0;
39 |
40 | // переключаемся на внешний кварцевый резонатор
41 | CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSE, DISABLE, CLK_CURRENTCLOCKSTATE_DISABLE);
42 | }
43 |
44 | @inline static void timers_init(void)
45 | {
46 | CLK->PCKENR1 |= CLK_PCKENR1_TIM1;
47 |
48 | // таймер 1 - "захват" первого импульса USB посылки
49 | TIM1_TimeBaseInit(0, TIM1_PSCRELOADMODE_UPDATE, 1000, 0);
50 | // захват сигнала по линии USB D-
51 | TIM1_ICInit(TIM1_CHANNEL_2, TIM1_ICPOLARITY_FALLING, TIM1_ICSELECTION_DIRECTTI, TIM1_ICPSC_DIV1, 0x02);
52 | TIM1_SelectInputTrigger(TIM1_TS_TI2FP2);
53 | TIM1_SelectSlaveMode(TIM1_SLAVEMODE_TRIGGER);
54 | TIM1_ClearFlag(TIM1_FLAG_CC2);
55 | TIM1_ITConfig(TIM1_IT_CC2, ENABLE);
56 | }
57 |
58 | void main(void)
59 | {
60 | disableInterrupts();
61 |
62 | gpio_init();
63 |
64 | clock_init();
65 |
66 | timers_init();
67 |
68 | enableInterrupts();
69 |
70 | // delay
71 | timer = 500000;
72 | while(timer-- > 0)
73 | {
74 | }
75 |
76 | // 1,5 kOm
77 | GPIOA->DDR = 0xff;
78 | GPIOA->ODR = 0xff;
79 | GPIOA->CR1 = 0xff;
80 | GPIOA->CR2 = 0xff;
81 |
82 | while(1)
83 | {
84 | usb_process();
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/main.h:
--------------------------------------------------------------------------------
1 | /*
2 | * File: main.h
3 | * Date: 02.01.2013
4 | * Denis Zheleznyakov aka ZiB @ http://ziblog.ru
5 | */
6 |
7 | #ifndef MAIN_H_
8 | #define MAIN_H_
9 |
10 | #include "stm8s.h"
11 |
12 | #include "macros.h"
13 |
14 | #include "mcu_gpio.h"
15 |
16 | #include "usb.h"
17 |
18 | #endif /* MAIN_H_ */
19 |
--------------------------------------------------------------------------------
/mcu/peripherals/mcu_gpio.h:
--------------------------------------------------------------------------------
1 | /*
2 | * File: mcu_gpio.h
3 | * Date: 23.01.2011
4 | * Denis Zheleznjakov @ ZiBlog.ru
5 | */
6 |
7 | #ifndef MCU_GPIO_H_
8 | #define MCU_GPIO_H_
9 |
10 | // PIN_TEST A, 3, HIGH, INPUT_FLOATING_WITHOUT_ITERRUPT
11 |
12 | #define INPUT_FLOATING_WITHOUT_ITERRUPT INPUT_FLOATING_WITHOUT_ITERRUPT
13 | #define INPUT_FLOATING_WITH_ITERRUPT INPUT_FLOATING_WITH_ITERRUPT
14 | #define INPUT_PULL_UP_WITHOUT_ITERRUPT INPUT_PULL_UP_WITHOUT_ITERRUPT
15 | #define INPUT_PULL_UP_WITH_ITERRUPT INPUT_PULL_UP_WITH_ITERRUPT
16 | #define OUTPUT_OPEN_DRAIN_NOSPEED_LIMIT OUTPUT_OPEN_DRAIN_NOSPEED_LIMIT
17 | #define OUTPUT_OPEN_DRAIN_SPEED_LIMIT_10MHZ OUTPUT_OPEN_DRAIN_SPEED_LIMIT_10MHZ
18 | #define OUTPUT_PUSH_PULL_NOSPEED_LIMIT OUTPUT_PUSH_PULL_NOSPEED_LIMIT
19 | #define OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ
20 |
21 | //------------------------------------------------------------------------------
22 | #define GPIO_PIN_CONFIGURATION_OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ(PORT, PIN, LEVEL, MODE) \
23 | { \
24 | GPIO##PORT->DDR |= (1 << PIN); \
25 | GPIO##PORT->CR1 |= (1 << PIN); \
26 | GPIO##PORT->CR2 |= (1 << PIN); \
27 | }
28 |
29 | #define GPIO_PIN_CONFIGURATION_OUTPUT_PUSH_PULL_NOSPEED_LIMIT(PORT, PIN, LEVEL, MODE) \
30 | { \
31 | GPIO##PORT->DDR |= (1 << PIN); \
32 | GPIO##PORT->CR1 |= (1 << PIN); \
33 | GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
34 | }
35 |
36 | #define GPIO_PIN_CONFIGURATION_OUTPUT_OPEN_DRAIN_SPEED_LIMIT_10MHZ(PORT, PIN, LEVEL, MODE) \
37 | { \
38 | GPIO##PORT->DDR |= (1 << PIN); \
39 | GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
40 | GPIO##PORT->CR2 |= (1 << PIN); \
41 | }
42 |
43 | #define GPIO_PIN_CONFIGURATION_OUTPUT_OPEN_DRAIN_NOSPEED_LIMIT(PORT, PIN, LEVEL, MODE) \
44 | { \
45 | GPIO##PORT->DDR |= (1 << PIN); \
46 | GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
47 | GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
48 | }
49 |
50 | #define GPIO_PIN_CONFIGURATION_INPUT_PULL_UP_WITH_ITERRUPT(PORT, PIN, LEVEL, MODE) \
51 | { \
52 | GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
53 | GPIO##PORT->CR1 |= (1 << PIN); \
54 | GPIO##PORT->CR2 |= (1 << PIN); \
55 | }
56 |
57 | #define GPIO_PIN_CONFIGURATION_INPUT_PULL_UP_WITHOUT_ITERRUPT(PORT, PIN, LEVEL, MODE) \
58 | { \
59 | GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
60 | GPIO##PORT->CR1 |= (1 << PIN); \
61 | GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
62 | }
63 |
64 | #define GPIO_PIN_CONFIGURATION_INPUT_FLOATING_WITH_ITERRUPT(PORT, PIN, LEVEL, MODE) \
65 | { \
66 | GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
67 | GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
68 | GPIO##PORT->CR2 |= (1 << PIN); \
69 | }
70 |
71 | #define GPIO_PIN_CONFIGURATION_INPUT_FLOATING_WITHOUT_ITERRUPT(PORT, PIN, LEVEL, MODE) \
72 | { \
73 | GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
74 | GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
75 | GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
76 | }
77 |
78 | //------------------------------------------------------------------------------
79 | #define GPIO_PIN_CONFIGURATION(PORT, PIN, LEVEL, MODE) \
80 | { \
81 | GPIO_PIN_CONFIGURATION_##MODE(PORT, PIN, LEVEL, MODE); \
82 | }
83 |
84 | //------------------------------------------------------------------------------
85 | #define GPIO_PIN_OFF_HIGH(PORT, PIN, LEVEL, MODE) \
86 | { GPIO##PORT->ODR &= (uint8_t)((uint8_t)(~(1 << PIN))); }
87 |
88 | #define GPIO_PIN_OFF_LOW(PORT, PIN, LEVEL, MODE) \
89 | { GPIO##PORT->ODR |= (1 << PIN); }
90 |
91 | #define GPIO_PIN_OFF(PORT, PIN, LEVEL, MODE) \
92 | { GPIO_PIN_OFF_##LEVEL(PORT, PIN, LEVEL, MODE) }
93 |
94 | //------------------------------------------------------------------------------
95 | #define GPIO_PIN_ON_HIGH(PORT, PIN, LEVEL, MODE) \
96 | { GPIO##PORT->ODR |= (1 << PIN); }
97 |
98 | #define GPIO_PIN_ON_LOW(PORT, PIN, LEVEL, MODE) \
99 | { GPIO##PORT->ODR &= (uint8_t)(~(1 << PIN)); }
100 |
101 | #define GPIO_PIN_ON(PORT, PIN, LEVEL, MODE) \
102 | { GPIO_PIN_ON_##LEVEL(PORT, PIN, LEVEL, MODE) }
103 |
104 | //------------------------------------------------------------------------------
105 | #define GPIO_PIN_TOGGLE(PORT, PIN, LEVEL, MODE) \
106 | { GPIO##PORT->ODR ^= (uint8_t)(1 << PIN); }
107 |
108 | //------------------------------------------------------------------------------
109 | #define GPIO_PIN_SIGNAL_HIGH(PORT, PIN, LEVEL, MODE) \
110 | ( (GPIO##PORT->IDR & (1 << PIN)) == (1 << PIN) )
111 |
112 | #define GPIO_PIN_SIGNAL_LOW(PORT, PIN, LEVEL, MODE) \
113 | ( (GPIO##PORT->IDR & (1 << PIN)) != (1 << PIN) )
114 |
115 | #define GPIO_PIN_SIGNAL(PORT, PIN, LEVEL, MODE) \
116 | ( GPIO_PIN_SIGNAL_##LEVEL(PORT, PIN, LEVEL, MODE) )
117 |
118 | //------------------------------------------------------------------------------
119 | #define PIN_CONFIGURATION(PIN_DESCRIPTION) GPIO_PIN_CONFIGURATION(PIN_DESCRIPTION)
120 | #define PIN_ON(PIN_DESCRIPTION) GPIO_PIN_ON(PIN_DESCRIPTION)
121 | #define PIN_OFF(PIN_DESCRIPTION) GPIO_PIN_OFF(PIN_DESCRIPTION)
122 | #define PIN_TOGGLE(PIN_DESCRIPTION) GPIO_PIN_TOGGLE(PIN_DESCRIPTION)
123 | #define PIN_SIGNAL(PIN_DESCRIPTION) GPIO_PIN_SIGNAL(PIN_DESCRIPTION)
124 |
125 | #endif /* MCU_GPIO_H_ */
126 |
--------------------------------------------------------------------------------
/mcu/std_lib/Release_Notes.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/Release_Notes.html
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_adc2.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_adc2.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the prototypes/macros for the ADC2 peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 |
23 | /* Define to prevent recursive inclusion -------------------------------------*/
24 | #ifndef __STM8S_ADC2_H
25 | #define __STM8S_ADC2_H
26 |
27 | /* Includes ------------------------------------------------------------------*/
28 | #include "stm8s.h"
29 |
30 | /* Exported types ------------------------------------------------------------*/
31 |
32 | /** @addtogroup ADC2_Exported_Types
33 | * @{
34 | */
35 |
36 | /**
37 | * @brief ADC2 clock prescaler selection
38 | */
39 |
40 | typedef enum {
41 | ADC2_PRESSEL_FCPU_D2 = (uint8_t)0x00, /**< Prescaler selection fADC2 = fcpu/2 */
42 | ADC2_PRESSEL_FCPU_D3 = (uint8_t)0x10, /**< Prescaler selection fADC2 = fcpu/3 */
43 | ADC2_PRESSEL_FCPU_D4 = (uint8_t)0x20, /**< Prescaler selection fADC2 = fcpu/4 */
44 | ADC2_PRESSEL_FCPU_D6 = (uint8_t)0x30, /**< Prescaler selection fADC2 = fcpu/6 */
45 | ADC2_PRESSEL_FCPU_D8 = (uint8_t)0x40, /**< Prescaler selection fADC2 = fcpu/8 */
46 | ADC2_PRESSEL_FCPU_D10 = (uint8_t)0x50, /**< Prescaler selection fADC2 = fcpu/10 */
47 | ADC2_PRESSEL_FCPU_D12 = (uint8_t)0x60, /**< Prescaler selection fADC2 = fcpu/12 */
48 | ADC2_PRESSEL_FCPU_D18 = (uint8_t)0x70 /**< Prescaler selection fADC2 = fcpu/18 */
49 | } ADC2_PresSel_TypeDef;
50 |
51 | /**
52 | * @brief ADC2 External conversion trigger event selection
53 | */
54 | typedef enum {
55 | ADC2_EXTTRIG_TIM = (uint8_t)0x00, /**< Conversion from Internal TIM TRGO event */
56 | ADC2_EXTTRIG_GPIO = (uint8_t)0x01 /**< Conversion from External interrupt on ADC_ETR pin*/
57 | } ADC2_ExtTrig_TypeDef;
58 |
59 | /**
60 | * @brief ADC2 data alignment
61 | */
62 | typedef enum {
63 | ADC2_ALIGN_LEFT = (uint8_t)0x00, /**< Data alignment left */
64 | ADC2_ALIGN_RIGHT = (uint8_t)0x08 /**< Data alignment right */
65 | } ADC2_Align_TypeDef;
66 |
67 | /**
68 | * @brief ADC2 schmitt Trigger
69 | */
70 | typedef enum {
71 | ADC2_SCHMITTTRIG_CHANNEL0 = (uint8_t)0x00, /**< Schmitt trigger disable on AIN0 */
72 | ADC2_SCHMITTTRIG_CHANNEL1 = (uint8_t)0x01, /**< Schmitt trigger disable on AIN1 */
73 | ADC2_SCHMITTTRIG_CHANNEL2 = (uint8_t)0x02, /**< Schmitt trigger disable on AIN2 */
74 | ADC2_SCHMITTTRIG_CHANNEL3 = (uint8_t)0x03, /**< Schmitt trigger disable on AIN3 */
75 | ADC2_SCHMITTTRIG_CHANNEL4 = (uint8_t)0x04, /**< Schmitt trigger disable on AIN4 */
76 | ADC2_SCHMITTTRIG_CHANNEL5 = (uint8_t)0x05, /**< Schmitt trigger disable on AIN5 */
77 | ADC2_SCHMITTTRIG_CHANNEL6 = (uint8_t)0x06, /**< Schmitt trigger disable on AIN6 */
78 | ADC2_SCHMITTTRIG_CHANNEL7 = (uint8_t)0x07, /**< Schmitt trigger disable on AIN7 */
79 | ADC2_SCHMITTTRIG_CHANNEL8 = (uint8_t)0x08, /**< Schmitt trigger disable on AIN8 */
80 | ADC2_SCHMITTTRIG_CHANNEL9 = (uint8_t)0x09, /**< Schmitt trigger disable on AIN9 */
81 | ADC2_SCHMITTTRIG_CHANNEL10 = (uint8_t)0x0A, /**< Schmitt trigger disable on AIN10 */
82 | ADC2_SCHMITTTRIG_CHANNEL11 = (uint8_t)0x0B, /**< Schmitt trigger disable on AIN11 */
83 | ADC2_SCHMITTTRIG_CHANNEL12 = (uint8_t)0x0C, /**< Schmitt trigger disable on AIN12 */
84 | ADC2_SCHMITTTRIG_CHANNEL13 = (uint8_t)0x0D, /**< Schmitt trigger disable on AIN13 */
85 | ADC2_SCHMITTTRIG_CHANNEL14 = (uint8_t)0x0E, /**< Schmitt trigger disable on AIN14 */
86 | ADC2_SCHMITTTRIG_CHANNEL15 = (uint8_t)0x0F, /**< Schmitt trigger disable on AIN15 */
87 | ADC2_SCHMITTTRIG_ALL = (uint8_t)0x1F /**< Schmitt trigger disable on all channels */
88 |
89 | } ADC2_SchmittTrigg_TypeDef;
90 |
91 | /**
92 | * @brief ADC2 conversion mode selection
93 | */
94 |
95 | typedef enum {
96 | ADC2_CONVERSIONMODE_SINGLE = (uint8_t)0x00, /**< Single conversion mode */
97 | ADC2_CONVERSIONMODE_CONTINUOUS = (uint8_t)0x01 /**< Continuous conversion mode */
98 | } ADC2_ConvMode_TypeDef;
99 |
100 | /**
101 | * @brief ADC2 analog channel selection
102 | */
103 |
104 | typedef enum {
105 | ADC2_CHANNEL_0 = (uint8_t)0x00, /**< Analog channel 0 */
106 | ADC2_CHANNEL_1 = (uint8_t)0x01, /**< Analog channel 1 */
107 | ADC2_CHANNEL_2 = (uint8_t)0x02, /**< Analog channel 2 */
108 | ADC2_CHANNEL_3 = (uint8_t)0x03, /**< Analog channel 3 */
109 | ADC2_CHANNEL_4 = (uint8_t)0x04, /**< Analog channel 4 */
110 | ADC2_CHANNEL_5 = (uint8_t)0x05, /**< Analog channel 5 */
111 | ADC2_CHANNEL_6 = (uint8_t)0x06, /**< Analog channel 6 */
112 | ADC2_CHANNEL_7 = (uint8_t)0x07, /**< Analog channel 7 */
113 | ADC2_CHANNEL_8 = (uint8_t)0x08, /**< Analog channel 8 */
114 | ADC2_CHANNEL_9 = (uint8_t)0x09, /**< Analog channel 9 */
115 | ADC2_CHANNEL_10 = (uint8_t)0x0A, /**< Analog channel 10 */
116 | ADC2_CHANNEL_11 = (uint8_t)0x0B, /**< Analog channel 11 */
117 | ADC2_CHANNEL_12 = (uint8_t)0x0C, /**< Analog channel 12 */
118 | ADC2_CHANNEL_13 = (uint8_t)0x0D, /**< Analog channel 13 */
119 | ADC2_CHANNEL_14 = (uint8_t)0x0E, /**< Analog channel 14 */
120 | ADC2_CHANNEL_15 = (uint8_t)0x0F /**< Analog channel 15 */
121 | } ADC2_Channel_TypeDef;
122 |
123 | /**
124 | * @}
125 | */
126 |
127 | /* Exported constants --------------------------------------------------------*/
128 |
129 | /* Exported macros ------------------------------------------------------------*/
130 |
131 | /* Private macros ------------------------------------------------------------*/
132 |
133 | /** @addtogroup ADC2_Private_Macros
134 | * @brief Macros used by the assert function to check the different functions parameters.
135 | * @{
136 | */
137 |
138 | /**
139 | * @brief Macro used by the assert function to check the different prescaler's values.
140 | */
141 | #define IS_ADC2_PRESSEL_OK(PRESCALER) (((PRESCALER) == ADC2_PRESSEL_FCPU_D2) || \
142 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D3) || \
143 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D4) || \
144 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D6) || \
145 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D8) || \
146 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D10) || \
147 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D12) || \
148 | ((PRESCALER) == ADC2_PRESSEL_FCPU_D18))
149 |
150 | /**
151 | * @brief Macro used by the assert function to check the different external trigger values.
152 | */
153 | #define IS_ADC2_EXTTRIG_OK(EXTRIG) (((EXTRIG) == ADC2_EXTTRIG_TIM) || \
154 | ((EXTRIG) == ADC2_EXTTRIG_GPIO))
155 |
156 | /**
157 | * @brief Macro used by the assert function to check the different alignement modes.
158 | */
159 | #define IS_ADC2_ALIGN_OK(ALIGN) (((ALIGN) == ADC2_ALIGN_LEFT) || \
160 | ((ALIGN) == ADC2_ALIGN_RIGHT))
161 |
162 |
163 | /**
164 | * @brief Macro used by the assert function to check the different schmitt trigger values.
165 | */
166 | #define IS_ADC2_SCHMITTTRIG_OK(SCHMITTTRIG) (((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL0) || \
167 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL1) || \
168 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL2) || \
169 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL3) || \
170 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL4) || \
171 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL5) || \
172 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL6) || \
173 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL7) || \
174 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL8) || \
175 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL9) || \
176 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL10) || \
177 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL11) || \
178 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL12) || \
179 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL13) || \
180 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL14) || \
181 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_CHANNEL15) || \
182 | ((SCHMITTTRIG) == ADC2_SCHMITTTRIG_ALL))
183 |
184 | /**
185 | * @brief Macro used by the assert function to check the different conversion modes.
186 | */
187 | #define IS_ADC2_CONVERSIONMODE_OK(MODE) (((MODE) == ADC2_CONVERSIONMODE_SINGLE) || \
188 | ((MODE) == ADC2_CONVERSIONMODE_CONTINUOUS))
189 |
190 | /**
191 | * @brief Macro used by the assert function to check the different channels values.
192 | */
193 | #define IS_ADC2_CHANNEL_OK(CHANNEL) (((CHANNEL) == ADC2_CHANNEL_0) || \
194 | ((CHANNEL) == ADC2_CHANNEL_1) || \
195 | ((CHANNEL) == ADC2_CHANNEL_2) || \
196 | ((CHANNEL) == ADC2_CHANNEL_3) || \
197 | ((CHANNEL) == ADC2_CHANNEL_4) || \
198 | ((CHANNEL) == ADC2_CHANNEL_5) || \
199 | ((CHANNEL) == ADC2_CHANNEL_6) || \
200 | ((CHANNEL) == ADC2_CHANNEL_7) || \
201 | ((CHANNEL) == ADC2_CHANNEL_8) || \
202 | ((CHANNEL) == ADC2_CHANNEL_9) || \
203 | ((CHANNEL) == ADC2_CHANNEL_10) || \
204 | ((CHANNEL) == ADC2_CHANNEL_11) || \
205 | ((CHANNEL) == ADC2_CHANNEL_12) || \
206 | ((CHANNEL) == ADC2_CHANNEL_13) || \
207 | ((CHANNEL) == ADC2_CHANNEL_14) || \
208 | ((CHANNEL) == ADC2_CHANNEL_15))
209 |
210 | /**
211 | * @}
212 | */
213 |
214 | /* Exported functions ------------------------------------------------------- */
215 |
216 | /** @addtogroup ADC2_Exported_Functions
217 | * @{
218 | */
219 | void ADC2_DeInit(void);
220 | void ADC2_Init(ADC2_ConvMode_TypeDef ADC2_ConversionMode,
221 | ADC2_Channel_TypeDef ADC2_Channel,
222 | ADC2_PresSel_TypeDef ADC2_PrescalerSelection,
223 | ADC2_ExtTrig_TypeDef ADC2_ExtTrigger,
224 | FunctionalState ADC2_ExtTriggerState,
225 | ADC2_Align_TypeDef ADC2_Align,
226 | ADC2_SchmittTrigg_TypeDef ADC2_SchmittTriggerChannel,
227 | FunctionalState ADC2_SchmittTriggerState);
228 | void ADC2_Cmd(FunctionalState NewState);
229 | void ADC2_ITConfig(FunctionalState NewState);
230 | void ADC2_PrescalerConfig(ADC2_PresSel_TypeDef ADC2_Prescaler);
231 | void ADC2_SchmittTriggerConfig(ADC2_SchmittTrigg_TypeDef ADC2_SchmittTriggerChannel,
232 | FunctionalState NewState);
233 | void ADC2_ConversionConfig(ADC2_ConvMode_TypeDef ADC2_ConversionMode,
234 | ADC2_Channel_TypeDef ADC2_Channel,
235 | ADC2_Align_TypeDef ADC2_Align);
236 | void ADC2_ExternalTriggerConfig(ADC2_ExtTrig_TypeDef ADC2_ExtTrigger, FunctionalState NewState);
237 | void ADC2_StartConversion(void);
238 | uint16_t ADC2_GetConversionValue(void);
239 | FlagStatus ADC2_GetFlagStatus(void);
240 | void ADC2_ClearFlag(void);
241 | ITStatus ADC2_GetITStatus(void);
242 | void ADC2_ClearITPendingBit(void);
243 | /**
244 | * @}
245 | */
246 |
247 | #endif /* __STM8S_ADC2_H */
248 |
249 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
250 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_awu.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_awu.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the AWU peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_AWU_H
24 | #define __STM8S_AWU_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Exported types ------------------------------------------------------------*/
30 |
31 | /** @addtogroup AWU_Exported_Types
32 | * @{
33 | */
34 |
35 | /**
36 | * @brief AWU TimeBase selection
37 | */
38 |
39 | typedef enum
40 | {
41 | AWU_TIMEBASE_NO_IT = (uint8_t)0, /*!< No AWU interrupt selected */
42 | AWU_TIMEBASE_250US = (uint8_t)1, /*!< AWU Timebase equals 0.25 ms */
43 | AWU_TIMEBASE_500US = (uint8_t)2, /*!< AWU Timebase equals 0.5 ms */
44 | AWU_TIMEBASE_1MS = (uint8_t)3, /*!< AWU Timebase equals 1 ms */
45 | AWU_TIMEBASE_2MS = (uint8_t)4, /*!< AWU Timebase equals 2 ms */
46 | AWU_TIMEBASE_4MS = (uint8_t)5, /*!< AWU Timebase equals 4 ms */
47 | AWU_TIMEBASE_8MS = (uint8_t)6, /*!< AWU Timebase equals 8 ms */
48 | AWU_TIMEBASE_16MS = (uint8_t)7, /*!< AWU Timebase equals 16 ms */
49 | AWU_TIMEBASE_32MS = (uint8_t)8, /*!< AWU Timebase equals 32 ms */
50 | AWU_TIMEBASE_64MS = (uint8_t)9, /*!< AWU Timebase equals 64 ms */
51 | AWU_TIMEBASE_128MS = (uint8_t)10, /*!< AWU Timebase equals 128 ms */
52 | AWU_TIMEBASE_256MS = (uint8_t)11, /*!< AWU Timebase equals 256 ms */
53 | AWU_TIMEBASE_512MS = (uint8_t)12, /*!< AWU Timebase equals 512 ms */
54 | AWU_TIMEBASE_1S = (uint8_t)13, /*!< AWU Timebase equals 1 s */
55 | AWU_TIMEBASE_2S = (uint8_t)14, /*!< AWU Timebase equals 2 s */
56 | AWU_TIMEBASE_12S = (uint8_t)15, /*!< AWU Timebase equals 12 s */
57 | AWU_TIMEBASE_30S = (uint8_t)16 /*!< AWU Timebase equals 30 s */
58 | } AWU_Timebase_TypeDef;
59 |
60 | /**
61 | * @}
62 | */
63 |
64 | /* Exported constants --------------------------------------------------------*/
65 |
66 | /** @addtogroup AWU_Exported_Constants
67 | * @{
68 | */
69 |
70 | #define LSI_FREQUENCY_MIN ((uint32_t)110000) /*!< LSI minimum value in Hertz */
71 | #define LSI_FREQUENCY_MAX ((uint32_t)150000) /*!< LSI maximum value in Hertz */
72 |
73 | /**
74 | * @}
75 | */
76 |
77 | /* Exported macros ------------------------------------------------------------*/
78 |
79 | /* Private macros ------------------------------------------------------------*/
80 |
81 | /** @addtogroup AWU_Private_Macros
82 | * @{
83 | */
84 |
85 | /**
86 | * @brief Macro used by the assert function to check the different functions parameters.
87 | */
88 |
89 | /**
90 | * @brief Macro used by the assert function to check the AWU timebases
91 | */
92 | #define IS_AWU_TIMEBASE_OK(TB) \
93 | (((TB) == AWU_TIMEBASE_NO_IT) || \
94 | ((TB) == AWU_TIMEBASE_250US) || \
95 | ((TB) == AWU_TIMEBASE_500US) || \
96 | ((TB) == AWU_TIMEBASE_1MS) || \
97 | ((TB) == AWU_TIMEBASE_2MS) || \
98 | ((TB) == AWU_TIMEBASE_4MS) || \
99 | ((TB) == AWU_TIMEBASE_8MS) || \
100 | ((TB) == AWU_TIMEBASE_16MS) || \
101 | ((TB) == AWU_TIMEBASE_32MS) || \
102 | ((TB) == AWU_TIMEBASE_64MS) || \
103 | ((TB) == AWU_TIMEBASE_128MS) || \
104 | ((TB) == AWU_TIMEBASE_256MS) || \
105 | ((TB) == AWU_TIMEBASE_512MS) || \
106 | ((TB) == AWU_TIMEBASE_1S) || \
107 | ((TB) == AWU_TIMEBASE_2S) || \
108 | ((TB) == AWU_TIMEBASE_12S) || \
109 | ((TB) == AWU_TIMEBASE_30S))
110 |
111 | /**
112 | * @brief Macro used by the assert function to check the LSI frequency (in Hz)
113 | */
114 | #define IS_LSI_FREQUENCY_OK(FREQ) \
115 | (((FREQ) >= LSI_FREQUENCY_MIN) && \
116 | ((FREQ) <= LSI_FREQUENCY_MAX))
117 |
118 | /**
119 | * @}
120 | */
121 |
122 | /* Exported functions ------------------------------------------------------- */
123 |
124 | /** @addtogroup AWU_Exported_Functions
125 | * @{
126 | */
127 | void AWU_DeInit(void);
128 | void AWU_Init(AWU_Timebase_TypeDef AWU_TimeBase);
129 | void AWU_Cmd(FunctionalState NewState);
130 | void AWU_LSICalibrationConfig(uint32_t LSIFreqHz);
131 | void AWU_IdleModeEnable(void);
132 | FlagStatus AWU_GetFlagStatus(void);
133 |
134 | /**
135 | * @}
136 | */
137 |
138 | #endif /* __STM8S_AWU_H */
139 |
140 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
141 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_beep.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_beep.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the BEEP peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 |
23 | /* Define to prevent recursive inclusion -------------------------------------*/
24 | #ifndef __STM8S_BEEP_H
25 | #define __STM8S_BEEP_H
26 |
27 | /* Includes ------------------------------------------------------------------*/
28 | #include "stm8s.h"
29 |
30 | /* Exported types ------------------------------------------------------------*/
31 |
32 | /** @addtogroup BEEP_Exported_Types
33 | * @{
34 | */
35 |
36 | /**
37 | * @brief BEEP Frequency selection
38 | */
39 | typedef enum {
40 | BEEP_FREQUENCY_1KHZ = (uint8_t)0x00, /*!< Beep signal output frequency equals to 1 KHz */
41 | BEEP_FREQUENCY_2KHZ = (uint8_t)0x40, /*!< Beep signal output frequency equals to 2 KHz */
42 | BEEP_FREQUENCY_4KHZ = (uint8_t)0x80 /*!< Beep signal output frequency equals to 4 KHz */
43 | } BEEP_Frequency_TypeDef;
44 |
45 | /**
46 | * @}
47 | */
48 |
49 | /* Exported constants --------------------------------------------------------*/
50 |
51 | /** @addtogroup BEEP_Exported_Constants
52 | * @{
53 | */
54 |
55 | #define BEEP_CALIBRATION_DEFAULT ((uint8_t)0x0B) /*!< Default value when calibration is not done */
56 |
57 | #define LSI_FREQUENCY_MIN ((uint32_t)110000) /*!< LSI minimum value in Hertz */
58 | #define LSI_FREQUENCY_MAX ((uint32_t)150000) /*!< LSI maximum value in Hertz */
59 |
60 | /**
61 | * @}
62 | */
63 |
64 | /* Exported macros -----------------------------------------------------------*/
65 | /* Private macros ------------------------------------------------------------*/
66 |
67 | /** @addtogroup BEEP_Private_Macros
68 | * @{
69 | */
70 |
71 | /**
72 | * @brief Macro used by the assert function to check the different functions parameters.
73 | */
74 |
75 | /**
76 | * @brief Macro used by the assert function to check the BEEP frequencies.
77 | */
78 | #define IS_BEEP_FREQUENCY_OK(FREQ) \
79 | (((FREQ) == BEEP_FREQUENCY_1KHZ) || \
80 | ((FREQ) == BEEP_FREQUENCY_2KHZ) || \
81 | ((FREQ) == BEEP_FREQUENCY_4KHZ))
82 |
83 | /**
84 | * @brief Macro used by the assert function to check the LSI frequency (in Hz).
85 | */
86 | #define IS_LSI_FREQUENCY_OK(FREQ) \
87 | (((FREQ) >= LSI_FREQUENCY_MIN) && \
88 | ((FREQ) <= LSI_FREQUENCY_MAX))
89 |
90 | /**
91 | * @}
92 | */
93 |
94 | /* Exported functions ------------------------------------------------------- */
95 |
96 | /** @addtogroup BEEP_Exported_Functions
97 | * @{
98 | */
99 |
100 | void BEEP_DeInit(void);
101 | void BEEP_Init(BEEP_Frequency_TypeDef BEEP_Frequency);
102 | void BEEP_Cmd(FunctionalState NewState);
103 | void BEEP_LSICalibrationConfig(uint32_t LSIFreqHz);
104 |
105 |
106 | /**
107 | * @}
108 | */
109 |
110 | #endif /* __STM8S_BEEP_H */
111 |
112 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
113 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_exti.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_exti.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the EXTI peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_EXTI_H__
24 | #define __STM8S_EXTI_H__
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Exported types ------------------------------------------------------------*/
30 |
31 | /** @addtogroup EXTI_Exported_Types
32 | * @{
33 | */
34 |
35 | /**
36 | * @brief EXTI Sensitivity values for PORTA to PORTE
37 | */
38 | typedef enum {
39 | EXTI_SENSITIVITY_FALL_LOW = (uint8_t)0x00, /*!< Interrupt on Falling edge and Low level */
40 | EXTI_SENSITIVITY_RISE_ONLY = (uint8_t)0x01, /*!< Interrupt on Rising edge only */
41 | EXTI_SENSITIVITY_FALL_ONLY = (uint8_t)0x02, /*!< Interrupt on Falling edge only */
42 | EXTI_SENSITIVITY_RISE_FALL = (uint8_t)0x03 /*!< Interrupt on Rising and Falling edges */
43 | } EXTI_Sensitivity_TypeDef;
44 |
45 | /**
46 | * @brief EXTI Sensitivity values for TLI
47 | */
48 | typedef enum {
49 | EXTI_TLISENSITIVITY_FALL_ONLY = (uint8_t)0x00, /*!< Top Level Interrupt on Falling edge only */
50 | EXTI_TLISENSITIVITY_RISE_ONLY = (uint8_t)0x04 /*!< Top Level Interrupt on Rising edge only */
51 | } EXTI_TLISensitivity_TypeDef;
52 |
53 | /**
54 | * @brief EXTI PortNum possible values
55 | */
56 | typedef enum {
57 | EXTI_PORT_GPIOA = (uint8_t)0x00, /*!< GPIO Port A */
58 | EXTI_PORT_GPIOB = (uint8_t)0x01, /*!< GPIO Port B */
59 | EXTI_PORT_GPIOC = (uint8_t)0x02, /*!< GPIO Port C */
60 | EXTI_PORT_GPIOD = (uint8_t)0x03, /*!< GPIO Port D */
61 | EXTI_PORT_GPIOE = (uint8_t)0x04 /*!< GPIO Port E */
62 | } EXTI_Port_TypeDef;
63 |
64 | /**
65 | * @}
66 | */
67 |
68 | /* Private macros ------------------------------------------------------------*/
69 |
70 | /** @addtogroup EXTI_Private_Macros
71 | * @{
72 | */
73 |
74 | /**
75 | * @brief Macro used by the assert function in order to check the different sensitivity values for PORTA to PORTE.
76 | */
77 | #define IS_EXTI_SENSITIVITY_OK(SensitivityValue) \
78 | (((SensitivityValue) == EXTI_SENSITIVITY_FALL_LOW) || \
79 | ((SensitivityValue) == EXTI_SENSITIVITY_RISE_ONLY) || \
80 | ((SensitivityValue) == EXTI_SENSITIVITY_FALL_ONLY) || \
81 | ((SensitivityValue) == EXTI_SENSITIVITY_RISE_FALL))
82 |
83 | /**
84 | * @brief Macro used by the assert function in order to check the different sensitivity values for TLI.
85 | */
86 | #define IS_EXTI_TLISENSITIVITY_OK(SensitivityValue) \
87 | (((SensitivityValue) == EXTI_TLISENSITIVITY_FALL_ONLY) || \
88 | ((SensitivityValue) == EXTI_TLISENSITIVITY_RISE_ONLY))
89 |
90 | /**
91 | * @brief Macro used by the assert function in order to check the different Port values
92 | */
93 | #define IS_EXTI_PORT_OK(PORT) \
94 | (((PORT) == EXTI_PORT_GPIOA) ||\
95 | ((PORT) == EXTI_PORT_GPIOB) ||\
96 | ((PORT) == EXTI_PORT_GPIOC) ||\
97 | ((PORT) == EXTI_PORT_GPIOD) ||\
98 | ((PORT) == EXTI_PORT_GPIOE))
99 |
100 | /**
101 | * @brief Macro used by the assert function in order to check the different values of the EXTI PinMask
102 | */
103 | #define IS_EXTI_PINMASK_OK(PinMask) ((((PinMask) & (uint8_t)0x00) == (uint8_t)0x00) && ((PinMask) != (uint8_t)0x00))
104 |
105 | /**
106 | * @}
107 | */
108 |
109 | /* Exported functions ------------------------------------------------------- */
110 |
111 | /** @addtogroup EXTI_Exported_Functions
112 | * @{
113 | */
114 |
115 | void EXTI_DeInit(void);
116 | void EXTI_SetExtIntSensitivity(EXTI_Port_TypeDef Port, EXTI_Sensitivity_TypeDef SensitivityValue);
117 | void EXTI_SetTLISensitivity(EXTI_TLISensitivity_TypeDef SensitivityValue);
118 | EXTI_Sensitivity_TypeDef EXTI_GetExtIntSensitivity(EXTI_Port_TypeDef Port);
119 | EXTI_TLISensitivity_TypeDef EXTI_GetTLISensitivity(void);
120 |
121 | /**
122 | * @}
123 | */
124 |
125 | #endif /* __STM8S_EXTI_H__ */
126 |
127 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
128 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_flash.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_flash.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the FLASH peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_FLASH_H
24 | #define __STM8S_FLASH_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Exported constants --------------------------------------------------------*/
30 |
31 | /** @addtogroup FLASH_Exported_Constants
32 | * @{
33 | */
34 |
35 | #define FLASH_PROG_START_PHYSICAL_ADDRESS ((uint32_t)0x008000) /*!< Program memory: start address */
36 |
37 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined (STM8AF52Ax) || defined (STM8AF62Ax)
38 | #define FLASH_PROG_END_PHYSICAL_ADDRESS ((uint32_t)0x027FFF) /*!< Program memory: end address */
39 | #define FLASH_PROG_BLOCKS_NUMBER ((uint16_t)1024) /*!< Program memory: total number of blocks */
40 | #define FLASH_DATA_START_PHYSICAL_ADDRESS ((uint32_t)0x004000) /*!< Data EEPROM memory: start address */
41 | #define FLASH_DATA_END_PHYSICAL_ADDRESS ((uint32_t)0x0047FF) /*!< Data EEPROM memory: end address */
42 | #define FLASH_DATA_BLOCKS_NUMBER ((uint16_t)16) /*!< Data EEPROM memory: total number of blocks */
43 | #define FLASH_BLOCK_SIZE ((uint8_t)128) /*!< Number of bytes in a block (common for Program and Data memories) */
44 | #endif /* STM8S208, STM8S207, STM8S007, STM8AF52Ax, STM8AF62Ax */
45 |
46 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8AF626x)
47 | #define FLASH_PROG_END_PHYSICAL_ADDRESS ((uint32_t)0xFFFF) /*!< Program memory: end address */
48 | #define FLASH_PROG_BLOCKS_NUMBER ((uint16_t)256) /*!< Program memory: total number of blocks */
49 | #define FLASH_DATA_START_PHYSICAL_ADDRESS ((uint32_t)0x004000) /*!< Data EEPROM memory: start address */
50 | #define FLASH_DATA_END_PHYSICAL_ADDRESS ((uint32_t)0x0043FF) /*!< Data EEPROM memory: end address */
51 | #define FLASH_DATA_BLOCKS_NUMBER ((uint16_t)8) /*!< Data EEPROM memory: total number of blocks */
52 | #define FLASH_BLOCK_SIZE ((uint8_t)128) /*!< Number of bytes in a block (common for Program and Data memories) */
53 | #endif /* STM8S105 or STM8AF626x */
54 |
55 | #if defined(STM8S103) || defined(STM8S003) || defined(STM8S903)
56 | #define FLASH_PROG_END_PHYSICAL_ADDRESS ((uint32_t)0x9FFF) /*!< Program memory: end address */
57 | #define FLASH_PROG_BLOCKS_NUMBER ((uint16_t)128) /*!< Program memory: total number of blocks */
58 | #define FLASH_DATA_START_PHYSICAL_ADDRESS ((uint32_t)0x004000) /*!< Data EEPROM memory: start address */
59 | #define FLASH_DATA_END_PHYSICAL_ADDRESS ((uint32_t)0x00427F) /*!< Data EEPROM memory: end address */
60 | #define FLASH_DATA_BLOCKS_NUMBER ((uint16_t)10) /*!< Data EEPROM memory: total number of blocks */
61 | #define FLASH_BLOCK_SIZE ((uint8_t)64) /*!< Number of bytes in a block (common for Program and Data memories) */
62 | #endif /* STM8S103, STM8S903 */
63 |
64 | #define FLASH_RASS_KEY1 ((uint8_t)0x56) /*!< First RASS key */
65 | #define FLASH_RASS_KEY2 ((uint8_t)0xAE) /*!< Second RASS key */
66 |
67 | #define OPTION_BYTE_START_PHYSICAL_ADDRESS ((uint16_t)0x4800)
68 | #define OPTION_BYTE_END_PHYSICAL_ADDRESS ((uint16_t)0x487F)
69 | #define FLASH_OPTIONBYTE_ERROR ((uint16_t)0x5555) /*!< Error code option byte
70 | (if value read is not equal to complement value read) */
71 | /**
72 | * @}
73 | */
74 |
75 | /* Exported types ------------------------------------------------------------*/
76 |
77 | /** @addtogroup FLASH_Exported_Types
78 | * @{
79 | */
80 |
81 | /**
82 | * @brief FLASH Memory types
83 | */
84 | typedef enum {
85 | FLASH_MEMTYPE_PROG = (uint8_t)0xFD, /*!< Program memory */
86 | FLASH_MEMTYPE_DATA = (uint8_t)0xF7 /*!< Data EEPROM memory */
87 | } FLASH_MemType_TypeDef;
88 |
89 | /**
90 | * @brief FLASH programming modes
91 | */
92 | typedef enum {
93 | FLASH_PROGRAMMODE_STANDARD = (uint8_t)0x00, /*!< Standard programming mode */
94 | FLASH_PROGRAMMODE_FAST = (uint8_t)0x10 /*!< Fast programming mode */
95 | } FLASH_ProgramMode_TypeDef;
96 |
97 | /**
98 | * @brief FLASH fixed programming time
99 | */
100 | typedef enum {
101 | FLASH_PROGRAMTIME_STANDARD = (uint8_t)0x00, /*!< Standard programming time fixed at 1/2 tprog */
102 | FLASH_PROGRAMTIME_TPROG = (uint8_t)0x01 /*!< Programming time fixed at tprog */
103 | } FLASH_ProgramTime_TypeDef;
104 |
105 | /**
106 | * @brief FLASH Low Power mode select
107 | */
108 | typedef enum {
109 | FLASH_LPMODE_POWERDOWN = (uint8_t)0x04, /*!< HALT: Power-Down / ACTIVE-HALT: Power-Down */
110 | FLASH_LPMODE_STANDBY = (uint8_t)0x08, /*!< HALT: Standby / ACTIVE-HALT: Standby */
111 | FLASH_LPMODE_POWERDOWN_STANDBY = (uint8_t)0x00, /*!< HALT: Power-Down / ACTIVE-HALT: Standby */
112 | FLASH_LPMODE_STANDBY_POWERDOWN = (uint8_t)0x0C /*!< HALT: Standby / ACTIVE-HALT: Power-Down */
113 | }
114 | FLASH_LPMode_TypeDef;
115 |
116 | /**
117 | * @brief FLASH status of the last operation
118 | */
119 | typedef enum {
120 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S105) || \
121 | defined(STM8S005) || defined (STM8AF52Ax) || defined (STM8AF62Ax) || defined(STM8AF626x)
122 | FLASH_STATUS_END_HIGH_VOLTAGE = (uint8_t)0x40, /*!< End of high voltage */
123 | #endif /* STM8S208, STM8S207, STM8S105, STM8AF62Ax, STM8AF52Ax, STM8AF626x */
124 | FLASH_STATUS_SUCCESSFUL_OPERATION = (uint8_t)0x04, /*!< End of operation flag */
125 | FLASH_STATUS_TIMEOUT = (uint8_t)0x02, /*!< Time out error */
126 | FLASH_STATUS_WRITE_PROTECTION_ERROR = (uint8_t)0x01 /*!< Write attempted to protected page */
127 | } FLASH_Status_TypeDef;
128 |
129 | /**
130 | * @brief FLASH flags definition
131 | * - Warning : FLAG value = mapping position register
132 | */
133 | typedef enum {
134 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S105) || \
135 | defined(STM8S005) || defined (STM8AF52Ax) || defined (STM8AF62Ax) || defined(STM8AF626x)
136 | FLASH_FLAG_HVOFF = (uint8_t)0x40, /*!< End of high voltage flag */
137 | #endif /* STM8S208, STM8S207, STM8S105, STM8AF62Ax, STM8AF52Ax, STM8AF626x */
138 | FLASH_FLAG_DUL = (uint8_t)0x08, /*!< Data EEPROM unlocked flag */
139 | FLASH_FLAG_EOP = (uint8_t)0x04, /*!< End of programming (write or erase operation) flag */
140 | FLASH_FLAG_PUL = (uint8_t)0x02, /*!< Flash Program memory unlocked flag */
141 | FLASH_FLAG_WR_PG_DIS = (uint8_t)0x01 /*!< Write attempted to protected page flag */
142 | } FLASH_Flag_TypeDef;
143 |
144 | /**
145 | * @}
146 | */
147 |
148 | /* Private macros ------------------------------------------------------------*/
149 |
150 | /**
151 | * @brief Macros used by the assert function in order to check the different functions parameters.
152 | * @addtogroup FLASH_Private_Macros
153 | * @{
154 | */
155 |
156 | /**
157 | * @brief Macro used by the assert function in order to check the different sensitivity values for the flash program Address
158 | */
159 |
160 | #define IS_FLASH_PROG_ADDRESS_OK(ADDRESS) (((ADDRESS) >= FLASH_PROG_START_PHYSICAL_ADDRESS) && \
161 | ((ADDRESS) <= FLASH_PROG_END_PHYSICAL_ADDRESS))
162 |
163 | /**
164 | * @brief Macro used by the assert function in order to check the different sensitivity values for the data eeprom Address
165 | */
166 |
167 | #define IS_FLASH_DATA_ADDRESS_OK(ADDRESS) (((ADDRESS) >= FLASH_DATA_START_PHYSICAL_ADDRESS) && \
168 | ((ADDRESS) <= FLASH_DATA_END_PHYSICAL_ADDRESS))
169 |
170 | /**
171 | * @brief Macro used by the assert function in order to check the different sensitivity values for the data eeprom and flash program Address
172 | */
173 | #define IS_FLASH_ADDRESS_OK(ADDRESS)((((ADDRESS) >= FLASH_PROG_START_PHYSICAL_ADDRESS) && ((ADDRESS) <= FLASH_PROG_END_PHYSICAL_ADDRESS)) || \
174 | (((ADDRESS) >= FLASH_DATA_START_PHYSICAL_ADDRESS) && ((ADDRESS) <= FLASH_DATA_END_PHYSICAL_ADDRESS)))
175 |
176 | /**
177 | * @brief Macro used by the assert function in order to check the different sensitivity values for the flash program Block number
178 | */
179 | #define IS_FLASH_PROG_BLOCK_NUMBER_OK(BLOCKNUM) ((BLOCKNUM) < FLASH_PROG_BLOCKS_NUMBER)
180 |
181 | /**
182 | * @brief Macro used by the assert function in order to check the different sensitivity values for the data eeprom Block number
183 | */
184 | #define IS_FLASH_DATA_BLOCK_NUMBER_OK(BLOCKNUM) ((BLOCKNUM) < FLASH_DATA_BLOCKS_NUMBER)
185 |
186 | /**
187 | * @brief Macro used by the assert function in order to check the different sensitivity values for the flash memory type
188 | */
189 |
190 | #define IS_MEMORY_TYPE_OK(MEMTYPE) (((MEMTYPE) == FLASH_MEMTYPE_PROG) || \
191 | ((MEMTYPE) == FLASH_MEMTYPE_DATA))
192 |
193 | /**
194 | * @brief Macro used by the assert function in order to check the different sensitivity values for the flash program mode
195 | */
196 |
197 | #define IS_FLASH_PROGRAM_MODE_OK(MODE) (((MODE) == FLASH_PROGRAMMODE_STANDARD) || \
198 | ((MODE) == FLASH_PROGRAMMODE_FAST))
199 |
200 | /**
201 | * @brief Macro used by the assert function in order to check the program time mode
202 | */
203 |
204 | #define IS_FLASH_PROGRAM_TIME_OK(TIME) (((TIME) == FLASH_PROGRAMTIME_STANDARD) || \
205 | ((TIME) == FLASH_PROGRAMTIME_TPROG))
206 |
207 | /**
208 | * @brief Macro used by the assert function in order to check the different
209 | * sensitivity values for the low power mode
210 | */
211 |
212 | #define IS_FLASH_LOW_POWER_MODE_OK(LPMODE) (((LPMODE) == FLASH_LPMODE_POWERDOWN) || \
213 | ((LPMODE) == FLASH_LPMODE_STANDBY) || \
214 | ((LPMODE) == FLASH_LPMODE_POWERDOWN_STANDBY) || \
215 | ((LPMODE) == FLASH_LPMODE_STANDBY_POWERDOWN))
216 |
217 | /**
218 | * @brief Macro used by the assert function in order to check the different
219 | * sensitivity values for the option bytes Address
220 | */
221 | #define IS_OPTION_BYTE_ADDRESS_OK(ADDRESS) (((ADDRESS) >= OPTION_BYTE_START_PHYSICAL_ADDRESS) && \
222 | ((ADDRESS) <= OPTION_BYTE_END_PHYSICAL_ADDRESS))
223 |
224 |
225 | /**
226 | * @brief Macro used by the assert function in order to check the different flags values
227 | */
228 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S105) || \
229 | defined(STM8S005) || defined (STM8AF52Ax) || defined (STM8AF62Ax) || defined(STM8AF626x)
230 | #define IS_FLASH_FLAGS_OK(FLAG) (((FLAG) == FLASH_FLAG_HVOFF) || \
231 | ((FLAG) == FLASH_FLAG_DUL) || \
232 | ((FLAG) == FLASH_FLAG_EOP) || \
233 | ((FLAG) == FLASH_FLAG_PUL) || \
234 | ((FLAG) == FLASH_FLAG_WR_PG_DIS))
235 | #else /* STM8S103, STM8S903 */
236 | #define IS_FLASH_FLAGS_OK(FLAG) (((FLAG) == FLASH_FLAG_DUL) || \
237 | ((FLAG) == FLASH_FLAG_EOP) || \
238 | ((FLAG) == FLASH_FLAG_PUL) || \
239 | ((FLAG) == FLASH_FLAG_WR_PG_DIS))
240 | #endif /* STM8S208, STM8S207, STM8S105, STM8AF62Ax, STM8AF52Ax, STM8AF626x */
241 | /**
242 | * @}
243 | */
244 |
245 | /* Exported functions ------------------------------------------------------- */
246 |
247 | /** @addtogroup FLASH_Exported_Functions
248 | * @{
249 | */
250 | void FLASH_Unlock(FLASH_MemType_TypeDef FLASH_MemType);
251 | void FLASH_Lock(FLASH_MemType_TypeDef FLASH_MemType);
252 | void FLASH_DeInit(void);
253 | void FLASH_ITConfig(FunctionalState NewState);
254 | void FLASH_EraseByte(uint32_t Address);
255 | void FLASH_ProgramByte(uint32_t Address, uint8_t Data);
256 | uint8_t FLASH_ReadByte(uint32_t Address);
257 | void FLASH_ProgramWord(uint32_t Address, uint32_t Data);
258 | uint16_t FLASH_ReadOptionByte(uint16_t Address);
259 | void FLASH_ProgramOptionByte(uint16_t Address, uint8_t Data);
260 | void FLASH_EraseOptionByte(uint16_t Address);
261 | void FLASH_SetLowPowerMode(FLASH_LPMode_TypeDef FLASH_LPMode);
262 | void FLASH_SetProgrammingTime(FLASH_ProgramTime_TypeDef FLASH_ProgTime);
263 | FLASH_LPMode_TypeDef FLASH_GetLowPowerMode(void);
264 | FLASH_ProgramTime_TypeDef FLASH_GetProgrammingTime(void);
265 | uint32_t FLASH_GetBootSize(void);
266 | FlagStatus FLASH_GetFlagStatus(FLASH_Flag_TypeDef FLASH_FLAG);
267 |
268 | /**
269 | @code
270 | All the functions declared below must be executed from RAM exclusively, except
271 | for the FLASH_WaitForLastOperation function which can be executed from Flash.
272 |
273 | Steps of the execution from RAM differs from one toolchain to another.
274 | for more details refer to stm8s_flash.c file.
275 |
276 | To enable execution from RAM you can either uncomment the following define
277 | in the stm8s.h file or define it in your toolchain compiler preprocessor
278 | - #define RAM_EXECUTION (1)
279 |
280 | @endcode
281 | */
282 | IN_RAM(void FLASH_EraseBlock(uint16_t BlockNum, FLASH_MemType_TypeDef FLASH_MemType));
283 | IN_RAM(void FLASH_ProgramBlock(uint16_t BlockNum, FLASH_MemType_TypeDef FLASH_MemType,
284 | FLASH_ProgramMode_TypeDef FLASH_ProgMode, uint8_t *Buffer));
285 | IN_RAM(FLASH_Status_TypeDef FLASH_WaitForLastOperation(FLASH_MemType_TypeDef FLASH_MemType));
286 |
287 | /**
288 | * @}
289 | */
290 |
291 | #endif /*__STM8S_FLASH_H */
292 |
293 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
294 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_gpio.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_gpio.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the GPIO peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_GPIO_H
24 | #define __STM8S_GPIO_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Exported variables ------------------------------------------------------- */
30 | /* Exported types ------------------------------------------------------------*/
31 |
32 | /** @addtogroup GPIO_Exported_Types
33 | * @{
34 | */
35 |
36 | /**
37 | * @brief GPIO modes
38 | *
39 | * Bits definitions:
40 | * - Bit 7: 0 = INPUT mode
41 | * 1 = OUTPUT mode
42 | * 1 = PULL-UP (input) or PUSH-PULL (output)
43 | * - Bit 5: 0 = No external interrupt (input) or No slope control (output)
44 | * 1 = External interrupt (input) or Slow control enabled (output)
45 | * - Bit 4: 0 = Low level (output)
46 | * 1 = High level (output push-pull) or HI-Z (output open-drain)
47 | */
48 | typedef enum
49 | {
50 | GPIO_MODE_IN_FL_NO_IT = (uint8_t)0x00, /*!< Input floating, no external interrupt */
51 | GPIO_MODE_IN_PU_NO_IT = (uint8_t)0x40, /*!< Input pull-up, no external interrupt */
52 | GPIO_MODE_IN_FL_IT = (uint8_t)0x20, /*!< Input floating, external interrupt */
53 | GPIO_MODE_IN_PU_IT = (uint8_t)0x60, /*!< Input pull-up, external interrupt */
54 | GPIO_MODE_OUT_OD_LOW_FAST = (uint8_t)0xA0, /*!< Output open-drain, low level, 10MHz */
55 | GPIO_MODE_OUT_PP_LOW_FAST = (uint8_t)0xE0, /*!< Output push-pull, low level, 10MHz */
56 | GPIO_MODE_OUT_OD_LOW_SLOW = (uint8_t)0x80, /*!< Output open-drain, low level, 2MHz */
57 | GPIO_MODE_OUT_PP_LOW_SLOW = (uint8_t)0xC0, /*!< Output push-pull, low level, 2MHz */
58 | GPIO_MODE_OUT_OD_HIZ_FAST = (uint8_t)0xB0, /*!< Output open-drain, high-impedance level,10MHz */
59 | GPIO_MODE_OUT_PP_HIGH_FAST = (uint8_t)0xF0, /*!< Output push-pull, high level, 10MHz */
60 | GPIO_MODE_OUT_OD_HIZ_SLOW = (uint8_t)0x90, /*!< Output open-drain, high-impedance level, 2MHz */
61 | GPIO_MODE_OUT_PP_HIGH_SLOW = (uint8_t)0xD0 /*!< Output push-pull, high level, 2MHz */
62 | }GPIO_Mode_TypeDef;
63 |
64 | /**
65 | * @brief Definition of the GPIO pins. Used by the @ref GPIO_Init function in
66 | * order to select the pins to be initialized.
67 | */
68 |
69 | typedef enum
70 | {
71 | GPIO_PIN_0 = ((uint8_t)0x01), /*!< Pin 0 selected */
72 | GPIO_PIN_1 = ((uint8_t)0x02), /*!< Pin 1 selected */
73 | GPIO_PIN_2 = ((uint8_t)0x04), /*!< Pin 2 selected */
74 | GPIO_PIN_3 = ((uint8_t)0x08), /*!< Pin 3 selected */
75 | GPIO_PIN_4 = ((uint8_t)0x10), /*!< Pin 4 selected */
76 | GPIO_PIN_5 = ((uint8_t)0x20), /*!< Pin 5 selected */
77 | GPIO_PIN_6 = ((uint8_t)0x40), /*!< Pin 6 selected */
78 | GPIO_PIN_7 = ((uint8_t)0x80), /*!< Pin 7 selected */
79 | GPIO_PIN_LNIB = ((uint8_t)0x0F), /*!< Low nibble pins selected */
80 | GPIO_PIN_HNIB = ((uint8_t)0xF0), /*!< High nibble pins selected */
81 | GPIO_PIN_ALL = ((uint8_t)0xFF) /*!< All pins selected */
82 | }GPIO_Pin_TypeDef;
83 |
84 | /**
85 | * @}
86 | */
87 |
88 | /* Exported constants --------------------------------------------------------*/
89 | /* Exported macros -----------------------------------------------------------*/
90 | /* Private macros ------------------------------------------------------------*/
91 |
92 | /** @addtogroup GPIO_Private_Macros
93 | * @{
94 | */
95 |
96 | /**
97 | * @brief Macro used by the assert function to check the different functions parameters.
98 | */
99 |
100 | /**
101 | * @brief Macro used by the assert function in order to check the different
102 | * values of GPIOMode_TypeDef.
103 | */
104 | #define IS_GPIO_MODE_OK(MODE) \
105 | (((MODE) == GPIO_MODE_IN_FL_NO_IT) || \
106 | ((MODE) == GPIO_MODE_IN_PU_NO_IT) || \
107 | ((MODE) == GPIO_MODE_IN_FL_IT) || \
108 | ((MODE) == GPIO_MODE_IN_PU_IT) || \
109 | ((MODE) == GPIO_MODE_OUT_OD_LOW_FAST) || \
110 | ((MODE) == GPIO_MODE_OUT_PP_LOW_FAST) || \
111 | ((MODE) == GPIO_MODE_OUT_OD_LOW_SLOW) || \
112 | ((MODE) == GPIO_MODE_OUT_PP_LOW_SLOW) || \
113 | ((MODE) == GPIO_MODE_OUT_OD_HIZ_FAST) || \
114 | ((MODE) == GPIO_MODE_OUT_PP_HIGH_FAST) || \
115 | ((MODE) == GPIO_MODE_OUT_OD_HIZ_SLOW) || \
116 | ((MODE) == GPIO_MODE_OUT_PP_HIGH_SLOW))
117 |
118 | /**
119 | * @brief Macro used by the assert function in order to check the different
120 | * values of GPIO_Pins.
121 | */
122 | #define IS_GPIO_PIN_OK(PIN) ((PIN) != (uint8_t)0x00)
123 |
124 | /**
125 | * @}
126 | */
127 |
128 | /* Exported functions ------------------------------------------------------- */
129 | /** @addtogroup GPIO_Exported_Functions
130 | * @{
131 | */
132 |
133 | void GPIO_DeInit(GPIO_TypeDef* GPIOx);
134 | void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin, GPIO_Mode_TypeDef GPIO_Mode);
135 | void GPIO_Write(GPIO_TypeDef* GPIOx, uint8_t PortVal);
136 | void GPIO_WriteHigh(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins);
137 | void GPIO_WriteLow(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins);
138 | void GPIO_WriteReverse(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins);
139 | uint8_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx);
140 | uint8_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx);
141 | BitStatus GPIO_ReadInputPin(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin);
142 | void GPIO_ExternalPullUpConfig(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin, FunctionalState NewState);
143 | /**
144 | * @}
145 | */
146 |
147 | #endif /* __STM8L_GPIO_H */
148 |
149 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
150 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_itc.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_itc.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the ITC peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_ITC_H__
24 | #define __STM8S_ITC_H__
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Exported types ------------------------------------------------------------*/
30 |
31 | /** @addtogroup ITC_Exported_Types
32 | * @{
33 | */
34 |
35 | /**
36 | * @brief ITC Interrupt Lines selection
37 | */
38 | typedef enum {
39 | ITC_IRQ_TLI = (uint8_t)0, /*!< Software interrupt */
40 | ITC_IRQ_AWU = (uint8_t)1, /*!< Auto wake up from halt interrupt */
41 | ITC_IRQ_CLK = (uint8_t)2, /*!< Clock controller interrupt */
42 | ITC_IRQ_PORTA = (uint8_t)3, /*!< Port A external interrupts */
43 | ITC_IRQ_PORTB = (uint8_t)4, /*!< Port B external interrupts */
44 | ITC_IRQ_PORTC = (uint8_t)5, /*!< Port C external interrupts */
45 | ITC_IRQ_PORTD = (uint8_t)6, /*!< Port D external interrupts */
46 | ITC_IRQ_PORTE = (uint8_t)7, /*!< Port E external interrupts */
47 |
48 | #if defined(STM8S208) || defined(STM8AF52Ax)
49 | ITC_IRQ_CAN_RX = (uint8_t)8, /*!< beCAN RX interrupt */
50 | ITC_IRQ_CAN_TX = (uint8_t)9, /*!< beCAN TX/ER/SC interrupt */
51 | #endif /*STM8S208 or STM8AF52Ax */
52 |
53 | #ifdef STM8S903
54 | ITC_IRQ_PORTF = (uint8_t)8, /*!< Port F external interrupts */
55 | #endif /*STM8S903*/
56 |
57 | ITC_IRQ_SPI = (uint8_t)10, /*!< SPI interrupt */
58 | ITC_IRQ_TIM1_OVF = (uint8_t)11, /*!< TIM1 update/overflow/underflow/trigger/
59 | break interrupt*/
60 | ITC_IRQ_TIM1_CAPCOM = (uint8_t)12, /*!< TIM1 capture/compare interrupt */
61 |
62 | #ifdef STM8S903
63 | ITC_IRQ_TIM5_OVFTRI = (uint8_t)13, /*!< TIM5 update/overflow/underflow/trigger/
64 | interrupt */
65 | ITC_IRQ_TIM5_CAPCOM = (uint8_t)14, /*!< TIM5 capture/compare interrupt */
66 | #else
67 | ITC_IRQ_TIM2_OVF = (uint8_t)13, /*!< TIM2 update /overflow interrupt */
68 | ITC_IRQ_TIM2_CAPCOM = (uint8_t)14, /*!< TIM2 capture/compare interrupt */
69 | #endif /*STM8S903*/
70 |
71 | ITC_IRQ_TIM3_OVF = (uint8_t)15, /*!< TIM3 update /overflow interrupt*/
72 | ITC_IRQ_TIM3_CAPCOM = (uint8_t)16, /*!< TIM3 update /overflow interrupt */
73 | ITC_IRQ_UART1_TX = (uint8_t)17, /*!< USART1 TX interrupt */
74 | ITC_IRQ_UART1_RX = (uint8_t)18, /*!< USART1 RX interrupt */
75 | ITC_IRQ_I2C = (uint8_t)19, /*!< I2C interrupt */
76 |
77 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8AF626x)
78 | ITC_IRQ_UART2_TX = (uint8_t)20, /*!< USART2 TX interrupt */
79 | ITC_IRQ_UART2_RX = (uint8_t)21, /*!< USART2 RX interrupt */
80 | #endif /*STM8S105 or STM8AF626x */
81 |
82 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8AF52Ax) || defined(STM8AF62Ax)
83 | ITC_IRQ_UART3_TX = (uint8_t)20, /*!< USART3 TX interrupt */
84 | ITC_IRQ_UART3_RX = (uint8_t)21, /*!< USART3 RX interrupt */
85 | ITC_IRQ_ADC2 = (uint8_t)22, /*!< ADC2 interrupt */
86 | #endif /*STM8S208 or STM8S207 or STM8AF52Ax or STM8AF62Ax */
87 |
88 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8S103) || defined(STM8S003) || defined(STM8S903) || defined(STM8AF626x)
89 | ITC_IRQ_ADC1 = (uint8_t)22, /*!< ADC2 interrupt */
90 | #endif /*STM8S105, STM8S103 or STM8S903 or STM8AF626x */
91 |
92 | #ifdef STM8S903
93 | ITC_IRQ_TIM6_OVFTRI = (uint8_t)23, /*!< TIM6 update/overflow/underflow/trigger/
94 | interrupt */
95 | #else
96 | ITC_IRQ_TIM4_OVF = (uint8_t)23, /*!< TIM4 update /overflow interrupt */
97 | #endif /*STM8S903*/
98 |
99 | ITC_IRQ_EEPROM_EEC = (uint8_t)24 /*!< Flash interrupt */
100 | } ITC_Irq_TypeDef;
101 |
102 | /**
103 | * @brief ITC Priority Levels selection
104 | */
105 | typedef enum {
106 | ITC_PRIORITYLEVEL_0 = (uint8_t)0x02, /*!< Software priority level 0 (cannot be written) */
107 | ITC_PRIORITYLEVEL_1 = (uint8_t)0x01, /*!< Software priority level 1 */
108 | ITC_PRIORITYLEVEL_2 = (uint8_t)0x00, /*!< Software priority level 2 */
109 | ITC_PRIORITYLEVEL_3 = (uint8_t)0x03 /*!< Software priority level 3 */
110 | } ITC_PriorityLevel_TypeDef;
111 |
112 | /**
113 | * @}
114 | */
115 |
116 | /* Exported constants --------------------------------------------------------*/
117 |
118 | /** @addtogroup ITC_Exported_Constants
119 | * @{
120 | */
121 |
122 | #define CPU_SOFT_INT_DISABLED ((uint8_t)0x28) /*!< Mask for I1 and I0 bits in CPU_CC register */
123 |
124 | /**
125 | * @}
126 | */
127 |
128 | /* Private macros ------------------------------------------------------------*/
129 |
130 | /**
131 | * @brief Macros used by the assert function in order to check the different functions parameters.
132 | * @addtogroup ITC_Private_Macros
133 | * @{
134 | */
135 |
136 | /* Used by assert function */
137 | #define IS_ITC_IRQ_OK(IRQ) ((IRQ) <= (uint8_t)24)
138 |
139 | /* Used by assert function */
140 | #define IS_ITC_PRIORITY_OK(PriorityValue) \
141 | (((PriorityValue) == ITC_PRIORITYLEVEL_0) || \
142 | ((PriorityValue) == ITC_PRIORITYLEVEL_1) || \
143 | ((PriorityValue) == ITC_PRIORITYLEVEL_2) || \
144 | ((PriorityValue) == ITC_PRIORITYLEVEL_3))
145 |
146 | /* Used by assert function */
147 | #define IS_ITC_INTERRUPTS_DISABLED (ITC_GetSoftIntStatus() == CPU_SOFT_INT_DISABLED)
148 |
149 | /**
150 | * @}
151 | */
152 |
153 | /* Exported functions ------------------------------------------------------- */
154 |
155 | /** @addtogroup ITC_Exported_Functions
156 | * @{
157 | */
158 |
159 | uint8_t ITC_GetCPUCC(void);
160 | void ITC_DeInit(void);
161 | uint8_t ITC_GetSoftIntStatus(void);
162 | void ITC_SetSoftwarePriority(ITC_Irq_TypeDef IrqNum, ITC_PriorityLevel_TypeDef PriorityValue);
163 | ITC_PriorityLevel_TypeDef ITC_GetSoftwarePriority(ITC_Irq_TypeDef IrqNum);
164 |
165 | /**
166 | * @}
167 | */
168 |
169 | #endif /* __STM8S_ITC_H__ */
170 |
171 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
172 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_iwdg.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_iwdg.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototypes and macros for the IWDG peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_IWDG_H
24 | #define __STM8S_IWDG_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /** @addtogroup STM8S_StdPeriph_Driver
30 | * @{
31 | */
32 |
33 | /** @addtogroup IWDG_Private_Define
34 | * @{
35 | */
36 |
37 | /**
38 | * @brief Define used to prevent watchdog reset
39 | */
40 | #define IWDG_KEY_REFRESH ((uint8_t)0xAA) /*!< This value written in the Key register prevent the watchdog reset */
41 |
42 | /**
43 | * @brief Define used to start the watchdog counter down
44 | */
45 | #define IWDG_KEY_ENABLE ((uint8_t)0xCC) /*!< This value written in the Key register start the watchdog counting down*/
46 |
47 | /**
48 | * @}
49 | */
50 |
51 | /** @addtogroup IWDG_Private_Macros
52 | * @{
53 | */
54 |
55 | /**
56 | * @brief Macro used by the assert function in order to check the different
57 | * values of the prescaler.
58 | */
59 | #define IS_IWDG_PRESCALER_OK(VALUE) (((VALUE) == IWDG_Prescaler_4 ) || \
60 | ((VALUE) == IWDG_Prescaler_8 ) || \
61 | ((VALUE) == IWDG_Prescaler_16 ) || \
62 | ((VALUE) == IWDG_Prescaler_32 ) || \
63 | ((VALUE) == IWDG_Prescaler_64 ) || \
64 | ((VALUE) == IWDG_Prescaler_128 ) || \
65 | ((VALUE) == IWDG_Prescaler_256))
66 |
67 | /**
68 | * @brief Macro used by the assert function in order to check the different
69 | * values of the counter register.
70 | */
71 | #define IS_IWDG_WRITEACCESS_MODE_OK(MODE) (((MODE) == IWDG_WriteAccess_Enable) || ((MODE) == IWDG_WriteAccess_Disable))
72 |
73 | /**
74 | * @}
75 | */
76 |
77 | /** @addtogroup IWDG_Exported_Types
78 | * @{
79 | */
80 |
81 | /** IWDG write acces enumeration */
82 | typedef enum
83 | {
84 | IWDG_WriteAccess_Enable = (uint8_t)0x55, /*!< Code 0x55 in Key register, allow write access to Prescaler and Reload registers */
85 | IWDG_WriteAccess_Disable = (uint8_t)0x00 /*!< Code 0x00 in Key register, not allow write access to Prescaler and Reload registers */
86 | } IWDG_WriteAccess_TypeDef;
87 |
88 | /** IWDG prescaler enumaration */
89 | typedef enum
90 | {
91 | IWDG_Prescaler_4 = (uint8_t)0x00, /*!< Used to set prescaler register to 4 */
92 | IWDG_Prescaler_8 = (uint8_t)0x01, /*!< Used to set prescaler register to 8 */
93 | IWDG_Prescaler_16 = (uint8_t)0x02, /*!< Used to set prescaler register to 16 */
94 | IWDG_Prescaler_32 = (uint8_t)0x03, /*!< Used to set prescaler register to 32 */
95 | IWDG_Prescaler_64 = (uint8_t)0x04, /*!< Used to set prescaler register to 64 */
96 | IWDG_Prescaler_128 = (uint8_t)0x05, /*!< Used to set prescaler register to 128 */
97 | IWDG_Prescaler_256 = (uint8_t)0x06 /*!< Used to set prescaler register to 256 */
98 | } IWDG_Prescaler_TypeDef;
99 |
100 | /**
101 | * @}
102 | */
103 |
104 | /** @addtogroup IWDG_Exported_Functions
105 | * @{
106 | */
107 |
108 | void IWDG_WriteAccessCmd(IWDG_WriteAccess_TypeDef IWDG_WriteAccess);
109 | void IWDG_SetPrescaler(IWDG_Prescaler_TypeDef IWDG_Prescaler);
110 | void IWDG_SetReload(uint8_t IWDG_Reload);
111 | void IWDG_ReloadCounter(void);
112 | void IWDG_Enable(void);
113 |
114 | /**
115 | * @}
116 | */
117 |
118 | #endif /* __STM8S_IWDG_H */
119 |
120 | /**
121 | * @}
122 | */
123 |
124 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
125 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_rst.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_rst.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the RST peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 | /* Define to prevent recursive inclusion -------------------------------------*/
22 | #ifndef __STM8S_RST_H
23 | #define __STM8S_RST_H
24 |
25 | /* Includes ------------------------------------------------------------------*/
26 | #include "stm8s.h"
27 |
28 | /** @addtogroup STM8S_StdPeriph_Driver
29 | * @{
30 | */
31 |
32 | /** @addtogroup RST_Exported_Types
33 | * @{
34 | */
35 | typedef enum {
36 | RST_FLAG_EMCF = (uint8_t)0x10, /*!< EMC reset flag */
37 | RST_FLAG_SWIMF = (uint8_t)0x08, /*!< SWIM reset flag */
38 | RST_FLAG_ILLOPF = (uint8_t)0x04, /*!< Illigal opcode reset flag */
39 | RST_FLAG_IWDGF = (uint8_t)0x02, /*!< Independent watchdog reset flag */
40 | RST_FLAG_WWDGF = (uint8_t)0x01 /*!< Window watchdog reset flag */
41 | }RST_Flag_TypeDef;
42 |
43 | /**
44 | * @}
45 | */
46 |
47 | /* Exported constants --------------------------------------------------------*/
48 | /* Exported macros -----------------------------------------------------------*/
49 |
50 | /** @addtogroup RST_Private_Macros
51 | * @{
52 | */
53 |
54 | /**
55 | * @brief Macro used by the assert function to check the different functions parameters.
56 | */
57 | /**
58 | * @brief Macro used by the assert function to check the different RST flags.
59 | */
60 | #define IS_RST_FLAG_OK(FLAG) (((FLAG) == RST_FLAG_EMCF) || \
61 | ((FLAG) == RST_FLAG_SWIMF) ||\
62 | ((FLAG) == RST_FLAG_ILLOPF) ||\
63 | ((FLAG) == RST_FLAG_IWDGF) ||\
64 | ((FLAG) == RST_FLAG_WWDGF))
65 |
66 | /**
67 | * @}
68 | */
69 |
70 | /** @addtogroup RST_Exported_functions
71 | * @{
72 | */
73 | FlagStatus RST_GetFlagStatus(RST_Flag_TypeDef RST_Flag);
74 | void RST_ClearFlag(RST_Flag_TypeDef RST_Flag);
75 |
76 | /**
77 | * @}
78 | */
79 |
80 | #endif /* __STM8S_RST_H */
81 |
82 | /**
83 | * @}
84 | */
85 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
86 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_spi.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_spi.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the SPI peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_SPI_H
24 | #define __STM8S_SPI_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /** @addtogroup STM8S_StdPeriph_Driver
30 | * @{
31 | */
32 |
33 | /** @addtogroup SPI_Exported_Types
34 | * @{
35 | */
36 |
37 | /**
38 | * @brief SPI data direction mode
39 | * Warning: element values correspond to BDM, BDOE, RXONLY bits position
40 | */
41 | typedef enum {
42 | SPI_DATADIRECTION_2LINES_FULLDUPLEX = (uint8_t)0x00, /*!< 2-line uni-directional data mode enable */
43 | SPI_DATADIRECTION_2LINES_RXONLY = (uint8_t)0x04, /*!< Receiver only in 2 line uni-directional data mode */
44 | SPI_DATADIRECTION_1LINE_RX = (uint8_t)0x80, /*!< Receiver only in 1 line bi-directional data mode */
45 | SPI_DATADIRECTION_1LINE_TX = (uint8_t)0xC0 /*!< Transmit only in 1 line bi-directional data mode */
46 | } SPI_DataDirection_TypeDef;
47 |
48 | /**
49 | * @brief SPI Slave Select management
50 | * Warning: element values correspond to LSBFIRST bit position
51 | */
52 | typedef enum
53 | {
54 | SPI_NSS_SOFT = (uint8_t)0x02, /*!< Software slave management disabled */
55 | SPI_NSS_HARD = (uint8_t)0x00 /*!< Software slave management enabled */
56 | } SPI_NSS_TypeDef;
57 |
58 |
59 | /**
60 | * @brief SPI direction transmit/receive
61 | */
62 |
63 | typedef enum {
64 | SPI_DIRECTION_RX = (uint8_t)0x00, /*!< Selects Rx receive direction in bi-directional mode */
65 | SPI_DIRECTION_TX = (uint8_t)0x01 /*!< Selects Tx transmission direction in bi-directional mode */
66 | } SPI_Direction_TypeDef;
67 |
68 | /**
69 | * @brief SPI master/slave mode
70 | * Warning: element values correspond to MSTR bit position
71 | */
72 | typedef enum {
73 | SPI_MODE_MASTER = (uint8_t)0x04, /*!< SPI Master configuration */
74 | SPI_MODE_SLAVE = (uint8_t)0x00 /*!< SPI Slave configuration */
75 | } SPI_Mode_TypeDef;
76 |
77 | /**
78 | * @brief SPI BaudRate Prescaler
79 | * Warning: element values correspond to BR bits position
80 | */
81 | typedef enum {
82 | SPI_BAUDRATEPRESCALER_2 = (uint8_t)0x00, /*!< SPI frequency = frequency(CPU)/2 */
83 | SPI_BAUDRATEPRESCALER_4 = (uint8_t)0x08, /*!< SPI frequency = frequency(CPU)/4 */
84 | SPI_BAUDRATEPRESCALER_8 = (uint8_t)0x10, /*!< SPI frequency = frequency(CPU)/8 */
85 | SPI_BAUDRATEPRESCALER_16 = (uint8_t)0x18, /*!< SPI frequency = frequency(CPU)/16 */
86 | SPI_BAUDRATEPRESCALER_32 = (uint8_t)0x20, /*!< SPI frequency = frequency(CPU)/32 */
87 | SPI_BAUDRATEPRESCALER_64 = (uint8_t)0x28, /*!< SPI frequency = frequency(CPU)/64 */
88 | SPI_BAUDRATEPRESCALER_128 = (uint8_t)0x30, /*!< SPI frequency = frequency(CPU)/128 */
89 | SPI_BAUDRATEPRESCALER_256 = (uint8_t)0x38 /*!< SPI frequency = frequency(CPU)/256 */
90 | } SPI_BaudRatePrescaler_TypeDef;
91 |
92 | /**
93 | * @brief SPI Clock Polarity
94 | * Warning: element values correspond to CPOL bit position
95 | */
96 | typedef enum {
97 | SPI_CLOCKPOLARITY_LOW = (uint8_t)0x00, /*!< Clock to 0 when idle */
98 | SPI_CLOCKPOLARITY_HIGH = (uint8_t)0x02 /*!< Clock to 1 when idle */
99 | } SPI_ClockPolarity_TypeDef;
100 |
101 | /**
102 | * @brief SPI Clock Phase
103 | * Warning: element values correspond to CPHA bit position
104 | */
105 | typedef enum {
106 | SPI_CLOCKPHASE_1EDGE = (uint8_t)0x00, /*!< The first clock transition is the first data capture edge */
107 | SPI_CLOCKPHASE_2EDGE = (uint8_t)0x01 /*!< The second clock transition is the first data capture edge */
108 | } SPI_ClockPhase_TypeDef;
109 |
110 | /**
111 | * @brief SPI Frame Format: MSB or LSB transmitted first
112 | * Warning: element values correspond to LSBFIRST bit position
113 | */
114 | typedef enum {
115 | SPI_FIRSTBIT_MSB = (uint8_t)0x00, /*!< MSB bit will be transmitted first */
116 | SPI_FIRSTBIT_LSB = (uint8_t)0x80 /*!< LSB bit will be transmitted first */
117 | } SPI_FirstBit_TypeDef;
118 |
119 | /**
120 | * @brief SPI CRC Transmit/Receive
121 | */
122 | typedef enum {
123 | SPI_CRC_RX = (uint8_t)0x00, /*!< Select Tx CRC register */
124 | SPI_CRC_TX = (uint8_t)0x01 /*!< Select Rx CRC register */
125 | } SPI_CRC_TypeDef;
126 |
127 | /**
128 | * @brief SPI flags definition - Warning : FLAG value = mapping position register
129 | */
130 | typedef enum {
131 | SPI_FLAG_BSY = (uint8_t)0x80, /*!< Busy flag */
132 | SPI_FLAG_OVR = (uint8_t)0x40, /*!< Overrun flag */
133 | SPI_FLAG_MODF = (uint8_t)0x20, /*!< Mode fault */
134 | SPI_FLAG_CRCERR = (uint8_t)0x10, /*!< CRC error flag */
135 | SPI_FLAG_WKUP = (uint8_t)0x08, /*!< Wake-up flag */
136 | SPI_FLAG_TXE = (uint8_t)0x02, /*!< Transmit buffer empty */
137 | SPI_FLAG_RXNE = (uint8_t)0x01 /*!< Receive buffer empty */
138 | } SPI_Flag_TypeDef;
139 |
140 | /**
141 | * @brief SPI_IT possible values
142 | * Elements values convention: 0xYX
143 | * X: Position of the corresponding Interrupt
144 | * Y: ITPENDINGBIT position
145 | */
146 | typedef enum
147 | {
148 | SPI_IT_WKUP = (uint8_t)0x34, /*!< Wake-up interrupt*/
149 | SPI_IT_OVR = (uint8_t)0x65, /*!< Overrun interrupt*/
150 | SPI_IT_MODF = (uint8_t)0x55, /*!< Mode fault interrupt*/
151 | SPI_IT_CRCERR = (uint8_t)0x45, /*!< CRC error interrupt*/
152 | SPI_IT_TXE = (uint8_t)0x17, /*!< Transmit buffer empty interrupt*/
153 | SPI_IT_RXNE = (uint8_t)0x06, /*!< Receive buffer not empty interrupt*/
154 | SPI_IT_ERR = (uint8_t)0x05 /*!< Error interrupt*/
155 | } SPI_IT_TypeDef;
156 |
157 | /**
158 | * @}
159 | */
160 |
161 | /* Private define ------------------------------------------------------------*/
162 |
163 | /** @addtogroup SPI_Private_Macros
164 | * @brief Macros used by the assert_param function to check the different functions parameters.
165 | * @{
166 | */
167 |
168 | /**
169 | * @brief Macro used by the assert_param function in order to check the data direction mode values
170 | */
171 | #define IS_SPI_DATA_DIRECTION_OK(MODE) (((MODE) == SPI_DATADIRECTION_2LINES_FULLDUPLEX) || \
172 | ((MODE) == SPI_DATADIRECTION_2LINES_RXONLY) || \
173 | ((MODE) == SPI_DATADIRECTION_1LINE_RX) || \
174 | ((MODE) == SPI_DATADIRECTION_1LINE_TX))
175 |
176 | /**
177 | * @brief Macro used by the assert_param function in order to check the mode
178 | * half duplex data direction values
179 | */
180 | #define IS_SPI_DIRECTION_OK(DIRECTION) (((DIRECTION) == SPI_DIRECTION_RX) || \
181 | ((DIRECTION) == SPI_DIRECTION_TX))
182 |
183 | /**
184 | * @brief Macro used by the assert_param function in order to check the NSS
185 | * management values
186 | */
187 | #define IS_SPI_SLAVEMANAGEMENT_OK(NSS) (((NSS) == SPI_NSS_SOFT) || \
188 | ((NSS) == SPI_NSS_HARD))
189 |
190 |
191 | /**
192 | * @brief Macro used by the assert_param function in order to check the different
193 | * sensitivity values for the CRC polynomial
194 | */
195 | #define IS_SPI_CRC_POLYNOMIAL_OK(POLYNOMIAL) ((POLYNOMIAL) > (uint8_t)0x00)
196 |
197 | /**
198 | * @brief Macro used by the assert_param function in order to check the SPI Mode values
199 | */
200 | #define IS_SPI_MODE_OK(MODE) (((MODE) == SPI_MODE_MASTER) || \
201 | ((MODE) == SPI_MODE_SLAVE))
202 |
203 | /**
204 | * @brief Macro used by the assert_param function in order to check the baudrate values
205 | */
206 | #define IS_SPI_BAUDRATE_PRESCALER_OK(PRESCALER) (((PRESCALER) == SPI_BAUDRATEPRESCALER_2) || \
207 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_4) || \
208 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_8) || \
209 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_16) || \
210 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_32) || \
211 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_64) || \
212 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_128) || \
213 | ((PRESCALER) == SPI_BAUDRATEPRESCALER_256))
214 |
215 | /**
216 | * @brief Macro used by the assert_param function in order to check the polarity values
217 | */
218 | #define IS_SPI_POLARITY_OK(CLKPOL) (((CLKPOL) == SPI_CLOCKPOLARITY_LOW) || \
219 | ((CLKPOL) == SPI_CLOCKPOLARITY_HIGH))
220 |
221 | /**
222 | * @brief Macro used by the assert_param function in order to check the phase values
223 | */
224 | #define IS_SPI_PHASE_OK(CLKPHA) (((CLKPHA) == SPI_CLOCKPHASE_1EDGE) || \
225 | ((CLKPHA) == SPI_CLOCKPHASE_2EDGE))
226 |
227 | /**
228 | * @brief Macro used by the assert_param function in order to check the first
229 | * bit to be transmited values
230 | */
231 | #define IS_SPI_FIRSTBIT_OK(BIT) (((BIT) == SPI_FIRSTBIT_MSB) || \
232 | ((BIT) == SPI_FIRSTBIT_LSB))
233 |
234 | /**
235 | * @brief Macro used by the assert_param function in order to check the CRC
236 | * Transmit/Receive
237 | */
238 | #define IS_SPI_CRC_OK(CRC) (((CRC) == SPI_CRC_TX) || \
239 | ((CRC) == SPI_CRC_RX))
240 |
241 | /**
242 | * @brief Macro used by the assert_param function in order to check the
243 | * different flags values
244 | */
245 | #define IS_SPI_FLAGS_OK(FLAG) (((FLAG) == SPI_FLAG_OVR) || \
246 | ((FLAG) == SPI_FLAG_MODF) || \
247 | ((FLAG) == SPI_FLAG_CRCERR) || \
248 | ((FLAG) == SPI_FLAG_WKUP) || \
249 | ((FLAG) == SPI_FLAG_TXE) || \
250 | ((FLAG) == SPI_FLAG_RXNE) || \
251 | ((FLAG) == SPI_FLAG_BSY))
252 |
253 | /**
254 | * @brief Macro used by the assert_param function in order to check the
255 | * different sensitivity values for the flag that can be cleared
256 | * by writing 0
257 | */
258 | #define IS_SPI_CLEAR_FLAGS_OK(FLAG) (((FLAG) == SPI_FLAG_CRCERR) || \
259 | ((FLAG) == SPI_FLAG_WKUP))
260 |
261 | /**
262 | * @brief Macro used by the assert_param function in order to check the
263 | * different sensitivity values for the Interrupts
264 | */
265 | #define IS_SPI_CONFIG_IT_OK(Interrupt) (((Interrupt) == SPI_IT_TXE) || \
266 | ((Interrupt) == SPI_IT_RXNE) || \
267 | ((Interrupt) == SPI_IT_ERR) || \
268 | ((Interrupt) == SPI_IT_WKUP))
269 |
270 | /**
271 | * @brief Macro used by the assert_param function in order to check the
272 | * different sensitivity values for the pending bit
273 | */
274 | #define IS_SPI_GET_IT_OK(ITPendingBit) (((ITPendingBit) == SPI_IT_OVR) || \
275 | ((ITPendingBit) == SPI_IT_MODF) || \
276 | ((ITPendingBit) == SPI_IT_CRCERR) || \
277 | ((ITPendingBit) == SPI_IT_WKUP) || \
278 | ((ITPendingBit) == SPI_IT_TXE) || \
279 | ((ITPendingBit) == SPI_IT_RXNE))
280 |
281 | /**
282 | * @brief Macro used by the assert_param function in order to check the
283 | * different sensitivity values for the pending bit that can be cleared
284 | * by writing 0
285 | */
286 | #define IS_SPI_CLEAR_IT_OK(ITPendingBit) (((ITPendingBit) == SPI_IT_CRCERR) || \
287 | ((ITPendingBit) == SPI_IT_WKUP))
288 |
289 | /**
290 | * @}
291 | */
292 |
293 | /** @addtogroup SPI_Exported_Functions
294 | * @{
295 | */
296 | void SPI_DeInit(void);
297 | void SPI_Init(SPI_FirstBit_TypeDef FirstBit,
298 | SPI_BaudRatePrescaler_TypeDef BaudRatePrescaler,
299 | SPI_Mode_TypeDef Mode, SPI_ClockPolarity_TypeDef ClockPolarity,
300 | SPI_ClockPhase_TypeDef ClockPhase,
301 | SPI_DataDirection_TypeDef Data_Direction,
302 | SPI_NSS_TypeDef Slave_Management, uint8_t CRCPolynomial);
303 | void SPI_Cmd(FunctionalState NewState);
304 | void SPI_ITConfig(SPI_IT_TypeDef SPI_IT, FunctionalState NewState);
305 | void SPI_SendData(uint8_t Data);
306 | uint8_t SPI_ReceiveData(void);
307 | void SPI_NSSInternalSoftwareCmd(FunctionalState NewState);
308 | void SPI_TransmitCRC(void);
309 | void SPI_CalculateCRCCmd(FunctionalState NewState);
310 | uint8_t SPI_GetCRC(SPI_CRC_TypeDef SPI_CRC);
311 | void SPI_ResetCRC(void);
312 | uint8_t SPI_GetCRCPolynomial(void);
313 | void SPI_BiDirectionalLineConfig(SPI_Direction_TypeDef SPI_Direction);
314 | FlagStatus SPI_GetFlagStatus(SPI_Flag_TypeDef SPI_FLAG);
315 | void SPI_ClearFlag(SPI_Flag_TypeDef SPI_FLAG);
316 | ITStatus SPI_GetITStatus(SPI_IT_TypeDef SPI_IT);
317 | void SPI_ClearITPendingBit(SPI_IT_TypeDef SPI_IT);
318 |
319 | /**
320 | * @}
321 | */
322 |
323 | #endif /* __STM8S_SPI_H */
324 |
325 | /**
326 | * @}
327 | */
328 |
329 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
330 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_tim3.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_tim3.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the TIM3 peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_TIM3_H
24 | #define __STM8S_TIM3_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /** @addtogroup STM8S_StdPeriph_Driver
30 | * @{
31 | */
32 |
33 | /* Exported types ------------------------------------------------------------*/
34 |
35 | /** @addtogroup TIM3_Exported_Types
36 | * @{
37 | */
38 |
39 | /** TIM3 Forced Action */
40 | typedef enum
41 | {
42 | TIM3_FORCEDACTION_ACTIVE = ((uint8_t)0x50),
43 | TIM3_FORCEDACTION_INACTIVE = ((uint8_t)0x40)
44 | } TIM3_ForcedAction_TypeDef;
45 |
46 | #define IS_TIM3_FORCED_ACTION_OK(ACTION) (((ACTION) == TIM3_FORCEDACTION_ACTIVE) || \
47 | ((ACTION) == TIM3_FORCEDACTION_INACTIVE))
48 |
49 | /** TIM3 Prescaler */
50 | typedef enum
51 | {
52 | TIM3_PRESCALER_1 = ((uint8_t)0x00),
53 | TIM3_PRESCALER_2 = ((uint8_t)0x01),
54 | TIM3_PRESCALER_4 = ((uint8_t)0x02),
55 | TIM3_PRESCALER_8 = ((uint8_t)0x03),
56 | TIM3_PRESCALER_16 = ((uint8_t)0x04),
57 | TIM3_PRESCALER_32 = ((uint8_t)0x05),
58 | TIM3_PRESCALER_64 = ((uint8_t)0x06),
59 | TIM3_PRESCALER_128 = ((uint8_t)0x07),
60 | TIM3_PRESCALER_256 = ((uint8_t)0x08),
61 | TIM3_PRESCALER_512 = ((uint8_t)0x09),
62 | TIM3_PRESCALER_1024 = ((uint8_t)0x0A),
63 | TIM3_PRESCALER_2048 = ((uint8_t)0x0B),
64 | TIM3_PRESCALER_4096 = ((uint8_t)0x0C),
65 | TIM3_PRESCALER_8192 = ((uint8_t)0x0D),
66 | TIM3_PRESCALER_16384 = ((uint8_t)0x0E),
67 | TIM3_PRESCALER_32768 = ((uint8_t)0x0F)
68 | } TIM3_Prescaler_TypeDef;
69 |
70 | #define IS_TIM3_PRESCALER_OK(PRESCALER) (((PRESCALER) == TIM3_PRESCALER_1 ) || \
71 | ((PRESCALER) == TIM3_PRESCALER_2 ) || \
72 | ((PRESCALER) == TIM3_PRESCALER_4 ) || \
73 | ((PRESCALER) == TIM3_PRESCALER_8 ) || \
74 | ((PRESCALER) == TIM3_PRESCALER_16 ) || \
75 | ((PRESCALER) == TIM3_PRESCALER_32 ) || \
76 | ((PRESCALER) == TIM3_PRESCALER_64 ) || \
77 | ((PRESCALER) == TIM3_PRESCALER_128 ) || \
78 | ((PRESCALER) == TIM3_PRESCALER_256 ) || \
79 | ((PRESCALER) == TIM3_PRESCALER_512 ) || \
80 | ((PRESCALER) == TIM3_PRESCALER_1024 ) || \
81 | ((PRESCALER) == TIM3_PRESCALER_2048 ) || \
82 | ((PRESCALER) == TIM3_PRESCALER_4096 ) || \
83 | ((PRESCALER) == TIM3_PRESCALER_8192 ) || \
84 | ((PRESCALER) == TIM3_PRESCALER_16384 ) || \
85 | ((PRESCALER) == TIM3_PRESCALER_32768 ))
86 |
87 | /** TIM3 Output Compare and PWM modes */
88 | typedef enum
89 | {
90 | TIM3_OCMODE_TIMING = ((uint8_t)0x00),
91 | TIM3_OCMODE_ACTIVE = ((uint8_t)0x10),
92 | TIM3_OCMODE_INACTIVE = ((uint8_t)0x20),
93 | TIM3_OCMODE_TOGGLE = ((uint8_t)0x30),
94 | TIM3_OCMODE_PWM1 = ((uint8_t)0x60),
95 | TIM3_OCMODE_PWM2 = ((uint8_t)0x70)
96 | } TIM3_OCMode_TypeDef;
97 |
98 | #define IS_TIM3_OC_MODE_OK(MODE) (((MODE) == TIM3_OCMODE_TIMING) || \
99 | ((MODE) == TIM3_OCMODE_ACTIVE) || \
100 | ((MODE) == TIM3_OCMODE_INACTIVE) || \
101 | ((MODE) == TIM3_OCMODE_TOGGLE)|| \
102 | ((MODE) == TIM3_OCMODE_PWM1) || \
103 | ((MODE) == TIM3_OCMODE_PWM2))
104 |
105 | #define IS_TIM3_OCM_OK(MODE)(((MODE) == TIM3_OCMODE_TIMING) || \
106 | ((MODE) == TIM3_OCMODE_ACTIVE) || \
107 | ((MODE) == TIM3_OCMODE_INACTIVE) || \
108 | ((MODE) == TIM3_OCMODE_TOGGLE)|| \
109 | ((MODE) == TIM3_OCMODE_PWM1) || \
110 | ((MODE) == TIM3_OCMODE_PWM2) || \
111 | ((MODE) == (uint8_t)TIM3_FORCEDACTION_ACTIVE) || \
112 | ((MODE) == (uint8_t)TIM3_FORCEDACTION_INACTIVE))
113 |
114 | /** TIM3 One Pulse Mode */
115 | typedef enum
116 | {
117 | TIM3_OPMODE_SINGLE = ((uint8_t)0x01),
118 | TIM3_OPMODE_REPETITIVE = ((uint8_t)0x00)
119 | } TIM3_OPMode_TypeDef;
120 |
121 | #define IS_TIM3_OPM_MODE_OK(MODE) (((MODE) == TIM3_OPMODE_SINGLE) || \
122 | ((MODE) == TIM3_OPMODE_REPETITIVE))
123 |
124 | /** TIM3 Channel */
125 |
126 | typedef enum
127 | {
128 | TIM3_CHANNEL_1 = ((uint8_t)0x00),
129 | TIM3_CHANNEL_2 = ((uint8_t)0x01)
130 | } TIM3_Channel_TypeDef;
131 |
132 | #define IS_TIM3_CHANNEL_OK(CHANNEL) (((CHANNEL) == TIM3_CHANNEL_1) || \
133 | ((CHANNEL) == TIM3_CHANNEL_2))
134 |
135 | #define IS_TIM3_PWMI_CHANNEL_OK(CHANNEL) (((CHANNEL) == TIM3_CHANNEL_1) || \
136 | ((CHANNEL) == TIM3_CHANNEL_2))
137 |
138 | /** TIM3 Output Compare Polarity */
139 | typedef enum
140 | {
141 | TIM3_OCPOLARITY_HIGH = ((uint8_t)0x00),
142 | TIM3_OCPOLARITY_LOW = ((uint8_t)0x22)
143 | } TIM3_OCPolarity_TypeDef;
144 |
145 | #define IS_TIM3_OC_POLARITY_OK(POLARITY) (((POLARITY) == TIM3_OCPOLARITY_HIGH) || \
146 | ((POLARITY) == TIM3_OCPOLARITY_LOW))
147 |
148 | /** TIM3 Output Compare states */
149 | typedef enum
150 | {
151 | TIM3_OUTPUTSTATE_DISABLE = ((uint8_t)0x00),
152 | TIM3_OUTPUTSTATE_ENABLE = ((uint8_t)0x11)
153 | } TIM3_OutputState_TypeDef;
154 |
155 | #define IS_TIM3_OUTPUT_STATE_OK(STATE) (((STATE) == TIM3_OUTPUTSTATE_DISABLE) || \
156 | ((STATE) == TIM3_OUTPUTSTATE_ENABLE))
157 |
158 | /** TIM3 Input Capture Polarity */
159 | typedef enum
160 | {
161 | TIM3_ICPOLARITY_RISING = ((uint8_t)0x00),
162 | TIM3_ICPOLARITY_FALLING = ((uint8_t)0x44)
163 | } TIM3_ICPolarity_TypeDef;
164 |
165 | #define IS_TIM3_IC_POLARITY_OK(POLARITY) (((POLARITY) == TIM3_ICPOLARITY_RISING) || \
166 | ((POLARITY) == TIM3_ICPOLARITY_FALLING))
167 |
168 | /** TIM3 Input Capture Selection */
169 | typedef enum
170 | {
171 | TIM3_ICSELECTION_DIRECTTI = ((uint8_t)0x01),
172 | TIM3_ICSELECTION_INDIRECTTI = ((uint8_t)0x02),
173 | TIM3_ICSELECTION_TRGI = ((uint8_t)0x03)
174 | } TIM3_ICSelection_TypeDef;
175 |
176 | #define IS_TIM3_IC_SELECTION_OK(SELECTION) (((SELECTION) == TIM3_ICSELECTION_DIRECTTI) || \
177 | ((SELECTION) == TIM3_ICSELECTION_INDIRECTTI) || \
178 | ((SELECTION) == TIM3_ICSELECTION_TRGI))
179 |
180 | /** TIM3 Input Capture Prescaler */
181 | typedef enum
182 | {
183 | TIM3_ICPSC_DIV1 = ((uint8_t)0x00),
184 | TIM3_ICPSC_DIV2 = ((uint8_t)0x04),
185 | TIM3_ICPSC_DIV4 = ((uint8_t)0x08),
186 | TIM3_ICPSC_DIV8 = ((uint8_t)0x0C)
187 | } TIM3_ICPSC_TypeDef;
188 |
189 | #define IS_TIM3_IC_PRESCALER_OK(PRESCALER) (((PRESCALER) == TIM3_ICPSC_DIV1) || \
190 | ((PRESCALER) == TIM3_ICPSC_DIV2) || \
191 | ((PRESCALER) == TIM3_ICPSC_DIV4) || \
192 | ((PRESCALER) == TIM3_ICPSC_DIV8))
193 |
194 | /** TIM3 Input Capture Filer Value */
195 | #define IS_TIM3_IC_FILTER_OK(ICFILTER) ((ICFILTER) <= 0x0F)
196 |
197 | /** TIM3 interrupt sources */
198 | typedef enum
199 | {
200 | TIM3_IT_UPDATE = ((uint8_t)0x01),
201 | TIM3_IT_CC1 = ((uint8_t)0x02),
202 | TIM3_IT_CC2 = ((uint8_t)0x04)
203 | } TIM3_IT_TypeDef;
204 |
205 | #define IS_TIM3_IT_OK(IT) (((IT) != 0x00) && ((IT) <= 0x07))
206 |
207 | #define IS_TIM3_GET_IT_OK(IT) (((IT) == TIM3_IT_UPDATE) || \
208 | ((IT) == TIM3_IT_CC1) || \
209 | ((IT) == TIM3_IT_CC2))
210 |
211 | /** TIM3 Prescaler Reload Mode */
212 | typedef enum
213 | {
214 | TIM3_PSCRELOADMODE_UPDATE = ((uint8_t)0x00),
215 | TIM3_PSCRELOADMODE_IMMEDIATE = ((uint8_t)0x01)
216 | } TIM3_PSCReloadMode_TypeDef;
217 |
218 | #define IS_TIM3_PRESCALER_RELOAD_OK(RELOAD) (((RELOAD) == TIM3_PSCRELOADMODE_UPDATE) || \
219 | ((RELOAD) == TIM3_PSCRELOADMODE_IMMEDIATE))
220 |
221 | /** TIM3 Event Source */
222 | typedef enum
223 | {
224 | TIM3_EVENTSOURCE_UPDATE = ((uint8_t)0x01),
225 | TIM3_EVENTSOURCE_CC1 = ((uint8_t)0x02),
226 | TIM3_EVENTSOURCE_CC2 = ((uint8_t)0x04)
227 | } TIM3_EventSource_TypeDef;
228 |
229 | #define IS_TIM3_EVENT_SOURCE_OK(SOURCE) (((SOURCE) != 0x00))
230 |
231 | /** TIM3 Update Source */
232 | typedef enum
233 | {
234 | TIM3_UPDATESOURCE_GLOBAL = ((uint8_t)0x00),
235 | TIM3_UPDATESOURCE_REGULAR = ((uint8_t)0x01)
236 | } TIM3_UpdateSource_TypeDef;
237 |
238 | #define IS_TIM3_UPDATE_SOURCE_OK(SOURCE) (((SOURCE) == TIM3_UPDATESOURCE_GLOBAL) || \
239 | ((SOURCE) == TIM3_UPDATESOURCE_REGULAR))
240 |
241 | /** TIM3 Flags */
242 | typedef enum
243 | {
244 | TIM3_FLAG_UPDATE = ((uint16_t)0x0001),
245 | TIM3_FLAG_CC1 = ((uint16_t)0x0002),
246 | TIM3_FLAG_CC2 = ((uint16_t)0x0004),
247 | TIM3_FLAG_CC1OF = ((uint16_t)0x0200),
248 | TIM3_FLAG_CC2OF = ((uint16_t)0x0400)
249 | } TIM3_FLAG_TypeDef;
250 |
251 | #define IS_TIM3_GET_FLAG_OK(FLAG) (((FLAG) == TIM3_FLAG_UPDATE) || \
252 | ((FLAG) == TIM3_FLAG_CC1) || \
253 | ((FLAG) == TIM3_FLAG_CC2) || \
254 | ((FLAG) == TIM3_FLAG_CC1OF) || \
255 | ((FLAG) == TIM3_FLAG_CC2OF) )
256 |
257 | #define IS_TIM3_CLEAR_FLAG_OK(FLAG) ((((uint16_t)(FLAG) & 0xF9F8) == 0x0000) && ((uint16_t)(FLAG)!= 0x0000))
258 |
259 | /**
260 | * @}
261 | */
262 |
263 | /* Exported macro ------------------------------------------------------------*/
264 |
265 | /* Exported functions --------------------------------------------------------*/
266 |
267 | /** @addtogroup TIM3_Exported_Functions
268 | * @{
269 | */
270 |
271 | void TIM3_DeInit(void);
272 | void TIM3_TimeBaseInit(TIM3_Prescaler_TypeDef TIM3_Prescaler, uint16_t TIM3_Period);
273 | void TIM3_OC1Init(TIM3_OCMode_TypeDef TIM3_OCMode, TIM3_OutputState_TypeDef TIM3_OutputState, uint16_t TIM3_Pulse, TIM3_OCPolarity_TypeDef TIM3_OCPolarity);
274 | void TIM3_OC2Init(TIM3_OCMode_TypeDef TIM3_OCMode, TIM3_OutputState_TypeDef TIM3_OutputState, uint16_t TIM3_Pulse, TIM3_OCPolarity_TypeDef TIM3_OCPolarity);
275 | void TIM3_ICInit(TIM3_Channel_TypeDef TIM3_Channel, TIM3_ICPolarity_TypeDef TIM3_ICPolarity, TIM3_ICSelection_TypeDef TIM3_ICSelection, TIM3_ICPSC_TypeDef TIM3_ICPrescaler, uint8_t TIM3_ICFilter);
276 | void TIM3_PWMIConfig(TIM3_Channel_TypeDef TIM3_Channel, TIM3_ICPolarity_TypeDef TIM3_ICPolarity, TIM3_ICSelection_TypeDef TIM3_ICSelection, TIM3_ICPSC_TypeDef TIM3_ICPrescaler, uint8_t TIM3_ICFilter);
277 | void TIM3_Cmd(FunctionalState NewState);
278 | void TIM3_ITConfig(TIM3_IT_TypeDef TIM3_IT, FunctionalState NewState);
279 | void TIM3_InternalClockConfig(void);
280 | void TIM3_UpdateDisableConfig(FunctionalState NewState);
281 | void TIM3_UpdateRequestConfig(TIM3_UpdateSource_TypeDef TIM3_UpdateSource);
282 | void TIM3_SelectOnePulseMode(TIM3_OPMode_TypeDef TIM3_OPMode);
283 | void TIM3_PrescalerConfig(TIM3_Prescaler_TypeDef Prescaler, TIM3_PSCReloadMode_TypeDef TIM3_PSCReloadMode);
284 | void TIM3_ForcedOC1Config(TIM3_ForcedAction_TypeDef TIM3_ForcedAction);
285 | void TIM3_ForcedOC2Config(TIM3_ForcedAction_TypeDef TIM3_ForcedAction);
286 | void TIM3_ARRPreloadConfig(FunctionalState NewState);
287 | void TIM3_CCPreloadControl(FunctionalState NewState);
288 | void TIM3_OC1PreloadConfig(FunctionalState NewState);
289 | void TIM3_OC2PreloadConfig(FunctionalState NewState);
290 | void TIM3_GenerateEvent(TIM3_EventSource_TypeDef TIM3_EventSource);
291 | void TIM3_OC1PolarityConfig(TIM3_OCPolarity_TypeDef TIM3_OCPolarity);
292 | void TIM3_OC2PolarityConfig(TIM3_OCPolarity_TypeDef TIM3_OCPolarity);
293 | void TIM3_CCxCmd(TIM3_Channel_TypeDef TIM3_Channel, FunctionalState NewState);
294 | void TIM3_SelectOCxM(TIM3_Channel_TypeDef TIM3_Channel, TIM3_OCMode_TypeDef TIM3_OCMode);
295 | void TIM3_SetCounter(uint16_t Counter);
296 | void TIM3_SetAutoreload(uint16_t Autoreload);
297 | void TIM3_SetCompare1(uint16_t Compare1);
298 | void TIM3_SetCompare2(uint16_t Compare2);
299 | void TIM3_SetIC1Prescaler(TIM3_ICPSC_TypeDef TIM3_IC1Prescaler);
300 | void TIM3_SetIC2Prescaler(TIM3_ICPSC_TypeDef TIM3_IC2Prescaler);
301 | uint16_t TIM3_GetCapture1(void);
302 | uint16_t TIM3_GetCapture2(void);
303 | uint16_t TIM3_GetCounter(void);
304 | TIM3_Prescaler_TypeDef TIM3_GetPrescaler(void);
305 | FlagStatus TIM3_GetFlagStatus(TIM3_FLAG_TypeDef TIM3_FLAG);
306 | void TIM3_ClearFlag(TIM3_FLAG_TypeDef TIM3_FLAG);
307 | ITStatus TIM3_GetITStatus(TIM3_IT_TypeDef TIM3_IT);
308 | void TIM3_ClearITPendingBit(TIM3_IT_TypeDef TIM3_IT);
309 |
310 | /**
311 | * @}
312 | */
313 |
314 | #endif /* __STM8S_TIM3_H */
315 |
316 | /**
317 | * @}
318 | */
319 |
320 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
321 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_tim4.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_tim4.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the TIM4 peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_TIM4_H
24 | #define __STM8S_TIM4_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /** @addtogroup STM8S_StdPeriph_Driver
30 | * @{
31 | */
32 |
33 | /* Exported types ------------------------------------------------------------*/
34 |
35 | /** @addtogroup TIM4_Exported_Types
36 | * @{
37 | */
38 |
39 |
40 |
41 | /** TIM4 Prescaler */
42 | typedef enum
43 | {
44 | TIM4_PRESCALER_1 = ((uint8_t)0x00),
45 | TIM4_PRESCALER_2 = ((uint8_t)0x01),
46 | TIM4_PRESCALER_4 = ((uint8_t)0x02),
47 | TIM4_PRESCALER_8 = ((uint8_t)0x03),
48 | TIM4_PRESCALER_16 = ((uint8_t)0x04),
49 | TIM4_PRESCALER_32 = ((uint8_t)0x05),
50 | TIM4_PRESCALER_64 = ((uint8_t)0x06),
51 | TIM4_PRESCALER_128 = ((uint8_t)0x07)
52 | } TIM4_Prescaler_TypeDef;
53 |
54 | #define IS_TIM4_PRESCALER_OK(PRESCALER) (((PRESCALER) == TIM4_PRESCALER_1 ) || \
55 | ((PRESCALER) == TIM4_PRESCALER_2 ) || \
56 | ((PRESCALER) == TIM4_PRESCALER_4 ) || \
57 | ((PRESCALER) == TIM4_PRESCALER_8 ) || \
58 | ((PRESCALER) == TIM4_PRESCALER_16 ) || \
59 | ((PRESCALER) == TIM4_PRESCALER_32 ) || \
60 | ((PRESCALER) == TIM4_PRESCALER_64 ) || \
61 | ((PRESCALER) == TIM4_PRESCALER_128 ) )
62 |
63 | /** TIM4 One Pulse Mode */
64 | typedef enum
65 | {
66 | TIM4_OPMODE_SINGLE = ((uint8_t)0x01),
67 | TIM4_OPMODE_REPETITIVE = ((uint8_t)0x00)
68 | } TIM4_OPMode_TypeDef;
69 |
70 | #define IS_TIM4_OPM_MODE_OK(MODE) (((MODE) == TIM4_OPMODE_SINGLE) || \
71 | ((MODE) == TIM4_OPMODE_REPETITIVE))
72 |
73 | /** TIM4 Prescaler Reload Mode */
74 | typedef enum
75 | {
76 | TIM4_PSCRELOADMODE_UPDATE = ((uint8_t)0x00),
77 | TIM4_PSCRELOADMODE_IMMEDIATE = ((uint8_t)0x01)
78 | } TIM4_PSCReloadMode_TypeDef;
79 |
80 | #define IS_TIM4_PRESCALER_RELOAD_OK(RELOAD) (((RELOAD) == TIM4_PSCRELOADMODE_UPDATE) || \
81 | ((RELOAD) == TIM4_PSCRELOADMODE_IMMEDIATE))
82 |
83 | /** TIM4 Update Source */
84 | typedef enum
85 | {
86 | TIM4_UPDATESOURCE_GLOBAL = ((uint8_t)0x00),
87 | TIM4_UPDATESOURCE_REGULAR = ((uint8_t)0x01)
88 | } TIM4_UpdateSource_TypeDef;
89 |
90 | #define IS_TIM4_UPDATE_SOURCE_OK(SOURCE) (((SOURCE) == TIM4_UPDATESOURCE_GLOBAL) || \
91 | ((SOURCE) == TIM4_UPDATESOURCE_REGULAR))
92 |
93 | /** TIM4 Event Source */
94 | typedef enum
95 | {
96 | TIM4_EVENTSOURCE_UPDATE = ((uint8_t)0x01)
97 | }TIM4_EventSource_TypeDef;
98 |
99 | #define IS_TIM4_EVENT_SOURCE_OK(SOURCE) (((SOURCE) == 0x01))
100 |
101 | /** TIM4 Flags */
102 | typedef enum
103 | {
104 | TIM4_FLAG_UPDATE = ((uint8_t)0x01)
105 | }TIM4_FLAG_TypeDef;
106 |
107 | #define IS_TIM4_GET_FLAG_OK(FLAG) ((FLAG) == TIM4_FLAG_UPDATE)
108 |
109 |
110 |
111 | /** TIM4 interrupt sources */
112 | typedef enum
113 | {
114 | TIM4_IT_UPDATE = ((uint8_t)0x01)
115 | }TIM4_IT_TypeDef;
116 |
117 | #define IS_TIM4_IT_OK(IT) ((IT) == TIM4_IT_UPDATE)
118 |
119 |
120 |
121 | /**
122 | * @}
123 | */
124 |
125 | /* Exported macro ------------------------------------------------------------*/
126 |
127 | /* Exported functions --------------------------------------------------------*/
128 |
129 | /** @addtogroup TIM4_Exported_Functions
130 | * @{
131 | */
132 | void TIM4_DeInit(void);
133 | void TIM4_TimeBaseInit(TIM4_Prescaler_TypeDef TIM4_Prescaler, uint8_t TIM4_Period);
134 | void TIM4_Cmd(FunctionalState NewState);
135 | void TIM4_ITConfig(TIM4_IT_TypeDef TIM4_IT, FunctionalState NewState);
136 | void TIM4_UpdateDisableConfig(FunctionalState NewState);
137 | void TIM4_UpdateRequestConfig(TIM4_UpdateSource_TypeDef TIM4_UpdateSource);
138 | void TIM4_SelectOnePulseMode(TIM4_OPMode_TypeDef TIM4_OPMode);
139 | void TIM4_PrescalerConfig(TIM4_Prescaler_TypeDef Prescaler, TIM4_PSCReloadMode_TypeDef TIM4_PSCReloadMode);
140 | void TIM4_ARRPreloadConfig(FunctionalState NewState);
141 | void TIM4_GenerateEvent(TIM4_EventSource_TypeDef TIM4_EventSource);
142 | void TIM4_SetCounter(uint8_t Counter);
143 | void TIM4_SetAutoreload(uint8_t Autoreload);
144 | uint8_t TIM4_GetCounter(void);
145 | TIM4_Prescaler_TypeDef TIM4_GetPrescaler(void);
146 | FlagStatus TIM4_GetFlagStatus(TIM4_FLAG_TypeDef TIM4_FLAG);
147 | void TIM4_ClearFlag(TIM4_FLAG_TypeDef TIM4_FLAG);
148 | ITStatus TIM4_GetITStatus(TIM4_IT_TypeDef TIM4_IT);
149 | void TIM4_ClearITPendingBit(TIM4_IT_TypeDef TIM4_IT);
150 |
151 |
152 | /**
153 | * @}
154 | */
155 |
156 | #endif /* __STM8S_TIM4_H */
157 |
158 | /**
159 | * @}
160 | */
161 |
162 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
163 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_tim6.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_tim6.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the TIM6 peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_TIM6_H
24 | #define __STM8S_TIM6_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /** @addtogroup STM8S_StdPeriph_Driver
30 | * @{
31 | */
32 |
33 | /* Exported variables ------------------------------------------------------- */
34 | /* Exported types ------------------------------------------------------------*/
35 |
36 | /** @addtogroup TIM6_Exported_Types
37 | * @{
38 | */
39 |
40 |
41 | /**
42 | * @brief TIM6 Prescaler
43 | */
44 | typedef enum
45 | {
46 | TIM6_PRESCALER_1 = ((uint8_t)0x00), /*!< Time base Prescaler = 1 (No effect)*/
47 | TIM6_PRESCALER_2 = ((uint8_t)0x01), /*!< Time base Prescaler = 2 */
48 | TIM6_PRESCALER_4 = ((uint8_t)0x02), /*!< Time base Prescaler = 4 */
49 | TIM6_PRESCALER_8 = ((uint8_t)0x03), /*!< Time base Prescaler = 8 */
50 | TIM6_PRESCALER_16 = ((uint8_t)0x04), /*!< Time base Prescaler = 16 */
51 | TIM6_PRESCALER_32 = ((uint8_t)0x05), /*!< Time base Prescaler = 32 */
52 | TIM6_PRESCALER_64 = ((uint8_t)0x06), /*!< Time base Prescaler = 64 */
53 | TIM6_PRESCALER_128 = ((uint8_t)0x07) /*!< Time base Prescaler = 128 */
54 | }TIM6_Prescaler_TypeDef;
55 |
56 | /**
57 | * @brief TIM6 One Pulse Mode
58 | */
59 | typedef enum
60 | {
61 | TIM6_OPMODE_SINGLE = ((uint8_t)0x01), /*!< Single one Pulse mode (OPM Active) */
62 | TIM6_OPMODE_REPETITIVE = ((uint8_t)0x00) /*!< Repetitive Pulse mode (OPM inactive) */
63 | }TIM6_OPMode_TypeDef;
64 |
65 | /**
66 | * @brief TIM6 Prescaler Reload Mode
67 | */
68 | typedef enum
69 | {
70 | TIM6_PSCRELOADMODE_UPDATE =((uint8_t)0x00), /*!< Prescaler value is reloaded at every update*/
71 | TIM6_PSCRELOADMODE_IMMEDIATE =((uint8_t)0x01) /*!< Prescaler value is reloaded immediatly*/
72 | }TIM6_PSCReloadMode_TypeDef;
73 |
74 | /**
75 | * @brief TIM6 Update Source
76 | */
77 | typedef enum
78 | {
79 | TIM6_UPDATESOURCE_GLOBAL =((uint8_t)0x00), /*!< Global Update request source */
80 | TIM6_UPDATESOURCE_REGULAR =((uint8_t)0x01) /*!< Regular Update request source */
81 | }TIM6_UpdateSource_TypeDef;
82 |
83 | /**
84 | * @brief TIM6 Event Source
85 | */
86 | typedef enum
87 | {
88 | TIM6_EVENTSOURCE_UPDATE = ((uint8_t)0x01), /*!< Update Event*/
89 | TIM6_EVENTSOURCE_TRIGGER = ((uint8_t)0x40) /*!< Trigger Event*/
90 | }TIM6_EventSource_TypeDef;
91 |
92 | /**
93 | * @brief TIM6 Trigger Output Source
94 | */
95 | typedef enum
96 | {
97 | TIM6_TRGOSOURCE_RESET = ((uint8_t)0x00), /*!< Trigger Output source = Reset*/
98 | TIM6_TRGOSOURCE_ENABLE = ((uint8_t)0x10), /*!< Trigger Output source = TIM5 is enabled*/
99 | TIM6_TRGOSOURCE_UPDATE = ((uint8_t)0x20) /*!< Trigger Output source = Update event*/
100 | }TIM6_TRGOSource_TypeDef;
101 |
102 | /**
103 | * @brief TIM6 Slave Mode
104 | */
105 | typedef enum
106 | {
107 | TIM6_SLAVEMODE_DISABLE = ((uint8_t)0x00), /*!< Disable slave mode to clock the prescaler directly with the internal clock */
108 | TIM6_SLAVEMODE_RESET = ((uint8_t)0x04), /*!< Slave Mode Selection = Reset*/
109 | TIM6_SLAVEMODE_GATED = ((uint8_t)0x05), /*!< Slave Mode Selection = Gated*/
110 | TIM6_SLAVEMODE_TRIGGER = ((uint8_t)0x06), /*!< Slave Mode Selection = Trigger*/
111 | TIM6_SLAVEMODE_EXTERNAL1 = ((uint8_t)0x07) /*!< Slave Mode Selection = External 1*/
112 | }TIM6_SlaveMode_TypeDef;
113 |
114 | /**
115 | * @brief TIM6 Flags
116 | */
117 | typedef enum
118 | {
119 | TIM6_FLAG_UPDATE = ((uint8_t)0x01), /*!< Update Flag */
120 | TIM6_FLAG_TRIGGER = ((uint8_t)0x40) /*!< Trigger Flag */
121 | }TIM6_FLAG_TypeDef;
122 |
123 | /**
124 | * @brief TIM6 interrupt sources
125 | */
126 | typedef enum
127 | {
128 | TIM6_IT_UPDATE = ((uint8_t)0x01), /*!< Update Interrupt*/
129 | TIM6_IT_TRIGGER = ((uint8_t)0x40) /*!< Trigger Interrupt*/
130 | }TIM6_IT_TypeDef;
131 |
132 | /**
133 | * @brief TIM6 Internal Trigger Selection
134 | */
135 | typedef enum
136 | {
137 | TIM6_TS_TIM1 = ((uint8_t)0x20),/*!< TRIG Input source = TIM1 TRIG Output */
138 | TIM6_TS_TIM5 = ((uint8_t)0x30) /*!< TRIG Input source = TIM5 TRIG Output */
139 | }TIM6_TS_TypeDef;
140 |
141 | /**
142 | * @}
143 | */
144 |
145 | /* Exported constants --------------------------------------------------------*/
146 | /* Exported macros -----------------------------------------------------------*/
147 | /* Private macros ------------------------------------------------------------*/
148 |
149 | /** @addtogroup TIM6_Private_Macros
150 | * @{
151 | */
152 |
153 | /**
154 | * @brief Macro used by the assert function to check the different functions parameters.
155 | */
156 |
157 | /**
158 | * @brief Macro TIM6 Prescaler
159 | */
160 | #define IS_TIM6_PRESCALER_OK(PRESCALER) \
161 | (((PRESCALER) == TIM6_PRESCALER_1) || \
162 | ((PRESCALER) == TIM6_PRESCALER_2) || \
163 | ((PRESCALER) == TIM6_PRESCALER_4) || \
164 | ((PRESCALER) == TIM6_PRESCALER_8) || \
165 | ((PRESCALER) == TIM6_PRESCALER_16) || \
166 | ((PRESCALER) == TIM6_PRESCALER_32) || \
167 | ((PRESCALER) == TIM6_PRESCALER_64) || \
168 | ((PRESCALER) == TIM6_PRESCALER_128))
169 | /**
170 | * @brief Macro TIM6 One Pulse Mode
171 | */
172 | #define IS_TIM6_OPM_MODE_OK(MODE) \
173 | (((MODE) == TIM6_OPMODE_SINGLE) || \
174 | ((MODE) == TIM6_OPMODE_REPETITIVE))
175 |
176 | /**
177 | * @brief Macro TIM6 Prescaler reload
178 | */
179 | #define IS_TIM6_PRESCALER_RELOAD_OK(RELOAD) \
180 | (((RELOAD) == TIM6_PSCRELOADMODE_UPDATE) || \
181 | ((RELOAD) == TIM6_PSCRELOADMODE_IMMEDIATE))
182 | /**
183 | * @brief Macro TIM6 Update source
184 | */
185 | #define IS_TIM6_UPDATE_SOURCE_OK(SOURCE) \
186 | (((SOURCE) == TIM6_UPDATESOURCE_GLOBAL) || \
187 | ((SOURCE) == TIM6_UPDATESOURCE_REGULAR))
188 | /**
189 | * @brief Macro TIM6 Event source
190 | */
191 | #define IS_TIM6_EVENT_SOURCE_OK(SOURCE) \
192 | ((((SOURCE) & (uint8_t)0xBE) == 0x00) && \
193 | ((SOURCE) != 0x00))
194 |
195 | /**
196 | * @brief Macro TIM6 TRGO source
197 | */
198 | #define IS_TIM6_TRGO_SOURCE_OK(SOURCE) \
199 | (((SOURCE) == TIM6_TRGOSOURCE_RESET) || \
200 | ((SOURCE) == TIM6_TRGOSOURCE_ENABLE)|| \
201 | ((SOURCE) == TIM6_TRGOSOURCE_UPDATE))
202 | /**
203 | * @brief Macro TIM6 Slave mode
204 | */
205 | #define IS_TIM6_SLAVE_MODE_OK(MODE) \
206 | (((MODE) == TIM6_SLAVEMODE_DISABLE) || \
207 | ((MODE) == TIM6_SLAVEMODE_RESET) || \
208 | ((MODE) == TIM6_SLAVEMODE_GATED) || \
209 | ((MODE) == TIM6_SLAVEMODE_TRIGGER) || \
210 | ((MODE) == TIM6_SLAVEMODE_EXTERNAL1))
211 | /**
212 | * @brief Macro TIM6 Flags
213 | */
214 | #define IS_TIM6_GET_FLAG_OK(FLAG) \
215 | (((FLAG) == TIM6_FLAG_UPDATE) || \
216 | ((FLAG) == TIM6_FLAG_TRIGGER))
217 |
218 | #define IS_TIM6_CLEAR_FLAG_OK(FLAG) \
219 | ((((FLAG) & (uint8_t)0xBE) == 0x00) && ((FLAG) != 0x00))
220 | /**
221 | * @brief Macro TIM6 interrupts
222 | */
223 | #define IS_TIM6_IT_OK(IT) \
224 | (((IT) != 0x00) && \
225 | (((IT) & (uint8_t)(~(uint8_t)(0x41)))== 0x00))
226 |
227 | #define IS_TIM6_GET_IT_OK(IT) \
228 | (((IT) == TIM6_IT_UPDATE) || \
229 | ((IT) == TIM6_IT_TRIGGER))
230 | /**
231 | * @brief Macro TIM6 Trigger selection
232 | */
233 | #define IS_TIM6_TRIGGER_SELECTION_OK(SELECTION) \
234 | (((SELECTION) == TIM6_TS_TIM5) || \
235 | ((SELECTION) == TIM6_TS_TIM1))
236 | /**
237 | * @}
238 | */
239 |
240 | /* Exported functions --------------------------------------------------------*/
241 |
242 | /** @addtogroup TIM6_Exported_Functions
243 | * @{
244 | */
245 |
246 | void TIM6_DeInit(void);
247 | void TIM6_TimeBaseInit(TIM6_Prescaler_TypeDef TIM6_Prescaler, uint8_t TIM6_Period);
248 | void TIM6_Cmd(FunctionalState NewState);
249 | void TIM6_UpdateDisableConfig(FunctionalState NewState);
250 | void TIM6_UpdateRequestConfig(TIM6_UpdateSource_TypeDef TIM6_UpdateSource);
251 | void TIM6_SelectOnePulseMode(TIM6_OPMode_TypeDef TIM6_OPMode);
252 | void TIM6_PrescalerConfig(TIM6_Prescaler_TypeDef Prescaler, TIM6_PSCReloadMode_TypeDef TIM6_PSCReloadMode);
253 | void TIM6_ARRPreloadConfig(FunctionalState NewState);
254 | void TIM6_SetCounter(uint8_t Counter);
255 | void TIM6_SetAutoreload(uint8_t Autoreload);
256 | uint8_t TIM6_GetCounter(void);
257 | TIM6_Prescaler_TypeDef TIM6_GetPrescaler(void);
258 | void TIM6_ITConfig(TIM6_IT_TypeDef TIM6_IT, FunctionalState NewState);
259 | void TIM6_ClearFlag(TIM6_FLAG_TypeDef TIM6_FLAG);
260 | ITStatus TIM6_GetITStatus(TIM6_IT_TypeDef TIM6_IT);
261 | void TIM6_GenerateEvent(TIM6_EventSource_TypeDef TIM6_EventSource);
262 | FlagStatus TIM6_GetFlagStatus(TIM6_FLAG_TypeDef TIM6_FLAG);
263 | void TIM6_ClearITPendingBit(TIM6_IT_TypeDef TIM6_IT);
264 | void TIM6_SelectOutputTrigger(TIM6_TRGOSource_TypeDef TIM6_TRGOSource);
265 | void TIM6_SelectMasterSlaveMode(FunctionalState NewState);
266 | void TIM6_SelectInputTrigger(TIM6_TS_TypeDef TIM6_InputTriggerSource);
267 | void TIM6_InternalClockConfig(void);
268 | void TIM6_SelectSlaveMode(TIM6_SlaveMode_TypeDef TIM6_SlaveMode);
269 |
270 | /**
271 | * @}
272 | */
273 |
274 | #endif /* __STM8S_TIM6_H */
275 |
276 | /**
277 | * @}
278 | */
279 |
280 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
281 |
--------------------------------------------------------------------------------
/mcu/std_lib/inc/stm8s_wwdg.h:
--------------------------------------------------------------------------------
1 | /**
2 | ********************************************************************************
3 | * @file stm8s_wwdg.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all functions prototype and macros for the WWDG peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_WWDG_H
24 | #define __STM8S_WWDG_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /** @addtogroup STM8S_StdPeriph_Driver
30 | * @{
31 | */
32 |
33 | /* Private macros ------------------------------------------------------------*/
34 |
35 | /** @addtogroup WWDG_Private_Macros
36 | * @{
37 | */
38 |
39 | /**
40 | * @brief Macro used by the assert function in order to check the
41 | * values of the window register.
42 | */
43 | #define IS_WWDG_WINDOWLIMITVALUE_OK(WindowLimitValue) ((WindowLimitValue) <= 0x7F)
44 |
45 | /**
46 | * @brief Macro used by the assert function in order to check the different
47 | * values of the counter register.
48 | */
49 | #define IS_WWDG_COUNTERVALUE_OK(CounterValue) ((CounterValue) <= 0x7F)
50 |
51 | /**
52 | * @}
53 | */
54 |
55 | /* Exported types ------------------------------------------------------------*/
56 |
57 | /* Exported functions ------------------------------------------------------- */
58 |
59 | /** @addtogroup WWDG_Exported_Functions
60 | * @{
61 | */
62 |
63 | void WWDG_Init(uint8_t Counter, uint8_t WindowValue);
64 | void WWDG_SetCounter(uint8_t Counter);
65 | uint8_t WWDG_GetCounter(void);
66 | void WWDG_SWReset(void);
67 | void WWDG_SetWindowValue(uint8_t WindowValue);
68 |
69 |
70 | /**
71 | * @}
72 | */
73 |
74 | #endif /* __STM8S_WWDG_H */
75 |
76 | /**
77 | * @}
78 | */
79 |
80 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
81 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_awu.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_awu.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the AWU peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_awu.h"
24 |
25 | /** @addtogroup STM8S_StdPeriph_Driver
26 | * @{
27 | */
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* Private define ------------------------------------------------------------*/
30 | /* Private macro -------------------------------------------------------------*/
31 | /* Private variables ---------------------------------------------------------*/
32 | /* Private function prototypes -----------------------------------------------*/
33 | /* Private functions ---------------------------------------------------------*/
34 |
35 | /* See also AWU_Timebase_TypeDef structure in stm8s_awu.h file :
36 | N 2 5 1 2 4 8 1 3 6 1 2 5 1 2 1 3
37 | O 5 0 m m m m 6 2 4 2 5 1 s s 2 0
38 | I 0 0 s s s s m m m 8 6 2 s s
39 | T u u s s s m m m
40 | s s s s s
41 | */
42 | /** Contains the different values to write in the APR register (used by AWU_Init function) */
43 | CONST uint8_t APR_Array[17] =
44 | {
45 | 0, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 61, 23, 23, 62
46 | };
47 |
48 | /** Contains the different values to write in the TBR register (used by AWU_Init function) */
49 | CONST uint8_t TBR_Array[17] =
50 | {
51 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 12, 14, 15, 15
52 | };
53 |
54 | /* Public functions ----------------------------------------------------------*/
55 |
56 | /**
57 | * @addtogroup AWU_Public_Functions
58 | * @{
59 | */
60 |
61 | /**
62 | * @brief Deinitializes the AWU peripheral registers to their default reset
63 | * values.
64 | * @param None
65 | * @retval None
66 | */
67 | void AWU_DeInit(void)
68 | {
69 | AWU->CSR = AWU_CSR_RESET_VALUE;
70 | AWU->APR = AWU_APR_RESET_VALUE;
71 | AWU->TBR = AWU_TBR_RESET_VALUE;
72 | }
73 |
74 | /**
75 | * @brief Initializes the AWU peripheral according to the specified parameters.
76 | * @param AWU_TimeBase : Time base selection (interval between AWU interrupts).
77 | * can be one of the values of @ref AWU_Timebase_TypeDef.
78 | * @retval None
79 | * @par Required preconditions:
80 | * The LS RC calibration must be performed before calling this function.
81 | */
82 | void AWU_Init(AWU_Timebase_TypeDef AWU_TimeBase)
83 | {
84 |
85 | /* Check parameter */
86 | assert_param(IS_AWU_TIMEBASE_OK(AWU_TimeBase));
87 |
88 | /* Enable the AWU peripheral */
89 | AWU->CSR |= AWU_CSR_AWUEN;
90 |
91 | /* Set the TimeBase */
92 | AWU->TBR &= (uint8_t)(~AWU_TBR_AWUTB);
93 | AWU->TBR |= TBR_Array[(uint8_t)AWU_TimeBase];
94 |
95 | /* Set the APR divider */
96 | AWU->APR &= (uint8_t)(~AWU_APR_APR);
97 | AWU->APR |= APR_Array[(uint8_t)AWU_TimeBase];
98 |
99 | }
100 |
101 | /**
102 | * @brief Enable or disable the AWU peripheral.
103 | * @param NewState Indicates the new state of the AWU peripheral.
104 | * @retval None
105 | * @par Required preconditions:
106 | * Initialisation of AWU and LS RC calibration must be done before.
107 | */
108 | void AWU_Cmd(FunctionalState NewState)
109 | {
110 | if (NewState != DISABLE)
111 | {
112 | /* Enable the AWU peripheral */
113 | AWU->CSR |= AWU_CSR_AWUEN;
114 | }
115 | else
116 | {
117 | /* Disable the AWU peripheral */
118 | AWU->CSR &= (uint8_t)(~AWU_CSR_AWUEN);
119 | }
120 | }
121 |
122 | /**
123 | * @brief Update APR register with the measured LSI frequency.
124 | * @par Note on the APR calculation:
125 | * A is the integer part of lsifreqkhz/4 and x the decimal part.
126 | * x <= A/(1+2A) is equivalent to A >= x(1+2A) and also to 4A >= 4x(1+2A) [F1]
127 | * but we know that A + x = lsifreqkhz/4 ==> 4x = lsifreqkhz-4A
128 | * so [F1] can be written :
129 | * 4A >= (lsifreqkhz-4A)(1+2A)
130 | * @param LSIFreqHz Low Speed RC frequency measured by timer (in Hz).
131 | * @retval None
132 | * @par Required preconditions:
133 | * - AWU must be disabled to avoid unwanted interrupts.
134 | */
135 | void AWU_LSICalibrationConfig(uint32_t LSIFreqHz)
136 | {
137 |
138 | uint16_t lsifreqkhz = 0x0;
139 | uint16_t A = 0x0;
140 |
141 | /* Check parameter */
142 | assert_param(IS_LSI_FREQUENCY_OK(LSIFreqHz));
143 |
144 | lsifreqkhz = (uint16_t)(LSIFreqHz / 1000); /* Converts value in kHz */
145 |
146 | /* Calculation of AWU calibration value */
147 |
148 | A = (uint16_t)(lsifreqkhz >> 2U); /* Division by 4, keep integer part only */
149 |
150 | if ((4U * A) >= ((lsifreqkhz - (4U * A)) * (1U + (2U * A))))
151 | {
152 | AWU->APR = (uint8_t)(A - 2U);
153 | }
154 | else
155 | {
156 | AWU->APR = (uint8_t)(A - 1U);
157 | }
158 | }
159 |
160 | /**
161 | * @brief Configures AWU in Idle mode to reduce power consumption.
162 | * @param None
163 | * @retval None
164 | */
165 | void AWU_IdleModeEnable(void)
166 | {
167 | /* Disable AWU peripheral */
168 | AWU->CSR &= (uint8_t)(~AWU_CSR_AWUEN);
169 |
170 | /* No AWU timebase */
171 | AWU->TBR = (uint8_t)(~AWU_TBR_AWUTB);
172 | }
173 |
174 | /**
175 | * @brief Returns status of the AWU peripheral flag.
176 | * @param None
177 | * @retval FlagStatus : Status of the AWU flag.
178 | * This parameter can be any of the @ref FlagStatus enumeration.
179 | */
180 | FlagStatus AWU_GetFlagStatus(void)
181 | {
182 | return((FlagStatus)(((uint8_t)(AWU->CSR & AWU_CSR_AWUF) == (uint8_t)0x00) ? RESET : SET));
183 | }
184 |
185 |
186 | /**
187 | * @}
188 | */
189 |
190 | /**
191 | * @}
192 | */
193 |
194 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
195 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_beep.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_beep.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the BEEP peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_beep.h"
24 |
25 | /** @addtogroup STM8S_StdPeriph_Driver
26 | * @{
27 | */
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* Private define ------------------------------------------------------------*/
30 | /* Private macro -------------------------------------------------------------*/
31 | /* Private variables ---------------------------------------------------------*/
32 | /* Private function prototypes -----------------------------------------------*/
33 | /* Private functions ---------------------------------------------------------*/
34 |
35 | /* Public functions ----------------------------------------------------------*/
36 |
37 | /**
38 | * @addtogroup BEEP_Public_Functions
39 | * @{
40 | */
41 |
42 | /**
43 | * @brief Deinitializes the BEEP peripheral registers to their default reset
44 | * values.
45 | * @param None
46 | * @retval None
47 | */
48 | void BEEP_DeInit(void)
49 | {
50 | BEEP->CSR = BEEP_CSR_RESET_VALUE;
51 | }
52 |
53 | /**
54 | * @brief Initializes the BEEP function according to the specified parameters.
55 | * @param BEEP_Frequency Frequency selection.
56 | * can be one of the values of @ref BEEP_Frequency_TypeDef.
57 | * @retval None
58 | * @par Required preconditions:
59 | * The LS RC calibration must be performed before calling this function.
60 | */
61 | void BEEP_Init(BEEP_Frequency_TypeDef BEEP_Frequency)
62 | {
63 |
64 | /* Check parameter */
65 | assert_param(IS_BEEP_FREQUENCY_OK(BEEP_Frequency));
66 |
67 | /* Set a default calibration value if no calibration is done */
68 | if ((BEEP->CSR & BEEP_CSR_BEEPDIV) == BEEP_CSR_BEEPDIV)
69 | {
70 | BEEP->CSR &= (uint8_t)(~BEEP_CSR_BEEPDIV); /* Clear bits */
71 | BEEP->CSR |= BEEP_CALIBRATION_DEFAULT;
72 | }
73 |
74 | /* Select the output frequency */
75 | BEEP->CSR &= (uint8_t)(~BEEP_CSR_BEEPSEL);
76 | BEEP->CSR |= (uint8_t)(BEEP_Frequency);
77 |
78 | }
79 |
80 | /**
81 | * @brief Enable or disable the BEEP function.
82 | * @param NewState Indicates the new state of the BEEP function.
83 | * @retval None
84 | * @par Required preconditions:
85 | * Initialisation of BEEP and LS RC calibration must be done before.
86 | */
87 | void BEEP_Cmd(FunctionalState NewState)
88 | {
89 | if (NewState != DISABLE)
90 | {
91 | /* Enable the BEEP peripheral */
92 | BEEP->CSR |= BEEP_CSR_BEEPEN;
93 | }
94 | else
95 | {
96 | /* Disable the BEEP peripheral */
97 | BEEP->CSR &= (uint8_t)(~BEEP_CSR_BEEPEN);
98 | }
99 | }
100 |
101 | /**
102 | * @brief Update CSR register with the measured LSI frequency.
103 | * @par Note on the APR calculation:
104 | * A is the integer part of LSIFreqkHz/4 and x the decimal part.
105 | * x <= A/(1+2A) is equivalent to A >= x(1+2A) and also to 4A >= 4x(1+2A) [F1]
106 | * but we know that A + x = LSIFreqkHz/4 ==> 4x = LSIFreqkHz-4A
107 | * so [F1] can be written :
108 | * 4A >= (LSIFreqkHz-4A)(1+2A)
109 | * @param LSIFreqHz Low Speed RC frequency measured by timer (in Hz).
110 | * @retval None
111 | * @par Required preconditions:
112 | * - BEEP must be disabled to avoid unwanted interrupts.
113 | */
114 | void BEEP_LSICalibrationConfig(uint32_t LSIFreqHz)
115 | {
116 |
117 | uint16_t lsifreqkhz;
118 | uint16_t A;
119 |
120 | /* Check parameter */
121 | assert_param(IS_LSI_FREQUENCY_OK(LSIFreqHz));
122 |
123 | lsifreqkhz = (uint16_t)(LSIFreqHz / 1000); /* Converts value in kHz */
124 |
125 | /* Calculation of BEEPER calibration value */
126 |
127 | BEEP->CSR &= (uint8_t)(~BEEP_CSR_BEEPDIV); /* Clear bits */
128 |
129 | A = (uint16_t)(lsifreqkhz >> 3U); /* Division by 8, keep integer part only */
130 |
131 | if ((8U * A) >= ((lsifreqkhz - (8U * A)) * (1U + (2U * A))))
132 | {
133 | BEEP->CSR |= (uint8_t)(A - 2U);
134 | }
135 | else
136 | {
137 | BEEP->CSR |= (uint8_t)(A - 1U);
138 | }
139 | }
140 |
141 | /**
142 | * @}
143 | */
144 |
145 | /**
146 | * @}
147 | */
148 |
149 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
150 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_can.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_can.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_exti.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_exti.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the EXTI peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_exti.h"
24 |
25 | /** @addtogroup STM8S_StdPeriph_Driver
26 | * @{
27 | */
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* Private define ------------------------------------------------------------*/
30 | /* Private macro -------------------------------------------------------------*/
31 | /* Private variables ---------------------------------------------------------*/
32 | /* Private function prototypes -----------------------------------------------*/
33 | /* Private functions ---------------------------------------------------------*/
34 |
35 | /* Public functions ----------------------------------------------------------*/
36 |
37 | /**
38 | * @addtogroup EXTI_Public_Functions
39 | * @{
40 | */
41 |
42 | /**
43 | * @brief Deinitializes the external interrupt control registers to their default reset value.
44 | * @param None
45 | * @retval None
46 | */
47 | void EXTI_DeInit(void)
48 | {
49 | EXTI->CR1 = EXTI_CR1_RESET_VALUE;
50 | EXTI->CR2 = EXTI_CR2_RESET_VALUE;
51 | }
52 |
53 | /**
54 | * @brief Set the external interrupt sensitivity of the selected port.
55 | * @warning
56 | * - The modification of external interrupt sensitivity is only possible when the interrupts are disabled.
57 | * - The normal behavior is to disable the interrupts before calling this function, and re-enable them after.
58 | * @param Port The port number to access.
59 | * @param SensitivityValue The external interrupt sensitivity value to set.
60 | * @retval None
61 | * @par Required preconditions:
62 | * Global interrupts must be disabled before calling this function.
63 | */
64 | void EXTI_SetExtIntSensitivity(EXTI_Port_TypeDef Port, EXTI_Sensitivity_TypeDef SensitivityValue)
65 | {
66 |
67 | /* Check function parameters */
68 | assert_param(IS_EXTI_PORT_OK(Port));
69 | assert_param(IS_EXTI_SENSITIVITY_OK(SensitivityValue));
70 |
71 | /* Set external interrupt sensitivity */
72 | switch (Port)
73 | {
74 | case EXTI_PORT_GPIOA:
75 | EXTI->CR1 &= (uint8_t)(~EXTI_CR1_PAIS);
76 | EXTI->CR1 |= (uint8_t)(SensitivityValue);
77 | break;
78 | case EXTI_PORT_GPIOB:
79 | EXTI->CR1 &= (uint8_t)(~EXTI_CR1_PBIS);
80 | EXTI->CR1 |= (uint8_t)((uint8_t)(SensitivityValue) << 2);
81 | break;
82 | case EXTI_PORT_GPIOC:
83 | EXTI->CR1 &= (uint8_t)(~EXTI_CR1_PCIS);
84 | EXTI->CR1 |= (uint8_t)((uint8_t)(SensitivityValue) << 4);
85 | break;
86 | case EXTI_PORT_GPIOD:
87 | EXTI->CR1 &= (uint8_t)(~EXTI_CR1_PDIS);
88 | EXTI->CR1 |= (uint8_t)((uint8_t)(SensitivityValue) << 6);
89 | break;
90 | case EXTI_PORT_GPIOE:
91 | EXTI->CR2 &= (uint8_t)(~EXTI_CR2_PEIS);
92 | EXTI->CR2 |= (uint8_t)(SensitivityValue);
93 | break;
94 | default:
95 | break;
96 | }
97 | }
98 |
99 | /**
100 | * @brief Set the TLI interrupt sensitivity.
101 | * @param SensitivityValue The TLI interrupt sensitivity value.
102 | * @retval None
103 | * @par Required preconditions:
104 | * Global interrupts must be disabled before calling this function.
105 | */
106 | void EXTI_SetTLISensitivity(EXTI_TLISensitivity_TypeDef SensitivityValue)
107 | {
108 | /* Check function parameters */
109 | assert_param(IS_EXTI_TLISENSITIVITY_OK(SensitivityValue));
110 |
111 | /* Set TLI interrupt sensitivity */
112 | EXTI->CR2 &= (uint8_t)(~EXTI_CR2_TLIS);
113 | EXTI->CR2 |= (uint8_t)(SensitivityValue);
114 | }
115 |
116 | /**
117 | * @brief Get the external interrupt sensitivity of the selected port.
118 | * @param Port The port number to access.
119 | * @retval EXTI_Sensitivity_TypeDef The external interrupt sensitivity of the selected port.
120 | */
121 | EXTI_Sensitivity_TypeDef EXTI_GetExtIntSensitivity(EXTI_Port_TypeDef Port)
122 | {
123 | uint8_t value = 0;
124 |
125 | /* Check function parameters */
126 | assert_param(IS_EXTI_PORT_OK(Port));
127 |
128 | switch (Port)
129 | {
130 | case EXTI_PORT_GPIOA:
131 | value = (uint8_t)(EXTI->CR1 & EXTI_CR1_PAIS);
132 | break;
133 | case EXTI_PORT_GPIOB:
134 | value = (uint8_t)((uint8_t)(EXTI->CR1 & EXTI_CR1_PBIS) >> 2);
135 | break;
136 | case EXTI_PORT_GPIOC:
137 | value = (uint8_t)((uint8_t)(EXTI->CR1 & EXTI_CR1_PCIS) >> 4);
138 | break;
139 | case EXTI_PORT_GPIOD:
140 | value = (uint8_t)((uint8_t)(EXTI->CR1 & EXTI_CR1_PDIS) >> 6);
141 | break;
142 | case EXTI_PORT_GPIOE:
143 | value = (uint8_t)(EXTI->CR2 & EXTI_CR2_PEIS);
144 | break;
145 | default:
146 | break;
147 | }
148 |
149 | return((EXTI_Sensitivity_TypeDef)value);
150 | }
151 |
152 | /**
153 | * @brief Get the TLI interrupt sensitivity.
154 | * @param None
155 | * @retval EXTI_TLISensitivity_TypeDef The TLI interrupt sensitivity read.
156 | */
157 | EXTI_TLISensitivity_TypeDef EXTI_GetTLISensitivity(void)
158 | {
159 |
160 | uint8_t value = 0;
161 |
162 | /* Get TLI interrupt sensitivity */
163 | value = (uint8_t)(EXTI->CR2 & EXTI_CR2_TLIS);
164 |
165 | return((EXTI_TLISensitivity_TypeDef)value);
166 | }
167 |
168 | /**
169 | * @}
170 | */
171 |
172 | /**
173 | * @}
174 | */
175 |
176 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
177 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_flash.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_flash.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_gpio.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_gpio.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the GPIO peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_gpio.h"
24 |
25 | /** @addtogroup STM8S_StdPeriph_Driver
26 | * @{
27 | */
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* Private define ------------------------------------------------------------*/
30 | /* Private macro -------------------------------------------------------------*/
31 | /* Private variables ---------------------------------------------------------*/
32 | /* Private function prototypes -----------------------------------------------*/
33 | /* Private functions ---------------------------------------------------------*/
34 |
35 | /* Public functions ----------------------------------------------------------*/
36 |
37 | /**
38 | * @addtogroup GPIO_Public_Functions
39 | * @{
40 | */
41 |
42 | /**
43 | * @brief Deinitializes the GPIOx peripheral registers to their default reset values.
44 | * @param GPIOx: Select the GPIO peripheral number (x = A to I).
45 | * @retval None
46 | */
47 | void GPIO_DeInit(GPIO_TypeDef* GPIOx)
48 | {
49 | GPIOx->ODR = GPIO_ODR_RESET_VALUE; /* Reset Output Data Register */
50 | GPIOx->DDR = GPIO_DDR_RESET_VALUE; /* Reset Data Direction Register */
51 | GPIOx->CR1 = GPIO_CR1_RESET_VALUE; /* Reset Control Register 1 */
52 | GPIOx->CR2 = GPIO_CR2_RESET_VALUE; /* Reset Control Register 2 */
53 | }
54 |
55 | /**
56 | * @brief Initializes the GPIOx according to the specified parameters.
57 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
58 | * @param GPIO_Pin : This parameter contains the pin number, it can be any value
59 | * of the @ref GPIO_Pin_TypeDef enumeration.
60 | * @param GPIO_Mode : This parameter can be a value of the
61 | * @Ref GPIO_Mode_TypeDef enumeration.
62 | * @retval None
63 | */
64 |
65 | void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin, GPIO_Mode_TypeDef GPIO_Mode)
66 | {
67 | /*----------------------*/
68 | /* Check the parameters */
69 | /*----------------------*/
70 |
71 | assert_param(IS_GPIO_MODE_OK(GPIO_Mode));
72 | assert_param(IS_GPIO_PIN_OK(GPIO_Pin));
73 |
74 | /* Reset corresponding bit to GPIO_Pin in CR2 register */
75 | GPIOx->CR2 &= (uint8_t)(~(GPIO_Pin));
76 |
77 | /*-----------------------------*/
78 | /* Input/Output mode selection */
79 | /*-----------------------------*/
80 |
81 | if ((((uint8_t)(GPIO_Mode)) & (uint8_t)0x80) != (uint8_t)0x00) /* Output mode */
82 | {
83 | if ((((uint8_t)(GPIO_Mode)) & (uint8_t)0x10) != (uint8_t)0x00) /* High level */
84 | {
85 | GPIOx->ODR |= (uint8_t)GPIO_Pin;
86 | }
87 | else /* Low level */
88 | {
89 | GPIOx->ODR &= (uint8_t)(~(GPIO_Pin));
90 | }
91 | /* Set Output mode */
92 | GPIOx->DDR |= (uint8_t)GPIO_Pin;
93 | }
94 | else /* Input mode */
95 | {
96 | /* Set Input mode */
97 | GPIOx->DDR &= (uint8_t)(~(GPIO_Pin));
98 | }
99 |
100 | /*------------------------------------------------------------------------*/
101 | /* Pull-Up/Float (Input) or Push-Pull/Open-Drain (Output) modes selection */
102 | /*------------------------------------------------------------------------*/
103 |
104 | if ((((uint8_t)(GPIO_Mode)) & (uint8_t)0x40) != (uint8_t)0x00) /* Pull-Up or Push-Pull */
105 | {
106 | GPIOx->CR1 |= (uint8_t)GPIO_Pin;
107 | }
108 | else /* Float or Open-Drain */
109 | {
110 | GPIOx->CR1 &= (uint8_t)(~(GPIO_Pin));
111 | }
112 |
113 | /*-----------------------------------------------------*/
114 | /* Interrupt (Input) or Slope (Output) modes selection */
115 | /*-----------------------------------------------------*/
116 |
117 | if ((((uint8_t)(GPIO_Mode)) & (uint8_t)0x20) != (uint8_t)0x00) /* Interrupt or Slow slope */
118 | {
119 | GPIOx->CR2 |= (uint8_t)GPIO_Pin;
120 | }
121 | else /* No external interrupt or No slope control */
122 | {
123 | GPIOx->CR2 &= (uint8_t)(~(GPIO_Pin));
124 | }
125 | }
126 |
127 | /**
128 | * @brief Writes data to the specified GPIO data port.
129 | * @note The port must be configured in output mode.
130 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
131 | * @param GPIO_PortVal : Specifies the value to be written to the port output
132 | * data register.
133 | * @retval None
134 | */
135 | void GPIO_Write(GPIO_TypeDef* GPIOx, uint8_t PortVal)
136 | {
137 | GPIOx->ODR = PortVal;
138 | }
139 |
140 | /**
141 | * @brief Writes high level to the specified GPIO pins.
142 | * @note The port must be configured in output mode.
143 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
144 | * @param PortPins : Specifies the pins to be turned high to the port output.
145 | * data register.
146 | * @retval None
147 | */
148 | void GPIO_WriteHigh(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins)
149 | {
150 | GPIOx->ODR |= (uint8_t)PortPins;
151 | }
152 |
153 | /**
154 | * @brief Writes low level to the specified GPIO pins.
155 | * @note The port must be configured in output mode.
156 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
157 | * @param PortPins : Specifies the pins to be turned low to the port output.
158 | * data register.
159 | * @retval None
160 | */
161 | void GPIO_WriteLow(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins)
162 | {
163 | GPIOx->ODR &= (uint8_t)(~PortPins);
164 | }
165 |
166 | /**
167 | * @brief Writes reverse level to the specified GPIO pins.
168 | * @note The port must be configured in output mode.
169 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
170 | * @param PortPins : Specifies the pins to be reversed to the port output.
171 | * data register.
172 | * @retval None
173 | */
174 | void GPIO_WriteReverse(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins)
175 | {
176 | GPIOx->ODR ^= (uint8_t)PortPins;
177 | }
178 |
179 | /**
180 | * @brief Reads the specified GPIO output data port.
181 | * @note The port must be configured in input mode.
182 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
183 | * @retval GPIO output data port value.
184 | */
185 | uint8_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx)
186 | {
187 | return ((uint8_t)GPIOx->ODR);
188 | }
189 |
190 | /**
191 | * @brief Reads the specified GPIO input data port.
192 | * @note The port must be configured in input mode.
193 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
194 | * @retval GPIO input data port value.
195 | */
196 | uint8_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx)
197 | {
198 | return ((uint8_t)GPIOx->IDR);
199 | }
200 |
201 | /**
202 | * @brief Reads the specified GPIO input data pin.
203 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
204 | * @param GPIO_Pin : Specifies the pin number.
205 | * @retval BitStatus : GPIO input pin status.
206 | */
207 | BitStatus GPIO_ReadInputPin(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin)
208 | {
209 | return ((BitStatus)(GPIOx->IDR & (uint8_t)GPIO_Pin));
210 | }
211 |
212 | /**
213 | * @brief Configures the external pull-up on GPIOx pins.
214 | * @param GPIOx : Select the GPIO peripheral number (x = A to I).
215 | * @param GPIO_Pin : Specifies the pin number
216 | * @param NewState : The new state of the pull up pin.
217 | * @retval None
218 | */
219 | void GPIO_ExternalPullUpConfig(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin, FunctionalState NewState)
220 | {
221 | /* Check the parameters */
222 | assert_param(IS_GPIO_PIN_OK(GPIO_Pin));
223 | assert_param(IS_FUNCTIONALSTATE_OK(NewState));
224 |
225 | if (NewState != DISABLE) /* External Pull-Up Set*/
226 | {
227 | GPIOx->CR1 |= (uint8_t)GPIO_Pin;
228 | } else /* External Pull-Up Reset*/
229 | {
230 | GPIOx->CR1 &= (uint8_t)(~(GPIO_Pin));
231 | }
232 | }
233 |
234 | /**
235 | * @}
236 | */
237 |
238 | /**
239 | * @}
240 | */
241 |
242 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
243 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_i2c.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_i2c.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_itc.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_itc.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the ITC peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_itc.h"
24 |
25 | /** @addtogroup STM8S_StdPeriph_Driver
26 | * @{
27 | */
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* Private define ------------------------------------------------------------*/
30 | /* Private macro -------------------------------------------------------------*/
31 | /* Private variables ---------------------------------------------------------*/
32 | /* Private function prototypes -----------------------------------------------*/
33 | /* Private functions ---------------------------------------------------------*/
34 |
35 | /** @addtogroup ITC_Private_Functions
36 | * @{
37 | */
38 |
39 | /**
40 | * @brief Utility function used to read CC register.
41 | * @param None
42 | * @retval CPU CC register value
43 | */
44 | uint8_t ITC_GetCPUCC(void)
45 | {
46 | #ifdef _COSMIC_
47 | _asm("push cc");
48 | _asm("pop a");
49 | return; /* Ignore compiler warning, the returned value is in A register */
50 | #elif defined _RAISONANCE_ /* _RAISONANCE_ */
51 | return _getCC_();
52 | #else /* _IAR_ */
53 | asm("push cc");
54 | asm("pop a"); /* Ignore compiler warning, the returned value is in A register */
55 | #endif /* _COSMIC_*/
56 | }
57 |
58 |
59 | /**
60 | * @}
61 | */
62 |
63 | /* Public functions ----------------------------------------------------------*/
64 |
65 | /** @addtogroup ITC_Public_Functions
66 | * @{
67 | */
68 |
69 | /**
70 | * @brief Deinitializes the ITC registers to their default reset value.
71 | * @param None
72 | * @retval None
73 | */
74 | void ITC_DeInit(void)
75 | {
76 | ITC->ISPR1 = ITC_SPRX_RESET_VALUE;
77 | ITC->ISPR2 = ITC_SPRX_RESET_VALUE;
78 | ITC->ISPR3 = ITC_SPRX_RESET_VALUE;
79 | ITC->ISPR4 = ITC_SPRX_RESET_VALUE;
80 | ITC->ISPR5 = ITC_SPRX_RESET_VALUE;
81 | ITC->ISPR6 = ITC_SPRX_RESET_VALUE;
82 | ITC->ISPR7 = ITC_SPRX_RESET_VALUE;
83 | ITC->ISPR8 = ITC_SPRX_RESET_VALUE;
84 | }
85 |
86 | /**
87 | * @brief Gets the interrupt software priority bits (I1, I0) value from CPU CC register.
88 | * @param None
89 | * @retval The interrupt software priority bits value.
90 | */
91 | uint8_t ITC_GetSoftIntStatus(void)
92 | {
93 | return (uint8_t)(ITC_GetCPUCC() & CPU_CC_I1I0);
94 | }
95 |
96 | /**
97 | * @brief Gets the software priority of the specified interrupt source.
98 | * @param IrqNum : Specifies the peripheral interrupt source.
99 | * @retval ITC_PriorityLevel_TypeDef : Specifies the software priority of the interrupt source.
100 | */
101 | ITC_PriorityLevel_TypeDef ITC_GetSoftwarePriority(ITC_Irq_TypeDef IrqNum)
102 | {
103 |
104 | uint8_t Value = 0;
105 | uint8_t Mask = 0;
106 |
107 | /* Check function parameters */
108 | assert_param(IS_ITC_IRQ_OK((uint8_t)IrqNum));
109 |
110 | /* Define the mask corresponding to the bits position in the SPR register */
111 | Mask = (uint8_t)(0x03U << (((uint8_t)IrqNum % 4U) * 2U));
112 |
113 | switch (IrqNum)
114 | {
115 | case ITC_IRQ_TLI: /* TLI software priority can be read but has no meaning */
116 | case ITC_IRQ_AWU:
117 | case ITC_IRQ_CLK:
118 | case ITC_IRQ_PORTA:
119 | Value = (uint8_t)(ITC->ISPR1 & Mask); /* Read software priority */
120 | break;
121 | case ITC_IRQ_PORTB:
122 | case ITC_IRQ_PORTC:
123 | case ITC_IRQ_PORTD:
124 | case ITC_IRQ_PORTE:
125 | Value = (uint8_t)(ITC->ISPR2 & Mask); /* Read software priority */
126 | break;
127 | #if defined(STM8S208) || defined(STM8AF52Ax)
128 | case ITC_IRQ_CAN_RX:
129 | case ITC_IRQ_CAN_TX:
130 | #endif /*STM8S208 or STM8AF52Ax */
131 |
132 | #ifdef STM8S903
133 | case ITC_IRQ_PORTF:
134 | #endif /*STM8S903*/
135 |
136 | case ITC_IRQ_SPI:
137 | case ITC_IRQ_TIM1_OVF:
138 | Value = (uint8_t)(ITC->ISPR3 & Mask); /* Read software priority */
139 | break;
140 | case ITC_IRQ_TIM1_CAPCOM:
141 | #ifdef STM8S903
142 | case ITC_IRQ_TIM5_OVFTRI:
143 | case ITC_IRQ_TIM5_CAPCOM:
144 | #else
145 | case ITC_IRQ_TIM2_OVF:
146 | case ITC_IRQ_TIM2_CAPCOM:
147 | #endif /*STM8S903*/
148 |
149 | case ITC_IRQ_TIM3_OVF:
150 | Value = (uint8_t)(ITC->ISPR4 & Mask); /* Read software priority */
151 | break;
152 | case ITC_IRQ_TIM3_CAPCOM:
153 | case ITC_IRQ_UART1_TX:
154 | case ITC_IRQ_UART1_RX:
155 | case ITC_IRQ_I2C:
156 | Value = (uint8_t)(ITC->ISPR5 & Mask); /* Read software priority */
157 | break;
158 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8AF626x)
159 | case ITC_IRQ_UART2_TX:
160 | case ITC_IRQ_UART2_RX:
161 | #endif /*STM8S105 or STM8AF626x*/
162 |
163 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8AF52Ax) || \
164 | defined(STM8AF62Ax)
165 | case ITC_IRQ_UART3_TX:
166 | case ITC_IRQ_UART3_RX:
167 | case ITC_IRQ_ADC2:
168 | #endif /*STM8S208 or STM8S207 or STM8AF52Ax or STM8AF62Ax */
169 |
170 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8S103) || defined(STM8S003) || \
171 | defined(STM8S903) || defined(STM8AF626x)
172 | case ITC_IRQ_ADC1:
173 | #endif /*STM8S105, STM8S103 or STM8S905 or STM8AF626x */
174 |
175 | #ifdef STM8S903
176 | case ITC_IRQ_TIM6_OVFTRI:
177 | #else
178 | case ITC_IRQ_TIM4_OVF:
179 | #endif /*STM8S903*/
180 | Value = (uint8_t)(ITC->ISPR6 & Mask); /* Read software priority */
181 | break;
182 | case ITC_IRQ_EEPROM_EEC:
183 | Value = (uint8_t)(ITC->ISPR7 & Mask); /* Read software priority */
184 | break;
185 | default:
186 | break;
187 | }
188 |
189 | Value >>= (uint8_t)(((uint8_t)IrqNum % 4u) * 2u);
190 |
191 | return((ITC_PriorityLevel_TypeDef)Value);
192 |
193 | }
194 |
195 | /**
196 | * @brief Sets the software priority of the specified interrupt source.
197 | * @note - The modification of the software priority is only possible when
198 | * the interrupts are disabled.
199 | * - The normal behavior is to disable the interrupt before calling
200 | * this function, and re-enable it after.
201 | * - The priority level 0 cannot be set (see product specification
202 | * for more details).
203 | * @param IrqNum : Specifies the peripheral interrupt source.
204 | * @param PriorityValue : Specifies the software priority value to set,
205 | * can be a value of @ref ITC_PriorityLevel_TypeDef .
206 | * @retval None
207 | */
208 | void ITC_SetSoftwarePriority(ITC_Irq_TypeDef IrqNum, ITC_PriorityLevel_TypeDef PriorityValue)
209 | {
210 |
211 | uint8_t Mask = 0;
212 | uint8_t NewPriority = 0;
213 |
214 | /* Check function parameters */
215 | assert_param(IS_ITC_IRQ_OK((uint8_t)IrqNum));
216 | assert_param(IS_ITC_PRIORITY_OK(PriorityValue));
217 |
218 | /* Check if interrupts are disabled */
219 | assert_param(IS_ITC_INTERRUPTS_DISABLED);
220 |
221 | /* Define the mask corresponding to the bits position in the SPR register */
222 | /* The mask is reversed in order to clear the 2 bits after more easily */
223 | Mask = (uint8_t)(~(uint8_t)(0x03U << (((uint8_t)IrqNum % 4U) * 2U)));
224 |
225 | /* Define the new priority to write */
226 | NewPriority = (uint8_t)((uint8_t)(PriorityValue) << (((uint8_t)IrqNum % 4U) * 2U));
227 |
228 | switch (IrqNum)
229 | {
230 |
231 | case ITC_IRQ_TLI: /* TLI software priority can be written but has no meaning */
232 | case ITC_IRQ_AWU:
233 | case ITC_IRQ_CLK:
234 | case ITC_IRQ_PORTA:
235 | ITC->ISPR1 &= Mask;
236 | ITC->ISPR1 |= NewPriority;
237 | break;
238 |
239 | case ITC_IRQ_PORTB:
240 | case ITC_IRQ_PORTC:
241 | case ITC_IRQ_PORTD:
242 | case ITC_IRQ_PORTE:
243 | ITC->ISPR2 &= Mask;
244 | ITC->ISPR2 |= NewPriority;
245 | break;
246 |
247 | #if defined(STM8S208) || defined(STM8AF52Ax)
248 | case ITC_IRQ_CAN_RX:
249 | case ITC_IRQ_CAN_TX:
250 | #endif /*STM8S208 or STM8AF52Ax */
251 |
252 | #ifdef STM8S903
253 | case ITC_IRQ_PORTF:
254 | #endif /*STM8S903*/
255 | case ITC_IRQ_SPI:
256 | case ITC_IRQ_TIM1_OVF:
257 | ITC->ISPR3 &= Mask;
258 | ITC->ISPR3 |= NewPriority;
259 | break;
260 |
261 | case ITC_IRQ_TIM1_CAPCOM:
262 | #ifdef STM8S903
263 | case ITC_IRQ_TIM5_OVFTRI:
264 | case ITC_IRQ_TIM5_CAPCOM:
265 | #else
266 | case ITC_IRQ_TIM2_OVF:
267 | case ITC_IRQ_TIM2_CAPCOM:
268 | #endif /*STM8S903*/
269 |
270 | case ITC_IRQ_TIM3_OVF:
271 | ITC->ISPR4 &= Mask;
272 | ITC->ISPR4 |= NewPriority;
273 | break;
274 |
275 | case ITC_IRQ_TIM3_CAPCOM:
276 | case ITC_IRQ_UART1_TX:
277 | case ITC_IRQ_UART1_RX:
278 | case ITC_IRQ_I2C:
279 | ITC->ISPR5 &= Mask;
280 | ITC->ISPR5 |= NewPriority;
281 | break;
282 |
283 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8AF626x)
284 | case ITC_IRQ_UART2_TX:
285 | case ITC_IRQ_UART2_RX:
286 | #endif /*STM8S105 or STM8AF626x */
287 |
288 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8AF52Ax) || \
289 | defined(STM8AF62Ax)
290 | case ITC_IRQ_UART3_TX:
291 | case ITC_IRQ_UART3_RX:
292 | case ITC_IRQ_ADC2:
293 | #endif /*STM8S208 or STM8S207 or STM8AF52Ax or STM8AF62Ax */
294 |
295 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8S103) || defined(STM8S003) || \
296 | defined(STM8S903) || defined(STM8AF626x)
297 | case ITC_IRQ_ADC1:
298 | #endif /*STM8S105, STM8S103 or STM8S905 or STM8AF626x */
299 |
300 | #ifdef STM8S903
301 | case ITC_IRQ_TIM6_OVFTRI:
302 | #else
303 | case ITC_IRQ_TIM4_OVF:
304 | #endif /*STM8S903*/
305 | ITC->ISPR6 &= Mask;
306 | ITC->ISPR6 |= NewPriority;
307 | break;
308 |
309 | case ITC_IRQ_EEPROM_EEC:
310 | ITC->ISPR7 &= Mask;
311 | ITC->ISPR7 |= NewPriority;
312 | break;
313 |
314 | default:
315 | break;
316 |
317 | }
318 |
319 | }
320 |
321 | /**
322 | * @}
323 | */
324 |
325 | /**
326 | * @}
327 | */
328 |
329 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
330 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_iwdg.c:
--------------------------------------------------------------------------------
1 | /**
2 | ********************************************************************************
3 | * @file stm8s_iwdg.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the IWDG peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_iwdg.h"
24 |
25 | /* Private define ------------------------------------------------------------*/
26 | /* Private macro -------------------------------------------------------------*/
27 | /* Private variables ---------------------------------------------------------*/
28 | /* Private function prototypes -----------------------------------------------*/
29 | /* Private functions ---------------------------------------------------------*/
30 | /* Public functions ----------------------------------------------------------*/
31 |
32 | /** @addtogroup IWDG_Public_Functions
33 | * @{
34 | */
35 |
36 | /**
37 | * @brief Enables or disables write access to Prescaler and Reload registers.
38 | * @param IWDG_WriteAccess : New state of write access to Prescaler and Reload
39 | * registers. This parameter can be a value of @ref IWDG_WriteAccess_TypeDef.
40 | * @retval None
41 | */
42 | void IWDG_WriteAccessCmd(IWDG_WriteAccess_TypeDef IWDG_WriteAccess)
43 | {
44 | /* Check the parameters */
45 | assert_param(IS_IWDG_WRITEACCESS_MODE_OK(IWDG_WriteAccess));
46 |
47 | IWDG->KR = (uint8_t)IWDG_WriteAccess; /* Write Access */
48 | }
49 |
50 | /**
51 | * @brief Sets IWDG Prescaler value.
52 | * @note Write access should be enabled
53 | * @param IWDG_Prescaler : Specifies the IWDG Prescaler value.
54 | * This parameter can be a value of @ref IWDG_Prescaler_TypeDef.
55 | * @retval None
56 | */
57 | void IWDG_SetPrescaler(IWDG_Prescaler_TypeDef IWDG_Prescaler)
58 | {
59 | /* Check the parameters */
60 | assert_param(IS_IWDG_PRESCALER_OK(IWDG_Prescaler));
61 |
62 | IWDG->PR = (uint8_t)IWDG_Prescaler;
63 | }
64 |
65 | /**
66 | * @brief Sets IWDG Reload value.
67 | * @note Write access should be enabled
68 | * @param IWDG_Reload : Reload register value.
69 | * This parameter must be a number between 0 and 0xFF.
70 | * @retval None
71 | */
72 | void IWDG_SetReload(uint8_t IWDG_Reload)
73 | {
74 | IWDG->RLR = IWDG_Reload;
75 | }
76 |
77 | /**
78 | * @brief Reloads IWDG counter
79 | * @note Write access should be enabled
80 | * @param None
81 | * @retval None
82 | */
83 | void IWDG_ReloadCounter(void)
84 | {
85 | IWDG->KR = IWDG_KEY_REFRESH;
86 | }
87 |
88 | /**
89 | * @brief Enables IWDG.
90 | * @param None
91 | * @retval None
92 | */
93 | void IWDG_Enable(void)
94 | {
95 | IWDG->KR = IWDG_KEY_ENABLE;
96 | }
97 |
98 | /**
99 | * @}
100 | */
101 |
102 | /**
103 | * @}
104 | */
105 |
106 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
107 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_rst.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_rst.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the RST peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 |
24 | #include "stm8s_rst.h"
25 |
26 | /** @addtogroup STM8S_StdPeriph_Driver
27 | * @{
28 | */
29 | /* Private typedef -----------------------------------------------------------*/
30 | /* Private define ------------------------------------------------------------*/
31 | /* Private macro -------------------------------------------------------------*/
32 | /* Private variables ---------------------------------------------------------*/
33 | /* Private function prototypes -----------------------------------------------*/
34 | /* Private Constants ---------------------------------------------------------*/
35 | /* Public functions ----------------------------------------------------------*/
36 | /**
37 | * @addtogroup RST_Public_Functions
38 | * @{
39 | */
40 |
41 |
42 | /**
43 | * @brief Checks whether the specified RST flag is set or not.
44 | * @param RST_Flag : specify the reset flag to check.
45 | * This parameter can be a value of @ref RST_FLAG_TypeDef.
46 | * @retval FlagStatus: status of the given RST flag.
47 | */
48 | FlagStatus RST_GetFlagStatus(RST_Flag_TypeDef RST_Flag)
49 | {
50 | /* Check the parameters */
51 | assert_param(IS_RST_FLAG_OK(RST_Flag));
52 |
53 | /* Get flag status */
54 |
55 | return ((FlagStatus)((uint8_t)RST->SR & (uint8_t)RST_Flag));
56 | }
57 |
58 | /**
59 | * @brief Clears the specified RST flag.
60 | * @param RST_Flag : specify the reset flag to clear.
61 | * This parameter can be a value of @ref RST_FLAG_TypeDef.
62 | * @retval None
63 | */
64 | void RST_ClearFlag(RST_Flag_TypeDef RST_Flag)
65 | {
66 | /* Check the parameters */
67 | assert_param(IS_RST_FLAG_OK(RST_Flag));
68 |
69 | RST->SR = (uint8_t)RST_Flag;
70 | }
71 |
72 | /**
73 | * @}
74 | */
75 |
76 | /**
77 | * @}
78 | */
79 |
80 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
81 |
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_tim1.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_tim1.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_tim2.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_tim2.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_tim3.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_tim3.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_tim4.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_tim4.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_tim5.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_tim5.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_tim6.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_tim6.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_uart1.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_uart1.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_uart2.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZiB/STM8S-USB/1844b1bc4d40433e264c68cd51c8f76a3d349eb6/mcu/std_lib/src/stm8s_uart2.c
--------------------------------------------------------------------------------
/mcu/std_lib/src/stm8s_wwdg.c:
--------------------------------------------------------------------------------
1 | /**
2 | ********************************************************************************
3 | * @file stm8s_wwdg.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains all the functions for the WWDG peripheral.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "stm8s_wwdg.h"
24 |
25 | /** @addtogroup STM8S_StdPeriph_Driver
26 | * @{
27 | */
28 | /* Private define ------------------------------------------------------------*/
29 | #define BIT_MASK ((uint8_t)0x7F)
30 | /* Private macro -------------------------------------------------------------*/
31 | /* Private variables ---------------------------------------------------------*/
32 | /* Private function prototypes -----------------------------------------------*/
33 | /* Private functions ---------------------------------------------------------*/
34 |
35 | /** @addtogroup WWDG_Public_Functions
36 | * @{
37 | */
38 |
39 | /**
40 | * @brief Initializes the WWDG peripheral.
41 | * This function set Window Register = WindowValue, Counter Register
42 | * according to Counter and \b ENABLE \b WWDG
43 | * @param Counter : WWDG counter value
44 | * @param WindowValue : specifies the WWDG Window Register, range is 0x00 to 0x7F.
45 | * @retval None
46 | */
47 | void WWDG_Init(uint8_t Counter, uint8_t WindowValue)
48 | {
49 | /* Check the parameters */
50 | assert_param(IS_WWDG_WINDOWLIMITVALUE_OK(WindowValue));
51 |
52 | WWDG->WR = WWDG_WR_RESET_VALUE;
53 | WWDG->CR = (uint8_t)((uint8_t)(WWDG_CR_WDGA | WWDG_CR_T6) | (uint8_t)Counter);
54 | WWDG->WR = (uint8_t)((uint8_t)(~WWDG_CR_WDGA) & (uint8_t)(WWDG_CR_T6 | WindowValue));
55 | }
56 |
57 | /**
58 | * @brief Refreshes the WWDG peripheral.
59 | * @param Counter : WWDG Counter Value
60 | * This parameter must be a number between 0x40 and 0x7F.
61 | * @retval None
62 | */
63 | void WWDG_SetCounter(uint8_t Counter)
64 | {
65 |
66 | /* Check the parameters */
67 | assert_param(IS_WWDG_COUNTERVALUE_OK(Counter));
68 |
69 | /* Write to T[6:0] bits to configure the counter value, no need to do
70 | a read-modify-write; writing a 0 to WDGA bit does nothing */
71 | WWDG->CR = (uint8_t)(Counter & (uint8_t)BIT_MASK);
72 |
73 | }
74 |
75 | /**
76 | * @brief Gets the WWDG Counter Value.
77 | * This value could be used to check if WWDG is in the window, where
78 | * refresh is allowed.
79 | * @param None
80 | * @retval WWDG Counter Value
81 | */
82 | uint8_t WWDG_GetCounter(void)
83 | {
84 | return(WWDG->CR);
85 | }
86 |
87 | /**
88 | * @brief Generates immediate WWDG RESET.
89 | * @param None
90 | * @retval None
91 | */
92 | void WWDG_SWReset(void)
93 | {
94 | WWDG->CR = WWDG_CR_WDGA; /* Activate WWDG, with clearing T6 */
95 | }
96 |
97 | /**
98 | * @brief Sets the WWDG window value.
99 | * @param WindowValue: specifies the window value to be compared to the
100 | * downcounter.
101 | * This parameter value must be lower than 0x80.
102 | * @retval None
103 | */
104 | void WWDG_SetWindowValue(uint8_t WindowValue)
105 | {
106 | /* Check the parameters */
107 | assert_param(IS_WWDG_WINDOWLIMITVALUE_OK(WindowValue));
108 |
109 | WWDG->WR = (uint8_t)((uint8_t)(~WWDG_CR_WDGA) & (uint8_t)(WWDG_CR_T6 | WindowValue));
110 | }
111 | /**
112 | * @}
113 | */
114 |
115 | /**
116 | * @}
117 | */
118 |
119 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
120 |
--------------------------------------------------------------------------------
/mcu/stm8_interrupt_vector.c:
--------------------------------------------------------------------------------
1 | /* BASIC INTERRUPT VECTORS TABLE FOR STM8 devices
2 | * Copyright (c) 2011 STMicroelectronics
3 | */
4 |
5 | #include "stm8s_it.h"
6 |
7 | typedef void @far (*interrupt_handler_t)(void);
8 |
9 | struct interrupt_vector {
10 | u8 interrupt_instruction;
11 | interrupt_handler_t interrupt_handler;
12 | };
13 |
14 | extern void usb_rx(void);
15 |
16 | struct interrupt_vector const _vectab[] = {
17 | {0x82, (interrupt_handler_t)_stext}, /* RESET */
18 | {0x82, (interrupt_handler_t)TRAP_IRQHandler}, /* TRAP - Software interrupt */
19 | {0x82, (interrupt_handler_t)TLI_IRQHandler}, /* irq0 - External Top Level interrupt (TLI) */
20 | {0x82, (interrupt_handler_t)AWU_IRQHandler}, /* irq1 - Auto Wake Up from Halt interrupt */
21 | {0x82, (interrupt_handler_t)CLK_IRQHandler}, /* irq2 - Clock Controller interrupt */
22 | {0x82, (interrupt_handler_t)EXTI_PORTA_IRQHandler}, /* irq3 - External interrupt 0 (GPIOA) */
23 | {0x82, (interrupt_handler_t)EXTI_PORTB_IRQHandler}, /* irq4 - External interrupt 1 (GPIOB) */
24 | {0x82, (interrupt_handler_t)EXTI_PORTC_IRQHandler}, /* irq5 - External interrupt 2 (GPIOC) */
25 | {0x82, (interrupt_handler_t)EXTI_PORTD_IRQHandler}, /* irq6 - External interrupt 3 (GPIOD) */
26 | {0x82, (interrupt_handler_t)EXTI_PORTE_IRQHandler}, /* irq7 - External interrupt 4 (GPIOE) */
27 |
28 | #if defined (STM8S208) || defined (STM8AF52Ax)
29 | {0x82, (interrupt_handler_t)CAN_RX_IRQHandler}, /* irq8 - CAN Rx interrupt */
30 | {0x82, (interrupt_handler_t)CAN_TX_IRQHandler}, /* irq9 - CAN Tx/ER/SC interrupt */
31 | #elif defined (STM8S903)
32 | {0x82, (interrupt_handler_t)EXTI_PORTF_IRQHandler}, /* irq8 - External interrupt 5 (GPIOF) */
33 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq9 - Reserved */
34 | #else /*STM8S207, STM8S105 or STM8AF62Ax or STM8AF626x*/
35 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq8 - Reserved */
36 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq9 - Reserved */
37 | #endif /* STM8S208 or STM8AF52Ax */
38 | {0x82, (interrupt_handler_t)SPI_IRQHandler}, /* irq10 - SPI End of transfer interrupt */
39 | {0x82, (interrupt_handler_t)TIM1_UPD_OVF_TRG_BRK_IRQHandler}, /* irq11 - TIM1 Update/Overflow/Trigger/Break interrupt */
40 | /*{0x82, (interrupt_handler_t)TIM1_CAP_COM_IRQHandler}, /* irq12 - TIM1 Capture/Compare interrupt */
41 | {0x82, (interrupt_handler_t)usb_rx},
42 |
43 | #ifdef STM8S903
44 | {0x82, (interrupt_handler_t)TIM5_UPD_OVF_BRK_TRG_IRQHandler}, /* irq13 - TIM5 Update/Overflow/Break/Trigger interrupt */
45 | {0x82, (interrupt_handler_t)TIM5_CAP_COM_IRQHandler}, /* irq14 - TIM5 Capture/Compare interrupt */
46 |
47 | #else /*STM8S208, STM8S207, STM8S105 or STM8S103 or STM8AF62Ax or STM8AF52Ax or STM8AF626x*/
48 | {0x82, (interrupt_handler_t)TIM2_UPD_OVF_BRK_IRQHandler}, /* irq13 - TIM2 Update/Overflow/Break interrupt */
49 | {0x82, (interrupt_handler_t)TIM2_CAP_COM_IRQHandler}, /* irq14 - TIM2 Capture/Compare interrupt */
50 | #endif /*STM8S903*/
51 |
52 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S105) || \
53 | defined(STM8S005) || defined(STM8AF52Ax) || defined(STM8AF62Ax) || defined(STM8AF626x)
54 | {0x82, (interrupt_handler_t)TIM3_UPD_OVF_BRK_IRQHandler}, /* irq15 - TIM3 Update/Overflow/Break interrupt */
55 | {0x82, (interrupt_handler_t)TIM3_CAP_COM_IRQHandler}, /* irq16 - TIM3 Capture/Compare interrupt */
56 | #else
57 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq15 - Reserved */
58 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq16 - Reserved */
59 | #endif /*STM8S208, STM8S207, STM8S105 or STM8AF62Ax or STM8AF52Ax or STM8AF626x*/
60 |
61 | #if defined (STM8S105) || defined (STM8S005) || defined(STM8AF626x)
62 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq17 - Reserved */
63 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq18 - Reserved */
64 | #else
65 | {0x82, (interrupt_handler_t)UART1_TX_IRQHandler}, /* irq17 - UART1 Tx complete interrupt */
66 | {0x82, (interrupt_handler_t)UART1_RX_IRQHandler}, /* irq18 - UART1 Rx interrupt */
67 | #endif /*STM8S105 or STM8AF626x */
68 | {0x82, (interrupt_handler_t)I2C_IRQHandler}, /* irq19 - I2C interrupt */
69 |
70 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8AF52Ax) || defined(STM8AF62Ax)
71 |
72 | {0x82, (interrupt_handler_t)UART3_TX_IRQHandler}, /* irq20 - UART3 Tx interrupt */
73 | {0x82, (interrupt_handler_t)UART3_RX_IRQHandler}, /* irq21 - UART3 Rx interrupt */
74 | #elif defined (STM8S105) || defined (STM8S005) || defined (STM8AF626x)
75 | {0x82, (interrupt_handler_t)UART2_TX_IRQHandler}, /* irq20 - UART2 Tx interrupt */
76 | {0x82, (interrupt_handler_t)UART2_RX_IRQHandler}, /* irq21 - UART2 Rx interrupt */
77 |
78 | #else /* STM8S103, STM8S903 */
79 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq20 - Reserved */
80 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq21 - Reserved */
81 | #endif /* STM8S208, STM8S207, STM8AF52Ax or STM8AF62Ax */
82 |
83 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8AF52Ax) || defined(STM8AF62Ax)
84 | {0x82, (interrupt_handler_t)ADC2_IRQHandler}, /* irq22 - ADC2 end of conversion interrupt */
85 | #else /* STM8S105, STM8S103, STM8S903 */
86 | {0x82, (interrupt_handler_t)ADC1_IRQHandler}, /* irq22 - ADC1 end of conversion/Analog watchdog interrupts */
87 |
88 | #endif /* STM8S208, STM8S207, STM8AF52Ax or STM8AF62Ax */
89 |
90 | #ifdef STM8S903
91 | {0x82, (interrupt_handler_t)TIM6_UPD_OVF_TRG_IRQHandler}, /* irq23 - TIM6 Update/Overflow/Trigger interrupt */
92 | #else
93 | {0x82, (interrupt_handler_t)TIM4_UPD_OVF_IRQHandler}, /* irq23 - TIM4 Update/Overflow interrupt */
94 | #endif /*STM8S903*/
95 | {0x82, (interrupt_handler_t)EEPROM_EEC_IRQHandler}, /* irq24 - FLASH interrupt */
96 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq25 - Reserved */
97 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq26 - Reserved */
98 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq27 - Reserved */
99 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq28 - Reserved */
100 | {0x82, (interrupt_handler_t)NonHandledInterrupt}, /* irq29 - Reserved */
101 |
102 | };
103 |
104 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
105 |
--------------------------------------------------------------------------------
/mcu/stm8s003f3.ini:
--------------------------------------------------------------------------------
1 | define emulator-reset-port-mcu
2 | target gdi -dll swim\stm_swim.dll -stlink3 -port $arg0 -mcuname $arg1
3 | mcuname -set $arg1
4 | end
5 |
6 | emulator-reset-port-mcu usb://usb stm8s003f3
7 | quit
--------------------------------------------------------------------------------
/mcu/stm8s003f3.lsf:
--------------------------------------------------------------------------------
1 | #==========================================================
2 | # File: Linker Script File
3 | # Date: 2013-01-02
4 | # Denis Zheleznyakov aka ZiB @ ZiBlog.ru
5 | #==========================================================
6 |
7 | # флеш-память: программный код, константы
8 | +seg .const -b 0x8480 -m 0x1f80 -n .const -it
9 | +seg .text -a .const -n .text
10 |
11 | # EEPROM
12 | +seg .eeprom -b 0x4000 -m 0x80 -n .eeprom
13 |
14 | # ОЗУ: нулевая страница
15 | +seg .bsct -b 0x0 -m 0x100 -n .bsct
16 | +seg .ubsct -a .bsct -n .ubsct
17 | +seg .bit -a .ubsct -n .bit -id
18 | #+seg .share -a .bit -n .share -is
19 |
20 | # ОЗУ:
21 | +seg .data -b 0x100 -m 0x100 -n .data
22 | +seg .in_ram -a .data -n .in_ram -ic
23 | +seg .bss -a .in_ram -n .bss
24 |
25 | #----------------------------------------------------------
26 |
27 | # начальная инициализация
28 | crtsi0.sm8
29 |
30 | # исходники
31 | target/main.o
32 | target/usb.o
33 | target/macros.o
34 | target/stm8s_it.o
35 | target/stm8s_clk.o
36 | target/stm8s_tim1.o
37 | target/stm8s_tim2.o
38 | target/stm8s_tim4.o
39 | target/stm8s_uart1.o
40 |
41 | # библиотеки
42 | libis0.sm8
43 | libm0.sm8
44 |
45 | # таблица прерываний
46 | +seg .const -b 0x8000 -k
47 | target/stm8_interrupt_vector.o
48 |
49 | +seg .text -b 0x8080
50 | target/usb_tx.o
51 |
52 | +seg .text -b 0x8280
53 | target/usb_rx.o
54 |
55 | # определения используются при начальной инициализации
56 | +def __endzp=@.ubsct
57 | +def __memory=@.bss
58 | +def __startmem=@.bss
59 | +def __endmem=0x1ff
60 | +def __stack=0x3ff
61 |
62 |
--------------------------------------------------------------------------------
/mcu/stm8s_conf.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_conf.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file is used to configure the Library.
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_CONF_H
24 | #define __STM8S_CONF_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Uncomment the line below to enable peripheral header file inclusion */
30 | #if defined(STM8S105) || defined(STM8S005) || defined(STM8S103) || defined(STM8S003) ||\
31 | defined(STM8S903) || defined (STM8AF626x)
32 | #include "stm8s_adc1.h"
33 | #endif /* (STM8S105) ||(STM8S103) || (STM8S903) || STM8AF626x*/
34 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined (STM8AF52Ax) ||\
35 | defined (STM8AF62Ax)
36 | #include "stm8s_adc2.h"
37 | #endif /* (STM8S208) || (STM8S207) || (STM8AF62Ax) || (STM8AF52Ax) */
38 | #include "stm8s_awu.h"
39 | #include "stm8s_beep.h"
40 | #if defined (STM8S208) || defined (STM8AF52Ax)
41 | #include "stm8s_can.h"
42 | #endif /* STM8S208 || STM8AF52Ax */
43 | #include "stm8s_clk.h"
44 | #include "stm8s_exti.h"
45 | #include "stm8s_flash.h"
46 | #include "stm8s_gpio.h"
47 | #include "stm8s_i2c.h"
48 | #include "stm8s_itc.h"
49 | #include "stm8s_iwdg.h"
50 | #include "stm8s_rst.h"
51 | #include "stm8s_spi.h"
52 | #include "stm8s_tim1.h"
53 | #ifndef STM8S903
54 | #include "stm8s_tim2.h"
55 | #endif /* STM8S903 */
56 | #if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) ||defined(STM8S105) ||\
57 | defined(STM8S005) || defined (STM8AF52Ax) || defined (STM8AF62Ax) || defined (STM8AF626x)
58 | #include "stm8s_tim3.h"
59 | #endif /* (STM8S208) ||defined(STM8S207) || defined(STM8S007) ||defined(STM8S105) */
60 | #ifndef STM8S903
61 | #include "stm8s_tim4.h"
62 | #endif /* STM8S903 */
63 | #ifdef STM8S903
64 | #include "stm8s_tim5.h"
65 | #include "stm8s_tim6.h"
66 | #endif /* STM8S903 */
67 | #if defined(STM8S208) ||defined(STM8S207) || defined(STM8S007) ||defined(STM8S103) ||\
68 | defined(STM8S003) || defined(STM8S903) || defined (STM8AF52Ax) || defined (STM8AF62Ax)
69 | #include "stm8s_uart1.h"
70 | #endif /* STM8S208 || STM8S207 || STM8S103 ||STM8S903 || STM8AF52Ax || STM8AF62Ax */
71 | #if defined(STM8S105) || defined(STM8S005) || defined (STM8AF626x)
72 | #include "stm8s_uart2.h"
73 | #endif /* STM8S105 || STM8AF626x */
74 | #if defined(STM8S208) ||defined(STM8S207) || defined(STM8S007) || defined (STM8AF52Ax) ||\
75 | defined (STM8AF62Ax)
76 | #include "stm8s_uart3.h"
77 | #endif /* STM8S208 || STM8S207 || STM8AF52Ax || STM8AF62Ax */
78 | #include "stm8s_wwdg.h"
79 |
80 | /* Exported types ------------------------------------------------------------*/
81 | /* Exported constants --------------------------------------------------------*/
82 | /* Uncomment the line below to expanse the "assert_param" macro in the
83 | Standard Peripheral Library drivers code */
84 | //#define USE_FULL_ASSERT (1)
85 |
86 | /* Exported macro ------------------------------------------------------------*/
87 | #ifdef USE_FULL_ASSERT
88 |
89 | /**
90 | * @brief The assert_param macro is used for function's parameters check.
91 | * @param expr: If expr is false, it calls assert_failed function
92 | * which reports the name of the source file and the source
93 | * line number of the call that failed.
94 | * If expr is true, it returns no value.
95 | * @retval : None
96 | */
97 | #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
98 | /* Exported functions ------------------------------------------------------- */
99 | void assert_failed(uint8_t* file, uint32_t line);
100 | #else
101 | #define assert_param(expr) ((void)0)
102 | #endif /* USE_FULL_ASSERT */
103 |
104 | #endif /* __STM8S_CONF_H */
105 |
106 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
107 |
--------------------------------------------------------------------------------
/mcu/stm8s_it.c:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_it.c
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief Main Interrupt Service Routines.
8 | * This file provides template for all peripherals interrupt service
9 | * routine.
10 | ******************************************************************************
11 | * @attention
12 | *
13 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
14 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
15 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
16 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
17 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
18 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
19 | *
20 | * © COPYRIGHT 2011 STMicroelectronics
21 | ******************************************************************************
22 | */
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "main.h"
26 | #include "stm8s_it.h"
27 |
28 | #ifdef _COSMIC_
29 | INTERRUPT_HANDLER(NonHandledInterrupt)
30 | {
31 | }
32 | #endif /*_COSMIC_*/
33 |
34 | INTERRUPT_HANDLER_TRAP( TRAP_IRQHandler)
35 | {
36 | }
37 |
38 | INTERRUPT_HANDLER( TLI_IRQHandler)
39 | {
40 | }
41 |
42 | INTERRUPT_HANDLER( AWU_IRQHandler)
43 | {
44 | }
45 |
46 | INTERRUPT_HANDLER( CLK_IRQHandler)
47 | {
48 | }
49 |
50 | INTERRUPT_HANDLER( EXTI_PORTA_IRQHandler)
51 | {
52 | }
53 |
54 | INTERRUPT_HANDLER( EXTI_PORTB_IRQHandler)
55 | {
56 | }
57 |
58 | INTERRUPT_HANDLER( EXTI_PORTC_IRQHandler)
59 | {
60 | }
61 |
62 | INTERRUPT_HANDLER( EXTI_PORTD_IRQHandler)
63 | {
64 | }
65 |
66 | INTERRUPT_HANDLER( EXTI_PORTE_IRQHandler)
67 | {
68 | }
69 |
70 | #ifdef STM8S903
71 | INTERRUPT_HANDLER(EXTI_PORTF_IRQHandler)
72 | {
73 | }
74 | #endif /*STM8S903*/
75 |
76 | #if defined (STM8S208) || defined (STM8AF52Ax)
77 | INTERRUPT_HANDLER(CAN_RX_IRQHandler)
78 | {
79 | }
80 |
81 | INTERRUPT_HANDLER(CAN_TX_IRQHandler)
82 | {
83 | }
84 | #endif /*STM8S208 || STM8AF52Ax */
85 |
86 | INTERRUPT_HANDLER( SPI_IRQHandler)
87 | {
88 | }
89 |
90 | INTERRUPT_HANDLER( TIM1_UPD_OVF_TRG_BRK_IRQHandler)
91 | {
92 | }
93 |
94 | //INTERRUPT_HANDLER( TIM1_CAP_COM_IRQHandler)
95 | //{
96 | //}
97 |
98 | #ifdef STM8S903
99 | INTERRUPT_HANDLER(TIM5_UPD_OVF_BRK_TRG_IRQHandler)
100 | {
101 | }
102 |
103 | INTERRUPT_HANDLER(TIM5_CAP_COM_IRQHandler)
104 | {
105 | }
106 |
107 | #else /*STM8S208, STM8S207, STM8S105 or STM8S103 or STM8AF62Ax or STM8AF52Ax or STM8AF626x */
108 | INTERRUPT_HANDLER( TIM2_UPD_OVF_BRK_IRQHandler)
109 | {
110 | }
111 |
112 | INTERRUPT_HANDLER( TIM2_CAP_COM_IRQHandler)
113 | {
114 | }
115 | #endif /*STM8S903*/
116 |
117 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S105) || \
118 | defined(STM8S005) || defined (STM8AF62Ax) || defined (STM8AF52Ax) || defined (STM8AF626x)
119 | INTERRUPT_HANDLER(TIM3_UPD_OVF_BRK_IRQHandler)
120 | {
121 | }
122 |
123 | INTERRUPT_HANDLER(TIM3_CAP_COM_IRQHandler)
124 | {
125 | }
126 | #endif /*STM8S208, STM8S207 or STM8S105 or STM8AF62Ax or STM8AF52Ax or STM8AF626x */
127 |
128 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S103) || \
129 | defined(STM8S003) || defined (STM8AF62Ax) || defined (STM8AF52Ax) || defined (STM8S903)
130 | INTERRUPT_HANDLER( UART1_TX_IRQHandler)
131 | {
132 | }
133 |
134 | INTERRUPT_HANDLER( UART1_RX_IRQHandler)
135 | {
136 | }
137 | #endif /*STM8S208 or STM8S207 or STM8S103 or STM8S903 or STM8AF62Ax or STM8AF52Ax */
138 |
139 | INTERRUPT_HANDLER( I2C_IRQHandler)
140 | {
141 | }
142 |
143 | #if defined(STM8S105) || defined(STM8S005) || defined (STM8AF626x)
144 | INTERRUPT_HANDLER(UART2_TX_IRQHandler)
145 | {
146 | }
147 |
148 | INTERRUPT_HANDLER(UART2_RX_IRQHandler)
149 | {
150 | }
151 | #endif /* STM8S105 or STM8AF626x */
152 |
153 | #if defined(STM8S207) || defined(STM8S007) || defined(STM8S208) || defined (STM8AF52Ax) || defined (STM8AF62Ax)
154 | INTERRUPT_HANDLER(UART3_TX_IRQHandler)
155 | {
156 | }
157 |
158 | INTERRUPT_HANDLER(UART3_RX_IRQHandler)
159 | {
160 | }
161 | #endif /*STM8S208 or STM8S207 or STM8AF52Ax or STM8AF62Ax */
162 |
163 | #if defined(STM8S207) || defined(STM8S007) || defined(STM8S208) || defined (STM8AF52Ax) || defined (STM8AF62Ax)
164 | INTERRUPT_HANDLER(ADC2_IRQHandler)
165 | {
166 | }
167 | #else /*STM8S105, STM8S103 or STM8S903 or STM8AF626x */
168 | INTERRUPT_HANDLER( ADC1_IRQHandler)
169 | {
170 | }
171 | #endif /*STM8S208 or STM8S207 or STM8AF52Ax or STM8AF62Ax */
172 |
173 | #ifdef STM8S903
174 | INTERRUPT_HANDLER(TIM6_UPD_OVF_TRG_IRQHandler)
175 | {
176 | }
177 | #else /*STM8S208, STM8S207, STM8S105 or STM8S103 or STM8AF52Ax or STM8AF62Ax or STM8AF626x */
178 | /**
179 | * @brief Timer4 Update/Overflow Interrupt routine.
180 | * @param None
181 | * @retval None
182 | */
183 |
184 | INTERRUPT_HANDLER( TIM4_UPD_OVF_IRQHandler)
185 | {
186 | }
187 | #endif /*STM8S903*/
188 |
189 | INTERRUPT_HANDLER( EEPROM_EEC_IRQHandler)
190 | {
191 | }
192 |
193 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
194 |
--------------------------------------------------------------------------------
/mcu/stm8s_it.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm8s_it.h
4 | * @author MCD Application Team
5 | * @version V2.1.0
6 | * @date 18-November-2011
7 | * @brief This file contains the headers of the interrupt handlers
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
12 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
13 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
14 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
15 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
16 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
17 | *
18 | * © COPYRIGHT 2011 STMicroelectronics
19 | ******************************************************************************
20 | */
21 |
22 | /* Define to prevent recursive inclusion -------------------------------------*/
23 | #ifndef __STM8S_IT_H
24 | #define __STM8S_IT_H
25 |
26 | /* Includes ------------------------------------------------------------------*/
27 | #include "stm8s.h"
28 |
29 | /* Exported types ------------------------------------------------------------*/
30 | /* Exported constants --------------------------------------------------------*/
31 | /* Exported macro ------------------------------------------------------------*/
32 | /* Exported functions ------------------------------------------------------- */
33 | #ifdef _COSMIC_
34 | void _stext(void); /* RESET startup routine */
35 | INTERRUPT void NonHandledInterrupt(void);
36 | #endif /* _COSMIC_ */
37 |
38 | #ifndef _RAISONANCE_
39 | INTERRUPT void TRAP_IRQHandler(void); /* TRAP */
40 | INTERRUPT void TLI_IRQHandler(void); /* TLI */
41 | INTERRUPT void AWU_IRQHandler(void); /* AWU */
42 | INTERRUPT void CLK_IRQHandler(void); /* CLOCK */
43 | INTERRUPT void EXTI_PORTA_IRQHandler(void); /* EXTI PORTA */
44 | INTERRUPT void EXTI_PORTB_IRQHandler(void); /* EXTI PORTB */
45 | INTERRUPT void EXTI_PORTC_IRQHandler(void); /* EXTI PORTC */
46 | INTERRUPT void EXTI_PORTD_IRQHandler(void); /* EXTI PORTD */
47 | INTERRUPT void EXTI_PORTE_IRQHandler(void); /* EXTI PORTE */
48 |
49 | #ifdef STM8S903
50 | INTERRUPT void EXTI_PORTF_IRQHandler(void); /* EXTI PORTF */
51 | #endif /*STM8S903*/
52 |
53 | #if defined (STM8S208) || defined (STM8AF52Ax)
54 | INTERRUPT void CAN_RX_IRQHandler(void); /* CAN RX */
55 | INTERRUPT void CAN_TX_IRQHandler(void); /* CAN TX/ER/SC */
56 | #endif /* STM8S208 || STM8AF52Ax */
57 |
58 | INTERRUPT void SPI_IRQHandler(void); /* SPI */
59 | INTERRUPT void TIM1_CAP_COM_IRQHandler(void); /* TIM1 CAP/COM */
60 | INTERRUPT void TIM1_UPD_OVF_TRG_BRK_IRQHandler(void); /* TIM1 UPD/OVF/TRG/BRK */
61 |
62 | #ifdef STM8S903
63 | INTERRUPT void TIM5_UPD_OVF_BRK_TRG_IRQHandler(void); /* TIM5 UPD/OVF/BRK/TRG */
64 | INTERRUPT void TIM5_CAP_COM_IRQHandler(void); /* TIM5 CAP/COM */
65 | #else /*STM8S208, STM8S207, STM8S105 or STM8S103 or STM8AF52Ax or STM8AF62Ax or STM8A626x*/
66 | INTERRUPT void TIM2_UPD_OVF_BRK_IRQHandler(void); /* TIM2 UPD/OVF/BRK */
67 | INTERRUPT void TIM2_CAP_COM_IRQHandler(void); /* TIM2 CAP/COM */
68 | #endif /*STM8S903*/
69 |
70 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S105) || \
71 | defined(STM8S005) || defined (STM8AF52Ax) || defined (STM8AF62Ax) || defined (STM8AF626x)
72 | INTERRUPT void TIM3_UPD_OVF_BRK_IRQHandler(void); /* TIM3 UPD/OVF/BRK */
73 | INTERRUPT void TIM3_CAP_COM_IRQHandler(void); /* TIM3 CAP/COM */
74 | #endif /*STM8S208, STM8S207 or STM8S105 or STM8AF52Ax or STM8AF62Ax or STM8A626x */
75 |
76 | #if defined (STM8S208) || defined(STM8S207) || defined(STM8S007) || defined(STM8S103) || \
77 | defined(STM8S003) || defined (STM8AF52Ax) || defined (STM8AF62Ax) || defined (STM8S903)
78 | INTERRUPT void UART1_TX_IRQHandler(void); /* UART1 TX */
79 | INTERRUPT void UART1_RX_IRQHandler(void); /* UART1 RX */
80 | #endif /*STM8S208, STM8S207, STM8S903 or STM8S103 or STM8AF52Ax or STM8AF62Ax */
81 |
82 | INTERRUPT void I2C_IRQHandler(void); /* I2C */
83 |
84 | #if defined(STM8S105) || defined(STM8S005) || defined (STM8AF626x)
85 | INTERRUPT void UART2_RX_IRQHandler(void); /* UART2 RX */
86 | INTERRUPT void UART2_TX_IRQHandler(void); /* UART2 TX */
87 | #endif /* STM8S105 or STM8AF626x */
88 |
89 | #if defined(STM8S207) || defined(STM8S007) || defined(STM8S208) || defined (STM8AF52Ax) || defined (STM8AF62Ax)
90 | INTERRUPT void UART3_RX_IRQHandler(void); /* UART3 RX */
91 | INTERRUPT void UART3_TX_IRQHandler(void); /* UART3 TX */
92 | #endif /*STM8S207, STM8S208, STM8AF62Ax or STM8AF52Ax */
93 |
94 | #if defined(STM8S207) || defined(STM8S007) || defined(STM8S208) || defined (STM8AF52Ax) || defined (STM8AF62Ax)
95 | INTERRUPT void ADC2_IRQHandler(void); /* ADC2 */
96 | #else /*STM8S105, STM8S103 or STM8S903*/
97 | INTERRUPT void ADC1_IRQHandler(void); /* ADC1 */
98 | #endif /*STM8S207, STM8S208, STM8AF62Ax or STM8AF52Ax */
99 |
100 | #ifdef STM8S903
101 | INTERRUPT void TIM6_UPD_OVF_TRG_IRQHandler(void); /* TIM6 UPD/OVF/TRG */
102 | #else /*STM8S208, STM8S207, STM8S105 or STM8S103 or STM8AF62Ax or STM8AF52Ax or STM8AF626x */
103 | INTERRUPT void TIM4_UPD_OVF_IRQHandler(void); /* TIM4 UPD/OVF */
104 | #endif /*STM8S903*/
105 | INTERRUPT void EEPROM_EEC_IRQHandler(void); /* EEPROM ECC CORRECTION */
106 | #endif /* _RAISONANCE_ */
107 |
108 | #endif /* __STM8S_IT_H */
109 |
110 | /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
111 |
--------------------------------------------------------------------------------
/target/target.s19:
--------------------------------------------------------------------------------
1 | S01400007461726765742F7461726765742E736D3868
2 | S123848012010001FF00000811223344556600000001090212000101008032090401000177
3 | S10E84A0000000000705810308000A2B
4 | S12384AEAE03FF9490CE84ABAE84ADF62720A5602717BF04EE03BF07BE04EE0190F6F75C76
5 | S12384CE905C90B30726F5BE041C000520DDAE00002002F75CA3000A26F9AE01002002F7A2
6 | S12384EE5CA3014126F9CD84F920FE9B35FF500335FF500835FF500D35FF501235FF501732
7 | S123850E35FF501C725F500D725F500E353F500C725F500A725F5002725F5000725F5003E9
8 | S123852E725F5004725F50C64B004B00AE01B4CD8891721E50C7854B00AE03E8894B005FFB
9 | S123854ECD891A5B044B024B004B01AE0101CD893E5B03A660CD89B3A606CD89C0AE000431
10 | S123856ECD8A01AE0401CD899D9AAEA120CF0102AE0007CF0100CE0100BF00CE0102BF026B
11 | S123858ECE01021D0001CF01022407CE01005ACF0100BE0226E0BE0026DC35FF500235FFA4
12 | S12385AE500035FF500335FF5004CD882620FB893540500A35FF500D35FF500E35FF500CA9
13 | S12385CEA6806B01A65A6B0235020140965CCF012ECD81A19D9D9D9D9D9D725F500E725F85
14 | S12385EE500D353F500C8581893540500A35FF500D35FF500E35FF500CA6806B01A6D26BB6
15 | S123860E0235020140965CCF012ECD81A19D9D9D9D9D9D725F500E725F500D353F500C858F
16 | S123862E81C60131A02D2723A01E2603CC8706A00F2603CC8714A00F271BA05A275CA00FFC
17 | S123864E27F1A00F270A725F01048135010104813503010481C60105A10226363540500AA5
18 | S123866E35FF500D35FF500E35FF500CAE011B55012B0140CF012ECD81A19D9D9D9D9D9D0E
19 | S123868E725F500E725F500D353F500C350301052003CD85BD3502010481C601044A2658DB
20 | S12386AE550130010A550131010B550132010C550133010D550134010E550135010F5501CE
21 | S12386CE36011055013701115501380112550139011355013A011455013B011555013C017F
22 | S12386EE1655013D011755013E011855013F0119CD85F63501010581C60104A1032607CDDD
23 | S123870E85F6725D010581895204AEFFFF1F030F01203C1E05F65C1F055F97011804011898
24 | S123872E03011F03A6086B02201C7B04A5012712040306047B04A8016B047B03A8A06B0370
25 | S123874E2004040306047B020A024D26DD0C017B01110925BE1E03531F031E057B04F75CE8
26 | S123876E1F057B03F75B06818989A64B6B01CC881CA108252E350C012B3580011B7B01C710
27 | S123878E011CA6026B025F16039790F6905C1703D7011B0C027B02A10A25EB7B07A0086B2C
28 | S12387AE07203CAB04C7012B3580011B7B01C7011CA6026B0220137B025F16039790F69087
29 | S12387CE5C1703D7011B0C027B025F977B07905F9097BF0472A9000290B3042CDA0F07C6FC
30 | S12387EE012BA00488AE011DCD8715847B01A14B2604A6C32002A64B6B0135020105200778
31 | S123880EC60104A102260EC60105A10227F27B072703CC877F5B0481C601054A2650C6016B
32 | S123882E0C2727A0802647C6010DA1062640C6010FA10126074B12AE84802009A102262E8A
33 | S123884E4B09AE8492CD87768481C6010DA105261D55010E01063504012B3580011B354B41
34 | S123886E011C725F011D725F011E35020105818080808080808080808080808080808080AC
35 | S123888E808080895204AE04911F03C650C36B017B054A262D721250C57B09270672145080
36 | S12388AEC52004721550C57B06C750C420035A1F03720150C5041E0326F41E0326170F02F0
37 | S12388CE20177B092706721450C52004721550C57B06C750C4A6016B027B0A260C7B01A1FF
38 | S12388EEE12606721150C0201E7B0A260C7B01A1D22606721750C0200E7B0A260A7B01A11D
39 | S123890EB42604721150C17B025B0681897B06C752627B07C752639EC752609FC75261C6FB
40 | S123892E5250A48F1A05C752507B08C752648581899E4D26147B07887B06977B0395CD8A88
41 | S123894E11847B06CD89CD20447B01A10126147B07887B06977B0395CD8A41847B06CD89E8
42 | S123896EDA202AA10226147B07887B06977B0395CD8A71847B06CD89E720127B07887B06E8
43 | S123898E977B0395CD8AA1847B06CD89F48581899F4D27069ECA525420067B0143C45254CF
44 | S12389AEC75254858188C65252A48F1A01C75252848188C65252A4F81A01C75252848188E1
45 | S12389CEC65258A4F31A01C75258848188C65259A4F31A01C75259848188C6525AA4F31A20
46 | S12389EE01C7525A848188C6525BA4F31A01C7525B8481899F43C752557B0143A41EC75253
47 | S1238A0E568581897211525C887B0697A610429F1A036B01C65258A40C1A01C752587B0245
48 | S1238A2E27067212525C20047213525C7210525C5B0381897219525C887B0697A610429F66
49 | S1238A4E1A036B01C65259A40C1A01C752597B022706721A525C2004721B525C7218525C52
50 | S1238A6E5B0381897211525D887B0697A610429F1A036B01C6525AA40C1A01C7525A7B025D
51 | S1238A8E27067212525D20047213525D7210525D5B0381897219525D887B0697A610429F02
52 | S1238AAE1A036B01C6525BA40C1A01C7525B7B022706721A525D2004721B525D7218525DEB
53 | S1068ACE5B0381C2
54 | S1238000820084AE8200887E8200887F8200888082008881820088828200888382008884DB
55 | S123802082008885820088868200887D8200887D820088878200888882008329820088892B
56 | S12380408200888A8200887D8200887D8200888B8200888C8200888D8200887D8200887DAA
57 | S12380608200888E8200888F820088908200887D8200887D8200887D8200887D8200887D8E
58 | S12380809D9D4A26589D9D9D7253500A9D9DA606204B9D9D9D9D4A26519D9D9D7253500A68
59 | S12380A09D9DA60620449D9D9D4A264A9D9D9D9D7253500A9DA606203D9D9D9D9D9D4A2627
60 | S12380C0439D9D9D7253500A9D9DA60620369D9D7625AD7253500AA6069D9D9D9D7625B417
61 | S12380E07253500AA6069D9D9D9D7625BB7253500AA6069D9D9D7625C29D7253500AA60680
62 | S12381009D9D9D9D7625417253500AA6069D9D9D9D7625487253500AA6069D9D9D9D76250F
63 | S12381204F7253500AA6069D9D7625579D9D7253500AA6065C725A014026959D9D9D725F24
64 | S1238140500A819D9D9D9D9D9D9D4A26C49D9D9D7253500A9D9DA60620B79D9D9D9D4A262A
65 | S1238160BD9D9D9D7253500A9D9DA60620B09D9D4A26B69D9D9D9D9D7253500AA60620A98D
66 | S12381809D9D9D4A26AE725A01409D5C9DA6069D7253500A9D725D01402704AC0080D020E7
67 | S11281A09BCE012EA640C7500AA606AC0080D085
68 | S1238280906314040190F62604AC00830C18016B019D906314040190F6277118016B015CB6
69 | S12382A09D906314040190F6276218016B019D9D906314040190F6275318016B019D906322
70 | S12382C014040190F6274518016B019D906314040190F6273718016B010A02272F9063148F
71 | S12382E0040190F6272618016B019D906314040190F6271818016B01F7799063140401901E
72 | S1238300F6270918016B0120899D9D9D8484C7012DCD862F725F500F35FB52557211525083
73 | S1238320725F525E725F525F80AE833772BB525EA383592401FC809D9D9D9D9D9D9D9D9DCC
74 | S12383409D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9DAE013090AE500B4C
75 | S10D8360A60E88A68088AC00828077
76 | S10684AB84AE0098
77 | S903FFFFFE
78 |
--------------------------------------------------------------------------------
/utility/macros.c:
--------------------------------------------------------------------------------
1 | /*
2 | * File: macros.c
3 | * Date: 09.01.2012
4 | * Denis Zheleznjakov @ ZiBlog.ru
5 | */
6 |
7 | #include "main.h"
8 |
9 | static volatile uint16_t delay_count;
10 | static volatile _Bool delay_flag;
11 | static volatile uint16_t random;
12 | static _Bool is_ready;
13 |
14 | void synchronization_10ms_refresh(void)
15 | {
16 | static uint8_t counter_0_5_ms;
17 |
18 | if (is_ready == FALSE)
19 | {
20 | if (++counter_0_5_ms >= 20)
21 | {
22 | counter_0_5_ms = 0;
23 | is_ready = TRUE;
24 | }
25 | }
26 | }
27 |
28 | _Bool time_synchronization_10ms(void)
29 | {
30 | if (is_ready == TRUE)
31 | {
32 | is_ready = FALSE;
33 | return TRUE;
34 | }
35 |
36 | return FALSE;
37 | }
38 |
39 | uint8_t get_random_byte(void)
40 | {
41 | random *= 5;
42 | random += 1;
43 | random %= 256;
44 |
45 | return (uint8_t) random;
46 | }
47 |
48 | void delay_ms(volatile uint16_t delay)
49 | {
50 | delay_count = delay << 1;
51 | delay_flag = TRUE;
52 |
53 | while (delay_flag == TRUE)
54 | {
55 | }
56 | }
57 |
58 | void delay_ms_refresh(void)
59 | {
60 | if (delay_flag == TRUE)
61 | {
62 | if (--delay_count == 0U)
63 | {
64 | delay_flag = FALSE;
65 | }
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/utility/macros.h:
--------------------------------------------------------------------------------
1 | /*
2 | * File: macros.h
3 | * Date: 28.01.2011
4 | * Denis Zheleznjakov @ ZiBlog.ru
5 | */
6 |
7 | #ifndef MACROS_H_
8 | #define MACROS_H_
9 |
10 | #define BIT(NUMBER) (1UL << (NUMBER))
11 |
12 | #define ARRAY_LENGHT(Value) (sizeof(Value) / sizeof(Value[0]))
13 |
14 | #define BYTES(value) ((uint8_t *) & (value))
15 |
16 | #define Bit_Set(Var, BitIdx) ((Var) |= BIT(BitIdx))
17 | #define Bit_Clr(Var, BitIdx) ((Var) &= ~BIT(BitIdx))
18 | #define Bit_Get(Var, BitIdx) ((Var) & BIT(BitIdx))
19 | #define Bit_Inv(Var, BitIdx) ((Var) ^= BIT(BitIdx))
20 | #define Bit_Is_Set(Var, BitIdx) (Bit_Get(Var, BitIdx) == BIT(BitIdx))
21 | #define Bit_Is_Clr(Var, BitIdx) (Bit_Get(Var, BitIdx) == 0x00)
22 | #define Set(FlagDef) Bit_Set(FlagDef)
23 | #define Clr(FlagDef) Bit_Clr(FlagDef)
24 | #define Get(FlagDef) Bit_Get(FlagDef)
25 | #define Inv(FlagDef) Bit_Inv(FlagDef)
26 | #define Is_Set(FlagDef) Bit_Is_Set(FlagDef)
27 | #define Is_Clr(FlagDef) Bit_Is_Clr(FlagDef)
28 |
29 | #define Bits_Set(Var, Mask) ((Var) |= (Mask))
30 | #define Bits_Clr(Var, Mask) ((Var) &= ~(Mask))
31 | #define Bits_Inv(Var, Mask) ((Var) ^= (Mask))
32 |
33 | void delay_ms_refresh(void);
34 | void delay_ms(volatile uint16_t delay);
35 | uint8_t get_random_byte(void);
36 | void synchronization_10ms_refresh(void);
37 | _Bool time_synchronization_10ms(void);
38 |
39 | #endif /* MACROS_H_ */
40 |
--------------------------------------------------------------------------------