286/3 svaje 2 i 10s

  #include <stdio.h>
//***********************************************TO DO 1*************************************************//
//*******************Uključiti datoteke xparameters.h, xtmrctr.h, xintc.h i xgpio.h**********************//
#include "xparameters.h"
#include "xtmrctr.h"
#include "xintc.h"
#include "xgpio.h"



//******************************************************************************************************//

//definiranje konstante za redni broj timera koji se koristi (unutar timer komponente postoje dva timera)
#define TIMER_CNTR_0 0

//***********************************************TO DO 2************************************************//
//*****************************Postaviti vrijednost konstante RESET_VALUE*******************************//

#define RESET_VALUE 99999998
//******************************************************************************************************//

/********************* Prototipi funkcija *************************/
int TmrCtrIntrInit(XIntc* IntcInstancePtr,
 XTmrCtr* TmrInstancePtr,
 u16 TimerDeviceId,
 u16 IntcDeviceId,
 u16 IntrSourceId,
 u8 TmrCtrNumber);

void TimerCounterHandler(void *CallBackRef, u8 TmrCtrNumber);

//***********************************************TO DO 3*************************************************//
//*****Deklarirati varijable InterruptController (XIntc), TimerCounterInst (XTmrCtr) i leds (XGpio)******//

XIntc InterruptController;
XTmrCtr TimerCounterInst;
XGpio prekidac,button;
int parne=0;


//******************************************************************************************************//

//***********************************************TO DO 4************************************************//
//***************************Deklarirati globalnu varijablu TimerExpired********************************//

 int volatile broj_sekundi=0;
//******************************************************************************************************//

int main(void)
{
    print("-- Start of the program! --\r\n");

    int Status;

    //***********************************************TO DO 5************************************************//
    //************************Inicijalizirati kontroler za komunikaciju s LE diodama************************//
    XGpio_Initialize(&button, XPAR_PUSH_BUTTONS_4BITS_DEVICE_ID);
    XGpio_SetDataDirection(&button,1,0xf);
    XGpio_Initialize(&prekidac, XPAR_DIP_SWITCHES_8BITS_DEVICE_ID);
    XGpio_SetDataDirection(&prekidac,1,0xff);

    int btnVal;

    //******************************************************************************************************//

    //Poziv funkcije za inicijalizaciju timera i upravljača prekidima
    Status = TmrCtrIntrInit(&InterruptController,
                            &TimerCounterInst,
                            XPAR_DELAY_DEVICE_ID,
                            XPAR_INTC_0_DEVICE_ID,
                            XPAR_INTC_0_TMRCTR_0_VEC_ID,
                            TIMER_CNTR_0);

    if (Status != XST_SUCCESS){
        return XST_FAILURE;
    }

    //***********************************************TO DO 6***********************************************//
    //******************************************Pokrenuti timer********************************************//
    XTmrCtr_Start(&TimerCounterInst, TIMER_CNTR_0);

    //*****************************************************************************************************//

    while (1) {
        btnVal = XGpio_DiscreteRead(&button, 1);
        if(btnVal == 0b0001)
        {
            broj_sekundi=0;
            parne=0;
        }
    }

    print("-- End of the program! --\r\n");
    return XST_SUCCESS;
}

