Kurs XMEGA: uklad PLL (10)

|

Kurs XMEGA
Znamy już generatory RC oraz kwarcowe, opisane w poprzednich odcinkach kursu mikrokontrolerów XMEGA. Niniejsza część, podobnie jak wszystkie pozostałe o sygnałach zegarowych, będzie wykorzystywać ten sam schemat i te same pliki źródłowe. Układ demonstracyjny wykorzystuje moduł prototypowy X3-DIL64 z Leon Instruments.


Pliki do pobrania:

Układ PLL


PLL, czyli pętla synchronizacji fazy, jest przeciwieństwem preskalera i służy do zwiększania częstotliwości sygnału. Układy PLL dotychczas stosowane były w mikrokontrolerach z wyższej półki oraz w FPGA, ale w XMEGA to rozwiązanie dostępne jest we wszystkich modelach, nawet w tych najtańszych za kilka złotych!

Mamy możliwość pomnożenia częstotliwości wybranego generatora do 31 razy. Do wyboru mamy następujące generatory:
  • wbudowany RC 2 MHz
  • wbudowany RC 32 MHz, ale wstępnie podzielony przez 4, czyli 8 MHz
  • kwarcowy 0.4-16 MHz
  • zewnętrzny sygnał zegarowy

Układ PLL nie może współpracować z generatorami 32 kHz.

Zwróć uwagę, że niewłaściwie konfigurując układ PLL można mocno przetaktować mikrokontroler, co może prowadzić do jego niestabilnej pracy. Pamiętaj, że rdzeń procesora może pracować z sygnałem takującym o częstotliwości 32 MHz. Częstotliwość na wyjściu układu PLL nie powinna być niższa niż 10 MHz, ani wyższa niż 200MHz. W razie potrzeby możesz wykorzystać preskalery (widoczne na rysunku 1 w 7 części kursu (link do 7 części)), by zmniejszyć częstotliwość zegara.


Napiszemy program, który pozwala zmienić konfigurację układu PLL podczas pracy procesora. Wciskając przycisk podłączony do pinu F4 na płytce X3-DIL64 z Leon Instruments, będziemy zwiększać mnożnik PLL o 1 aż do 31, a po kolejnym wciśnięciu mnożnik ustawi się na 1, by móc go znów zwiększać. Jako źródło sygnału wykorzystany generator 2 MHz, a częstotliwości uzyskane dzięki PLL będą sięgać nawet 62 MHz, co daleko przekracza dopuszczalny limit! Zmiany sygnału zegarowego będziemy obserwować dzięki mrugającej diodzie, a dodatkową informacją będzie wyświetlenie częstotliwości na wyświetlaczu LCD.

Prześledźmy, co dzieje się w funkcji OscPLL. Pierwszym krokiem jest uruchomienie generatora, który będzie źródłem sygnału dla PLL i ustawienie go jako źródła. Trzeba w tym momencie wyraźnie zaznaczyć, że nie można zmieniać konfiguracji układu PLL podczas, gdy jest on uruchomiony, a tym bardziej kiedy jest źródłem sygnału zegarowego.
 
