wtorek, 29 marca 2016

[10a] STM32F4 - Discovery - DAC, generacja sygnałów

W tym poście chciałbym przedstawić sposób generacji sygnałów za pomocą DAC oraz DMA.

Za pomocą konwertera cyfrowo analogowego można wygenerować sygnał prostokątny, piłokształtny trójkątny oraz sinusoidalny.

Sposób działania


Poniżej przedstawiam schemat blokowy pojedynczego konwertera cyfrowo analogowego. Dla przypomnienia w STM32 znajdują się dwa takie układy.

Rys. 1. Schemat DAC



VDDA - jest to napięcie wejściowe, zasilanie analogowe części układu
VSSA - wejściowe, uziemienie części analogowej
VREF+ - napięcie referencyjne dodatnie z zakresi od 1,8V do VDDA

Przed konfiguracją należy ustawić piny wyjściowe jako analogowe. Spowodowane jest to tym, że DAC po odpowiedniej konfiguracji generuje sygnał na wybranym pinie.

Sama konwersja odbywa się w części znajdującej się na samym dole rysunku. Działa ona we współpracy z liniami zasilającymi oraz referencyjnymi mikrokontrolera. Dane wyjściowe dostępne są na pinie oznaczonym jako DAC_OUTx. Natomiast dane wejściowe podawana są do 32-bitowego rejestru przechowującego DHR. Z niego przesyłane są do rejestru DOR gdzie zostają bezpośrednio zamienione na wartości analogowe. Dostęp uzyskuje się do 12 bitów DAC_DHR12R1, DAC_DHR12R2 odpowiednio dla DAC1 oraz dla DAC2.

Dane nie mogą być bezpośrednio przesłane do DOR z pominięciem DHR. 

Transfer danych pomiędzy DHR a DOR może przebiegać automatycznie lub poprzez użycie wyzwalania programowego SWTRIGx, sprzętowego TIMx_TRGO bądź z przerwania EXTI_9. Wybór definiowany jest przez rejestr TSELx[2:0]. 

Dodatkowe układy sprzętowe są umieszczone w jednostce kontrolnej, takie jak generator szumu lub sygnału trójkątnego. Informacje o ich użyciu są dodawane do rejestru DHR. 

Bity rozmieszczone pomiędzy rejestrami kontrolnym, sygnału programowego oraz statusu definiują sposoby działania DAC.

Istnieje też możliwość transferu danych za pomocą DMA.

Programowanie


W związku z tym, że przetwornik jest 12 bitowy, dobrze jest sygnał sinusoidany generować w zakresie od 0 do 4095, ze środkiem znajdującym się pomiędzy tymi wartościami. Aby tego dokonać należy stworzyć tablice z zdefiniowanymi próbkami sygnałów. 

  1. //Przebieg sinusoidalny 32 próbki
  2. uint32_t Sinus[32] =
  3. {
  4.     2047, 2447, 2831, 3185, 3498, 3750, 3939, 4056,
  5.     4095, 4056, 3939, 3750, 3495, 3185, 2831, 2447,
  6.     2047, 1647, 1263, 909, 599, 344, 155, 38,
  7.     0, 38, 155, 344, 599, 909, 1263, 1647
  8. };
  10. //Przebieg sinusoidalny 128 próbek
  11. const uint32_t Sinus2[128] =
  12. {
  13.      2048, 2145, 2242, 2339, 2435, 2530, 2624, 2717, 2808, 2897,
  14.    2984, 3069, 3151, 3230, 3307, 3381, 3451, 3518, 3581, 3640,
  15.    3696, 3748, 3795, 3838, 3877, 3911, 3941, 3966, 3986, 4002,
  16.    4013, 4019, 4020, 4016, 4008, 3995, 3977, 3954, 3926, 3894,
  17.    3858, 3817, 3772, 3722, 3669, 3611, 3550, 3485, 3416, 3344,
  18.    3269, 3191, 3110, 3027, 2941, 2853, 2763, 2671, 2578, 2483,
  19.    2387, 2291, 2194, 2096, 1999, 1901, 1804, 1708, 1612, 1517,
  20.    1424, 1332, 1242, 1154, 1068, 985, 904, 826, 751, 679,
  21.    610, 545, 484, 426, 373, 323, 278, 237, 201, 169,
  22.    141, 118, 100, 87, 79, 75, 76, 82, 93, 109,
  23.    129, 154, 184, 218, 257, 300, 347, 399, 455, 514,
  24.    577, 644, 714, 788, 865, 944, 1026, 1111, 1198, 1287,
  25.    1378, 1471, 1565, 1660, 1756, 1853, 1950, 2047
  26. };  
  28. //Przebieg trojkatny
  29. uint32_t Triangle[32] =
  30. {
  31.     0, 256, 512, 768, 1024, 1279, 1535, 1791,
  32.     2047, 2303, 2559, 2815, 3071, 3326, 3582, 3838,
  33.     4095, 3838, 3582, 3326, 3071, 2815, 2559, 2303,
  34.     2047, 1791, 1535, 1279, 1024, 768, 512, 256
  35. };
  37. //Przebieg piloksztaltny
  38. uint32_t Sawtooth[32] =
  39. {
  40.     0, 132, 264, 396, 528, 660, 792, 924,
  41.     1057, 1189, 1321, 1453, 1585, 1717, 1849, 1981,
  42.     2113, 2245, 2377, 2509, 2641, 2773, 2905, 3037,
  43.     3170, 3302, 3434, 3566, 3698, 3830, 3962, 4095
  44. };
  46. //Przebieg prostokatny
  47. uint16_t Square[2] =
  48. {
  49.     0, 4095
  50. };

