FAST PWM - Sposób na DAC

Autor: drzasiek
Redakcja: dondu


Drzaśkowy pamiętnik: Spis treści

Mikrokontroler Atmega 8 oferuje dwie sprzętowe możliwości pomiaru wielkości analogowych bez dołączania specjalizowanych układów zewnętrznych. Tymi sposobami są:

• pomiar napięcia wbudowanym  ADC  (przetwornikiem analogowo-cyfrowym)
• pomiar i/lub porównywanie napięcia wbudowanym komparatorem analogowym

Jednak systemy które budujemy nie tylko „obserwują” i liczą ale również w zależności od założeń czasami muszą czymś sterować. Jeśli mają sterować urządzeniami posiadającymi interfejs do komunikacji cyfrowej to nie ma problemu, ale czasem trzeba sterować bezpośrednio prądem, napięciem lub mocą oddawaną do odbiornika.

Mikrokontroler jednak jako urządzenie cyfrowe bezpośrednio na swoich wyprowadzeniach cyfrowych może ustalać stan wysoki (czyli zbliżony do napięcia zasilania) lub stan niski (czyli zbliżony do masy zasilania) czy też stan wysokiej impedancji.

Tak wiec wyprowadzenia cyfrowe bezpośrednio nie mogą sterować napięciem lub prądem. Bardziej rozbudowane mikrokontrolery posiadają jeszcze jedno lub kilka wyjść analogowych dzięki wbudowanemu przetwornikowi cyfrowo analogowemu tzw. DAC (Digital to analog converter).

Mikrokontrolery takie jak Atmega nie posiadają jednak DAC . Co więc w takiej sytuacji uczynić gdy zaistnieje potrzeba regulacji prądu i/lub napięcia? Wymienić mikrokontroler na lepszy? Można, ale nie jest to konieczne.

Większość mikrokontrolerów posiada możliwość konfiguracji przynajmniej jednego Timera do pracy w trybie PWM.

Czym jest więc PWM?
PWM to skrót od Pulse Width Modulation – czyli jest to modulacja szerokości impulsu. Innymi słowy to powtarzający się ciąg impulsów o takiej samej bądź różnej szerokości.

Jednym z parametrów takiego ciągu impulsów jest Duty Cycle czyli współczynnik wypełnienia sygnału. Jest to stosunek czasu trwania impulsu do czasu trwania okresu sygnału okresowego.

Współczynnik wypełnienia oblicza się następująco:

Czyli np. jeśli czas impulsu trwa 60ms, a okres trwa 100ms, to współczynnik wypełnienia wynosi:

Ale co to ma wspólnego z regulacją prądu lub napięcia?

Otóż w czasie trwania impulsu 5V prąd płynie z/do odbiornika, natomiast w czasie gdy napięcie jest równe 0V prąd nie płynie. Zatem średnia wartość prądu jest równa prądowi maksymalnemu pomnożonemu przez współczynnik wypełnienia.

Dla przykładu załóżmy, że podłączyliśmy diodę LED przez szeregowo dołączony rezystor do wyjścia cyfrowego mikrokontrolera zasilanego napięciem 5V. Rezystor dobrany jest tak (możesz wykorzystać kalkulator LED), by przez diodę płyną prąd 10 mA. Jeśli teraz na wyjście uC ustawimy stan wysoki czyli 5V, to dioda będzie świecić i popłynie prąd 10mA.

A co się stanie jeśli na to wyjście nie podamy stanu wysokiego ale wygenerujemy sprzętowo sygnał prostokątny o wypełnieniu 50%? Średni prąd płynący przez diodę będzie równy 5mA, a więc dioda będzie świecić słabiej.

Czas więc teraz wypróbować, to w praktyce przy użyciu mikrokontrolera Atmega 8.

Zatem przeglądnąć trzeba dokumentację Atmega8. Posiada ona dwa timery, które mogą pracować w trybie PWM. Jest to 16 bitowy Timer/Counter 1

oraz 8 bitowy Timer/Counter2:

Nawet taki prosty mikrokontroler jak Atmega8 dysponuje kilkoma trybami pracy PWM. Ja zastosowałem jednak ten najczęściej stosowany w amatorskich konstrukcjach, czyli tryb Fast PWM dla Timera 1 (16 bit) ponieważ jest dokładniejszy (większa rozdzielczość) i posiada większe możliwości.

Timer/Counter1 posiada dwa rejestry porównania, a więc można wygenerować dwa sygnały o tej samej częstotliwości, ale o różnym współczynniku wypełnienia:

Rys. Timer1 w Atmega8 

Na powyższym schemacie zaznaczyłem dwa kanały, które podłączone są odpowiednio do pinów OC1A i OC1B.

