Introduction à la bibliothèque mr
mr-library est un framework léger pour les systèmes embarqués. Il fournit un modèle de périphérique pilote sous-jacent unifié et des fonctions de service de base. Il présente les caractéristiques de conception modulaire, de configurabilité et d'évolutivité, et peut aider les développeurs à créer rapidement des applications embarquées.
Le framework mr-library prend en charge les fonctions de base du noyau telles que les verrous mutex et la gestion des objets. Intégrez un cadre asynchrone basé sur les événements (événement), un minuteur logiciel de base multi-temps (soft-timer) et d'autres services. Fournissez des modèles de périphériques de pilotes pour les périphériques courants tels que les ports série, SPI, I2C, ADC/DAC, etc., accédez aux périphériques matériels sous-jacents via une interface de pilote unifiée (ouverture, fermeture, ioctl, lecture, écriture) et découplez les pilotes et applications sous-jacents. .
Scénarios d'application
-
Pilote de bas niveau développé par MCU.
-
Framework de plug-in pour le système d'exploitation en temps réel RTOS (utilisé comme framework de périphérique pilote).
-
Développement rapide de divers produits IoT et matériels intelligents.
cadre de périphérique pilote
Les développeurs peuvent accéder aux périphériques de manière orientée objet, simplifiant ainsi le processus de développement de la logique du pilote. Le framework implémente des modèles de pilotes universels pour les périphériques couramment utilisés, et les développeurs peuvent rapidement les porter sur différentes plates-formes matérielles.
La structure des périphériques pilotes prend en charge les interfaces communes pour les périphériques communs, le contrôle automatique des périphériques de bus et la prise en charge des interruptions de plusieurs périphériques.
Interface du périphérique d'entraînement
Le cadre du pilote de périphérique fournit une interface d'opération unifiée. Toutes les opérations du périphérique doivent être implémentées via les interfaces suivantes :
| interface | décrire |
|---|---|
| mr_device_add | Ajouter un appareil |
| mr_device_find | Rechercher un appareil |
| mr_device_open | Allumez l'appareil |
| mr_device_close | Éteignez l'appareil |
| mr_device_ioctl | dispositif de contrôle |
| mr_device_read | Lire les données de l'appareil |
| mr_device_write | Écrire des données sur l'appareil |
Exemple d'utilisation d'un appareil SPI :
/* 定义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);
cadre de services
Le framework mr-library intègre un framework de services léger pour créer des services d'application dans le développement embarqué, prenant en charge la surveillance des événements asynchrones, les minuteries logicielles de base multi-temporelles, etc. Le cadre de service est utilisé pour compléter le découplage des différentes applications dans la couche application, obtenant ainsi une modularisation et une personnalisation des applications, une logique métier claire, un développement rapide et une réutilisation élevée du code.
service événementiel
Le service d'événements est un mécanisme de traitement d'événements asynchrone qui peut améliorer efficacement les capacités de traitement asynchrone, le découplage et l'évolutivité du système grâce à la distribution d'événements et aux rappels.
Le service d'événements se compose de deux parties : le serveur d'événements et les événements.
-
Le serveur d'événements est utilisé pour recevoir et distribuer des événements. Il gère une file d'attente d'événements en interne pour stocker les événements en attente et une liste d'événements pour stocker les événements créés.
-
Les événements doivent être créés sur le serveur d'événements et fournir une fonction de rappel.
Lorsqu'un événement se produit, le serveur d'événements insère l'événement dans la file d'attente des événements pour la mise en cache. Le serveur d'événements supprimera périodiquement les événements de la file d'attente des événements pour les distribuer et trouvera le rappel d'événement correspondant pour le traitement des événements.
Interface d'exploitation du service d'événements
| interface | décrire |
|---|---|
| mr_event_server_find | Rechercher un serveur d'événements |
| mr_event_server_add | Ajouter un serveur d'événements |
| mr_event_server_remove | Supprimer le serveur d'événements |
| mr_event_server_handle | Traitement du serveur d'événements |
| mr_event_create | Créer un évènement |
| mr_event_delete | Supprimer l'événement |
| mr_event_notify | Notifier l'occurrence d'un événement |
| mr_event_trigger | événement déclencheur |
Exemple d'utilisation du service d'événements :
/* 定义事件 */
#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énomène:
event1_cb
event2_cb
event3_cb
Service de minuterie logicielle
La minuterie logicielle est un mécanisme qui implémente des fonctions de synchronisation au niveau logiciel. Grâce à la minuterie logicielle, des événements spécifiques peuvent être déclenchés à des moments ou à des intervalles spécifiques. Les minuteries logicielles sont souvent utilisées pour implémenter des fonctions telles que les tâches périodiques, le traitement des délais d'attente et les interruptions de minuterie.
Les minuteries logicielles contiennent deux composants principaux : les serveurs de synchronisation et les minuteries.
-
Le serveur de synchronisation est utilisé pour la gestion du temps et le traitement du minuteur.
-
Le minuteur est utilisé pour gérer un traitement de délai d'attente spécifique. Il doit être enregistré auprès du serveur de synchronisation et fournir une fonction de rappel.
Interface d'exploitation du service de minuterie logicielle
| interface | décrire |
|---|---|
| mr_soft_timer_server_find | Trouver un serveur de synchronisation |
| mr_soft_timer_server_add | Ajouter un serveur de synchronisation |
| mr_soft_timer_server_remove | Supprimer le serveur de synchronisation |
| mr_soft_timer_server_update | Mise à jour du signal de la base de temps du serveur de synchronisation |
| mr_soft_timer_server_handle | Traitement du serveur de synchronisation |
| mr_soft_timer_add | Ajouter une minuterie |
| mr_soft_timer_remove | Supprimer la minuterie |
| mr_soft_timer_start | Démarrer la minuterie |
| mr_soft_timer_stop | Minuterie de pause |
| mr_soft_timer_add_then_start | Ajouter une minuterie et démarrer |
Exemple d'utilisation du service de minuterie logicielle :
/* 定义定时服务器和定时器 */
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);
}
}
Répertoire de codes
La structure du répertoire de code de mr-library est présentée dans le tableau suivant :
| nom | décrire |
|---|---|
| bsp | Forfait de soutien au conseil d’administration |
| appareil | fichier de périphérique |
| document | document |
| conducteur | fichier de pilote |
| inclure | fichier d'en-tête de bibliothèque |
| module | Composants |
| emballer | progiciel |
| src | Fichiers sources de la bibliothèque |
-
Couche noyau : partie centrale de mr-library , qui implémente la gestion des objets, le contrôle des périphériques, les interfaces de service, etc.
-
Couche périphérique : fournit une interface de périphérique unifiée pour connecter les périphériques au noyau.
-
Couche pilote : fournit le pilote matériel sous-jacent pour le périphérique. Lorsque le matériel est remplacé, seule la couche pilote doit être modifiée.
-
Couche de composants : implémentez différentes fonctions via l'API fournie par le framework. Y compris, mais sans s'y limiter, les systèmes de fichiers virtuels, les modules de capteurs universels, les infrastructures réseau, etc.
-
Progiciel : un progiciel pouvant être utilisé de manière indépendante et ne comportant aucune dépendance.
Texte original : https://gitee.com/MacRsh/mr-library