Kolejnym elementem jest odpowiednie odpowiednie włączenie DAC-a, timera oraz DMA. Jeśli chodzi o liczniki, to do dyspozycji są TIM2, TIM3, TIM4, TIM6, TIM7, TIM15. Dodatkowo wyzwalanie może nastąpić programowo bądź z przerwania EXTI_9. 

Rys. 1. Sposoby wyzwalania DAC

Poniżej przedstawiam funkcje inicjujące pracę poszczególnych układów.

Kolejnym elementem jest konfiguracja timera:

  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.   TimerInitStructure.TIM_Period        = (uint16_t)(TIM_APB_DAC1/Num_Samp_DAC1)*Signal_Freq_DAC1;          
  13.   TimerInitStructure.TIM_Prescaler     = 0;      
  14.   TimerInitStructure.TIM_ClockDivision = 0;
  15.   //Zliczanie w gore
  16.   TimerInitStructure.TIM_CounterMode   = TIM_CounterMode_Up;  
  17.   TIM_TimeBaseInit(Tim_Number1, &TimerInitStructure);
  18.   TIM_SelectOutputTrigger(Tim_Number1, TIM_TRGOSource_Update);
  20.   TIM_Cmd(Tim_Number1, ENABLE);
  21. }
  23. //Deklaracja timera dla DAC2 PA5
  24. static void TIMConfig_DAC2(void)
  25. {
  26.   TIM_TimeBaseInitTypeDef TimerInitStructure;
  27.    
  28.   //Wlaczenie zegara dla wybranego timera
  29.   RCC_APB1PeriphClockCmd(Timer_Clock2, ENABLE);
  31.   TIM_TimeBaseStructInit(&TimerInitStructure);
  32.   //Ustawienie okresu jako:
  33.   //zegar (APB1 Tim6/ilosc probek)*czestotliwosc sygnalu
  34.  TimerInitStructure.TIM_Period    = (uint16_t)(TIM_APB_DAC2/Num_Samp_DAC2)*Signal_Freq_DAC2;          
  35.   TimerInitStructure.TIM_Prescaler     = 0;      
  36.   TimerInitStructure.TIM_ClockDivision = 0;
  37.   //Zliczanie w gore
  38.   TimerInitStructure.TIM_CounterMode   = TIM_CounterMode_Up;  
  39.   TIM_TimeBaseInit(Tim_Number2, &TimerInitStructure);
  40.   TIM_SelectOutputTrigger(Tim_Number2, TIM_TRGOSource_Update);
  42.   TIM_Cmd(Tim_Number2, ENABLE);
  43. }

Do deklaracji DMA trzeba znać deklarację odpowiednich rejestrów dla DAC, które przechowują dane. Ich deklaracje są następujące:

  1.   DAC->CR       = 0x00010001 // Control Register
  2.   DAC->SWTRIGR               // SoftWare TRIGger Register
  3.   DAC->DHR12R1               // Data Holding Register, 12bit, Right aligned, ch1
  4.   DAC->DHR12L1               // Data Holding Register, 12bit, Left aligned, ch1
  5.   DAC->DHR8R1                // Data Holding Register,  8bit, Right aligned, ch1
  6.   DAC->DHR12R2               // Data Holding Register, 12bit, Right aligned, ch2
  7.   DAC->DHR12L2               // Data Holding Register, 12bit, Left aligned, ch2
  8.   DAC->DHR8R2                // Data Holding Register,  8bit, Right aligned, ch2
  9.   DAC->DHR12RD               // Data Holding Register, 12bit, Right aligned, Dual
  10.   DAC->DHR12LD               // Data Holding Register, 12bit, Left aligned, Dual
  11.   DAC->DHR8RD                // Data Holding Register,  8bit, Right aligned, Dual
  12.   DAC->DOR1                  // Data Output Register, ch1, read only
  13.   DAC->DOR2                  // Data Output Register, ch2, read only
  14.   DAC->SR                    // Status Register

