Микроконтроллеры

Информация о пользователе

Привет, Гость! Войдите или зарегистрируйтесь.


Вы здесь » Микроконтроллеры » STM32: * » Мелкие полезности STM32F1xx


Мелкие полезности STM32F1xx

Сообщений 1 страница 28 из 28

1

Люди выкладывайте мелкие полезные наработки, библиотеки или даже функции для работы с stm32.

2

Дефайны для удобной настройки stm32f1xx.

Код:
#define  IN_ANALOG                               ((uint32_t)0x00000000)
#define  IN_FLOATING                             ((uint32_t)0x00000004)
#define  IN_PULL                                 ((uint32_t)0x00000008)
#define  OUT_GEN_PUSH_PULL_2MHZ                  ((uint32_t)0x00000002)
#define  OUT_GEN_PUSH_PULL_10MHZ                 ((uint32_t)0x00000001)
#define  OUT_GEN_PUSH_PULL_50MHZ                 ((uint32_t)0x00000003)
#define  OUT_GEN_OPEN_DRAIN_2MHZ                 ((uint32_t)0x00000006)
#define  OUT_GEN_OPEN_DRAIN_10MHZ                ((uint32_t)0x00000005)
#define  OUT_GEN_OPEN_DRAIN_50MHZ                ((uint32_t)0x00000007)
#define  OUT_ALT_PUSH_PULL_2MHZ                  ((uint32_t)0x0000000A)
#define  OUT_ALT_PUSH_PULL_10MHZ                 ((uint32_t)0x00000009)
#define  OUT_ALT_PUSH_PULL_50MHZ                 ((uint32_t)0x0000000B)
#define  OUT_ALT_OPEN_DRAIN_2MHZ                 ((uint32_t)0x0000000E)
#define  OUT_ALT_OPEN_DRAIN_10MHZ                ((uint32_t)0x0000000D)
#define  OUT_ALT_OPEN_DRAIN_50MHZ                ((uint32_t)0x0000000F)

#define  IN0_ANALOG                        ((uint32_t)IN_ANALOG << 0)
#define  IN0_FLOATING                      ((uint32_t)IN_FLOATING << 0)
#define  IN0_PULL                          ((uint32_t)IN_PULL << 0)
#define  OUT0_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 0)
#define  OUT0_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 0)
#define  OUT0_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 0)
#define  OUT0_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 0)
#define  OUT0_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 0)
#define  OUT0_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 0)
#define  OUT0_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 0)
#define  OUT0_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 0)
#define  OUT0_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 0)
#define  OUT0_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 0)
#define  OUT0_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 0)
#define  OUT0_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 0)
#define  OUT0_MSK                          ((uint32_t)0x0000000F << 0)

#define  IN1_ANALOG                        ((uint32_t)IN_ANALOG << 4)
#define  IN1_FLOATING                      ((uint32_t)IN_FLOATING << 4)
#define  IN1_PULL                          ((uint32_t)IN_PULL << 4)
#define  OUT1_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 4)
#define  OUT1_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 4)
#define  OUT1_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 4)
#define  OUT1_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 4)
#define  OUT1_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 4)
#define  OUT1_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 4)
#define  OUT1_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 4)
#define  OUT1_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 4)
#define  OUT1_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 4)
#define  OUT1_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 4)
#define  OUT1_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 4)
#define  OUT1_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 4)
#define  OUT1_MSK                          ((uint32_t)0x0000000F << 4)

#define  IN2_ANALOG                        ((uint32_t)IN_ANALOG << 8)
#define  IN2_FLOATING                      ((uint32_t)IN_FLOATING << 8)
#define  IN2_PULL                          ((uint32_t)IN_PULL << 8)
#define  OUT2_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 8)
#define  OUT2_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 8)
#define  OUT2_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 8)
#define  OUT2_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 8)
#define  OUT2_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 8)
#define  OUT2_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 8)
#define  OUT2_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 8)
#define  OUT2_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 8)
#define  OUT2_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 8)
#define  OUT2_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 8)
#define  OUT2_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 8)
#define  OUT2_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 8)
#define  OUT2_MSK                          ((uint32_t)0x0000000F << 8)

