[2] STM32F4 - Discovery - Projekt - Generator sygnałów DAC

W tym poście chciałbym przedstawić szybki mały projekt generatora sygnałów, wykonanego w oparciu o STM32F4 - Discovery. Układ generował będzie wybrane przez użytkownika sygnały za pomocą DAC na pinach PA4 oraz PA5. Z dostępnych sygnałów będzie do wybory sygnał sinusoidalny, trójkątny, piłokształtny, prostokątny oraz szum. W celu wybrania funkcji będzie wykorzystywany wyświetlacz Nokia 5110 oraz kilka przycisków.

Podłączenie

Elementem wykorzystywanym do prezentacji danych będzie wspomniany wcześniej wyświetlacz Nokia 5110. Jego podłączenie jest następujące:

• RST - GPIOC15
• CE - GPIOC13
• DC - GPIOC14
• Din - GPIOC3
• Clk - GPIOB10
• VCC - 3,3V
• BL - Włączenie podświetlenia wyświetlacza
• GND - GND

Kolejnym elementem będą przyciski funkcyjne, które zostały podłączone w następujący sposób:

• Przycisk 1 do PD0 (przycisk już wbudowany w Discovery)
• Przycisk 2 do PD1
• Przycisk 3 do PD2
• Przycisk 4 do PD3

Sygnały z DAC-a został wystawiony na liniach PA4 oraz PA5.

Programowanie

Poniżej przedstawiam krótki opis poszczególnych części programu:

• Definicja tablic z danymi dla wyświetlacza oraz DAC-a
• Inicjalizacja DAC1 oraz DAC2 oraz portów GPIO dla nich
• Inicjalizacja timerów dla DAC1, DAC2
• Przygotowanie funkcji uruchamiającej generator szumu dla DAC2
• Włączenie wyświetlacza Nokia 5110 wraz z SPI oraz dodatkowymi funkcjami wykorzystywanymi przy przesyłaniu danych.
• Włączenie funkcji przerwania dla przycisków PD1, PD2 oraz PD3. Aby je odpowiednio wykonać należy uruchomić EXTI, NVIC odpowiedni port GPIO.
• PD1 będzie miał za zadanie ustawianie wybranego typu sygnału, który byłby generowany poprzez DAC1
• PD2 odpowiada za ustawienie częstotliwości z jaką sygnał z DAC1 będzie taktowany
• PD3 będzie miał za zadanie ustawianie wybranego typu sygnału, który byłby generowany poprzez DAC2
• PD4 odpowiada za ustawienie częstotliwości z jaką sygnał z DAC2 będzie taktowany
• PD5 jego zadaniem będzie włączenie sygnału z wprowadzonymi parametrami
• Ostatnim elementem będzie obsługa przerwania dla zdeklarowanych przycisków, Każde z nich oprócz odpowiedniego zabezpieczenia sprzętowego musi być wyposażony w funkcję sprawdzającą stany poszczególnych przycisków.

W pierwszej kolejności należy włączyć DAC oraz przygotować tablicę z danymi dla generowanych sygnałów. Aby generator działał poprawnie należy dodatkowo zdeklarować licznik dla DAC1 oraz DAC2. W funkcji z inicjacją DAC-a znajduje się także włączenie DMA oraz GPIO dla pinów z generowanym sygnałem.

Poniżej przedstawiam deklarację dla TIM1.

1. //Deklaracja timera dla DAC1 PA4
2. static void TIMConfig_DAC1(void)
3. {
4.   TIM_TimeBaseInitTypeDef TimerInitStructure;
5.    
6.     //Wlaczenie zegara dla timera 6
7.   RCC_APB1PeriphClockCmd(Timer_Clock1, ENABLE);
9.   TIM_TimeBaseStructInit(&TimerInitStructure);
10.     //Ustawienie okresu jako:
11.     //zegar (APB1 Tim6/ilosc probek)*czestotliwosc sygnalu
12.     if(signaltype == 1)
13.     {
14.         TimerInitStructure.TIM_Period      = (uint16_t)(TIM_APB_DAC1/Num_Samp_DAC1_128)*Signal_Freq_DAC1;
15.     }
16.     else
17.     {
18.         TimerInitStructure.TIM_Period      = (uint16_t)(TIM_APB_DAC1/Num_Samp_DAC1_32)*(Signal_Freq_DAC1*1000)
19. ;
20.     }
21.   TimerInitStructure.TIM_Prescaler     = 0;      
22.   TimerInitStructure.TIM_ClockDivision = 0;
23.     //Zliczanie w gore
24.   TimerInitStructure.TIM_CounterMode   = TIM_CounterMode_Up;  
25.   TIM_TimeBaseInit(Tim_Number1, &TimerInitStructure);
26.   TIM_SelectOutputTrigger(Tim_Number1, TIM_TRGOSource_Update);
28.   TIM_Cmd(Tim_Number1, ENABLE);
29. }