Tryb szybki PWM (Fast PWM) posiada możliwość pracy przy największej częstotliwości oraz różni się tym od pozostałych trybów tym, że zmiana stanów następuje tylko na jednym zboczu zmiany wartości licznika.

Zasada działania jest prosta. Timer zlicza w górę impulsy zegarowe (z wybranego źródła podzielone przez  ustawiony preskaler) od początkowo zadanej wartości w rejestrze TCNT1. Jeśli wartość rejestru TCNT1 jest równa wartości w rejestrze porównania OCR1A, to wyjście OC1A zmienia stan. Tak samo dzieje się w przypadku OCR1B i OC1B.

O tym jaka to będzie zmiana decyduje programista ustawiając odpowiednie bity w rejestrze konfiguracyjnym:

Kolejna zmiana następuje przy wartości TOP(kiedy to licznik się zeruje).
Wartość TOP również zależnej od wybranego trybu pracy PWM:

Zatem spróbujmy poskładać układzik z dwiema naprzemiennie płynnie regulowanymi diodami LED.
Wykorzystałem do tego możliwość wygenerowania dwóch sygnałów z Timera2.

Ale na których nogach uC będę miał sygnały? Jak zwykle odpowiedź leży w dokumentacji:

A więc trzeba poszukać gdzie znajdują się nogi z możliwością pracy jako OC1A oraz OC1B:

Jak widać obudowa PDIP posiada te wyprowadzenia na nogach PB1 oraz PB2.

Pora więc narysować schemat:

Pobierz schemat: eagle_1.rar


Ustawienia mikrokontrolera
Atmegę ustawiłem do pracy z wewnętrznym oscylatorem 1MHz.
Timer1 skonfigurowany do pracy w trybie Fast PWM, tryb 14 z tabeli 16-5.
Timer2 – przerwanie od przepełnienie licznika tzw. overflow (zmiana współczynnika wypełnienia)

Program:

// ***********************************************************
// Atmega8 - PWM
// FCPU 1MHz
// http://www.mikrokontrolery.blogspot.com
// ***********************************************************
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h> 

#define LED1 (1<<PB1)
#define LED2 (1<<PB2)

volatile int8_t kierunek=1;

int main(void) 
{
   DDRB |= LED1 | LED2;   //Wyjścia LED
 
   //Inicjalizacja Timer1 (PWM)
   TCCR1A |= (1<<COM1A1) //Zmiana stanu wyjścia OC1A na niski przy porównaniu A
          |  (1<<COM1B1) //Zmiana stanu wyjścia OC1B na niski przy porównaniu B
          |  (1<<WGM11); //Tryb 14 (FAST PWM, TOP=ICR1)

   TCCR1B |= (1<<WGM13) | (1<<WGM12)  //Tryb 14 (FAST PWM, TOP=ICR1)
          | (1<<CS10);                //Brak preskalera

   ICR1 = 1000;  //Wartość maksymalna (dla trybu 14)
                 //a więc częstotliwość = CLK/ICR1 = 1kHz

   OCR1A=500;    //Wartość początkowa porównania A (Wyjście OC1A - PB1),
                 //wypełnenie = 50%

   OCR1B=500;    //Wartość początkowa porównania B (Wyjście OC1B - PBB), 
                 //wypełnenie = 50%

   //Inicjalizacja Timer0 (zmiana współczynnika wypełnienia) 
   TCCR0 |= (1<<CS01);    // źródłem CLK, preskaler 8
   TIMSK |= (1<<TOIE0);   //Przerwanie overflow (przepełnienie timera)  

   sei();    //Globalne uruchomienie przerwań  

   for(;;);  //Pętla nieskończona
} 

//Procedura obsługi przerwania od przepełnienia Timer0
ISR(TIMER0_OVF_vect)   
{
   //jeśli dojdzie do granicy to zmienia kierunek
   if(OCR1A==1000 || OCR1A==0) kierunek*=-1;

   OCR1A+=kierunek;   //zmienia współczynniki wypełnienia
   OCR1B-=kierunek;
}

Pobierz kod: pwmA.rar

Efekt uzyskany:

---

Dwukanałowy generator funkcyjny


Timer w trybie PWM można również wykorzystać jako prosty przetwornik cyfrowo-analogowy. Dodając na wyjścia OC1x proste pasywne filtry RC uzyskane napięcia za filtrem będą mniej więcej równe:

Takie założenie można wykorzystać do budowy prostego generatora funkcyjnego (należy jednak pamiętać o ograniczonej wydajności prądowej takiego źródła napięcia, a dla wzmocnienia prądowego można za filtrem dać wtórnik napięcia).

Pobierz schemat: eagle_2.rar