#define  IN3_ANALOG                        ((uint32_t)IN_ANALOG << 12)
#define  IN3_FLOATING                      ((uint32_t)IN_FLOATING << 12)
#define  IN3_PULL                          ((uint32_t)IN_PULL << 12)
#define  OUT3_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 12)
#define  OUT3_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 12)
#define  OUT3_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 12)
#define  OUT3_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 12)
#define  OUT3_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 12)
#define  OUT3_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 12)
#define  OUT3_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 12)
#define  OUT3_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 12)
#define  OUT3_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 12)
#define  OUT3_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 12)
#define  OUT3_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 12)
#define  OUT3_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 12)
#define  OUT3_MSK                          ((uint32_t)0x0000000F << 12)

#define  IN4_ANALOG                        ((uint32_t)IN_ANALOG << 16)
#define  IN4_FLOATING                      ((uint32_t)IN_FLOATING << 16)
#define  IN4_PULL                          ((uint32_t)IN_PULL << 16)
#define  OUT4_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 16)
#define  OUT4_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 16)
#define  OUT4_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 16)
#define  OUT4_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 16)
#define  OUT4_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 16)
#define  OUT4_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 16)
#define  OUT4_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 16)
#define  OUT4_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 16)
#define  OUT4_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 16)
#define  OUT4_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 16)
#define  OUT4_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 16)
#define  OUT4_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 16)
#define  OUT4_MSK                          ((uint32_t)0x0000000F << 16)


#define  IN5_ANALOG                        ((uint32_t)IN_ANALOG << 20)
#define  IN5_FLOATING                      ((uint32_t)IN_FLOATING << 20)
#define  IN5_PULL                          ((uint32_t)IN_PULL << 20)
#define  OUT5_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 20)
#define  OUT5_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 20)
#define  OUT5_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 20)
#define  OUT5_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 20)
#define  OUT5_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 20)
#define  OUT5_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 20)
#define  OUT5_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 20)
#define  OUT5_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 20)
#define  OUT5_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 20)
#define  OUT5_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 20)
#define  OUT5_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 20)
#define  OUT5_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 20)
#define  OUT5_MSK                          ((uint32_t)0x0000000F << 20)

#define  IN6_ANALOG                        ((uint32_t)IN_ANALOG << 24)
#define  IN6_FLOATING                      ((uint32_t)IN_FLOATING << 24)
#define  IN6_PULL                          ((uint32_t)IN_PULL << 24)
#define  OUT6_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 24)
#define  OUT6_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 24)
#define  OUT6_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 24)
#define  OUT6_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 24)
#define  OUT6_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 24)
#define  OUT6_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 24)
#define  OUT6_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 24)
#define  OUT6_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 24)
#define  OUT6_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 24)
#define  OUT6_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 24)
#define  OUT6_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 24)
#define  OUT6_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 24)
#define  OUT6_MSK                          ((uint32_t)0x0000000F << 24)

#define  IN7_ANALOG                        ((uint32_t)IN_ANALOG << 28)
#define  IN7_FLOATING                      ((uint32_t)IN_FLOATING << 28)
#define  IN7_PULL                          ((uint32_t)IN_PULL << 28)
#define  OUT7_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 28)
#define  OUT7_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 28)
#define  OUT7_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 28)
#define  OUT7_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 28)
#define  OUT7_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 28)
#define  OUT7_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 28)
#define  OUT7_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 28)
#define  OUT7_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 28)
#define  OUT7_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 28)
#define  OUT7_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 28)
#define  OUT7_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 28)
#define  OUT7_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 28)
#define  OUT7_MSK                          ((uint32_t)0x0000000F << 28)

#define  IN8_ANALOG                        ((uint32_t)IN_ANALOG << 0)
#define  IN8_FLOATING                      ((uint32_t)IN_FLOATING << 0)
#define  IN8_PULL                          ((uint32_t)IN_PULL << 0)
#define  OUT8_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 0)
#define  OUT8_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 0)
#define  OUT8_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 0)
#define  OUT8_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 0)
#define  OUT8_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 0)
#define  OUT8_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 0)
#define  OUT8_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 0)
#define  OUT8_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 0)
#define  OUT8_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 0)
#define  OUT8_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 0)
#define  OUT8_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 0)
#define  OUT8_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 0)
#define  OUT8_MSK                          ((uint32_t)0x0000000F << 0)