Poniżej włączenie DAC1 z GPIO oraz DMA.

1. //Wlaczenie DAC1
2. void DAC1Init()
3. {
4.     DAC_InitTypeDef DACInit;
5.     GPIO_InitTypeDef GPIOInit;  
6.     DMA_InitTypeDef DMAInit;
8.     //Wlaczenie zegara dla portu GPIOA
9.     //RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
10.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
11.    
12.     //Wlaczenie zegara dla DAC
13.     //RCC->APB1ENR |= RCC_APB1ENR_DACEN;
14.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
15.    
16.     //Wlaczenie zegara dla DMA
17.     //RCC->AHB1ENR |= RCC_AHB1ENR_DMA1EN;
18.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
19.    
20.     //Pozostale ustawienia wyprowadzen GPIO
21.     GPIOInit.GPIO_Pin = GPIO_Pin_4;
22.     GPIOInit.GPIO_Mode = GPIO_Mode_AN;
23.     GPIOInit.GPIO_OType = GPIO_OType_PP;
24.     GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
25.     GPIOInit.GPIO_Speed = GPIO_Speed_50MHz;
26.     GPIO_Init(GPIOA, &GPIOInit);
27.    
28.     //Ustawienie opcji dla DAC
29.     //Sygnal wyzwalajacy
30.     DACInit.DAC_Trigger = DAC1_Trigger;
31.     //Generacja sygnalu wylaczona
32.     DACInit.DAC_WaveGeneration = DAC_WaveGeneration_None;
33.     //Bufor wyjsciowy wlaczony
34.     DACInit.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
35.     DAC_Init(DAC_Channel_1, &DACInit);
36.    
37.     DMA_DeInit(DMA1_Stream5);
38.     DMAInit.DMA_Channel = DMA_Channel_7;
39.     //Data holding register, 12 bit, right aligned ch1
40.     DMAInit.DMA_PeripheralBaseAddr = (uint32_t)&DAC->DHR12R1;
41.     switch(signaltype)
42.     {
43.         case 1:
44.         {
45.             DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Sinus2;
46.             break;
47.         }
48.         case 2:
49.         {
50.             DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Sinus;
51.             break;
52.         }
53.         case 3:
54.         {
55.             DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Triangle;
56.             break;
57.         }
58.         case 4:
59.         {
60.             DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Sawtooth;
61.             break;
62.         }
63.         case 5:
64.         {
65.             DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Square;
66.             break;
67.         }
68.     }
69.     //Jak dane beda generowane
70.     DMAInit.DMA_DIR = DMA_DIR_MemoryToPeripheral;
71.     if(signaltypedac2 == 1)
72.     {
73.       //Liczba próbek sygnalu
74.       DMAInit.DMA_BufferSize = Num_Samp_DAC1_128;
75.     }
76.     else
77.     {
78.       DMAInit.DMA_BufferSize = Num_Samp_DAC1_32;
79.     }    
80.     //Wylaczony automatyczny zwiekszanie adresu
81.     DMAInit.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
82.     //Wylaczony transfer z pamieci do pamieci
83.     DMAInit.DMA_MemoryInc = DMA_MemoryInc_Enable;
84.     //Rozmiar przeslanych danych 16b
85.     DMAInit.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
86.     //Rozmiar danych po stronie pamieci
87.     DMAInit.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
88.     //Ciagly tryb pracy
89.     DMAInit.DMA_Mode = DMA_Mode_Circular;
90.     //Priprytet wysoki
91.     DMAInit.DMA_Priority = DMA_Priority_High;
92.     //Tryb fifo wylaczony
93.     DMAInit.DMA_FIFOMode = DMA_FIFOMode_Disable;
94.     DMAInit.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;
95.     //Pojedyncze wyzwalanie
96.     DMAInit.DMA_MemoryBurst = DMA_MemoryBurst_Single;
97.     DMAInit.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
99.     //Wylaczenie DMA
100.     DMA_DeInit(DMA1_Stream5);
101.     //Inicjacja i wlaczenie DMA
102.     DMA_Init(DMA1_Stream5, &DMAInit);
103.     DMA_Cmd(DMA1_Stream5, ENABLE);
104.    
105.     //Wlaczenie DAC-a
106.     DAC_Cmd(DAC_Channel_1, ENABLE);
107.     DAC_DMACmd(DAC_Channel_1, ENABLE);
108.    
109.     //Inicjacja i wlaczenie wybranego pinu DAC
110.     DAC_Init(DAC_Channel_1, &DACInit);
111.        
112.     //Wlaczenie kanalu pierwszego
113.     //DAC->CR |= DAC_CR_EN1;
114.     DAC_Cmd(DAC_Channel_1, ENABLE);
115. }

