ADC podstawy EK-TM4C123GXL

Procesor TM4C1233H6PM posiada dwa identyczne przetworniki ADC. Każdy przetwornik może pobierać próbki z 12 analogowych wejść, ma 12 bitową rozdzielczość. Maksymalne próbkowanie million samples/second Analogowe wejscia mogą byc typu "Single-ended" (jeden pin z sygnałem, odnieienie do GND) lub "differential-input" (wykorzystuje dwa piny, sygnał ujemny i dodatni względem GND). Procesor ma wbudowany czujnik temperatury który może być odczytany przez ADC.

Aby ADC działał poprawnie musi być włączony PLL ze zgodnym oscylatorem lub sam oscylator 16 MHz.
Przetwornik działa z zegarem 16MHz, jeżeli działa PLL to jego częstotliwość jest dzielona przez 25 (400/16=16).


Jeżeli będziemy korzystali z analogowych wejść procesora, należy skonfigurować piny które wykorzystamy jako AIN-analog in.

 
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);//PE3-AIN0

Następnie uruchamiamy sprzętowy ADC, do wyboru są dwa przetworniki ADC0 i ADC1.
Można ustawić szybkość próbkowania, domyślnie jest ustawione 125K samples/second. Można wybrać jeszcze 250K, 500K i 1M samples/second. Funkcja SysCtlADCSpeedGet() służy do pobierania prędkości ADC, zwraca wartość w formie 32 bitowego słowa "000000000000000000000111100000000" (dla 1M samples/s) w którym bity 8:9 ADC0 i 10:11 ADC1 reprezentują wartości speed. Ponieważ funkcja SysCtlADCSpeedSet ustawia oba rejestry (ADC 0 i ADC1) jednakowo, do odczytu wartości prętkości można wykorzystać zapis:

speed=(SysCtlADCSpeedGet()>>10); // 3=1M, 2=500K, 1=250K, 0=125K (0 is default)   

Dodatkowo istnieje opcja sprzętowego uśredniania sampli przed ich zapisem do "sequencers", w takiej opcji każdy pojedyńczy sampel w "sequencer" składa się ze średniej kilku pomiarów. Może to być 2, 4, 8 ,16, 32, 64 pomiarów przed uśrednieniem. Zabieg uśredniania zwiększa precyzję pomiaru, ale zmniejsza przepustowość (prędkość pobierania próbek należy podzielić przez liczbę uśrednianych pomiarów).

SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);  // ADC0
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_125KSPS); // speed 125
ADCHardwareOversampleConfigure(ADC0_BASE, 64); // hardware averaging

Następnie wyłączamy "Sample Sequencers", należy to uczynić przed konfiguracją. Konfigurujemy źródło wyzwolenia pomiaru, może to być program (funkcja ADCProcessorTrigger), comparator, timer, GPIO. Każdy przetwornik posiada 4 sprzętowe "Sample Sequencers" w których są przechowywane sample z pomiarów, zasada FIFO.
"Sample Sequencers" w zależności od swojego numeru może przyjąć 8 (SS0),4 (SS1 i SS2), lub 1 (SS3) sampel. Po wybraniu numeru "Sample Sequencers" należy skonfigurować każdy krok, dla SS0 będzie to osiem kroków. W każdym należy wybrać źródło pomiaru, można zaznaczyć czy ma być wywołane przerwanie, można wybrać tryb "Single-ended" lub "differential-input", można wybrać comparator. Aby zaznaczyć, że dany krok jest końcowy wpisuje się informację ADC_CTL_END. Następnie należy aktywować "Sample Sequencers".

 ADCSequenceDisable(ADC0_BASE, 3);  //sequence 3 - depth FIFO= 1
 ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); // software trigger
 //sequence 3 has one step
 ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE|ADC_CTL_END); // ch0,interrupt,end
 ADCSequenceEnable(ADC0_BASE,3);

Poniżej prosty kod programu wykorzystujący odczyt jednego pinu AIN0 ADC0. Program na podstawie wartości napięcia podawanego na pin PE3 zmienia ustawienia PWM na trzech diodach (kolor niebieski dla 0V do czerwonego dla 3,3V). ADC jest traktowane liniowo i kolory diod zmieniają się dosyć nagle gdyż ich intensywność świecenia nie jest liniowa względem wypełnienia sygnału. Do ustawiania napięcia posłużył mały potencjometr 4,7 kR, jedna końcówka do złącza GND, druga do zworki z napięciem 3,3V. Środkowe wyprowadzenie do pinu procesora, powstał dzielnik napięcia od 0V do 3,3V. Taki zakres zostanie przekształcony w liczby od 0 do 4095 (pełne 12 bit).

