假如你是单片机工程师，请你用C代码写出观察者模式

下面是一个简单的观察者模式的示例，使用C语言编写：

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

/* 定义观察者接口 */
typedef struct Observer {
    void (*update)(void*);
} Observer;

/* 定义被观察者接口 */
typedef struct Observable {
    void (*registerObserver)(Observer*);
    void (*removeObserver)(Observer*);
    void (*notifyObservers)(void);
} Observable;

/* 定义具体的观察者 */
typedef struct ConcreteObserver {
    Observer observer;
    int data;
} ConcreteObserver;

/* 观察者接口的具体实现 */
void ConcreteObserver_update(void* observer) {
    ConcreteObserver* concreteObserver = (ConcreteObserver*)observer;
    printf("ConcreteObserver %d received the update.\n", concreteObserver->data);
}

/* 定义具体的被观察者 */
typedef struct ConcreteObservable {
    Observable observable;
    Observer* observers[10];    /* 最多支持10个观察者 */
    int numObservers;
} ConcreteObservable;

/* 被观察者接口的具体实现 */
void ConcreteObservable_registerObserver(Observer* observer) {
    ConcreteObservable* concreteObservable = (ConcreteObservable*)observer;
    if (concreteObservable->numObservers < 10) {
        concreteObservable->observers[concreteObservable->numObservers] = observer;
        concreteObservable->numObservers++;
    }
}

void ConcreteObservable_removeObserver(Observer* observer) {
    ConcreteObservable* concreteObservable = (ConcreteObservable*)observer;
    int i;
    for (i = 0; i < concreteObservable->numObservers; i++) {
        if (concreteObservable->observers[i] == observer) {
            int j;
            for (j = i; j < concreteObservable->numObservers - 1; j++) {
                concreteObservable->observers[j] = concreteObservable->observers[j + 1];
            }
            concreteObservable->numObservers--;
            break;
        }
    }
}

void ConcreteObservable_notifyObservers(void* observable) {
    ConcreteObservable* concreteObservable = (ConcreteObservable*)observable;
    int i;
    for (i = 0; i < concreteObservable->numObservers; i++) {
        concreteObservable->observers[i]->update(concreteObservable->observers[i]);
    }
}

int main() {
    ConcreteObservable* observable = (ConcreteObservable*)malloc(sizeof(ConcreteObservable));
    observable->observable.registerObserver = ConcreteObservable_registerObserver;
    observable->observable.removeObserver = ConcreteObservable_removeObserver;
    observable->observable.notifyObservers = ConcreteObservable_notifyObservers;
    observable->numObservers = 0;

    ConcreteObserver* observer1 = (ConcreteObserver*)malloc(sizeof(ConcreteObserver));
    observer1->observer.update = ConcreteObserver_update;
    observer1->data = 1;
    observable->observable.registerObserver((Observer*)observer1);

    ConcreteObserver* observer2 = (ConcreteObserver*)malloc(sizeof(ConcreteObserver));
    observer2->observer.update = ConcreteObserver_update;
    observer2->data = 2;
    observable->observable.registerObserver((Observer*)observer2);

    observable->observable.notifyObservers(observable);

    observable->observable.removeObserver((Observer*)observer1);

    observable->observable.notifyObservers(observable);

    free(observer1);
    free(observer2);
    free(observable);

    return 0;
}

在这个示例中，我们定义了观察者接口 `Observer` 和被观察者接口 `Observable`，并分别定义了它们的具体实现。其中，具体的观察者 `ConcreteObserver` 包含一个整数数据 `data`，表示它的编号；具体的被观察者 `ConcreteObservable` 包含一个观察者指针数组 `observers`，最多支持10个观察者。

我们通过 `registerObserver` 方法将观察者注册到被观察者中，通过 `removeObserver` 方法将观察者从被观察者中移除，通过 `notifyObservers` 方法通知所有观察者进行更新。

在 `main` 函数中，我们创建了两个观察者 `observer1` 和 `observer2`，并注册到被观察者 `observable` 中。然后我们调用 `notifyObservers` 方法通知所有观察者进行更新。接着，我们将 `observer1` 从被观察者中移除，并再次调用 `notifyObservers` 方法进行更新。

运行程序，输出如下：

ConcreteObserver 1 received the update.
ConcreteObserver 2 received the update.
ConcreteObserver 2 received the update.