Aby przyspieszyć działanie generatora zmieniłem częstotliwość taktowania uC na 8 MHz z wewnętrznego generatora RC.

Timer1 - skonfigurowany do pracy w trybie Fast PWM, tryb 14 z tabeli 16-5.
Timer2 - przerwanie overflow (przepisywanie buforów do rejestrów OCR1A oraz OCR1B)

Generator na wyjściu OUTA generuje sygnał sinusoidalny, a na wyjściu OUTB sygnał piłokształtny.

Program:

// ***********************************************************
// Atmega8 - Generator Funkcyjny na PWM
// www.mikrokontrolery.blogspot.com
// FCPU _ 8MHz
// ***********************************************************
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h> 
#include <math.h> 

#define OUT1 (1<<PB1)
#define OUT2 (1<<PB2)

volatile uint8_t bufor_sinus[256];//bufor na wartości funkcji sinus
volatile uint8_t bufor_pila[256];//bufor na wartości funkcji piła
volatile uint8_t indeks = 0;  //indeks bufora do odczytu w przerwaniu

int main(void) 
{
   DDRB |= OUT1 | OUT2;//Wyjścia Generatora
 
   //Inicjalizacja Timer1 (PWM)
   TCCR1A |= (1<<COM1A1) //Zmiana stanu wyjścia OC1A na niski przy porównaniu A
          |  (1<<COM1B1) //Zmiana stanu wyjścia OC1B na niski przy porównaniu B
          |  (1<<WGM11); //Tryb 14 (FAST PWM, TOP=ICR1)

   TCCR1B |= (1<<WGM13) | (1<<WGM12)  //Tryb 14 (FAST PWM, TOP=ICR1)
          |  (1<<CS10);  //Brak preskalera

   ICR1 = 255; //Wartość maksymalna (dla trybu 14) 
               //a więc częstotliwość = CLK/ICR1=8kHz

   OCR1A=127;  //Wartość porównania A (Wyjście OC1A - PB1), wypełnenie = 33%
   OCR1B=127;  //Wartość porównania B (Wyjście OC1B - PBB), wypełnenie = 66%

   //Inicjalizacja Timer0 (zmiana współczynnika wypełnienia) 
   TCCR0 |= (1<<CS00);  // źródłem CLK, brak preskalera
   TIMSK |= (1<<TOIE0);    //Przerwanie overflow (przepełnienie timera)  

   //Tworzy bufor funkcji Sinus
   for(unsigned short x=0; x<256; x++) bufor_sinus[x]=128+126*sin(6.26/256*x);

   //Tworzy bufor funkcji piła
   for(unsigned short x=0; x<256; x++) bufor_pila[x]=x;

   sei(); //Globalne uruchomienie przerwań  

   for(;;); //Pętla nieskończona
} 

//Procedura obsługi przerwania od przepełnienia Timera0
ISR(TIMER0_OVF_vect)   
{
   OCR1A=bufor_sinus[indeks]; //przepisuje do rejestru porównia wartość funkcji
   OCR1B=bufor_pila[indeks];  //przepisuje do rejestru porównia wartość funkcji

   if(indeks<255)//inkrementuje indeks bufora 
      indeks++;
   else//jeśli koniec bufora to powrót na początek
      indeks=0;
} 

Pobierz kod: pwmB.rar

Otrzymany efekt na oscyloskopie:

Dlaczego przebieg piły nie jest idealny?
Ponieważ przebiegiem podstawowym jest sinus, a inne przebiegi, np. piła składa się z sinusa o tej samej częstotliwości oraz z szeregu harmonicznych sinusa.

Poniżej widmo piły:

Aby wygładzić przebieg z PWM przepuszcza się go przez filtr dolnoprzepustowy, który wycina wyższe harmoniczne. Zatem wycina on też wyższe harmoniczne przebiegu piły a co za tym idzie przebieg "ma ochotę" coraz bardziej upodobnić się do sinusa. Jeśli filtr będzie miał za małe pasmo, to wytnie praktycznie wszystkie harmoniczne i zostanie w widmie sam prążek sinusa:

(na rysunku linią czerwoną zaznaczyłem przykładową-dość optymistyczną-charakterystykę przejściową filtra) zatem w sygnale zostaje praktycznie sama składowa częstotliwości podstawowej a więc z sygnału zrobi się sygnał bardzo zbliżony do sinusa (a teoretycznie po wycięciu wszystkich wyższych składowych powstanie sinus).

---

Przykłady wykorzystania

Jednym z przykładów wykorzystania PWM i filtru RC jako przetwornika DAC jest generowanie dźwięku wraz z obwiednią ADSR. Przykładowe programy znajdziesz w temacie: Generowanie obwiedni ADSR za pomocą mikrokontrolera