#include "inc/hw_types.h"

#include "inc/hw_types.h"

#include "driverlib/sysctl.h"

#include "driverlib/adc.h"

#include "driverlib/pin_map.h"

#include "driverlib/gpio.h"

#include "driverlib/timer.h"

#include "inc/hw_memmap.h"



int main(void)

{

 unsigned long ADC33[1]; // ADC buffer 0-3,3v, 0-4095

 unsigned long ledBlPWM, ledGrPWM, ledRePWM;  // led pwm TimerMatchSet value 

 unsigned long period=1024; // PWM frequency = 40000000/1024 = 3,9 kHz



 SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); // 40 MHz



 // AIN0 = PE3

 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);

 GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);



 // ADC Config

 SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);  // ADC0

 SysCtlADCSpeedSet(SYSCTL_ADCSPEED_125KSPS); // speed 125

 ADCHardwareOversampleConfigure(ADC0_BASE, 64); // hardware averaging



 ADCSequenceDisable(ADC0_BASE, 3);  //sequence 3 - depth FIFO= 1

 ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); // software trigger

 //sequence 3 has one step

 ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE|ADC_CTL_END); // ch0,interrupt,end

 ADCSequenceEnable(ADC0_BASE,3);







 // Configure PWM Pins

 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

 //Configure PF1 as T0CCP1 Timer0 PWM1 RED LED

 GPIOPinConfigure(GPIO_PF1_T0CCP1 );

 GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_1);

 //Configure PF2 as T1CCP0 Timer1 PWM0 BLUE LED

 GPIOPinConfigure(GPIO_PF2_T1CCP0 );

 GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_2);

 //Configure PF3 as T1CCP1 Timer1 PWM1 GREEN LED

 GPIOPinConfigure(GPIO_PF3_T1CCP1 );

 GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_3);





 // Enable Peripheral Timer0 and Timer1

 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0 | SYSCTL_PERIPH_TIMER1);



 // Configure Timers as PWM

 TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_B_PWM); //RED LED

 TimerConfigure(TIMER1_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PWM|TIMER_CFG_B_PWM); //BLUE and GREEN LEDS



 TimerLoadSet(TIMER0_BASE, TIMER_B, period+1); // 39 kHz

 TimerLoadSet(TIMER1_BASE, TIMER_A, period+1);

 TimerLoadSet(TIMER1_BASE, TIMER_B, period+1);







 TimerEnable(TIMER0_BASE,TIMER_B);

 TimerEnable(TIMER1_BASE,TIMER_BOTH);







 while(1){

  ADCIntClear(ADC0_BASE, 3);



  TimerMatchSet(TIMER0_BASE, TIMER_B, ledRePWM);

  TimerMatchSet(TIMER1_BASE, TIMER_A, ledBlPWM);

  TimerMatchSet(TIMER1_BASE, TIMER_B, ledGrPWM);





  ADCProcessorTrigger(ADC0_BASE, 3);





  while(!ADCIntStatus(ADC0_BASE, 3, false)){

   }



  ADCSequenceDataGet(ADC0_BASE, 3, ADC33);





  // turn off LED

  ledRePWM=1023;

  ledBlPWM=1023;

  ledGrPWM=1023;





  // PWM LED depending on the ADC

  if(ADC33[0]<1024){

   ledBlPWM=0;

   ledGrPWM=1024-ADC33[0];

  }

  else if (ADC33[0]<2048) {

   ledGrPWM=0;

   ledBlPWM=ADC33[0]-1024;

  }

  else if (ADC33[0]<3072) {

   ledGrPWM=0;

   ledRePWM=3071-ADC33[0];

  }

  else{

   ledRePWM=0;

   ledGrPWM=ADC33[0]-3072;

  }

 }

}

Zmiany wartości zmiennych podczas pracy debuggera:

Timer0 w trybie OneShot z funkcją WaitOnTrigger EK-TM4C123GXL

Działanie Timera w trybie one shot polega na jednorazowym przejściu licznika i zatrzymaniu działania. Aby odliczanie rozpoczęło się ponownie należy włączyć ponownie Timer.

W przykładzie zastosowałem dodatkowe ustawienie  Wait-for-Trigger mode Timera0_B.
Jest to opcja polegająca na starcie n+1 Timera po zakończeniu zliczania Timera n, czyli Timera wcześniejszego w procesorze. Funkcja Wait-for-Trigger w daisy chaining nie działa dla Timera 0-A lub timera0-A 32bit gdyż nie ma przed nimi wcześniejszego timera wyzwalającego.

