1. #include "stm32f4xx.h"
2. #include "stm32f4_discovery.h"
3. char znak;
4. int i=0;
5. int p=0;
6. void TIM4_IRQHandler(void)
7. {
8.         if(TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
9.         {
10.  
11.                 TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
12.         }
13. }
14.  
15. uint8_t usartGetChar(void)
16. {
17.         // czekaj na odebranie danych
18.         while (USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == RESET);
19.         return USART_ReceiveData(USART3);
20. }
21.  
22. void USART3_IRQHandler(void)
23. {
24.         // sprawdzenie flagi zwiazanej z odebraniem danych przez USART
25.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
26.         {
27.                 // odebrany bajt znajduje sie w rejestrze USART3->DR
28.                 if (USART3->DR == '+' )
29.                 {
30.                         p++;
31.                 }
32.                 if (USART3->DR == '-' )
33.                 {
34.                         if(p>0){
35.                         p--;
36.                         }
37.                 }
38.  
39.         }
40. }
41.  
42.  
43.  
44.  
45. int main(void)
46. {
47.  
48.         // wlaczenie taktowania wybranego portu
49.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
50.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
51.         // wlaczenie taktowania wybranego układu USART
52.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
53.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
54.  
55.         // konfiguracja linii Rx i Tx
56.         GPIO_InitTypeDef GPIO_InitStructure;
57.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
58.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
59.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
60.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
61.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
62.         GPIO_Init(GPIOC, &GPIO_InitStructure);
63.         // ustawienie funkcji alternatywnej dla pinów (USART)
64.         GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);
65.         GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);
66.  
67.  
68.  
69.         USART_InitTypeDef USART_InitStructure;
70.         // predkosc transmisji (mozliwe standardowe opcje: 9600, 19200, 38400, 57600, 115200, ...)
71.         USART_InitStructure.USART_BaudRate = 9600;
72.         // długość słowa (USART_WordLength_8b lub USART_WordLength_9b)
73.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
74.         // liczba bitów stopu (USART_StopBits_1, USART_StopBits_0_5, USART_StopBits_2, USART_StopBits_1_5)
75.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
76.         // sprawdzanie parzystości (USART_Parity_No, USART_Parity_Even, USART_Parity_Odd)
77.         USART_InitStructure.USART_Parity = USART_Parity_No;
78.         // sprzętowa kontrola przepływu (USART_HardwareFlowControl_None, USART_HardwareFlowControl_RTS, USART_HardwareFlowControl_CTS, USART_HardwareFlowControl_RTS_CTS)
79.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
80.         // tryb nadawania/odbierania (USART_Mode_Rx, USART_Mode_Rx )
81.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
82.         // konfiguracja
83.         USART_Init(USART3, &USART_InitStructure);
84.  
85.  
86.         USART_Cmd(USART3, ENABLE);
87.  
88.         //struktura do konfiguracji kontrolera NVIC
89.         NVIC_InitTypeDef NVIC_InitStructure2;
90.         // wlaczenie przerwania związanego z odebraniem danych (pozostale zrodla przerwan zdefiniowane sa w pliku stm32f4xx_usart.h)
91.         USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
92.         NVIC_InitStructure2.NVIC_IRQChannel = USART3_IRQn;
93.         NVIC_InitStructure2.NVIC_IRQChannelPreemptionPriority = 0;
94.         NVIC_InitStructure2.NVIC_IRQChannelSubPriority = 0;
95.         NVIC_InitStructure2.NVIC_IRQChannelCmd = ENABLE;
96.         // konfiguracja kontrolera przerwan
97.         NVIC_Init(&NVIC_InitStructure2);
98.         // wlaczenie przerwan od ukladu USART
99.         NVIC_EnableIRQ(USART3_IRQn);
100.  
101.  
102.  
103.  
104.         TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
105.         TIM_TimeBaseStructure.TIM_Period = 42000;
106.         TIM_TimeBaseStructure.TIM_Prescaler = 1000;
107.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
108.         TIM_TimeBaseStructure.TIM_CounterMode =  TIM_CounterMode_Up;
109.         TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
110.  
111.  
112.         NVIC_InitTypeDef NVIC_InitStructure;
113.         NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
114.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
115.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
116.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
117.         NVIC_Init(&NVIC_InitStructure);
118.  
119.         TIM_Cmd(TIM4, ENABLE);
120.  
121.         TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
122.         TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
123.  
124.  
125.  
126.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
127.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
128.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
129.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
130.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
131.         GPIO_Init(GPIOD, &GPIO_InitStructure);
132.  
133.  
134. int j=0,m;
135.         for(;;)
136.         {
137.  
138.                 if(TIM_GetFlagStatus(TIM4, TIM_FLAG_Update)) {
139.  
140.                         if (j!=0){
141.                                 j--;
142.                                 if(j==0)
143.                                 {
144.                                         i=m;
145.                                 }
146.                         }
147.                         else if(j==0 && p!=0){
148.                         j=p;
149.                         if(p!=0){
150.                         m=i;
151.                         i=5;
152.                         }
153.                         }
154.  
155.                         if(i==4){
156.                         i=0;
157.                         GPIO_ToggleBits(GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
158.                         }
159.                         else if(i==3){
160.                                 GPIO_ToggleBits(GPIOD, GPIO_Pin_15);
161.                                 i++;
162.                         }
163.                         else if(i==2){
164.                                 GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
165.                                 i++;
166.                         }
167.                         else if(i==1){
168.                                 GPIO_ToggleBits(GPIOD, GPIO_Pin_13);
169.                                 i++;
170.                         }
171.                         else if(i==0){
172.                                 GPIO_ToggleBits(GPIOD, GPIO_Pin_12);
173.                                 i++;
174.                         }
175.  
176.  
177.  
178.  
179.  
180.  
181.  
182.  
183.                                         TIM_ClearFlag(TIM2, TIM_FLAG_Update);
184.  
185.         }
186.  
187. }
188. }