#define  IN9_ANALOG                        ((uint32_t)IN_ANALOG << 4)
#define  IN9_FLOATING                      ((uint32_t)IN_FLOATING << 4)
#define  IN9_PULL                          ((uint32_t)IN_PULL << 4)
#define  OUT9_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 4)
#define  OUT9_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 4)
#define  OUT9_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 4)
#define  OUT9_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 4)
#define  OUT9_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 4)
#define  OUT9_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 4)
#define  OUT9_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 4)
#define  OUT9_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 4)
#define  OUT9_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 4)
#define  OUT9_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 4)
#define  OUT9_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 4)
#define  OUT9_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 4)
#define  OUT9_MSK                          ((uint32_t)0x0000000F << 4)

#define  IN10_ANALOG                        ((uint32_t)IN_ANALOG << 8)
#define  IN10_FLOATING                      ((uint32_t)IN_FLOATING << 8)
#define  IN10_PULL                          ((uint32_t)IN_PULL << 8)
#define  OUT10_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 8)
#define  OUT10_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 8)
#define  OUT10_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 8)
#define  OUT10_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 8)
#define  OUT10_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 8)
#define  OUT10_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 8)
#define  OUT10_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 8)
#define  OUT10_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 8)
#define  OUT10_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 8)
#define  OUT10_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 8)
#define  OUT10_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 8)
#define  OUT10_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 8)
#define  OUT10_MSK                          ((uint32_t)0x0000000F << 8)

#define  IN11_ANALOG                        ((uint32_t)IN_ANALOG << 12)
#define  IN11_FLOATING                      ((uint32_t)IN_FLOATING << 12)
#define  IN11_PULL                          ((uint32_t)IN_PULL << 12)
#define  OUT11_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 12)
#define  OUT11_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 12)
#define  OUT11_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 12)
#define  OUT11_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 12)
#define  OUT11_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 12)
#define  OUT11_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 12)
#define  OUT11_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 12)
#define  OUT11_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 12)
#define  OUT11_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 12)
#define  OUT11_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 12)
#define  OUT11_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 12)
#define  OUT11_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 12)
#define  OUT11_MSK                          ((uint32_t)0x0000000F << 12)

#define  IN12_ANALOG                        ((uint32_t)IN_ANALOG << 16)
#define  IN12_FLOATING                      ((uint32_t)IN_FLOATING << 16)
#define  IN12_PULL                          ((uint32_t)IN_PULL << 16)
#define  OUT12_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 16)
#define  OUT12_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 16)
#define  OUT12_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 16)
#define  OUT12_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 16)
#define  OUT12_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 16)
#define  OUT12_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 16)
#define  OUT12_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 16)
#define  OUT12_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 16)
#define  OUT12_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 16)
#define  OUT12_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 16)
#define  OUT12_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 16)
#define  OUT12_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 16)
#define  OUT12_MSK                          ((uint32_t)0x0000000F << 16)

#define  IN13_ANALOG                        ((uint32_t)IN_ANALOG << 20)
#define  IN13_FLOATING                      ((uint32_t)IN_FLOATING << 20)
#define  IN13_PULL                          ((uint32_t)IN_PULL << 20)
#define  OUT13_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 20)
#define  OUT13_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 20)
#define  OUT13_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 20)
#define  OUT13_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 20)
#define  OUT13_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 20)
#define  OUT13_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 20)
#define  OUT13_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 20)
#define  OUT13_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 20)
#define  OUT13_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 20)
#define  OUT13_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 20)
#define  OUT13_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 20)
#define  OUT13_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 20)
#define  OUT13_MSK                          ((uint32_t)0x0000000F << 20)

#define  IN14_ANALOG                        ((uint32_t)IN_ANALOG << 24)
#define  IN14_FLOATING                      ((uint32_t)IN_FLOATING << 24)
#define  IN14_PULL                          ((uint32_t)IN_PULL << 24)
#define  OUT14_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 24)
#define  OUT14_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 24)
#define  OUT14_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 24)
#define  OUT14_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 24)
#define  OUT14_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 24)
#define  OUT14_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 24)
#define  OUT14_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 24)
#define  OUT14_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 24)
#define  OUT14_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 24)
#define  OUT14_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 24)
#define  OUT14_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 24)
#define  OUT14_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 24)
#define  OUT14_MSK                          ((uint32_t)0x0000000F << 24)