Dodatkowo w przykładzie został ustawiony preskaler dla Timera0-A aby przy częstotliwości CPU 3,125Mhz uzyskać wywoływanie one szhot Timera0-B co 1s. W przeciwieństwie do preskalera przy PWM mode, preskaler Timera działającego w periodic mode lub one-shot mode z liczeniem w dół jest uruchomiany inaczej. Jest on mnożnikiem liczby przekazanej w TimerLoadSet().

#include "inc/hw_ints.h"

#include "inc/hw_types.h"

#include "inc/hw_memmap.h"

#include "driverlib/sysctl.h"

#include "driverlib/gpio.h"

#include "driverlib/timer.h"

#include "driverlib/pin_map.h"

#include "driverlib/interrupt.h"



int main(void) {



 //clock:

 SysCtlClockSet(SYSCTL_USE_PLL|SYSCTL_SYSDIV_64|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); // OSC MAIN and PLL DIV 64 = 3,125-MHz frequency


    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);



    // Enable Peripheral Timer0

    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);

    TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_PERIODIC|TIMER_CFG_B_ONE_SHOT);



    TimerControlWaitOnTrigger(TIMER0_BASE, TIMER_B,1); // after the Timer0 A is 0 Timer0 B is start



    TimerLoadSet(TIMER0_BASE, TIMER_B, 65535); // 6536 Tc = 0,0209s and one shot -> go to Timer0IntHandlerB

    TimerLoadSet(TIMER0_BASE, TIMER_A,31250);

    TimerPrescaleSet(TIMER0_BASE, TIMER_A, 100);  // one second period 100*31250Tc



    IntEnable(INT_TIMER0B);                         // enable interrupt Timer0 B

    TimerIntEnable(TIMER0_BASE, TIMER_TIMB_TIMEOUT);  // interrupt on TIMEOUT

    IntMasterEnable();



    TimerEnable(TIMER0_BASE, TIMER_BOTH); // enable Timer0 A and B



    while(1) {

    }

}





void Timer0IntHandlerB(void){



 TimerIntClear(TIMER0_BASE, TIMER_TIMB_TIMEOUT); // clear interrupt register

 TimerEnable(TIMER0_BASE, TIMER_B); // one shot mode must be enabled after every use



 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 8); // blink green led

 SysCtlDelay(50000);  // in real project never use SysCtlDelay in interrupt

 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);

}

Timer w trybie PWM i preskaler EK-TM4C123GXL

Procesor TM4C123H6PM nie posiada połączenia sprzętowego PWM z diodą RGB na płytce testowej, pozostaje tylko opcja generowania PWM przez sprzętowy timer i włączenia odpowiednich pinów jako wyjścia generatora.

Aby sterować czerwoną diodą na płytce należy przypisać do pinu PF1 -> T0CCP1 aby na pin był wysyłany sygnał z "16-Bit Timer 0 PWM 1".

Biblioteka zawiera mapę pinów  "driverlib/pin_map.h" dzięki której w prosty sposób można włączyć PWM na pinie procesora. Należy wcześniej w opcjach projektu  dodać "predefined symbols" "PART_LM4F230H5QR", gdyż bez tego biblioteka nie zwróci odpowiednich map dla naszego procesora. W zależności od płytki może być potrzebny inny zapis, więcej na forum TI link.

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

GPIOPinConfigure(GPIO_PF1_T0CCP1 );

GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_1); 

Następnie należy włączyć sprzętowy Timer0 w funkcji PWM kanał B.

SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);

TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_B_PWM);

//TIMER_CFG_SPLIT_PAIR dzieli 32-bitowy timer na dwa 16 bitowe kanały A i B.

Teraz należy ustawić częstotliwość PWM oraz wypełnienie, wpiszę maksymalną liczbę cykli zegara jaką przyjmie 16-bitowy rejestr PWM - 65 535 oraz wypełnienie 10% czyli 58 982 cykli po których zmieni się stan wyjścia na przeciwny na pinie PF1 (z 0 na 1). Przy częstotliwości CPU 80 MHz uzyskamy częstotliwość PWM 1220 Hz.Aby uzyskać niższą należy zastosować preskaler.

TimerLoadSet(TIMER0_BASE, TIMER_B, 65535);

TimerMatchSet(TIMER0_BASE, TIMER_B, 58982);// 10%