Kolejnym elementem jest dodanie funkcji odpowiedzialnej za obsługę wyświetlacza. ZOstały one opisane w jednym ze wcześniejszych postów.

W ostatnim kroku należy przygotować funkcję odpowiedzialną za przerwania od przycisków funkcyjnych.

Poniżej przedstawiam jedną z funkcji ustawiającą przerwanie dla PD2:

1. void Configure_PD2(void)
2. {
3.     GPIO_InitTypeDef GPIO_InitStruct;
4.     EXTI_InitTypeDef EXTI_InitStruct;
5.     NVIC_InitTypeDef NVIC_InitStruct;
6.    
7.     //Wlaczenie zegarow
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
9.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
10.    
11.     //Ustawienie pinu dla przycisku, jako wejscie
12.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
13.     GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
14.     GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;
15.     GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
16.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
17.     GPIO_Init(GPIOD, &GPIO_InitStruct);
18.    
19.     //Przypisanie przerwania pod PD2
20.     SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOD, EXTI_PinSource2);
21.    
22.     //Wlaczenie lini PD2 dla przerwania
23.     EXTI_InitStruct.EXTI_Line = EXTI_Line2;
24.     //Wlaczenie przerwania
25.     EXTI_InitStruct.EXTI_LineCmd = ENABLE;
26.     //Wlaczenie trybu przerwania
27.     EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
28.     //Przerwanie aktywowane zboczem opadajacym
29.     EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
30.     EXTI_Init(&EXTI_InitStruct);
32.     //Dodanie wektora przerwania do NVIC, PD2 podpiete pod EXTI2_IRQn
33.     NVIC_InitStruct.NVIC_IRQChannel = EXTI2_IRQn;
34.     //Wybranie prioryteru
35.     NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0x01;
36.     //Podpriorytet
37.     NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0x00;
38.     //Wlaczenie przerwania
39.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
40.     NVIC_Init(&NVIC_InitStruct);
41. }

Do tego należy dodać funkcje obsługującą przerwania. Poniżej przedstawiam funkcję odpowiedzialną za ustawienie i generowanie sygnału szumu losowego dla DAC1.