Pozwala to na odwołania do rejestru kontrolnego, przechowującego dane, wyjściowego bądź rejestru przechowującego status pracy konwertera.

Następnym elementem w kolejce jest odpowiednie ustawienie portów GPIO, DAC 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.     //Jaki sygnal bedzie generowany
  42.     DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Signal_DAC1;
  43.     //Jak dane beda generowane
  44.     DMAInit.DMA_DIR                = DMA_DIR_MemoryToPeripheral;
  45.     //Liczba próbek sygnaBu
  46.     DMAInit.DMA_BufferSize         = Num_Samp_DAC1;
  47.     //Wylaczony automatyczny zwiekszanie adresu
  48.     DMAInit.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;
  49.     //Wylaczony transfer z pamieci do pamieci
  50.     DMAInit.DMA_MemoryInc          = DMA_MemoryInc_Enable;
  51.     //Rozmiar przeslanych danych 16b
  52.     DMAInit.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  53.     //Rozmiar danych po stronie pamieci
  54.     DMAInit.DMA_MemoryDataSize     = DMA_MemoryDataSize_HalfWord;
  55.     //Ciagly tryb pracy
  56.     DMAInit.DMA_Mode               = DMA_Mode_Circular;
  57.     //Priprytet wysoki
  58.     DMAInit.DMA_Priority           = DMA_Priority_High;
  59.     //Tryb fifo wylaczony
  60.     DMAInit.DMA_FIFOMode           = DMA_FIFOMode_Disable;
  61.     DMAInit.DMA_FIFOThreshold      = DMA_FIFOThreshold_HalfFull;
  62.     //Pojedyncze wyzwalanie
  63.     DMAInit.DMA_MemoryBurst        = DMA_MemoryBurst_Single;
  64.     DMAInit.DMA_PeripheralBurst    = DMA_PeripheralBurst_Single;
  66.     //Wylaczenie DMA
  67.     DMA_DeInit(DMA1_Stream5);
  68.     //Inicjacja i wlaczenie DMA
  69.     DMA_Init(DMA1_Stream5, &DMAInit);
  70.     DMA_Cmd(DMA1_Stream5, ENABLE);
  71.    
  72.     //Wlaczenie DAC-a
  73.     DAC_Cmd(DAC_Channel_1, ENABLE);
  74.     DAC_DMACmd(DAC_Channel_1, ENABLE);
  75.    
  76.     //Inicjacja i wlaczenie wybranego pinu DAC
  77.     DAC_Init(DAC_Channel_1, &DACInit);
  78.        
  79.     //Wlaczenie kanalu pierwszego
  80.     //DAC->CR |= DAC_CR_EN1;
  81.     DAC_Cmd(DAC_Channel_1, ENABLE);
  82. }
  84. //Wlaczenie DAC2
  85. void DAC2Init(void)
  86. {
  87.     DAC_InitTypeDef DACInit;
  88.     GPIO_InitTypeDef GPIOInit;  
  89.     DMA_InitTypeDef DMAInit;
  91.     //Wlaczenie zegara dla portu GPIOA
  92.     //RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
  93.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  94.    
  95.     //Wlaczenie zegara dla DAC
  96.     //RCC->APB1ENR |= RCC_APB1ENR_DACEN;
  97.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
  98.    
  99.     //Wlaczenie zegara dla DMA
  100.     //RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;
  101.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
  102.    
  103.     //Pozostale ustawienia wyprowadzen GPIO
  104.     GPIOInit.GPIO_Pin = GPIO_Pin_5;
  105.     GPIOInit.GPIO_Mode = GPIO_Mode_AN;
  106.     GPIOInit.GPIO_OType = GPIO_OType_PP;
  107.     GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
  108.     GPIOInit.GPIO_Speed = GPIO_Speed_50MHz;
  109.     GPIO_Init(GPIOA, &GPIOInit);
  110.    
  111.     //Ustawienie opcji dla DAC
  112.     //Sygnal wyzwalajacy
  113.     DACInit.DAC_Trigger = DAC1_Trigger;
  114.     //Generacja sygnalu wylaczona
  115.     DACInit.DAC_WaveGeneration = DAC_WaveGeneration_None;
  116.     //Bufor wyjsciowy wlaczony
  117.     DACInit.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
  118.     DAC_Init(DAC_Channel_2, &DACInit);
  119.    
  120.     DMA_DeInit(DMA1_Stream6);
  121.     DMAInit.DMA_Channel            = DMA_Channel_7;
  122.     //Data holding register, 12 bit, right aligned ch1
  123.     DMAInit.DMA_PeripheralBaseAddr = (uint32_t)&DAC->DHR12R2;
  124.     //Jaki sygnal bedzie generowany
  125.     DMAInit.DMA_Memory0BaseAddr    = (uint32_t)Signal_DAC2;
  126.     //Jak dane beda generowane
  127.     DMAInit.DMA_DIR                = DMA_DIR_MemoryToPeripheral;
  128.     //Liczba próbek sygnaBu
  129.     DMAInit.DMA_BufferSize         = Num_Samp_DAC2;
  130.     //Wylaczony automatyczny zwiekszanie adresu
  131.     DMAInit.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;
  132.     //Wylaczony transfer z pamieci do pamieci
  133.     DMAInit.DMA_MemoryInc          = DMA_MemoryInc_Enable;
  134.     //Rozmiar przeslanych danych 16b
  135.     DMAInit.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  136.     //Rozmiar danych po stronie pamieci
  137.     DMAInit.DMA_MemoryDataSize     = DMA_MemoryDataSize_HalfWord;
  138.     //Ciagly tryb pracy
  139.     DMAInit.DMA_Mode               = DMA_Mode_Circular;
  140.     //Priprytet wysoki
  141.     DMAInit.DMA_Priority           = DMA_Priority_High;
  142.     //Tryb fifo wylaczony
  143.     DMAInit.DMA_FIFOMode           = DMA_FIFOMode_Disable;
  144.     DMAInit.DMA_FIFOThreshold      = DMA_FIFOThreshold_HalfFull;
  145.     //Pojedyncze wyzwalanie
  146.     DMAInit.DMA_MemoryBurst        = DMA_MemoryBurst_Single;
  147.     DMAInit.DMA_PeripheralBurst    = DMA_PeripheralBurst_Single;
  149.     //Wylaczenie DMA
  150.     DMA_DeInit(DMA1_Stream6);
  151.     //Inicjacja i wlaczenie DMA
  152.     DMA_Init(DMA1_Stream6, &DMAInit);
  153.     DMA_Cmd(DMA1_Stream6, ENABLE);
  154.    
  155.     //Wlaczenie DAC-a
  156.     DAC_Cmd(DAC_Channel_2, ENABLE);
  157.     DAC_DMACmd(DAC_Channel_2, ENABLE);
  158.    
  159.     //Inicjacja i wlaczenie wybranego pinu DAC
  160.     DAC_Init(DAC_Channel_2, &DACInit);
  161.        
  162.     //Wlaczenie kanalu pierwszego
  163.     //DAC->CR |= DAC_CR_EN2;
  164.     DAC_Cmd(DAC_Channel_2, ENABLE);
  165. }