TimerEnable(TIMER0_BASE,TIMER_B);

Dioda powinna się świecić słabym światłem.

Aby uzyskać niższą częstotliwość PWM można zastosować preskaler, w trybie PWM działa on jako przedłużenie licznika o 65 536 cykli zegara.
Preskaler  jest  8-bitowy i może maksymalnie wynosić 255 (czyli 255 x 65 536 cykli zegara plus to co zostało wpisane w TimerLoadSet(max 65535))
minimalna częstotliwość przy FCPU 80 MHz to 4,76 Hz (czas 256x65536x13ns=0,209s)

TimerPrescaleSet(TIMER0_BASE, TIMER_B, 255);

TimerPrescaleMatchSet(TIMER0_BASE, TIMER_B, 127); // 50% 127x65536 Tc

Kod z użyciem preskalera, dioda powinna migać z wypełnieniem 50% około 5 razy na sekundę:

#include "inc/hw_types.h"

#include "inc/hw_memmap.h"

#include "driverlib/sysctl.h"

#include "driverlib/gpio.h"

#include "driverlib/timer.h"

#include "driverlib/pin_map.h"





int main(void) {



    //clock:

    SysCtlClockSet(SYSCTL_USE_PLL|SYSCTL_SYSDIV_2_5|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); // OSC MAIN and PLL DIV 2,5 = 80-MHz frequency



    //Configure PF1 as T0CCP1

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

    GPIOPinConfigure(GPIO_PF1_T0CCP1 );

    GPIOPinTypeTimer(GPIO_PORTF_BASE, GPIO_PIN_1);



    // Enable Peripheral Timer0

    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);



    // Configure Timer0 as PWM

    TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR|TIMER_CFG_B_PWM);





    TimerLoadSet(TIMER0_BASE, TIMER_B, 65535); //  frequency in 1x prescaler = 1 to 65536 Tc

    TimerPrescaleSet(TIMER0_BASE, TIMER_B, 255); // max prescaler 255x65536 Tc

    TimerMatchSet(TIMER0_BASE, TIMER_B,65535);

    TimerPrescaleMatchSet(TIMER0_BASE, TIMER_B, 127); // 50% 127x65536 Tc



    TimerEnable(TIMER0_BASE,TIMER_B);



    while(1) {

    }

}

Włączenie peryferiów EK-TM4C123GXL

Procesor po włączeniu zasilania ma wyłączone wszystkie peryferia, należy je przed użyciem aktywować.
Do włączenia peryferiów należy zastosować funkcję SysCtlPeripheralEnable() z przekazanym urządzeniem peryferyjnym do włączenia. Funkcja potrzebuje 5 cykli zegara do aktywacji.

Funkcja przyjmuje tylko jeden parametr. Należy wywołać ją osobno dla każdego kolejnego.
Wszystkie możliwe argumenty funkcji:

SYSCTL_PERIPH_ADC0, SYSCTL_PERIPH_ADC1, SYSCTL_PERIPH_CAN0, SYSCTL_PERIPH_CAN1, SYSCTL_PERIPH_CAN2, SYSCTL_PERIPH_COMP0, SYSCTL_PERIPH_COMP1, SYSCTL_PERIPH_COMP2, SYSCTL_PERIPH_EEPROM0, SYSCTL_PERIPH_EPI0, SYSCTL_PERIPH_ETH, SYSCTL_PERIPH_FAN0, SYSCTL_PERIPH_GPIOA, SYSCTL_PERIPH_GPIOB, SYSCTL_PERIPH_GPIOC, SYSCTL_PERIPH_GPIOD, SYSCTL_PERIPH_GPIOE, SYSCTL_PERIPH_GPIOF, SYSCTL_PERIPH_GPIOG, SYSCTL_PERIPH_GPIOH, SYSCTL_PERIPH_GPIOJ, SYSCTL_PERIPH_GPIOK, SYSCTL_PERIPH_GPIOL, SYSCTL_PERIPH_GPIOM, SYSCTL_PERIPH_GPION, SYSCTL_PERIPH_GPIOP, SYSCTL_PERIPH_GPIOQ, SYSCTL_PERIPH_HIBERNATE, SYSCTL_PERIPH_I2C0, SYSCTL_PERIPH_I2C1, SYSCTL_PERIPH_I2C2, SYSCTL_PERIPH_I2C3, SYSCTL_PERIPH_I2C4, SYSCTL_PERIPH_I2C5, SYSCTL_PERIPH_I2S0, SYSCTL_PERIPH_LPC0, SYSCTL_PERIPH_PECI0, SYSCTL_PERIPH_PWM0, SYSCTL_PERIPH_PWM1, SYSCTL_PERIPH_QEI0, SYSCTL_PERIPH_QEI1, SYSCTL_PERIPH_SSI0, SYSCTL_PERIPH_SSI1, SYSCTL_PERIPH_SSI2, SYSCTL_PERIPH_SSI3, SYSCTL_PERIPH_TIMER0, SYSCTL_PERIPH_TIMER1, SYSCTL_PERIPH_TIMER2, SYSCTL_PERIPH_TIMER3, SYSCTL_PERIPH_TIMER4, SYSCTL_PERIPH_TIMER5, SYSCTL_PERIPH_UART0, SYSCTL_PERIPH_UART1, SYSCTL_PERIPH_UART2, SYSCTL_PERIPH_UART3, SYSCTL_PERIPH_UART4, SYSCTL_PERIPH_UART5, SYSCTL_PERIPH_UART6, SYSCTL_PERIPH_UART7, SYSCTL_PERIPH_UDMA, SYSCTL_PERIPH_USB0, SYSCTL_PERIPH_WDOG0, SYSCTL_PERIPH_WDOG1, SYSCTL_PERIPH_WTIMER0, SYSCTL_PERIPH_WTIMER1, SYSCTL_PERIPH_WTIMER2, SYSCTL_PERIPH_WTIMER3, SYSCTL_PERIPH_WTIMER4, or SYSCTL_PERIPH_WTIMER5.