#define  IN15_ANALOG                        ((uint32_t)IN_ANALOG << 28)
#define  IN15_FLOATING                      ((uint32_t)IN_FLOATING << 28)
#define  IN15_PULL                          ((uint32_t)IN_PULL << 28)
#define  OUT15_GEN_PUSH_PULL_2MHZ           ((uint32_t)OUT_GEN_PUSH_PULL_2MHZ << 28)
#define  OUT15_GEN_PUSH_PULL_10MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_10MHZ << 28)
#define  OUT15_GEN_PUSH_PULL_50MHZ          ((uint32_t)OUT_GEN_PUSH_PULL_50MHZ << 28)
#define  OUT15_GEN_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_GEN_OPEN_DRAIN_2MHZ << 28)
#define  OUT15_GEN_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_10MHZ << 28)
#define  OUT15_GEN_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_GEN_OPEN_DRAIN_50MHZ << 28)
#define  OUT15_ALT_PUSH_PULL_2MHZ           ((uint32_t)OUT_ALT_PUSH_PULL_2MHZ << 28)
#define  OUT15_ALT_PUSH_PULL_10MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_10MHZ << 28)
#define  OUT15_ALT_PUSH_PULL_50MHZ          ((uint32_t)OUT_ALT_PUSH_PULL_50MHZ << 28)
#define  OUT15_ALT_OPEN_DRAIN_2MHZ          ((uint32_t)OUT_ALT_OPEN_DRAIN_2MHZ << 28)
#define  OUT15_ALT_OPEN_DRAIN_10MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_10MHZ << 28)
#define  OUT15_ALT_OPEN_DRAIN_50MHZ         ((uint32_t)OUT_ALT_OPEN_DRAIN_50MHZ << 28)
#define  OUT15_MSK                          ((uint32_t)0x0000000F << 28)
//-------------------------------------------------------------------------------------------------

/*
void PIO_Init(void)
{
  AFIO->MAPR = AFIO_MAPR_SWJ_CFG_JTAGDISABLE;

  GPIOA->CRL = IN0_FLOATING | IN1_FLOATING | OUT2_ALT_PUSH_PULL_50MHZ | IN3_PULL | IN4_FLOATING | IN5_FLOATING | IN6_FLOATING | IN7_FLOATING;
  GPIOA->CRH = 0x08800000 | IN8_FLOATING | IN9_FLOATING | IN10_FLOATING | IN11_FLOATING | IN12_FLOATING | IN15_FLOATING;
  GPIOA->ODR = 0x2000 | GPIO_ODR_ODR3;

  GPIOB->CRL = OUT0_GEN_PUSH_PULL_50MHZ | OUT1_GEN_PUSH_PULL_50MHZ | OUT2_GEN_PUSH_PULL_50MHZ | OUT3_GEN_PUSH_PULL_50MHZ | OUT4_GEN_PUSH_PULL_50MHZ | OUT5_GEN_PUSH_PULL_50MHZ | OUT6_GEN_PUSH_PULL_50MHZ | OUT7_GEN_PUSH_PULL_50MHZ;
  GPIOB->CRH = OUT8_GEN_PUSH_PULL_50MHZ | OUT9_GEN_PUSH_PULL_50MHZ | OUT10_GEN_PUSH_PULL_50MHZ | OUT11_GEN_PUSH_PULL_50MHZ | OUT12_GEN_PUSH_PULL_50MHZ | OUT13_GEN_PUSH_PULL_50MHZ | OUT14_GEN_PUSH_PULL_50MHZ | OUT15_GEN_PUSH_PULL_50MHZ;
}
*/

3

А нет ли где на просторах интернета сниппетов для F1?

4

Пример настройки тактового генератора на максимальные частоты под stm32f103c8 (72 MHz) кварц 8 MHz. (без USB нужно еще на 1.5 делить основную часоту) + настройка тактирования модулей. Это просто пример взятый из моего проекта.