/********************************************************************/
/**
* Inicijalizacija timera i upravljača prekidima.
* Funkcija prima sljedeće parametre:
*
* @paramIntcInstancePtr - pokazivač na varijablu tipa XIntc,
* @paramTmrCtrInstancePtr - pokazivač na varijablu tipa XTmrCtr,
* @paramTimerDeviceId - vrijednost konstante XPAR_<TmrCtr_instance>_DEVICE_ID iz datoteke xparameters.h,
* @paramIntcDeviceId - vrijednost konstante XPAR_<Intc_instance>_DEVICE_ID iz datoteke xparameters.h,
* @paramIntrSourceId - vrijednost konstante XPAR_<INTC_instance>_<TmrCtr_instance>_INTERRUPT_INTR iz datoteke xparameters.h,
* @paramTmrCtrNumber - redni broj timera koji se inicijalizira.
*
* @returnXST_SUCCESS ako je inicijalizacija uspješna, a u suprotno funkcija vraća XST_FAILURE
*
*********************************************************************/
int TmrCtrIntrInit(XIntc* IntcInstancePtr,
 XTmrCtr* TmrCtrInstancePtr,
 u16 TimerDeviceId,
 u16 IntcDeviceId,
 u16 IntrSourceId,
 u8 TmrCtrNumber)
{
    int Status;

    print("Init STARTED\r\n");

    //***********************************************TO DO 7************************************************//
    //**********Inicijalizirati timer, povratnu vrijednost funkcije spremiti u varijablu Status************//

    Status = XTmrCtr_Initialize(TmrCtrInstancePtr,TimerDeviceId );
    //*****************************************************************************************************//
    if (Status != XST_SUCCESS) {
        print("Timer Initialize FAILED\r\n");
        return XST_FAILURE;
    }
    print("Timer Initialize SUCCESS\r\n");

    //**********************************************TO DO 8*************************************************//
    //****Inicijalizirati upravljač prekidima, povratnu vrijednost funkcije spremiti u varijablu Status****//

Status=XIntc_Initialize(IntcInstancePtr,IntcDeviceId);
    //*****************************************************************************************************//
    if (Status != XST_SUCCESS) {
        print("Intc Initialize FAILED\r\n");
        return XST_FAILURE;
    }
    print("Intc Initialize SUCCESS\r\n");

    /*
     * Povezivanje upravljača prekida s rukovateljem prekida koji se
     * poziva kada se dogodi prekid. Rukovatelj prekida obavlja
     * specifične zadatke vezane za rukovanje prekidima.
     */
    Status = XIntc_Connect(IntcInstancePtr, IntrSourceId,
     (XInterruptHandler)XTmrCtr_InterruptHandler,
     (void *)TmrCtrInstancePtr);

    if (Status != XST_SUCCESS) {
        print("Intc Connect FAILED\r\n");
        return XST_FAILURE;
    }
    print("Intc Connect SUCCESS\r\n");

    //***********************************************TO DO 9******************************+****************//
    //***Postaviti mod rada upravljača prekida, povratnu vrijednost funkcije spremiti u varijablu Status***//
XIntc_Start(IntcInstancePtr, XIN_REAL_MODE);

    //*****************************************************************************************************//
    if (Status != XST_SUCCESS) {
        print("Intc Start FAILED\r\n");
        return XST_FAILURE;
    }
    print("Intc Start SUCCESS\r\n");

    //**********************************************TO DO 10******************************+****************//
    //*********************************Omogućiti rad upravljača prekidima**********************************//

XIntc_Enable(IntcInstancePtr,IntrSourceId);
    //*****************************************************************************************************//

    //Omogućavanje microblaze prekida.
    microblaze_enable_interrupts();

    /*
     * Postavljanje prekidne rutine koja će biti pozvana kada se dogodi prekid
     * od strane timera. Kao parametri predaju se pokazivač na komponentu za
     * koju se postavlja prekidna rutina, naziv prekidne rutine (funkcije)
     * i pointer na timer, kako bi prekidna rutina mogla pristupiti timeru.
     */
    XTmrCtr_SetHandler(TmrCtrInstancePtr,
     TimerCounterHandler,
     TmrCtrInstancePtr);

    //**********************************************TO DO 11******************************+****************//
    //*************************************Postaviti postavke timera***************************************//
    //************Omogućiti prekide, omogućiti auto reload, odabrati brojanje prema dolje******************//

XTmrCtr_SetOptions(TmrCtrInstancePtr,TmrCtrNumber,XTC_DOWN_COUNT_OPTION|XTC_AUTO_RELOAD_OPTION|XTC_INT_MODE_OPTION);
    //*****************************************************************************************************//

    //**********************************************TO DO 12******************************+****************//
    //********************************Postaviti početnu vrijednost timera**********************************//

XTmrCtr_SetResetValue(TmrCtrInstancePtr,TmrCtrNumber,RESET_VALUE);
    //*****************************************************************************************************//

    print("Init FINISHED\r\n");
    return XST_SUCCESS;
}

/*
 * Prekidna rutina koja se poziva kada timer generira prekid.
 * Funkcija prima pokazivač na void parametar CallBackRef
 * koji se cast-a na pokazivač tipa XTmrCtr.
 * Ovaj parametar je napravljen kako bi se pokazao način na
 * koji se unutar prekidne rutine može pristupiti timer
 * komponenti i njenim funkcijama.
*/
void TimerCounterHandler(void *CallBackRef, u8 TmrCtrNumber)
{
    print("Interrupt Handler!\r\n");

    XTmrCtr *InstancePtr = (XTmrCtr *)CallBackRef;
    u8 ucount;
    int vrijednostsklopki, timeMS;
    //**********************************************TO DO 13***********************************************//
    //*************************Deklarirati varijable timeMS (int) i uCount (uint)**************************//


    //************************************************************************************+****************//

    //**********************************************TO DO 14***********************************************//
    //*****************Brojati prekide i vrijednost prikazati na LE diodama razvojnog sustava**************//
    broj_sekundi++;


    if(broj_sekundi%2 == 0){
        xil_printf("Elapsed time: %d\r\n", broj_sekundi);
        vrijednostsklopki=XGpio_DiscreteRead(&prekidac,1);
        xil_printf("rezultat: %d\r\n", vrijednostsklopki);

       if(vrijednostsklopki%2==0)
       {
           parne++;
       }


    }
    if(broj_sekundi%10 == 0)
    {
        xil_printf("broj parnih vrijednosti: %d\r\n", parne);
    }
    //*****************************************************************************************************//

    //**********************************************TO DO 15***********************************************//
    //******Dohvatiti vrijednost brojača, izračunati vrijeme u ms i vrijednost poslati preko UART-a********//
    ucount = XTmrCtr_GetValue(InstancePtr,TmrCtrNumber);
    timeMS = (ucount+2)/50000;

    //xil_printf("timems: %d\r\n", timeMS);


    //************************************************************************************+****************//
}