Odpowiednie sygnały będą generowane w zależności od ustawienia wartości początkowej w polach define.

  1. //Timer DAC1
  2. #define Tim_Number1 TIM6
  3. #define Timer_Clock1 RCC_APB1Periph_TIM6
  4. #define TIM_APB_DAC1 42000000
  5. #define Num_Samp_DAC1 32
  6. #define Signal_Freq_DAC1 5000
  7. #define DAC1_Trigger DAC_Trigger_T6_TRGO
  8. //Definicja generowanego sygnalu:
  9. //Do wyboru Sinus, Sinus2, Triangle, Sawtooth, Square
  10. #define Signal_DAC1 Sinus
  12. //Timer DAC2
  13. #define Tim_Number2 TIM5
  14. #define Timer_Clock2 RCC_APB1Periph_TIM5
  15. #define TIM_APB_DAC2 42000000
  16. #define Num_Samp_DAC2 32
  17. #define Signal_Freq_DAC2 5000
  18. #define DAC2_Trigger DAC_Trigger_T5_TRGO
  19. //Definicja generowanego sygnalu:
  20. //Do wyboru Sinus, Sinus2, Triangle, Sawtooth, Square
  21. #define Signal_DAC2 Sinus

Główna funkcja programu polega na wywołaniu funkcji inicjujących z odpowiednimi parametrami dobranymi na samym początku programu.

Bibliografia


[1] RM0090 - Reference manual 

Autor: o
Etykiety: ,