Код:
void SysClock_Init(void)
{
  FLASH->ACR = 0x30 | FLASH_ACR_LATENCY_1;

  RCC->CR |= RCC_CR_HSEON;
  while(!(RCC->CR & RCC_CR_HSERDY));
  RCC->CFGR = RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL9 | RCC_CFGR_PPRE1_2;
  RCC->CR |= RCC_CR_PLLON;
  while(!(RCC->CR & RCC_CR_PLLRDY));
  RCC->CFGR |= RCC_CFGR_SW_PLL;

  RCC->AHBENR = 0x00000014 | RCC_AHBENR_DMA1EN;
  RCC->APB1ENR = RCC_APB1ENR_TIM4EN | RCC_APB1ENR_USART2EN;
  RCC->APB2ENR = RCC_APB2ENR_AFIOEN | RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_TIM1EN;
}

Из стартапа нужно убрать функцию настройки тактовой частоты

Код:
/* Call the clock system intitialization function.*/
  bl  SystemInit    // ЭТОТ ВЫЗОВ УДАЛИТЬ  //
/* Call static constructors */
  bl __libc_init_array  
/* Call the application's entry point.*/
	bl	main
	bx	lr

Соответственно убрать теперь неиспользуемые файлы из проекта, если вы не используете HAL или SPL.

Код:
system_stm32f10x.c
stm32f10x_conf.h
и всю папку относящююся к SPL - STM32F10x_StdPeriph_Driver

Я делаю так и по привычке экономлю несколько сотн байтов флеша.

Отредактировано MasterElectric (2017-06-24 01:10:52)

5

0x00000014 — что это?
Магические числа не стоит использовать, все надо дефайнами фигачить. А то потом спустя какое-то время откроешь, и будешь гадать, что же там...

6

Это значение по умолчанию, просто вместо более длинной |=, я использую =. Ничего страшного я думаю. Можно конечно битовыми именами заменить, но так можно что-то да удалить важное. а так эту константу я просто не трогаю.

7

Eddy_Em написал(а):

А нет ли где на просторах интернета сниппетов для F1?

Глянь на chibios hal - https://sourceforge.net/p/chibios/svn/H … rts/STM32/
Именно на хал, а не на ртось, его можно и отдельно использовать.
Если понравится и захочешь использовать, то я готов присоединиться и свой код сюда выкладывать под него.

8

Не, мне именно сниппеты хочется. HAL — нафиг-нафиг!
Куски из чибиоси особо не попользуешь: уж очень там сыро все...

9

Eddy_Em
А чем тебя сниппетсы от F0 не устраивают? Таймеры например практически во всех линейках одинаковы, на остальную периферию здесь по мере возможности выкладываем...

10

Скажем, на USB я сниппетов не встречал. Либо портянки дикие, либо то, что еще нужно допиливать и допиливать!
Мне бы минимальный набор CDC, HID и чего-нибудь с хорошей скоростью (bulk-как-там-его) в разных сниппетах — тупо взял, поменял VID/PID и еще пару строк, и уже можно пользоваться...
Для начала CDC — оно мне прежде всего в F0 понадобится (посредник между CAN-шиной и одноплатником), не хочу лишнюю PL2303 впаивать, когда на борту есть USB. Хоть у них с CAN и общий буфер, но размер там приличный, не погрызутся.
Ну и насчет CAN: тоже хотелось бы посмотреть простеньких проектов, чтобы не городить эти 100500 регистров, а обойтись минимальной кровью. Мне хоть и не горит особо (к следующему лету все должно быть готово), но по поводу CAN уже меня пинают — было бы неплохо у телескопа фокусировку обновить, надо будет МК воткнуть, который с CAN будет брать данные, слать на сервик импульсы, и обратно в CAN выплевывать данные с энкодера.

11

12

Там слишком сыро — допиливать и допиливать!

13

Eddy_Em
Э нет, читать, читать и думать .Ни кто тебе халявы не обещал...

14

Вот читать и думать — самое в данном случае фиговое, т.к. на это месяц-другой уйдет. А времени нет. Ну, да ладно, буду медленно, но верно... Все-таки, SPL или калокуб — это совсем уже финиш! Как и использование готового китайского быдлокода. Они там, похоже, вообще ничего об оптимизации и использовании аппаратных ресурсов не слышали. Аврщики сраные!!!

15

