Einführung in die mr-Bibliothek
mr-library ist ein leichtes Framework für eingebettete Systeme. Es bietet ein einheitliches zugrunde liegendes Treibergerätemodell und grundlegende Servicefunktionen. Es zeichnet sich durch modulares Design, Konfigurierbarkeit und Skalierbarkeit aus und kann Entwicklern dabei helfen, schnell eingebettete Anwendungen zu erstellen. Programm.
Das Mr-Library- Framework unterstützt grundlegende Kernelfunktionen wie Mutex-Sperren und Objektverwaltung. Integrieren Sie ein asynchrones ereignisgesteuertes Framework (Ereignis), einen mehrzeitigen Basis-Software-Timer (Soft-Timer) und andere Dienste. Stellen Sie Treibergerätemodelle für gängige Peripheriegeräte wie serielle Schnittstellen, SPI, I2C, ADC/DAC usw. bereit, greifen Sie über eine einheitliche Treiberschnittstelle (Öffnen, Schließen, Ioctl, Lesen, Schreiben) auf zugrunde liegende Hardwaregeräte zu und entkoppeln Sie zugrunde liegende Treiber und Anwendungen .
Anwendungsszenarien
-
Von MCU entwickelter Low-Level-Treiber.
-
Plug-in-Framework für das Echtzeitbetriebssystem RTOS (wird als Treibergeräte-Framework verwendet).
-
Schnelle Entwicklung verschiedener IoT- und Smart-Hardware-Produkte.
Treiber-Geräte-Framework
Entwickler können objektorientiert auf Peripheriegeräte zugreifen, was den Entwicklungsprozess der Treiberlogik vereinfacht. Das Framework implementiert universelle Treibervorlagen für häufig verwendete Peripheriegeräte und Entwickler können diese schnell auf verschiedene Hardwareplattformen portieren.
Das Treibergeräte-Framework unterstützt gemeinsame Schnittstellen für gemeinsame Geräte, die automatische Bussteuerung von Busgeräten und die Interrupt-Übernahme mehrerer Geräte.
Antriebsgeräteschnittstelle
Das Gerätetreiber-Framework stellt eine einheitliche Betriebsschnittstelle bereit. Alle Vorgänge des Geräts müssen über die folgenden Schnittstellen implementiert werden:
| Schnittstelle | beschreiben |
|---|---|
| mr_device_add | Gerät hinzufügen |
| mr_device_find | Gerät finden |
| mr_device_open | Schalten Sie das Gerät ein |
| mr_device_close | Schalten Sie das Gerät aus |
| mr_device_ioctl | Steuergerät |
| mr_device_read | Daten vom Gerät lesen |
| mr_device_write | Daten auf das Gerät schreiben |
Beispiel für die Verwendung eines SPI-Geräts:
/* 定义SPI设备 */
#define SPI_DEVICE0_CS_PIN 10
#define SPI_DEVICE1_CS_PIN 20
struct mr_spi_device spi_device0, spi_device1;
/* 添加SPI设备 */
mr_spi_device_add(&spi_device0, "spi10", SPI_DEVICE0_CS_PIN);
mr_spi_device_add(&spi_device1, "spi11", SPI_DEVICE1_CS_PIN);
/* 查找SPI设备 */
mr_device_t spi0_device = mr_device_find("spi10");
mr_device_t spi1_device = mr_device_find("spi11");
/* 挂载总线 */
mr_device_ioctl(spi0_device, MR_CTRL_ATTACH, "spi1");
mr_device_ioctl(spi1_device, MR_CTRL_ATTACH, "spi1");
/* 以可读可写的方式打开SPI设备 */
mr_device_open(spi0_device, MR_OPEN_RDWR);
mr_device_open(spi1_device, MR_OPEN_RDWR);
/* 发送数据 */
char buffer0[] = "hello";
char buffer1[] = "world";
mr_device_write(spi0_device, 0, buffer0, sizeof(buffer0) - 1);
mr_device_write(spi1_device, 0, buffer1, sizeof(buffer1) - 1);
/* 读取数据 */
mr_device_read(spi0_device, 0, buffer0, sizeof(buffer0) - 1);
mr_device_read(spi1_device, 0, buffer1, sizeof(buffer1) - 1);
/* 关闭设备 */
mr_device_close(spi0_device);
mr_device_close(spi1_device);
Service-Framework
Das MR-Library- Framework integriert ein leichtes Service-Framework zum Erstellen von Anwendungsdiensten in der eingebetteten Entwicklung und unterstützt asynchrone Ereignisüberwachung, mehrzeitige Basis-Software-Timer usw. Das Service-Framework wird verwendet, um die Entkopplung verschiedener Anwendungen in der Anwendungsschicht abzuschließen und so eine Modularisierung und Anpassbarkeit von Anwendungen, eine klare Geschäftslogik, eine schnelle Entwicklung und eine hohe Wiederverwendung von Code zu erreichen.
Veranstaltungsservice
Der Ereignisdienst ist ein asynchroner Ereignisverarbeitungsmechanismus, der die asynchronen Verarbeitungsfähigkeiten, die Entkopplung und die Skalierbarkeit des Systems durch Ereignisverteilung und Rückrufe effektiv verbessern kann.
Der Event-Service besteht aus zwei Teilen: Event-Server und Events.
-
Der Ereignisserver wird zum Empfangen und Verteilen von Ereignissen verwendet. Er unterhält intern eine Ereigniswarteschlange zum Speichern ausstehender Ereignisse und eine Ereignisliste zum Speichern erstellter Ereignisse.
-
Ereignisse müssen auf dem Ereignisserver erstellt werden und eine Rückruffunktion bereitstellen.
Wenn ein Ereignis auftritt, fügt der Ereignisserver das Ereignis zur Zwischenspeicherung in die Ereigniswarteschlange ein. Der Ereignisserver entnimmt der Ereigniswarteschlange regelmäßig Ereignisse zur Verteilung und sucht den entsprechenden Ereignisrückruf für die Ereignisverarbeitung.
Schnittstelle für den Ereignisdienstbetrieb
| Schnittstelle | beschreiben |
|---|---|
| mr_event_server_find | Finden Sie den Ereignisserver |
| mr_event_server_add | Ereignisserver hinzufügen |
| mr_event_server_remove | Eventserver entfernen |
| mr_event_server_handle | Verarbeitung des Ereignisservers |
| mr_event_create | Veranstaltung erstellen |
| mr_event_delete | Ereignis entfernen |
| mr_event_notify | Ereigniseintritt benachrichtigen |
| mr_event_trigger | auslösendes Ereignis |
Beispiel für die Nutzung eines Event-Service:
/* 定义事件 */
#define EVENT1 1
#define EVENT2 2
#define EVENT3 3
/* 定义事件服务器 */
struct mr_event_server event_server;
mr_err_t event1_cb(mr_event_server_t server, void *args)
{
printf("event1_cb\r\n");
/* 通知事件服务器事件2发生 */
mr_event_notify(EVENT2, server);
return MR_ERR_OK;
}
mr_err_t event2_cb(mr_event_server_t server, void *args)
{
printf("event2_cb\r\n");
/* 通知事件服务器事件3发生 */
mr_event_notify(EVENT3, server)
return MR_ERR_OK;
}
mr_err_t event3_cb(mr_event_server_t server, void *args)
{
printf("event3_cb\r\n");
return MR_ERR_OK;
}
int main(void)
{
/* 添加事件服务器到内核容器 */
mr_event_server_add(&event_server, "server", 4);
/* 创建事件到服务器 */
mr_event_create(EVENT1, event1_cb, MR_NULL, &event_server);
mr_event_create(EVENT2, event2_cb, MR_NULL, &event_server);
mr_event_create(EVENT3, event3_cb, MR_NULL, &event_server);
/* 通知事件服务器事件1发生 */
mr_event_notify(EVENT1, &event_server);
while (1)
{
/* 事件服务器处理 */
mr_event_server_handle(&event_server);
}
}
Phänomen:
event1_cb
event2_cb
event3_cb
Software-Timer-Dienst
Software-Timer ist ein Mechanismus, der Timing-Funktionen auf Softwareebene implementiert. Durch Software-Timer können bestimmte Ereignisse zu bestimmten Zeitpunkten oder Intervallen ausgelöst werden. Software-Timer werden häufig zur Implementierung von Funktionen wie periodischen Aufgaben, Timeout-Verarbeitung und Timer-Interrupts verwendet.
Software-Timer bestehen aus zwei Hauptkomponenten: Timing-Servern und Timern.
-
Der Timing-Server wird für die Zeitverwaltung und Timer-Verarbeitung verwendet.
-
Der Timer wird für die spezifische Timeout-Verarbeitung verwendet. Er muss beim Timing-Server registriert werden und eine Rückruffunktion bereitstellen.
Bedienschnittstelle für Software-Timer-Dienste
| Schnittstelle | beschreiben |
|---|---|
| mr_soft_timer_server_find | Finden Sie den Timing-Server |
| mr_soft_timer_server_add | Timing-Server hinzufügen |
| mr_soft_timer_server_remove | Entfernen Sie den Timing-Server |
| mr_soft_timer_server_update | Aktualisierung des Zeitbasissignals des Timing-Servers |
| mr_soft_timer_server_handle | Timing-Server-Verarbeitung |
| mr_soft_timer_add | Timer hinzufügen |
| mr_soft_timer_remove | Timer entfernen |
| mr_soft_timer_start | Timer starten |
| mr_soft_timer_stop | Pause-Timer |
| mr_soft_timer_add_then_start | Timer hinzufügen und starten |
Beispiel für die Nutzung des Software-Timer-Dienstes:
/* 定义定时服务器和定时器 */
struct mr_soft_timer_server server;
struct mr_soft_timer timer1, timer2, timer3;
mr_err_t timer1_callback(mr_soft_timer timer, void *args)
{
printf("timer1_callback\r\n");
return MR_ERR_OK;
}
mr_err_t timer2_callback(mr_soft_timer timer, void *args)
{
printf("timer2_callback\r\n");
return MR_ERR_OK;
}
mr_err_t timer3_callback(mr_soft_timer timer, void *args)
{
printf("timer3_callback\r\n");
mr_soft_timer_stop(timer);
return MR_ERR_OK;
}
int main(void)
{
/* 添加定时服务器 */
mr_soft_timer_server_add(&server, "soft-timer");
/* 添加定时器并启动 */
mr_soft_timer_add_then_start(&timer1, 5, timer1_callback, MR_NULL, &server);
mr_soft_timer_add_then_start(&timer2, 10, timer2_callback, MR_NULL, &server);
mr_soft_timer_add_then_start(&timer3, 15, timer3_callback, MR_NULL, &server);
while (1)
{
/* 更新定时服务器时钟 */
mr_soft_timer_server_update(&server, 1);
/* 定时服务器处理（放在哪里，回调就将在哪里被调用） */
mr_soft_timer_server_handle(&server);
}
}
Codeverzeichnis
Die Codeverzeichnisstruktur der mr-library ist in der folgenden Tabelle dargestellt:
| Name | beschreiben |
|---|---|
| bsp | Board-Support-Paket |
| Gerät | Gerätedatei |
| dokumentieren | dokumentieren |
| Treiber | Treiberdatei |
| enthalten | Bibliotheks-Header-Datei |
| Modul | Komponenten |
| Paket | Softwarepaket |
| src | Quelldateien der Bibliothek |
-
Kernel-Schicht: Der Kernteil der mr-library , der Objektverwaltung, Gerätesteuerung, Serviceschnittstellen usw. implementiert.
-
Geräteschicht: Bietet eine einheitliche Geräteschnittstelle zum Verbinden von Geräten mit dem Kernel.
-
Treiberschicht: Stellt den zugrunde liegenden Hardwaretreiber für das Gerät bereit. Wenn die Hardware ausgetauscht wird, muss nur die Treiberschicht geändert werden.
-
Komponentenschicht: Implementieren Sie verschiedene Funktionen über die vom Framework bereitgestellte API. Einschließlich, aber nicht beschränkt auf virtuelle Dateisysteme, universelle Sensormodule, Netzwerk-Frameworks usw.
-
Softwarepaket: Ein Softwarepaket, das unabhängig verwendet werden kann und keine Abhängigkeiten aufweist.
Originaltext: https://gitee.com/MacRsh/mr-library