...
// Pinnin asetusmuuttuja
PIN_Config buttonConfig[] = {
   Board_BUTTON0  | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_NEGEDGE,
   PIN_TERMINATE 
};
...
// Pinnin keskeytyksen käsittelijä
void buttonFxn(PIN_Handle handle, PIN_Id pinId) {
   ...
}

Int main() {
   ...
   // Kerrotaan RTOS:lle että pinnin buttonHandle keskeytyksen käsittelijä on buttonFxn
   if (PIN_registerIntCb(buttonHandle, &buttonFxn) != 0) {
      System_abort("Error registering button callback function");
   }
   ...
}

...
uint8_t rxBuf[10];   // Vastaanottopuskuri
...
static void uartFxn(UArg arg0, UArg arg1) {
   UART_Handle handle;
   UART_Params params;

   UART_Params_init(&params);
   params.baudRate      = 9600;
   params.readMode      = UART_MODE_CALLBACK; // Keskeytyspohjainen vastaanotto!
   params.readCallback  = &uart_receive; // Käsittelijäfunktio!
   params.readDataMode  = UART_DATA_TEXT;
   params.writeDataMode = UART_DATA_TEXT;

    // Otetaan UART käyttöön ohjelmassa	
   handle = UART_open(Board_UART, &params);
   if (handle == NULL) {
      System_abort("Error opening the UART");
   }

   // Käynnistetään odotus, odotamme kunnes tulossa on yksi merkki dataa
   UART_read(handle, rxBuf, 1);

   while(1) {
      // ikuinen looppi
   }
}

// Käsittelijäfunktio
static void uart_receive(UART_Handle handle, void *rxBuf, size_t len) {

   // Nyt meillä on siis haluttu määrä merkkejä käytettävissä
   // rxBuf-taulukossa, pituus len, jota voimme käsitellä halutusti
   // Tässä ne annetaan argumentiksi toiselle funktiolle (esimerkin vuoksi)
   tehdaan_jotain_nopeasti(rxBuf,len);

   // Käsittelijän viimeisenä asiana siirrytään odottamaan uutta keskeytystä..
   UART_read(handle, rxBuf, len);
}

Int main() {
   ...
   Board_initUART();	
   ...
   BIOS_start();
  
   return 0;
}

// Pinnien asetus
static PIN_Config MpuPinTable[] = {
    Board_MPU_INT    | PIN_INPUT_EN | PIN_PULLDOWN | PIN_IRQ_DIS | PIN_HYSTERESIS, // TAI-operaatio
    PIN_TERMINATE
};
...
// Taskifunktio
Void sensorTask(UArg arg0, UArg arg1) {
   ...
   // Taskin alussa sallitaan nousevan reunan keskeytys pinniltä Board_MPU_INT
   PIN_setInterrupt(hMpuPin, PIN_ID(Board_MPU_INT) | PIN_IRQ_POSEDGE); // Hox! TAI-operaatio
   ...
   // Taskin lopuksi kielletään pinnin Board_MPU_INT keskeytykset vakiolla  PIN_IRQ_DIS
   PIN_setInterrupt(hMpuPin, PIN_ID(Board_MPU_INT) | PIN_IRQ_DIS); // Hox! PIN_IRQ_DIS
}

// Käsittelijafunktio
Void MpuIntFxn(PIN_Handle handle, PIN_Id pinId) {
      tee_jotain();
}

int main(void) {
   ...
   // Otetaan käyttöön pinnin ym. MpuPin
   hMpuPin = PIN_open(&MpuPinState, MpuPinTable);
   if (hMpuPin == NULL) {
      System_abort("Pin open failed!");
   }

   // Asetetaan sen keskeytyksen käsittelijäfunktio
   PIN_registerIntCb(hMpuPin, &MpuIntFxn);
   ...
}

...
#include <ti/sysbios/knl/Clock.h>
...

// Kellokeskeytyksen käsittelijä
Void clkFxn(UArg arg0) {

   // Tässä esimerkkinä vain, älkää tehkö näin koska todella hidas operaatio!
   sprintf(str,"System time: %.5fs\n", (double)Clock_getTicks() / 100000.0);
   System_printf(str);
   System_flush();
}

int main(void) {

   // RTOS:n kellomuuttujat
   Clock_Handle clkHandle;
   Clock_Params clkParams;

   Board_initGeneral();

   // Alustetaan kello halutusti
   Clock_Params_init(&clkParams);
   clkParams.period = 1000000 / Clock_tickPeriod;
   clkParams.startFlag = TRUE;

   // Luodaan kello
   clkHandle = Clock_create((Clock_FuncPtr)clkFxn, 1000000 / Clock_tickPeriod, &clkParams, NULL);
   if (clkHandle == NULL) {
      System_abort("Clock create failed");
   }

   BIOS_start();

   return(0);
}

...
#include <ti/sysbios/hal/Seconds.h>
...

Void clkFxn(UArg arg0) {

   time_t nyt = time(NULL);
   struct tm *aika = localtime(&nyt);
   System_printf("Kello on %02d:%02d:%02d\n", aika->tm_hour+3, aika->tm_min, aika->tm_sec);
   System_flush();
}

Int main() {
   ...
   // Asetetaan reaaliaikakellon aloitusaika
   Seconds_set(1475578882); // Jännempi argumentti..
   
   BIOS_Start();
   
   return 0;
}