1.  
2. #include "stm32f4xx.h"
3. #include "stm32f4_discovery.h"
4.  
5. extern const u8 rawAudio[123200];
6.  
7.  
8. int globalna = 0;
9. float napiecie = 0;
10.  
11. int main(void)
12. {
13.  
14.         // wlaczenie taktowania wybranego portu
15.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
16.         // wlaczenie taktowania wybranego układu USART
17.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
18.  
19. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA , ENABLE); // zegar dla portu GPIO z którego wykorzystany zostanie pin jako wejście ADC (PA1)
20. RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); // zegar dla modułu ADC1
21. RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2, ENABLE); // zegar dla modułu ADC2
22.  
23.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
24.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
25.  
26.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA , ENABLE); // zegar dla portu GPIO z którego wykorzystany zostanie pin jako wyjście DAC (PA4)
27.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE); // zegar dla modułu DAC
28.  
29.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
30.  
31.                 /* Time base configuration*/
32.                                 TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
33.                                 TIM_TimeBaseStructure.TIM_Period = 8400;
34.                                 TIM_TimeBaseStructure.TIM_Prescaler = 10000;
35.                                 TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
36.                                 TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
37.                                 TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
38.  
39.  
40.         GPIO_InitTypeDef GPIO_InitStructure;
41.                         GPIO_InitStructure.GPIO_Pin =
42.                         GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
43.                         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
44.                         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
45.                         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
46.                         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
47.                         GPIO_Init(GPIOD, &GPIO_InitStructure);
48.  
49.                         GPIO_InitTypeDef GPIO_InitStructure2;
50.                                 //inicjalizacja wejścia ADC
51.                                 GPIO_InitStructure2.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
52.                                 GPIO_InitStructure2.GPIO_Mode = GPIO_Mode_AN;
53.                                 GPIO_InitStructure2.GPIO_PuPd = GPIO_PuPd_NOPULL;
54.                                 GPIO_Init(GPIOA, &GPIO_InitStructure2);
55.  
56.                                 /*GPIO_InitTypeDef GPIO_InitStructure3;
57.                                                                 //inicjalizacja wejścia ADC
58.                                                                 GPIO_InitStructure3.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4;
59.                                                                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
60.                                                                                         GPIO_InitStructure3.GPIO_OType = GPIO_OType_PP;
61.                                                                                         GPIO_InitStructure3.GPIO_Speed = GPIO_Speed_100MHz;
62.                                                                                         GPIO_InitStructure3.GPIO_PuPd = GPIO_PuPd_UP;
63.                                                                                         GPIO_Init(GPIOA, &GPIO_InitStructure3);*/
64.  
65.                                                                                         GPIO_InitTypeDef GPIO_InitStructure4;
66.                                                                                         //inicjalizacja wyjścia DAC
67.                                                                                         GPIO_InitStructure4.GPIO_Pin = GPIO_Pin_4;
68.                                                                                         GPIO_InitStructure4.GPIO_Mode = GPIO_Mode_AN;
69.                                                                                         GPIO_InitStructure4.GPIO_Speed = GPIO_Speed_100MHz;
70.                                                                                         GPIO_InitStructure4.GPIO_PuPd = GPIO_PuPd_NOPULL;
71.                                                                                         GPIO_Init(GPIOA, &GPIO_InitStructure4);
72.  
73.                                                                                                 // konfiguracja linii Rx i Tx
74.                                                                                                 GPIO_InitTypeDef GPIO_InitStructure5;
75.                                                                                                 GPIO_InitStructure5.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
76.                                                                                                 GPIO_InitStructure5.GPIO_Mode = GPIO_Mode_AF;
77.                                                                                                 GPIO_InitStructure5.GPIO_OType = GPIO_OType_PP;
78.                                                                                                 GPIO_InitStructure5.GPIO_PuPd = GPIO_PuPd_UP;
79.                                                                                                 GPIO_InitStructure5.GPIO_Speed = GPIO_Speed_50MHz;
80.                                                                                                 GPIO_Init(GPIOC, &GPIO_InitStructure5);
81.                                                                                                 // ustawienie funkcji alternatywnej dla pinów (USART)
82.                                                                                                 GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);
83.                                                                                                 GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);
84.  
85.                                                                                                 // ustawienie trybu pracy priorytetów przerwan
86.                                                                                                                 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
87.  
88.                                                                                                                 //struktura do konfiguracji kontrolera NVIC
89.                                                                                                                                                                                                                         NVIC_InitTypeDef NVIC_InitStructure;
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_InitStructure.NVIC_IRQChannel = USART3_IRQn;
93.                                                                                                                                                                                                                                         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
94.                                                                                                                                                                                                                                 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
95.                                                                                                                                                                                                                                 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
96.                                                                                                                                                                                                                                         // konfiguracja kontrolera przerwan
97.                                                                                                                                                                                                                                         NVIC_Init(&NVIC_InitStructure);
98.                                                                                                                                                                                                                                         // wlaczenie przerwan od ukladu USART
99.                                                                                                                                                                                                                                                 NVIC_EnableIRQ(USART3_IRQn);
100.  
101.                                                                                                                 NVIC_InitTypeDef NVIC_InitStructure2;
102.                                                                                                                                                 // numer przerwania
103.                                                                                                                                                 NVIC_InitStructure2.NVIC_IRQChannel = TIM4_IRQn;
104.                                                                                                                                                 // priorytet glówny
105.                                                                                                                                                 NVIC_InitStructure2.NVIC_IRQChannelPreemptionPriority = 0x00;
106.                                                                                                                                                 // subpriorytet
107.                                                                                                                                                 NVIC_InitStructure2.NVIC_IRQChannelSubPriority = 0x00;
108.                                                                                                                                                 // uruchom dany kanal
109.                                                                                                                                         NVIC_InitStructure2.NVIC_IRQChannelCmd = ENABLE;
110.                                                                                                                                                 // zapisz wypelniona strukture do rejestrów
111.                                                                                                                                                 NVIC_Init(&NVIC_InitStructure2);
112.  
113.  
114.  
115.  
116.         ADC_CommonInitTypeDef ADC_CommonInitStructure;
117.         // niezależny tryb pracy przetworników
118.         ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
119.         // zegar główny podzielony przez 2
120.         ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
121.         // opcja istotna tylko dla trybu multi ADC
122.         ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
123.         // czas przerwy pomiędzy kolejnymi konwersjami
124.         ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
125.         ADC_CommonInit(&ADC_CommonInitStructure);
126.  
127.         ADC_InitTypeDef ADC_InitStructure;
128.         //ustawienie rozdzielczości przetwornika na maksymalną (12 bitów)
129.         ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
130.         //wyłączenie trybu skanowania (odczytywać będziemy jedno wejście ADC
131.         //w trybie skanowania automatycznie wykonywana jest konwersja na wielu //wejściach/kanałach)
132.         ADC_InitStructure.ADC_ScanConvMode = DISABLE;
133.         //włączenie ciągłego trybu pracy
134.         ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
135.         //wyłączenie zewnętrznego wyzwalania
136.         //konwersja może być wyzwalana timerem, stanem wejścia itd. (szczegóły w //dokumentacji)
137.         ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
138.         ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
139.         //wartość binarna wyniku będzie podawana z wyrównaniem do prawej
140.         //funkcja do odczytu stanu przetwornika ADC zwraca wartość 16-bitową
141.         //dla przykładu, wartość 0xFF wyrównana w prawo to 0x00FF, w lewo 0x0FF0
142.         ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
143.         //liczba konwersji równa 1, bo 1 kanał
144.         ADC_InitStructure.ADC_NbrOfConversion = 1;
145.         // zapisz wypełnioną strukturę do rejestrów przetwornika numer 1
146.         ADC_Init(ADC1, &ADC_InitStructure);
147.  
148.         ADC_CommonInitTypeDef ADC_CommonInitStructure2;
149.                 // niezależny tryb pracy przetworników
150.                 ADC_CommonInitStructure2.ADC_Mode = ADC_Mode_Independent;
151.                 // zegar główny podzielony przez 2
152.                 ADC_CommonInitStructure2.ADC_Prescaler = ADC_Prescaler_Div2;
153.                 // opcja istotna tylko dla trybu multi ADC
154.                 ADC_CommonInitStructure2.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
155.                 // czas przerwy pomiędzy kolejnymi konwersjami
156.                 ADC_CommonInitStructure2.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
157.                 ADC_CommonInit(&ADC_CommonInitStructure2);
158.  
159.                 ADC_InitTypeDef ADC_InitStructure2;
160.                 //ustawienie rozdzielczości przetwornika na maksymalną (12 bitów)
161.                 ADC_InitStructure2.ADC_Resolution = ADC_Resolution_12b;
162.                 //wyłączenie trybu skanowania (odczytywać będziemy jedno wejście ADC
163.                 //w trybie skanowania automatycznie wykonywana jest konwersja na wielu //wejściach/kanałach)
164.                 ADC_InitStructure2.ADC_ScanConvMode = DISABLE;
165.                 //włączenie ciągłego trybu pracy
166.                 ADC_InitStructure2.ADC_ContinuousConvMode = ENABLE;
167.                 //wyłączenie zewnętrznego wyzwalania
168.                 //konwersja może być wyzwalana timerem, stanem wejścia itd. (szczegóły w //dokumentacji)
169.                 ADC_InitStructure2.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
170.                 ADC_InitStructure2.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
171.                 //wartość binarna wyniku będzie podawana z wyrównaniem do prawej
172.                 //funkcja do odczytu stanu przetwornika ADC zwraca wartość 16-bitową
173.                 //dla przykładu, wartość 0xFF wyrównana w prawo to 0x00FF, w lewo 0x0FF0
174.                 ADC_InitStructure2.ADC_DataAlign = ADC_DataAlign_Right;
175.                 //liczba konwersji równa 1, bo 1 kanał
176.                 ADC_InitStructure2.ADC_NbrOfConversion = 1;
177.                 // zapisz wypełnioną strukturę do rejestrów przetwornika numer 1
178.                 ADC_Init(ADC2, &ADC_InitStructure);
179.  
180.                 DAC_InitTypeDef DAC_InitStructure;
181.                 //wyłączenie zewnętrznego wyzwalania
182.                 //konwersja może być wyzwalana timerem, stanem wejścia itd. (szczegóły w dokumentacji)
183.                 DAC_InitStructure.DAC_Trigger = DAC_Trigger_None;
184.                 //nast. 2 linie - wyłączamy generator predefiniowanych przebiegów //wyjściowych (wartości zadajemy sami, za pomocą odpowiedniej funkcji)
185.                 DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
186.                 DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_LFSRUnmask_Bit0;
187.                 //włączamy buforowanie sygnału wyjściowego
188.                 DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
189.                 DAC_Init(DAC_Channel_1, &DAC_InitStructure);
190.  
191.                 USART_InitTypeDef USART_InitStructure;
192.                 // predkosc transmisji (mozliwe standardowe opcje: 9600, 19200, 38400, 57600, 115200, ...)
193.                 USART_InitStructure.USART_BaudRate = 115200;
194.                 // długość słowa (USART_WordLength_8b lub USART_WordLength_9b)
195.                 USART_InitStructure.USART_WordLength = USART_WordLength_8b;
196.                 // liczba bitów stopu (USART_StopBits_1, USART_StopBits_0_5, USART_StopBits_2, USART_StopBits_1_5)
197.                 USART_InitStructure.USART_StopBits = USART_StopBits_1;
198.                 // sprawdzanie parzystości (USART_Parity_No, USART_Parity_Even, USART_Parity_Odd)
199.                 USART_InitStructure.USART_Parity = USART_Parity_No;
200.                 // sprzętowa kontrola przepływu (USART_HardwareFlowControl_None, USART_HardwareFlowControl_RTS, USART_HardwareFlowControl_CTS, USART_HardwareFlowControl_RTS_CTS)
201.                 USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
202.                 // tryb nadawania/odbierania (USART_Mode_Rx, USART_Mode_Rx )
203.                 USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
204.  
205.                 // konfiguracja
206.                 USART_Init(USART3, &USART_InitStructure);
207.  
208.                 USART_Cmd(USART3, ENABLE);
209.  
210.                 // wyczyszczenie przerwania od timera 3 (wystapilo przy konfiguracji timera)
211.                                                 TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
212.                                                 // zezwolenie na przerwania od przepelnienia dla timera 3
213.                                                 TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
214.  
215.  
216.         ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_84Cycles);
217.  
218.  
219.         ADC_Cmd(ADC1, ENABLE);
220.  
221.         DAC_Cmd(DAC_Channel_1, ENABLE);
222.  
223.         ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SampleTime_84Cycles);
224.  
225.  
226.  
227.                 DAC_SetChannel1Data(DAC_Align_12b_R, globalna);
228.  
229.                 TIM_Cmd(TIM4, ENABLE);
230.  
231.  
232.  
233. /*
234.         GPIO_SetBits(GPIOD, GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);
235.         GPIO_SetBits(GPIOA, GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_1);
236. */
237.  
238.  
239.  
240.         for(;;){
241.  
242.  
243.  
244.                 DAC_SetChannel1Data(DAC_Align_12b_R, rawAudio[globalna]);
245.                 globalna++;
246.                 if(globalna>123199){
247.                         globalna = 0;
248.                 }
249.                 for(int i=0; i<700; i++){}
250.  
251.  
252.                 ADC_SoftwareStartConv(ADC1);
253.                 while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
254.                 //globalna = ADC_GetConversionValue(ADC1);
255.  
256.                 //napiecie = globalna * 0.00072;
257. /*
258.                 if(globalna < 40033){
259.                         GPIO_SetBits(GPIOD, GPIO_Pin_13);
260.                         GPIO_ResetBits(GPIOD, GPIO_Pin_14);
261.                         GPIO_ResetBits(GPIOD, GPIO_Pin_15);
262.  
263.                 }
264.                 else if(globalna >= 40033 && globalna <= 80666){
265.                         GPIO_SetBits(GPIOD, GPIO_Pin_14);
266.                                                 GPIO_ResetBits(GPIOD, GPIO_Pin_13);
267.                                                 GPIO_ResetBits(GPIOD, GPIO_Pin_15);
268.  
269.                 }
270.                 else {
271.                         GPIO_SetBits(GPIOD, GPIO_Pin_15);
272.                                                 GPIO_ResetBits(GPIOD, GPIO_Pin_14);
273.                                                 GPIO_ResetBits(GPIOD, GPIO_Pin_13);
274.  
275.                 }
276. */
277.  
278.         }
279.  
280.  
281.  
282. }
283.  
284.  
285. void TIM4_IRQHandler(void)
286. {
287.              if(TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
288.              {
289.  
290.                  //czekaj na opróżnienie bufora wyjściowego
291.                                 while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
292.                                 // wyslanie danych
293.                                 USART_SendData(USART3, 'a');
294.                                 // czekaj az dane zostana wyslane
295.                                 while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
296.                     // wyzerowanie flagi wyzwolonego przerwania
297.                     TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
298.              }
299. }
300.  
301.  
302.  
303. uint8_t usartGetChar(void)
304. {
305.     // czekaj na odebranie danych
306.        while (USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == RESET);
307.  
308.        return USART_ReceiveData(USART3);
309. }
310.  
311. void USART3_IRQHandler(void)
312. {
313.     // sprawdzenie flagi zwiazanej z odebraniem danych przez USART
314.     if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
315.        {
316.         // odebrany bajt znajduje sie w rejestrze USART3->DR
317.         if(USART3->DR == 'a'){
318.                 USART3->DR = USART3->DR - 32;
319.                  //czekaj na opróżnienie bufora wyjściowego
320.                                                 while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
321.                                                 // wyslanie danych
322.                                                 USART_SendData(USART3, USART3->DR);
323.                                                 // czekaj az dane zostana wyslane
324.                                                 while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
325.         }
326.         if(USART3->DR == 'b'){
327.                 GPIO_ToggleBits(GPIOD, GPIO_Pin_13);
328.         }
329.         if(USART3->DR == 'c'){
330.                 GPIO_ToggleBits(GPIOD, GPIO_Pin_14);
331.         }
332.         if(USART3->DR == 'd'){
333.                 GPIO_ToggleBits(GPIOD, GPIO_Pin_15);
334.         }
335.     }
336. }
337.  
338.  
339.