Eddy_Em написал(а):

Как и использование готового китайского быдлокода. Они там, похоже, вообще ничего об оптимизации и использовании аппаратных ресурсов не слышали. Аврщики сраные!!!

Если ты это про chibios, то ты очень ошибаешься )
Посмотри кто автор - http://www.betterembedded.it/conference … i-di-sirio
Обрати внимание, что оно портировано для spc5 (http://www.st.com/en/automotive-microco … ctId=SC963), и кругом lint (https://ru.wikipedia.org/wiki/Lint) в сорцах
Из всего этого можно предположить, что за люди этот chibios делают, и что нам всем тут, вместе взятым, до них как до Луны )

16

Eddy_Em написал(а):

Аврщики сраные!!!

Когда тебе начнут платить по количеству строк кода - сам таким станешь.;)

17

omercury написал(а):

Когда тебе начнут платить по количеству строк кода

А что, где-то есть такое дубовое начальство, которому не результат нормальный нужен, а количество строк кода?

18

http://www.st.com/content/st_com/en/ext … edTo=FM141
STM32Snippets F0, L0

Отредактировано MasterElectric (2017-07-01 22:54:12)

19

Eddy_Em написал(а):

А что, где-то есть такое дубовое начальство, которому не результат нормальный нужен, а количество строк кода?

А что, где-то есть начальство, которому нужен качественный результат в ущерб скорости разработки?

Высокое качество может позволить себе хоббист, профессионал ограничивается достаточным качеством - лишь бы работало без видимых глюков. ;)

Отредактировано omercury (2017-07-02 18:31:10)

20

Работа с данными с АЦП:

Код:
typedef struct
{
  uint16_t                            ADC_ChnlNum;                  // номер аналогового входа
  uint16_t                            ADC_to;                            // максимальное значение преобразователя
  uint16_t                            ADC_from;                        // минимальное значение преобразователя
  float                                 FV;                                    // расчитанные данные по шкале
  float                                 FV_from;                           // минимальное значение измеряемой величины
  float                                 FV_to;                               // максимальное значение измеряемой величины
} typ_AI_Chnl;

void AI_Chnl_GetFV(register typ_AI_Chnl *tAI_Chnl);

// преобразование данных с АЦП к шкале измеряемого сигнала
void Cls_KBase::AI_Chnl_GetFV(register typ_AI_Chnl *tAI_Chnl)
{
float w;

  w = (tAI_Chnl->ADC_to - tAI_Chnl->ADC_from);
  if(w != 0) w = tAI_Chnl->FV_from + (z_ADC[tAI_Chnl->ADC_ChnlNum] - tAI_Chnl->ADC_from) * (tAI_Chnl->FV_to - tAI_Chnl->FV_from) / w;
  tAI_Chnl->FV = w;
}


Вот так можно преобразовать данные АЦП в значение к измеряемому диапозону. Шкала может быть абсолютно любой как отрицательная, вывернутая и т.д. все считает правильно.

21

Код:
void NonMaskableInt_IRQnHandler(void)    /*!< 2 Non Maskable Interrupt                             */
{
}
void MemoryManagement_IRQnHandler(void)    /*!< 4 Cortex-M3 Memory Management Interrupt              */
{
}
void BusFault_IRQnHandler(void)    /*!< 5 Cortex-M3 Bus Fault Interrupt                      */
{
}
void UsageFault_IRQnHandler(void)    /*!< 6 Cortex-M3 Usage Fault Interrupt                    */
{
}
void SVCall_IRQnHandler(void)     /*!< 11 Cortex-M3 SV Call Interrupt                       */
{
}
void DebugMonitor_IRQnHandler(void)     /*!< 12 Cortex-M3 Debug Monitor Interrupt                 */
{
}
void PendSV_IRQnHandler(void)     /*!< 14 Cortex-M3 Pend SV Interrupt                       */
{
}
void SysTick_IRQnHandler(void)     /*!< 15 Cortex-M3 System Tick Interrupt                   */
{
}