void OscPLL(uint8_t pllfactor) {
    
    // uruchomienie generatora 2MHz i ustawienie go jako źródła zegara
    OSC.CTRL           =    OSC_RC2MEN_bm;            // włączenie oscylatora 2MHz
    while(!(OSC.STATUS & OSC_RC2MRDY_bm));            // czekanie na ustabilizowanie się generatora
    CPU_CCP            =    CCP_IOREG_gc;             // odblokowanie zmiany źródła zegarowego
    CLK.CTRL           =    CLK_SCLKSEL_RC2M_gc;      // zmiana źródła sygnału zegarowego na RC 2MHz
 
Następnie, możemy przystąpić do konfiguracji układu PLL. Jednak jeśli jest on już włączony, to koniecznie musimy go najpierw wyłączyć. W przeciwnym razie próba zmiany konfiguracji będzie nieskuteczna. Kluczowy w tym fragmencie jest rejestr OSC.PLLCTRL, którego opis przedstawiono na rysunku 2. Ustawić w nim musimy źródło sygnału, współczynnik mnożący (zmienna pllfactor jest argumentem funkcji OscPLL), a opcjonalnie możemy częstotliwość sygnału wyjściowego podzielić przez dwa.
 
    // wyłączenie PLL
    OSC.CTRL          &=   ~OSC_PLLEN_bm;
            
    // konfiguracja PLL
    OSC.PLLCTRL        =    OSC_PLLSRC_RC2M_gc |      // wybór RC 2MHz jako źródło sygnału dla PLL
                            pllfactor;                // mnożnik częstotliwości (od 1 do 31)
                        
    // uruchomienie PLL
    OSC.CTRL           =    OSC_PLLEN_bm;             // włączenie układu PLL


Podobnie jak w przypadku innych generatorów, poczekać musimy aż sygnał zegarowy się ustabilizuje, poprzez sprawdzanie czy już został ustawiony odpowiedni bit w rejestrze statusowym. Dopiero wtedy możemy przełączyć źródło sygnału taktującego mikrokontroler.
 
    // czekanie na ustabilizowanie się generatora            
    while(!(OSC.STATUS & OSC_PLLRDY_bm));

    CPU_CCP            =    CCP_IOREG_gc;             // odblokowanie zmiany źródła sygnału
    CLK.CTRL           =    CLK_SCLKSEL_PLL_gc;       // wybór źródła sygnału zegarowego PLL
 
Układ PLL może stracić synchronizację fazy, jeśli sygnał zegarowy będzie zbyt wolny, zbyt szybki lub z jakiegoś powodu będzie niestabilny. Na szczęście mikrokontrolery XMEGA mają możliwość monitorowania układu PLL, podobnie jak w przypadku generatora kwarcowego. W razie stwierdzenia nieprawidłowości, automatycznie uruchomi się wbudowany generator 2 MHz oraz zostanie wygenerowane przerwanie OSC_OSCF_vect.
 
    // układ nadzorujący PLL
    CPU_CCP            =    CCP_IOREG_gc;             // odblokowanie modyfikacji ważnych rejestrów 
    OSC.XOSCFAIL       =    OSC_PLLFDEN_bm;           // włączenie układu detekcji błędu
 
Podczas niniejszych ćwiczeń przetaktowaliśmy rdzeń procesora prawie dwukrotnie. Zgodnie z danymi firmy Atmel, układ powinien być taktowany w zakresie od 10 MHz (minimalna częstotliwość wyjściowa PLL) do 32 MHz (maksymalna częstotliwość rdzenia). Ciekawy jestem, czy czytelnicy zauważyli jakieś nieprawidłowości w działaniu mikrokontrolera poza tym zakresem. W moim przypadku wszystko działało bez zarzutu. Mimo to, w normalnych zastosowaniach nigdy nie należy przekraczać dopuszczalnych zakresów podanych przez producenta układu!

Oto kod całego programu, demonstrującego możliwości układu generowania i dystrybucji sygnałów zegarowych, który tworzyliśmy od 7 części kursu do części 10.
 
#define F_CPU 62000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "hd44780.h"

void Osc2MHz(void) {
    OSC.CTRL          =    OSC_RC2MEN_bm;               // włączenie oscylatora 2MHz
    while(!(OSC.STATUS & OSC_RC2MRDY_bm));              // czekanie na ustabilizowanie się generatora
    CPU_CCP           =    CCP_IOREG_gc;                // odblokowanie zmiany źródła sygnału 
    CLK.CTRL          =    CLK_SCLKSEL_RC2M_gc;         // zmiana źródła sygnału zegarowego na RC 2MHz
    LcdClear();                                         // czyszczenie wyświetlacza
    Lcd("RC 2MHz");                                     // komunikat o uruchomieniu generatora
}

void Osc32MHz(void) {
    OSC.CTRL          =    OSC_RC32MEN_bm;              // włączenie oscylatora 32MHz
    while(!(OSC.STATUS & OSC_RC32MRDY_bm));             // czekanie na ustabilizowanie się generatora
    CPU_CCP           =    CCP_IOREG_gc;                // odblokowanie zmiany źródła sygnału 
    CLK.CTRL          =    CLK_SCLKSEL_RC32M_gc;        // zmiana źródła sygnału zegarowego na RC 32MHz
    LcdClear();                                         // czyszczenie wyświetlacza
    Lcd("RC 32MHz");                                    // komunikat o uruchomieniu generatora
}

void OscXtal(void) {
        
    // konfiguracja generatora kwarcowego        
    OSC.XOSCCTRL      =    OSC_FRQRANGE_12TO16_gc |     // wybór kwarcu od 12 do 16 MHZ
                           OSC_XOSCSEL_XTAL_16KCLK_gc;  // czas na uruchomienie generatora
    OSC.CTRL          =    OSC_XOSCEN_bm;               // uruchomienie generatora kwarcowego
    
    // czekanie na ustabilizowanie się generatora
    for(uint8_t i=0; i<255; i++) {                        
        if(OSC.STATUS & OSC_XOSCRDY_bm) {
            CPU_CCP        =    CCP_IOREG_gc;           // odblokowanie zmiany źródła sygnału 
            CLK.CTRL       =    CLK_SCLKSEL_XOSC_gc;    // wybór źródła sygnału na XTAL 16MHz
            LcdClear();                                 // czyszczenie wyświetlacza
            Lcd("XTAL");                                // komunikat o uruchomieniu generatora
            
            // układ nadzorujący kwarc
            CPU_CCP        =    CCP_IOREG_gc;           // odblokowanie modyfikacji ważnych rejestrów 
            OSC.XOSCFAIL   =    OSC_XOSCFDEN_bm;        // włączenie układu detekcji błędu sygnału 
            return;                                     // wyjście z funkcji gdy generator działa
        }
        _delay_us(10);
    }     
    
    // komunikat w przypadku braku uruchomienia generatora kwarcowego
    LcdClear();
    Lcd("Brak XTAL");
}

void OscPLL(uint8_t pllfactor) {
    
    // uruchomienie generatora 2MHz i ustawienie go jako źródła zegara
    OSC.CTRL          =    OSC_RC2MEN_bm;               // włączenie oscylatora 2MHz
    while(!(OSC.STATUS & OSC_RC2MRDY_bm));              // czekanie na ustabilizowanie się generatora
    CPU_CCP           =    CCP_IOREG_gc;                // odblokowanie zmiany źródła sygnału 
    CLK.CTRL          =    CLK_SCLKSEL_RC2M_gc;         // zmiana źródła sygnału zegarowego na RC 2MHz
    
    // wyłączenie PLL
    OSC.CTRL         &=   ~OSC_PLLEN_bm;
            
    // konfiguracja PLL
    OSC.PLLCTRL       =    OSC_PLLSRC_RC2M_gc |         // wybór RC 2MHz jako źródło sygnału dla PLL
                           pllfactor;                   // mnożnik częstotliwości (od 1 do 31)
                        
    // uruchomienie PLL
    OSC.CTRL          =    OSC_PLLEN_bm;                // włączenie układu PLL
    
    // czekanie na ustabilizowanie się generatora            
    while(!(OSC.STATUS & OSC_PLLRDY_bm));

    // przełączenie źródła sygnału zegarowego
    CPU_CCP           =    CCP_IOREG_gc;                // odblokowanie zmiany źródła sygnału 
    CLK.CTRL          =    CLK_SCLKSEL_PLL_gc;          // wybór źródła sygnału zegarowego PLL
            
    // układ nadzorujący PLL
    CPU_CCP           =    CCP_IOREG_gc;                // odblokowanie modyfikacji ważnych rejestrów 
    OSC.XOSCFAIL      =    OSC_PLLFDEN_bm;              // włączenie układu detekcji błędu sygnału
    
    // wyświetlenie komunikatu
    LcdClear();
    Lcd("PLL ");
    LcdDec(pllfactor*2);                                // *2 bo generator RC ma 2MHz
    Lcd("MHz");
}

int main(void) {
    
    // zmienna
    uint8_t pll = 4;
    
    // diody
    PORTE.DIR         =    PIN0_bm;                     // dioda LED
                    
    // przyciski
    PORTA.DIRCLR      =    PIN0_bm;                     // przycisk - RC 2MHz
    PORTA.PIN0CTRL    =    PORT_OPC_PULLUP_gc;          // podciągnięcie do zasilania
    PORTE.DIRCLR      =    PIN5_bm;                     // przycisk FLIP - RC 32MHz
    PORTE.PIN5CTRL    =    PORT_OPC_PULLUP_gc;          // podciągnięcie do zasilania
    PORTE.DIRCLR      =    PIN6_bm;                     // przycisk - XTAL
    PORTE.PIN6CTRL    =    PORT_OPC_PULLUP_gc;          // podciągnięcie do zasilania
    PORTF.DIRCLR      =    PIN4_bm;                     // przycisk - PLL
    PORTF.PIN4CTRL    =    PORT_OPC_PULLUP_gc;          // podciągnięcie do zasilania
    
    // wyświetlacz LCD
    LcdInit();
    
    // komunikat o źródłe sygnału zegarowego
    LcdClear();
    Lcd("RC 2MHz");
    
    // włączenie przerwań
    sei();
    
    while(1) {
        PORTE.OUTTGL  =    PIN0_bm;
        _delay_ms(50);
        
        if(!(PORTA.IN & PIN0_bm)) Osc2MHz();
        if(!(PORTE.IN & PIN5_bm)) Osc32MHz();
        if(!(PORTE.IN & PIN6_bm)) OscXtal();
        if(!(PORTF.IN & PIN4_bm)) {    
            pll++;                                      // zwiększ zmienną pll
            if(pll > 31) pll = 1;                       // jeśli pll większe od 31 to ustaw na 1
            OscPLL(pll);                                // funkcja konfigurująca PLL
        }
    }
}

ISR(OSC_OSCF_vect) {                                    // przerwanie w razie awarii oscylatora
    OSC.XOSCFAIL     |=    OSC_XOSCFDIF_bm;             // kasowanie flagi przerwania
    LcdClear();
    Lcd("Awaria!");    
}
 
Temat generatorów sygnału zegarowego w mikrokontrolerach XMEGA zajął aż cztery odcinki, to jednak nie wyczerpują one tematu. Oprócz tego mamy do dyspozycji jeszcze:
  • układ synchronizujący DFLL
  • zegar czasu rzeczywistego RTC
  • generatory energooszczędne
  • generator sygnału zegarowego do USB
  • kalibrację generatorów

Te możliwości zostały opisane w książce Tomasza Francuza AVR. Praktyczne projekty którą szczerze polecam.
Kurs XMEGA:Moduły prototypowe:

13 komentarze :

ursmar pisze...

W jakim programie powstał schemat?

Dominik Leon Bieczyński pisze...

W Excelu :)

