采用面向对象的方法，使用C语音写一段代码，定义一个结构体，成员包括故障类型和调用函数，从触发到执行的间隔时间，调用函数的指针在结构体初始化时进行赋值。触发处置时，将调用函数插入处置序列，等待执行时间到时，执行调用函数。使用一个单独的线程来模拟产生定时器，用定时器时间来判断等待执行时间到达。

下面是使用C语言的面向对象方法编写的代码，实现了结构体的定义、故障类型的触发和调用函数的执行，以及使用单独的线程来模拟定时器产生等待执行时间到达的效果：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

// 定义故障类型和调用函数的结构体
typedef struct {
    int faultType;
    void (*callFunc)();
    int executionTime;
} FaultHandler;

// 定义处置序列的结构体
typedef struct {
    void (*disposalFunc)();
    int interval;
} DisposalSequence;

// 定义故障类型N的调用函数
void funN() {
    printf("Handling fault type N.\n");
}

// 定义处置函数1
void disposalFunc1() {
    printf("Disposal function 1.\n");
}

// 定义处置函数2
void disposalFunc2() {
    printf("Disposal function 2.\n");
}

// 定时器线程函数
void* timerThread(void* arg) {
    int executionTime = *(int*)arg;
    sleep(executionTime / 1000); // 等待执行时间到达
    printf("Timer: execution time reached.\n");
    pthread_exit(NULL);
}

int main() {
    // 初始化故障类型和调用函数的表
    FaultHandler faultTable[] = {
        {1, NULL, 0}, // 故障类型1，对应的调用函数为空，执行时间为0ms
        {2, NULL, 0}, // 故障类型2，对应的调用函数为空，执行时间为0ms
        {3, funN, 5000}, // 故障类型3，对应的调用函数为funN，执行时间为5000ms
        // 添加其他故障类型、调用函数和执行时间
    };

    // 初始化处置序列
    DisposalSequence sequence[] = {
        {disposalFunc1, 1000}, // 调用处置函数1，间隔时间为1000ms
        {disposalFunc2, 2000}  // 调用处置函数2，间隔时间为2000ms
        // 添加其他处置函数和对应的间隔时间
    };

    int n = 5; // 连续检测次数
    int threshold = 3; // 阈值

    int currFaultType = 3; // 当前故障类型

    int count = 0; // 连续检测到故障类型N的次数

    for (int i = 0; i < n; i++) {
        if (currFaultType == faultTable[count].faultType) {
            count++;

            if (count >= threshold) {
                if (faultTable[count-1].callFunc != NULL) {
                    // 创建定时器线程
                    pthread_t timer;
                    pthread_create(&timer, NULL, timerThread, &(faultTable[count-1].executionTime));

                    // 插入处置序列
                    for (int j = 0; j < sizeof(sequence) / sizeof(DisposalSequence); j++) {
                        printf("Disposal function %d after %d ms.\n", j+1, sequence[j].interval);
                        usleep(sequence[j].interval * 1000); // 等待间隔时间
                        faultTable[count-1].callFunc(); // 执行调用函数
                    }

                    pthread_join(timer, NULL); // 等待定时器线程结束
                }
                break;
            }
        } else {
            count = 0; // 重置连续检测次数
        }
    }

    return 0;
}

在上面的代码中，除了之前的定义和初始化部分，新增了一个名为`timerThread`的线程函数，用于模拟定时器的功能。

在`main`函数中，创建了一个定时器线程`timer`，线程函数为`timerThread`，传入的参数为故障类型的执行时间。

在插入处置序列时，使用了`usleep`函数进行等待，单位是毫秒。

最后，使用`pthread_join`函数等待定时器线程结束。

注：由于C语言并没有直接的面向对象的特性，这里使用了结构体和函数指针来模拟面向对象的思想，并使用了线程来模拟定时器。