/******  STM32 specific Interrupt Numbers *********************************************************/
void WWDG_IRQnHandler(void)      /*!< Window WatchDog Interrupt                            */
{
}
void PVD_IRQnHandler(void)      /*!< PVD through EXTI Line detection Interrupt            */
{
}
void TAMPER_IRQnHandler(void)      /*!< Tamper Interrupt                                     */
{
}
void RTC_IRQnHandler(void)      /*!< RTC global Interrupt                                 */
{
}
void FLASH_IRQnHandler(void)      /*!< FLASH global Interrupt                               */
{
}
void RCC_IRQnHandler(void)      /*!< RCC global Interrupt                                 */
{
}
void EXTI0_IRQnHandler(void)      /*!< EXTI Line0 Interrupt                                 */
{
}
void EXTI1_IRQnHandler(void)      /*!< EXTI Line1 Interrupt                                 */
{
}
void EXTI2_IRQnHandler(void)      /*!< EXTI Line2 Interrupt                                 */
{
}
void EXTI3_IRQnHandler(void)      /*!< EXTI Line3 Interrupt                                 */
{
}
void EXTI4_IRQnHandler(void)              /*!< EXTI Line4 Interrupt                                 */
{
}
void DMA1_Channel1_IRQnHandler(void)     /*!< DMA1 Channel 1 global Interrupt                      */
{
}
void DMA1_Channel2_IRQnHandler(void)     /*!< DMA1 Channel 2 global Interrupt                      */
{
}
void DMA1_Channel3_IRQnHandler(void)     /*!< DMA1 Channel 3 global Interrupt                      */
{
}
void DMA1_Channel4_IRQnHandler(void)     /*!< DMA1 Channel 4 global Interrupt                      */
{
}
void DMA1_Channel5_IRQnHandler(void)     /*!< DMA1 Channel 5 global Interrupt                      */
{
}
void DMA1_Channel6_IRQnHandler(void)     /*!< DMA1 Channel 6 global Interrupt                      */
{
}
void DMA1_Channel7_IRQnHandler(void)     /*!< DMA1 Channel 7 global Interrupt                      */
{
}
void ADC1_2_IRQnHandler(void)     /*!< ADC1 and ADC2 global Interrupt                       */
{
}
void USB_HP_CAN1_TX_IRQnHandler(void)     /*!< USB Device High Priority or CAN1 TX Interrupts       */
{
}
void USB_LP_CAN1_RX0_IRQnHandler(void)     /*!< USB Device Low Priority or CAN1 RX0 Interrupts       */
{
}
void CAN1_RX1_IRQnHandler(void)     /*!< CAN1 RX1 Interrupt                                   */
{
}
void CAN1_SCE_IRQnHandler(void)     /*!< CAN1 SCE Interrupt                                   */
{
}
void EXTI9_5_IRQnHandler(void)     /*!< External Line[9:5] Interrupts                        */
{
}
void TIM1_BRK_IRQnHandler(void)     /*!< TIM1 Break Interrupt                                 */
{
}
void TIM1_UP_IRQnHandler(void)     /*!< TIM1 Update Interrupt                                */
{
}
void TIM1_TRG_COM_IRQnHandler(void)     /*!< TIM1 Trigger and Commutation Interrupt               */
{
}
void TIM1_CC_IRQnHandler(void)     /*!< TIM1 Capture Compare Interrupt                       */
{
}
void TIM2_IRQnHandler(void)     /*!< TIM2 global Interrupt                                */
{
}
void TIM3_IRQnHandler(void)     /*!< TIM3 global Interrupt                                */
{
}
void TIM4_IRQnHandler(void)     /*!< TIM4 global Interrupt                                */
{
}
void I2C1_EV_IRQnHandler(void)     /*!< I2C1 Event Interrupt                                 */
{
}
void I2C1_ER_IRQnHandler(void)     /*!< I2C1 Error Interrupt                                 */
{
}
void I2C2_EV_IRQnHandler(void)     /*!< I2C2 Event Interrupt                                 */
{
}
void I2C2_ER_IRQnHandler(void)     /*!< I2C2 Error Interrupt                                 */
{
}
void SPI1_IRQnHandler(void)     /*!< SPI1 global Interrupt                                */
{
}
void SPI2_IRQnHandler(void)     /*!< SPI2 global Interrupt                                */
{
}
void USART1_IRQnHandler(void)     /*!< USART1 global Interrupt                              */
{
}
void USART2_IRQnHandler(void)     /*!< USART2 global Interrupt                              */
{
}
void USART3_IRQnHandler(void)     /*!< USART3 global Interrupt                              */
{
}
void EXTI15_10_IRQnHandler(void)     /*!< External Line[15:10] Interrupts                      */
{
}
void RTCAlarm_IRQnHandler(void)     /*!< RTC Alarm through EXTI Line Interrupt                */
{
}
void USBWakeUp_IRQnHandler(void)      /*!< USB Device WakeUp from suspend through EXTI Line Interrupt */ 
{
}	