Do sprawdzenia stanu peryferiów służy funkcja SysCtlPeripheralReady() która zwraca 1(True) lub 0(False).

Pobieranie częstotliwości zegara EK-TM4C123GXL

Funkcja SysCtlClockGet() zwraca wartość aktualnej częstotliwości zegara, aby działała poprawnie należy wcześniej ustawić zegar funkcją  SysCtlClockSet()

unsigned long fcpu;

fcpu= SysCtlClockGet();

Ustawienie częstotliwości zegara na płycie EK-TM4C123GXL

Wbudowany oscylator precyzyjny PIOSC 16MHz:

SysCtlClockSet(SYSCTL_USE_OSC|SYSCTL_OSC_INT); // Precision Internal Oscillator (PIOSC) providing a 16-MHz frequency

Wbudowany oscylator precyzyjny PIOSC 16MHz podzielony przez 4 - częstotliwość 4 MHz:

SysCtlClockSet(SYSCTL_USE_OSC|SYSCTL_OSC_INT4); // Precision Internal Oscillator (PIOSC) providing a 16/4 = 4-MHz frequency

Wbudowany oscylator precyzyjny PIOSC 16MHz i pętla PLL (400 MHz /2 = 200 MHz):

Można uzyskać częstotliwości w zależności od ustawionego dzielnika PLL, dzielnik od 2,5 do 64 krok 0,5:
SYSCTL_SYSDIV_2_5  - 80 MHz
SYSCTL_SYSDIV_3  - 66,67 MHz
SYSCTL_SYSDIV_4  - 50 MHz
SYSCTL_SYSDIV_5  - 40 MHz
...
SYSCTL_SYSDIV_10  - 20 MHz
...
SYSCTL_SYSDIV_64  - 3,125 MHz

SysCtlClockSet(SYSCTL_USE_PLL|SYSCTL_SYSDIV_3|SYSCTL_OSC_INT); // Precision Internal Oscillator (PIOSC) PLL DIV 3 = 66,67-MHz frequency

Zewnętrzny oscylator 16MHz:

SysCtlClockSet(SYSCTL_USE_OSC|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); // OSC MAIN-16 MHz frequency

Zewnętrzny oscylator 16MHz na płycie i pętla PLL (400 MHz /2 = 200 MHz):

Można uzyskać częstotliwości w zależności od ustawionego dzielnika PLL, dzielnik od 2,5 do 64 krok 0,5:
SYSCTL_SYSDIV_2_5  - 80 MHz
SYSCTL_SYSDIV_3  - 66,67 MHz
SYSCTL_SYSDIV_4  - 50 MHz
SYSCTL_SYSDIV_5  - 40 MHz
...
SYSCTL_SYSDIV_10  - 20 MHz
...
SYSCTL_SYSDIV_64  - 3,125 MHz

SysCtlClockSet(SYSCTL_USE_PLL|SYSCTL_SYSDIV_5|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); // OSC MAIN and PLL DIV 5 40-MHz