ISR event manager.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

typedef struct {
    int ID;
    int timestamp;
}proc_t;

typedef struct {
    int n_elements;
    proc_t *ON_procs;   //Puntero a posicion de procesos a encender
    proc_t *OFF_procs; //Puntero a posicion de procesos a apagar
}org_t;
static org_t* org=NULL; //Variable interna de la "libreria"
static org_t* organizador=NULL; //Variable externa
static org_t* init_org(org_t **_org, int _capacidad){   //You have to pass the pointer to the pointer... bruh
//ok, recibimos el puntero al puntero de la posicion del struct
    *_org=malloc(sizeof(org_t)); //Damos una seccion de espacio para _org. Aqui estamos escribiendo en el puntero el puntero a la posicion alocada por malloc
    (*_org)->ON_procs=malloc(_capacidad*sizeof(proc_t));
    (*_org)->OFF_procs=malloc(_capacidad*sizeof(proc_t));
    assert((*_org)->ON_procs!=NULL && (*_org)->OFF_procs != NULL);
    
    //(*_org).n_elements=0;
    org=*_org;
    return org;
}
int proc_t_cmp(const void * a, const void * b){
    if(((proc_t*)a)->timestamp>=((proc_t*)b)->timestamp)return 1;
    return -1;
}
static org_t* set_event(int _ID, int on_tim, int off_tim){
    int i=0;
    do{
        if((org->ON_procs+i)->ID == _ID | i>=org->n_elements){
            (org->ON_procs+i)->ID = _ID;
            (org->ON_procs+i)->timestamp = on_tim;
            break;
        }
        i++;
    }while(i<=org->n_elements);
    
    i=0;
    do{
        if((org->OFF_procs+i)->ID == _ID | i>=org->n_elements){
            (org->OFF_procs+i)->ID = _ID;
            (org->OFF_procs+i)->timestamp = off_tim;
            break;
        }
        i++;
    }while(i<=org->n_elements);
    if(i>=(org->n_elements)) org->n_elements++;
    qsort(org->ON_procs, org->n_elements, sizeof(proc_t), proc_t_cmp);
    qsort(org->OFF_procs, org->n_elements, sizeof(proc_t), proc_t_cmp);
    return org;
}
static org_t* del_event(int _ID){
    int i = org->n_elements;
    while(i != 0){
        i--;
        if((org->ON_procs+i)->ID == _ID){
            if(i==(org->n_elements-1)){
                org->n_elements--;
                break;
            }
            else{
                org->n_elements--;
                memcpy(org->ON_procs+i, org->ON_procs+org->n_elements, sizeof(proc_t));
                break;
            }
        }
    }
    i = org->n_elements;
    while(i != 0){
        i--;
        if((org->OFF_procs+i)->ID == _ID){
            if(i==(org->n_elements)){
                break;
            }
            else{
                memcpy(org->OFF_procs+i, org->OFF_procs+org->n_elements, sizeof(proc_t));
                break;
            }
        }
    }
    qsort(org->ON_procs, org->n_elements, sizeof(proc_t), proc_t_cmp);
    qsort(org->OFF_procs, org->n_elements, sizeof(proc_t), proc_t_cmp);
    return org;
}

int main()
{
    printf("Hello World");
    init_org(&organizador, 3);
    set_event(1, 2, 4);
    set_event(2, 4, 6);
    set_event(3, 9, 8);
    set_event(1, 4, 8);
    del_event(2);
    del_event(1);
    del_event(1);
    del_event(3);
    
    //fflush(stdout);

    return 0;
}

Program that saves inside a struct (org_t) timing events for an ISR, that way, the ISR doesnt spend to much time calculating its next event.
Events are saved into 2 sub structs (proc_t) named ON_procs and OFF_ procs