22

домовой, а что хотелось-то ?

23

ничего.

24

Данную процедуру производить при тактировании от HSI!!!

Код:
/* Enable the Over-drive to extend the clock frequency to 216 MHz */
  RCC->APB1ENR |= RCC_APB1ENR_PWREN;
  PWR->CR1 |= PWR_CR1_ODEN;
  while(!(PWR->CSR1 & PWR_CSR1_ODRDY));
  PWR->CR1 |= PWR_CR1_ODSWEN;
  while(!(PWR->CSR1 & PWR_CSR1_ODSWRDY));

25

Функция копирования памяти STM32f1xx

Код:
#define  DMA_Stream  DMA1_Channel7

void CopyMemory(uint32_t tAdrDest, uint32_t tAdrSrc, uint16_t tCnt)
{
  DMA_Stream->CCR = 0;
  DMA_Stream->CPAR = tAdrDest;
  DMA_Stream->CMAR = tAdrSrc;
  DMA_Stream->CNDTR = tCnt;
  DMA_Stream->CCR = DMA_CCR1_MEM2MEM | DMA_CCR1_PL | DMA_CCR1_MSIZE_1 | DMA_CCR1_PSIZE_1 | DMA_CCR1_MINC | DMA_CCR1_PINC | DMA_CCR1_DIR;
  DMA1->IFCR = DMA_IFCR_CGIF7 | DMA_IFCR_CTCIF7 | DMA_IFCR_CHTIF7 | DMA_IFCR_CTEIF7;
  DMA_Stream->CCR |= DMA_CCR1_EN | DMA_CCR1_TCIE;
}

или так, в зависимости от задач

void CopyMemory(void *tAdrDest, const void *tAdrSrc, uint16_t tCnt)
{
  DMA_Stream->CCR = 0;
  DMA_Stream->CPAR = (uint32_t) tAdrDest;
  DMA_Stream->CMAR = (uint32_t) tAdrSrc;
  DMA_Stream->CNDTR = tCnt;
  DMA_Stream->CCR = DMA_CCR1_MEM2MEM | DMA_CCR1_PL | DMA_CCR1_MSIZE_1 | DMA_CCR1_PSIZE_1 | DMA_CCR1_MINC | DMA_CCR1_PINC | DMA_CCR1_DIR;
  DMA1->IFCR = DMA_IFCR_CGIF7 | DMA_IFCR_CTCIF7 | DMA_IFCR_CHTIF7 | DMA_IFCR_CTEIF7;
  DMA_Stream->CCR |= DMA_CCR1_EN | DMA_CCR1_TCIE;
}

Отредактировано MasterElectric (2017-11-18 03:03:57)

26

Вот только интересно насколько быстрей копирует DMA,чем через саму программу. То есть я буду ждать прерывания от DMA чтоб дальше работать с копией в памяти. Думаю конечно быстрей :)  Спасибо за пример,как раз попробую массив разбить по кускам двух мерный.

27

CERGEI В моем случае как раз нужно в фоне, быстрее гораздо чем на С. В примере копирование словами. А если блокирование нужно, то наверное смысла не очень много.

28

Попробовал копирование из массива в массив,думал  с прерываниями,но сделал просто ожидание конца переда DMA.

Код:
    	  CopyMemory(ssd1306_1,&s_ssd1306[1][0],128);
    	  while (!(DMA1->ISR & DMA_ISR_TCIF7))
        {
        }
        DMA1->IFCR |= DMA_IFCR_CTCIF7;
        // off channel7 dma tx
        DMA1_Channel7->CCR &= ~DMA_CCR7_EN ;

Вы здесь » Микроконтроллеры » STM32: * » Мелкие полезности STM32F1xx