ursmar pisze...

No te bloczki kolorowe tak mi właśnie znajomo wyglądały ;)

Dominik Leon Bieczyński pisze...

Rysunku do tych artykułów też powstawały w Excelu :)
http://www.leon-instruments.pl/2013/03/verilog-pwm-z-korekcja-fazy.html
http://leon-instruments.blogspot.com/2013/09/wzmacniacze-operacyjne.html

Cegła pisze...

Ciekawostka:
W xmega64A3 w dokumentacji także jest wektor przerwania "OSCF_INT_vect" jednakże w pliku rejestrów iox64a3.h jest "OSC_XOSCF_vect" jako ten właśnie wektor 1.
Tak jak by ktoś szukał :)

doman pisze...

Dlaczego ostatni zdefiniowany plik naglowkowy .h jest w "" a nie <> ?

doman pisze...

Dlaczego ostatni .h jest w "" a nie <> ?

Dominik Leon Bieczyński pisze...

Bo to jest biblioteka lokalna a nie globalna

Łukasz Jeleń pisze...

Witam.
Mam problem ze skonfigurowaniem PLL. Wywołanie funkcji:
http://pastebin.com/cn0e92dG
kręci moją ATXmega16D4-AU do 40 MHz zamiast 32MHz (sprawdzałem na timerze i używając delay, oba sposoby wykazując 40MHz).
Gdy jako sygnał zegarowy ustawię rezonator kwarcowy dostaję ładne 16MHz, czyli coś źle robię z PLL.
PLL taktowany z 16MHz rezonatora, mnoży zegagar x8, później preskalery B i C dzielą zegar każdy przez dwa, co powinno dać 32MHz
Mógłby mi Pan powiedzieć co jest nie tak?
Dziękuję.

