Un petit système front-end et back-end pour MCU

Introduction à JxOS

JxOS est un petit système frontal et back-end pour MCU, fournissant des services tels que des messages et des événements, ainsi que des modules fonctionnels courants tels que des minuteries logicielles, une gestion de faible consommation, des boutons et des LED.

L'adresse de l'entrepôt du gîte est (copier dans le navigateur et ouvrir) :

https://gitee.com/jeremyceng/JxOS/tree/master

Sur cette base, une simple fonction de réseau sans fil basée sur 433 est implémentée.

L'idée de conception de ce projet est la suivante : découpler fortement les modules fonctionnels du matériel pour améliorer la réutilisabilité des modules de code ; améliorer la compatibilité entre les différentes plates-formes matérielles et compilateurs sans utiliser de structures de données et de syntaxe complexes, et réaliser des projets sur différentes plates-formes. Transplantez rapidement entre les MCU ; fournissez des modules fonctionnels pratiques, stables et couramment utilisés pour réaliser un développement de projet rapide ; définissez un cadre de développement d'applications standard pour réduire la charge de travail et la difficulté du développement d'applications.

Les plates-formes matérielles qui ont utilisé ce système pour des projets de développement sont : N76E003, STM8S103K, PC, KF8TS2716.

Architecture logicielle

JxOS
├───demo_code    参考代码，未整理代码
│
├───jxos     jxos
│   ├───bsp     过时分类，将逐步归类到 driver 和 lib 中
│   ├───kernel    内核，提供系统内核功能：任务、事件、消息、公告板、邮箱、管道、注册、内存分配……
│   ├───driver    使用 静态 初始化的功能代码模块，使用config.h文件进行配置；此目录下的代码大部分与硬件相关，如：传感器、按键扫描、屏幕…… （driver 与 lib 有时并没有清晰的界限，如driver:led_blink 就有可能抽象成 lib:sw_pwm）
│   ├───lib     使用 动态 初始化的功能代码模块，使用初始化函数进行配置；此目录下的模代码大部分与硬件无关，如：环形缓冲区、crc16、栈、软件定时器…… 
│   ├───sys_service   基于任务实现的系统服务，如：低功耗管理、软件定时器、打印输出……（只有对外接口，不发出对外消息）
│   └───std_app    基于任务实现的常用标准应用，如独立按键扫描、按键多次点击、指示灯闪烁……（此类模块和user app属于同一级别，只不过已经标准化；此类模块发出对外消息，也有对外接口，用于兼容不能支持消息功能的硬件平台）
│
├───platform
│   ├───N76E003    ┐
│   ├───N76E003    ├───  基于 jxos 实现的，使用不同平台硬件的具体项目
│   └───STM8S103K3 ┘
│
├───JSnet   ┐
├───....    ├───   基于 jxos 实现的功能模块
└───SRTnet  ┘

