MC3172 Introduction
Le MC3172 est un processeur temps réel multithread parallèle RISC 32 bits développé par GXchip en Chine. Il utilise un nouveau mode de fonctionnement du processeur et un nouveau mode de développement logiciel. Contrairement au mode de programmation monothread, les différents threads du multithreading parallèle s'exécutent de manière synchrone sans s'interférer les uns les autres, et il n'y a pas de concept de priorité.
MC3172 Brochage
Caractéristiques du MC3172
Ce microcontrôleur MC3172 présente de nombreuses similitudes avec les microcontrôleurs courants que nous utilisons, tels que GPIO, UART, SPI, USB, CAN et d'autres périphériques courants.
Mais il possède une caractéristique très unique : il s'agit d'un processeur temps réel multithread parallèle basé sur le jeu d'instructions RISC-V RV32IMC.
En d'autres termes, il dispose d'une capacité multithread RTOS, mais au lieu d'un ordonnancement logiciel RTOS classique, il répond en temps réel au niveau matériel sans routines de service d'interruption.
- Prise en charge de la combinaison du jeu d'instructions RV32IMC, multiplication en un seul cycle
- 64 threads fonctionnant en parallèle sans service d'interruption
- Les ressources des threads peuvent être configurées à la demande et aucun système d'exploitation en temps réel n'est nécessaire
- 100 % d'instructions à cycle unique, pas de prédiction de branche
- Prise en charge des interfaces USART, SPI, USB 2.0 hôte/périphérique, CAN 2.0B
- Jusqu'à 4 canaux pour la capture d'entrée/comparaison de sortie/PWM/comptage d'impulsions
- Temporisateur système : compteur auto-incrémentiel 32 bits
Spécifications MC3172
| Attributes | Value |
|---|---|
| Frequency | up to 200MHz |
| SRAM | 128KB |
| Core voltage | 1.62V to 1.98V |
| GPIO voltage | 1.8V ~ 3.3V |
| RC oscillator | 8MHz, 200MHz |
| External oscillator | 4MHz～40MHz |
| Input clock | 133MHz max. |
| Counters | 8 |
| I/O ports | up to 64 |
| Communication interface | 12 |
| Package | LQFP100 |
Tutoriel de programmation de la carte de développement MC3172
Avant de programmer le microcontrôleur MC3172, nous devons télécharger l'outil de développement MounRiver Studio et le pack de projet MC3172.
Télécharger et installer MounRiver Studio
Le logiciel de développement du MC3172 est MounRiver Studio, dont l'adresse de téléchargement est :
Après avoir installé MounRiver Studio, l'écran de démarrage se présente comme suit :
Cliquez sur « Charger le projet/la solution » et sélectionnez notre projet MC3172. Ce fichier de projet se trouve dans le fichier MC3172_Template_v1.21 de la collecte de données MC3172 que nous venons de télécharger.
Tous les programmes de démonstration fournis par le site officiel se trouvent dans le fichier « GPIO_GPCOM_TIMER_Example.c ». Nous nous référerons également à cette partie pour notre portage.
Ouvrez l'outil de configuration du fil.
Dans le fichier de collecte de données MC3172 que vous venez de télécharger, vous trouverez également un outil de configuration de thread pour le logiciel de configuration de puce_V1.exe. Il se trouve dans le répertoire MC3172 data collection_V1.03 \ MC3172_Template \ MC3172.
Le code correspondant à ce logiciel est open source, adresse open source : https://gitee.com/gxchip.
Ouvrez le logiciel de téléchargement du programme.
Le fichier MC3172_V1.03 téléchargé depuis le site officiel contient un logiciel de téléchargement de programme pour puce, situé dans le répertoire MC3172_V1.03\MC3172_Template\Release.
Programmation MC3172 - Clignotement des LED
Les étapes ci-dessus nous ont permis de préparer l'environnement de développement MC3172. Nous allons maintenant concevoir le programme d'éclairage LED le plus basique.
Configuration des ressources mcu
Ouvrez le logiciel Thread Configuration Tool_V1.exe et réglez les paramètres comme suit :
Cliquez sur « Générer le code ». Lorsque vous définissez l'allocation SRAM, le fichier de projet MC3172.lds sera automatiquement mis à jour. Lorsque vous définissez l'allocation de threads, le fichier thread_config.h sera automatiquement mis à jour. Remarque : la sélection de la source d'horloge doit être notée. La source d'horloge système interne RC 200 MHz est activée par défaut. Après aucune configuration d'horloge ou réinitialisation, l'oscillateur RC interne 200 MHz est utilisé comme horloge CPU par défaut. Vous pouvez ensuite choisir en plus un cristal externe 4~40 MHz (la carte d'évaluation est équipée d'un cristal passif 48 m) pour piloter oscillateur RC 8 MHz ou horloge à entrée directe externe comme horloge du noyau. Cela signifie que le paramètre défini ici sera directement utilisé comme horloge du noyau ultérieurement.
Écrire le programme
En ouvrant le projet avec l'outil ide (MounRiver Studio), nous pouvons d'abord nous référer au code du programme dans le fichier GPIO_GPCOM_TIMER_Example.c :
//when main.c
GPIO_EXAMPLE(GPIOA_BASE_ADDR).
//GPIO_GPCOM_TIMER_Example.c
void GPIO_EXAMPLE(u32 gpio_sel)
{
//enables the GPIOA clock (run|thread group|peripheral clock division setting)
INTDEV_SET_CLK_RST(gpio_sel,(INTDEV_RUN|INTDEV_IS_GROUP0|INTDEV_CLK_IS_CORECLK_DIV2)).
//PA0-PA7 configured as output
GPIO_SET_OUTPUT_EN_VALUE(gpio_sel,(GPIO_PIN_7_0),GPIO_SET_ENABLE).
//PA8-PA15 configured as input
GPIO_SET_INPUT_EN_VALUE(gpio_sel,(GPIO_PIN_15_8),GPIO_SET_ENABLE).
//set output high
GPIO_SET_OUTPUT_PIN_TO_1(gpio_sel,(GPIO_PIN0|GPIO_PIN1|GPIO_PIN2|GPIO_PIN3)).
//set output low
GPIO_SET_OUTPUT_PIN_TO_0(gpio_sel,(GPIO_PIN4|GPIO_PIN5|GPIO_PIN6|GPIO_PIN7)).
while(1){
//Invert the pin level
GPIO_SET_OUTPUT_PIN_INV(gpio_sel,(GPIO_PIN0|GPIO_PIN2)).
u16 rx_data.
//Get the full level of GPIOA
rx_data=GPIO_GET_INPUT_VALUE_SAFE(gpio_sel).
//set the value of gpio
GPIO_SET_OUTPUT_PIN_VALUE(gpio_sel,(GPIO_PIN4|GPIO_PIN5|GPIO_PIN6|GPIO_PIN7),(rx_data>>4)).
for (u32 var = 0; var < 5000; ++var) {
NOP().
}
}
}
Suite à ce qui précède, écrivez un programme dans void thread0_main(void) dans main.c comme suit :
void thread0_main(void)
{
// Enables the clock of GPIOA
INTDEV_SET_CLK_RST(GPIOA_BASE_ADDR,(INTDEV_RUN|INTDEV_IS_GROUP0|INTDEV_CLK_IS_CORECLK_DIV2)).
// Set PA0 to output mode
GPIO_SET_OUTPUT_EN_VALUE(GPIOA_BASE_ADDR,(GPIO_PIN0),GPIO_SET_ENABLE).
// Configure the default output to be high
GPIO_SET_OUTPUT_PIN_TO_1(GPIOA_BASE_ADDR,GPIO_PIN0).
while(1) {
//Invert the pins
GPIO_SET_OUTPUT_PIN_INV(GPIOA_BASE_ADDR,GPIO_PIN0).
//Delay
for (u32 var = 0; var < 5000; ++var) {
NOP().
}
}
thread_end().
}
Téléchargez le programme sur le MC3172.
Connectez d'abord la carte de développement à l'ordinateur, puis ouvrez le logiciel de téléchargement du programme de la carte de développement. À ce moment-là, un périphérique sera reconnu. Cliquez sur « Connect Device » (Connecter le périphérique), sélectionnez le micrologiciel MC3172.hex, puis cliquez sur « Burn Firmware » (Graver le micrologiciel). Lorsque la barre de progression atteint 100 %, le téléchargement est terminé.
Vérifier le programme
Pour vérifier la programmation du clignotement des LED, nous pouvons suivre les étapes suivantes :
- Vérifiez le code : assurez-vous que le code de programmation est correct et qu'il respecte la syntaxe de votre langage de programmation.
- Connectez la LED : connectez la LED à la broche que vous avez définie dans votre code de programmation.
- Observez la LED : si tout est correct, la LED devrait commencer à clignoter conformément au code de programmation.
- Déboguer : si la LED ne clignote pas comme prévu, vérifiez à nouveau votre code et assurez-vous que tout est correctement connecté.
Test d'exécution parallèle multithread MC3172
Nous écrivons deux threads, des threads pour la même configuration, deux threads pour chacune des deux E/S à inverser, un code de test tel que :
voidLED0_GPIOA_PIN0_TEST(void)
{
//Start GPIOA and set privilege group and clock frequency
INTDEV_SET_CLK_RST(GPIOA_BASE_ADDR,(INTDEV_RUN|INTDEV_IS_GROUP0|INTDEV_CLK_IS_CORECLK_DIV2)).
//Enable the GPIOAPIN0 pin
GPIO_SET_OUTPUT_EN_VALUE(GPIOA_BASE_ADDR,GPIO_PIN0,GPIO_SET_ENABLE).
while(1)
{
//GPIOAPIN0 output 1
GPIO_SET_OUTPUT_PIN_TO_1(GPIOA_BASE_ADDR,GPIO_PIN0).
//Delay
for(u32var=0;var< 5000;++var)
{
NOP().
}
//GPIOAPIN0 output 0
GPIO_SET_OUTPUT_PIN_TO_0(GPIOA_BASE_ADDR,GPIO_PIN0).
//Delay
for(u32var=0;var< 5000;++var)
{
NOP().
}
}
}
voidLED1_GPIOA_PIN1_TEST(void)
{
//Start GPIOA and set privilege group and clock frequency
INTDEV_SET_CLK_RST(GPIOA_BASE_ADDR,(INTDEV_RUN|INTDEV_IS_GROUP0|INTDEV_CLK_IS_CORECLK_DIV2)).
//Enable the GPIOAPIN1 pin
GPIO_SET_OUTPUT_EN_VALUE(GPIOA_BASE_ADDR,GPIO_PIN1,GPIO_SET_ENABLE).
while(1)
{
//GPIOAPIN1 output 1
GPIO_SET_OUTPUT_PIN_TO_1(GPIOA_BASE_ADDR,GPIO_PIN1).
//delay
for(u32var=0;var< 5000;++var)
{
NOP().
}
//GPIOAPIN1 output 0
GPIO_SET_OUTPUT_PIN_TO_0(GPIOA_BASE_ADDR,GPIO_PIN1).
//Delay
for(u32var=0;var< 5000;++var)
{
NOP().
}
}
}
////////////////////////////////////////////////////////////
voidthread_end(void)
{
while(1).
}
////////////////////////////////////////////////////////////
voidthread0_main(void)
{
while(1){
//usercodesection
}
thread_end().
}
////////////////////////////////////////////////////////////
voidthread1_main(void)
{
while(1){
//usercodesection
LED0_GPIOA_PIN0_TEST().
}
thread_end().
}
////////////////////////////////////////////////////////////
voidthread2_main(void)
{
while(1){
//usercodesection
LED1_GPIOA_PIN1_TEST().
}
thread_end().
}
Gravez le programme et utilisez un analyseur logique pour capturer les changements de niveau des broches GPIOA_PIN0 et GPIOA_PIN1 comme suit :
Comme le montre la figure, les deux formes d'onde sont entièrement synchronisées et le CPU effectue deux tâches simultanément, obtenant ainsi le même effet que le multithreading RTOS.
Programmation MC3172 vs programmation RTOS
Comme mentionné ci-dessus, la caractéristique unique du microcontrôleur MC3172 est un processeur temps réel multithread parallèle. Il résout les problèmes tels que le processus de portage fastidieux, la planification chronophage, etc., qui surviennent lors du développement d'un RTOS. Grâce à la réponse temps réel au niveau matériel, il peut atteindre un véritable « fonctionnement en temps réel ».
Voici un exemple de code de programmation multithread parallèle du microcontrôleur MC3172 :
void thread0_main(void)
{
while(1)
{
/// Application code
}
}
void thread1_main(void)
{
while(1)
{
/// Application code
}
}
void thread2_main(void)
void thread3_main(void)
------
Nous savons tous que les threads de planification sous-jacents au RTOS prendront plusieurs us (consommation de temps processeur différente), mais le processeur MC3172 est presque proche d'une consommation de temps nulle. Cela signifie que les threads MC3172 s'exécutent en parallèle à leur propre fréquence stable, sans surcharge de commutation ni gigue.
De plus, les données de réponse périphérique du processeur MC3172 sont plus en temps réel. Par exemple : le port série UART pour recevoir des données externes, plusieurs threads peuvent recevoir et répondre aux données série en parallèle. (Les microcontrôleurs ordinaires ont généralement une priorité d'interruption, ils « pausent » pour répondre aux données série à faible priorité, bloquant ainsi le cas, mais perdant également des données).
Conclusion
Le microcontrôleur MC3172 est un processeur unique en son genre que j'ai découvert en Chine. Il résout certains des problèmes liés aux RTOS et améliore l'efficacité de la programmation des puces.
Si vous utilisez le développement RTOS et rencontrez des problèmes tels que des retards de planification entre les threads, vous pouvez essayer le microcontrôleur MC3172.