1. void DAC1Init_NoiseGeneration()
2. {
3.     DAC_InitTypeDef DACInit;
4.     GPIO_InitTypeDef GPIOInit;  
6.     //Wlaczenie zegara dla portu GPIOA
7.     //RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
9.    
10.     //Wlaczenie zegara dla DAC
11.     //RCC->APB1ENR |= RCC_APB1ENR_DACEN;
12.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
13.    
14.     //Pozostale ustawienia wyprowadzen GPIO
15.     GPIOInit.GPIO_Pin = GPIO_Pin_4;
16.     GPIOInit.GPIO_Mode = GPIO_Mode_AN;
17.     GPIOInit.GPIO_OType = GPIO_OType_PP;
18.     GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
19.     GPIOInit.GPIO_Speed = GPIO_Speed_50MHz;
20.     GPIO_Init(GPIOA, &GPIOInit);
21.    
22.     //Ustawienie opcji dla DAC
23.     //Sygnal wyzwalajacy
24.     DACInit.DAC_Trigger = DAC_Trigger_Software;
25.     //Generacja sygnalu wylaczona
26.     DACInit.DAC_WaveGeneration = DAC_WaveGeneration_Noise;
27.     //Bufor wyjsciowy wlaczony
28.     DACInit.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
29.     //0x3FF - 1111111111
30.     DACInit.DAC_LFSRUnmask_TriangleAmplitude = 0x3FF;
31.     DAC_Init(DAC_Channel_1, &DACInit);
32.    
33.     //Wlaczenie DAC-a
34.     DAC_Cmd(DAC_Channel_1, ENABLE);
35.     DAC_DMACmd(DAC_Channel_1, ENABLE);
36.    
37.     //Inicjacja i wlaczenie wybranego pinu DAC
38.     DAC_Init(DAC_Channel_1, &DACInit);
39. }

Poniżej przedstawiam programy obsługujące przerwania dla DAC1, oraz część włączającą generację sygnałów.

1. void EXTI1_IRQHandler(void)
2. {
3.     if (EXTI_GetITStatus(EXTI_Line1) != RESET)
4.         {
5.         if (!keylog1 && !(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_1)))
6.         {
7.                 keylog1 = 1;
8.                 del(700);
9.                 LCDDraw(0, 30, "         ");
10.                 signaltype++;
11.                    
12.                 switch(signaltype)
13.                 {
14.                   case 1:
15.                   {
16.                     LCDDraw(0, 30, "Sinus 128");
17.                     break;
18.                   }
19.                   case 2:
20.                   {
21.                     LCDDraw(0, 30, "Sinus");
22.                     break;
23.                   }
24.                   case 3:
25.                   {
26.                     LCDDraw(0, 30, "Triangle");
27.                     break;
28.                   }
29.                   case 4:
30.                   {
31.                     LCDDraw(0, 30, "Sawtooth");
32.                     break;
33.                   }
34.                   case 5:
35.                   {
36.                     LCDDraw(0, 30, "Square");
37.                     break;
38.                   }
39.                   case 6:
40.                   {
41.                     LCDDraw(0, 30, "Noise");
42.                     break;
43.                   }
44.                   case 7:
45.                   {
46.                     signaltype = 0;
47.                     LCDDraw(0, 30, "Brak");
48.                     break;
49.                   }
50.               }
51.         //Czyszczenie flagi przerwania
52.         EXTI_ClearITPendingBit(EXTI_Line1);
53.         keylog1 = 0;
54.       }
55.     }
56. }
58. void EXTI2_IRQHandler(void)
59. {
60.     char res[20];
61.    
62.     //Sprawdzenie czy flaga przerwania zostala ustawiona
63.     if (EXTI_GetITStatus(EXTI_Line2) != RESET)
64.     {
65.         if (!keylog2 && !(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_2)))
66.         {
67.             keylog2 = 1;
68.             del(700);
69.             Signal_Freq_DAC1++;
70.                
71.             sprintf(res, "%d [kHz]", Signal_Freq_DAC1);
72.             LCDDraw(1, 30, res);   
73.          }
75.          EXTI_ClearITPendingBit(EXTI_Line2);
76.          keylog2 = 0;
77.     }
78. }

Wszystkie części kodu zostaną udostępnione na dysku onet, dostępne z zakładki STM32 na blogu.

Co do częstotliwości i parametrów sygnałów. To sinus działa bardzo dobrze przy częstotliwości 100 kHz, Natomiast sygnał prostokątny przy 50kHz, z wypełnieniem równym 50%.

Należy pamiętać, że sygnały generowane są w przedziale od 0 do 4095, wobec tego punkt "zerowy" dla sygnałów znajdzie się w połowie tego zakresu. Powoduje to, że dla sygnału brak jest części ujemnej. Aby były generowane wartości ujemne należałoby podłączyć kondensator w szeregowo z wyjściem sygnału.