Dominik Leon Bieczyński pisze...

W jaki sposób dokładniej mierzysz częstotliwość zegara?

Łukasz Jeleń pisze...

Wiem, że linkowanie do obcego forum nie jest ładne, ale proszę najwyżej tego nie dodawać do komentarzy.
http://forum.atnel.pl/topic10829.html
Wie może pan dlaczego |= nie jest równoznaczne z =, jeżeli wg. noty initial value rejestru OSC_PLLCTRL to 0? Proszę o maila. deerjelen@gmail.com. Ew mógłbym podesłać disassembly obu funkcji.

Dominik Leon Bieczyński pisze...

Trudno powiedzieć. Najprawdopodobniej coś już było wpisane do OSC_PLLCTRL i użycie operatora |= nadpisało nową wartość na starą i w ten sposób możliwe, że PLL dostawał nie ten sygnał co trzeba. Zdecydowanie odradzam stosowanie operatorów |= oraz &= wszędzie jak leci, bo można się na tym nieźle przejechać. Tylko operator = daje pewność, że odpowiednie bity zostaną ustawione lub wyzerowane (a poza tym = działa szybciej i zajmuje mniej pamięci niż |=)

Rafał pisze...

Witam. W książce "AVR Praktyczne projekty" i w tym artykule pisze Pan, że do poprawnej pracy PLL, czętotliwość wyjściowa zegara musi wynosić co najmniej 10 MHz. Mógłby Pan podać źródło tej informacji bo szukałem w nocie PDF mojego procesora (ATXmega128A1U" oraz w dokumentacji AVR:1003 i nie udało mi sie na to trafić. Rozumiem przez to, że dla wewnętrznego oscylatora RC 2 MHz i PLL = 4 nie uda się uzyskać 8 MHz bo coś będzie się "krzaczyć"?
Pozdrawiam

Prześlij komentarz

Skomentuj!

Sklep Leon Instruments