Le noyau fournit les fonctions du noyau système : tâches, événements, messages, tableaux d'affichage, boîtes aux lettres, canaux, enregistrement, allocation de mémoire...
Le pilote utilise un module de code de fonction initialisé statiquement et utilise le fichier config.h pour la configuration ; la plupart du code de ce répertoire est lié au matériel, tel que : les capteurs, l'analyse des clés, les écrans... (Le pilote et la lib le font parfois n'a pas de limite claire, comme driver:led_blink peut être résumé dans lib:sw_pwm)
lib utilise des modules de codes de fonction initialisés dynamiquement et utilise des fonctions d'initialisation pour la configuration ; la plupart des codes de modules de ce répertoire n'ont rien à voir avec le matériel, tels que : tampon en anneau, crc16, pile, minuterie logicielle...
sys_service est un service système basé sur l'implémentation de tâches, telles que : gestion de faible consommation, minuterie logicielle, sortie d'impression... (uniquement interface externe, aucun message externe n'est envoyé)
std_app est une application standard couramment utilisée, implémentée sur la base de tâches telles que l'analyse indépendante des boutons, les clics multiples sur les boutons, le voyant clignotant... (Ce type de module appartient au même niveau que l'application utilisateur, mais a été standardisé ; ce type du module envoie des messages externes et dispose également d'interfaces externes. , pour la compatibilité avec les plates-formes matérielles qui ne peuvent pas prendre en charge les fonctions de messagerie)
La plate-forme est basée sur jxos et constitue un projet spécifique utilisant un matériel de plate-forme différent.
Dans certains environnements de compilateur, il peut y avoir certaines restrictions (les pointeurs de fonction ne sont pas pris en charge, l'appel d'autres fonctions dans les fonctions de gestion des interruptions n'est pas pris en charge, les pointeurs de fonction avec des paramètres ne sont pas pris en charge et les structures ne sont pas prises en charge), de sorte que les messages fournis par std_app peuvent ne doit pas être utilisé. , en complément, std_app fournira également des variables globales pour transmettre des informations et des interfaces de fonction pour transmettre des informations.
Pour améliorer la compatibilité du code ; essayez de ne pas utiliser de pointeurs de fonction
Afin d'améliorer la réutilisabilité du code, les fonctions de std_app sont implémentées autant que possible dans le pilote et la lib. Le code de std_app n'est utilisé que pour fournir des ticks système et des fonctions d'interface externe unifiées.
Les modules et std_app peuvent fournir plusieurs fichiers avec différentes méthodes d'implémentation, tout en conservant une interface externe unifiée.
Deux ensembles de solutions d'interface sont fournis en externe : jxos_public.h fournit des interfaces de haut niveau (messages et événements, etc.), et jxos_public_lite.h fournit des interfaces de bas niveau (variables globales, fonctions).

Information Direct : parcours d'apprentissage de la technologie du code source du noyau Linux + didacticiel vidéo sur le code source du noyau

Learning Express : code source du noyau Linux, réglage de la mémoire, système de fichiers, gestion des processus, pilote de périphérique/pile de protocole réseau

Instructions

Importez jxos_public.h pour appeler toutes les interfaces externes du système
Chaque projet configure le système via jxos_init_config.c et jxos_config.h, c'est-à-dire que chaque projet dispose d'un fichier de configuration indépendant.
Dans jxos_init_config.c, implémentez l'initialisation matérielle des modules système nécessitant une prise en charge matérielle et la séquence d'initialisation des tâches utilisateur.
Configurez les paramètres et l'activation du module système dans jxos_config.h
l'événement est utilisé pour la synchronisation du signal au sein de la tâche, principalement pour transmettre le signal d'interruption à la tâche
msg est utilisé pour transmettre des messages entre les tâches. Utilisez jxos_msg_get_handle pour obtenir le handle du message via le nom du message (chaîne).

如何建立新项目：
 获取 Jxos 所有文件和目录结构
 在 \platform 目录下建立当前工程的目录（platform\芯片型号\工程命名\）
 在 \工程名称 目录下新建工程文件（keil、iar 等IDE的newproject）
 在 \工程名称 目录下新建 \config 目录，增加 jxos_config.h type.h 系统配置文件
 在 \config 目录下增加工程用到的功能模块的配置文件 （如 button_config.h sim_timer_config.h ...）
 在 \工程名称 目录下新建 \framework 目录
 在 \framework 目录下增加 main.c ，实现main函数，在main函数中调用jxos_run() （ void main(void) {jxos_run();} ）
 在 \framework 目录下增加 isr.c ，实现工程需要的中断处理函数
 在 \framework 目录下增加 callback_handler.c ，实现工程用到的功能模块的callback函数
 建议在 \工程名称 目录下新建 \app 目录，实现用户功能任务
 建议在 \芯片型号 目录下增加芯片需要用到的库文件目录
 在IDE的新工程中导入 jxos.c
 在IDE的新工程中导入需要的Jxos模块的文件（kernel、sys_service ...）
 在IDE的新工程中导入 main.c， isr.c， callback_handler.c
 在IDE的新工程中导入用户任务文件 （\工程名称\app\）
 在IDE的新工程中增加include目录，包括：\joxs，\platform\芯片型号\工程命名\config
 在IDE的新工程中增加其他的include目录，如芯片库文件的头文件
 按照框架实现用户任务

如何配置与使用 kernel
如何配置与使用 sys_service
如何配置与使用 std_app
如何使用标准框架的 driver 模块
如何使用标准框架的 lib 模块

Auteur original : [ Apprendre Embedded Together ]