Introduzione a MC3172
MC3172 è un processore real-time multithread parallelo RISC a 32 bit sviluppato da GXchip in Cina. Utilizza una nuova modalità di funzionamento della CPU e una nuova modalità di sviluppo software. A differenza della modalità di programmazione a thread singolo, i vari thread del multithreading parallelo vengono eseguiti in modo sincrono senza interferire l’uno con l’altro e non esiste il concetto di priorità.
Schema dei pin MC3172
Caratteristiche di MC3172
Questo microcontrollore MC3172 ha molto in comune con i microcontrollori comuni che utilizziamo, come GPIO, UART, SPI, USB, CAN e altre periferiche comuni.
Ma ha una caratteristica molto unica: è un processore real-time multithread parallelo basato sul set di istruzioni RISC-V RV32IMC.
In altre parole, ha funzionalità di multithreading RTOS, ma invece della normale pianificazione software RTOS, risponde in tempo reale a livello hardware senza routine di servizio di interrupt.
- Supporta la combinazione di set di istruzioni RV32IMC, moltiplicazione a ciclo singolo
- 64 thread in esecuzione in parallelo senza servizio di interrupt
- Le risorse del thread possono essere configurate su richiesta e non è richiesto un sistema operativo real-time
- 100% di istruzioni a ciclo singolo, nessuna previsione di diramazione
- Supporta l’interfaccia USART, SPI, l’interfaccia host/dispositivo USB2.0, CAN2.0B
- Fino a 4 canali per acquisizione di input/confronto di output/PWM/conteggio di impulsi
- Timer di sistema: contatore a incremento automatico a 32 bit
Specifiche di 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 |
Tutorial di programmazione della scheda di sviluppo MC3172
Prima di programmare il microcontrollore MC3172, dobbiamo scaricare lo strumento di sviluppo – MounRiver Studio e il pacchetto di progetto MC3172.
Scarica e installa MounRiver Studio
Il software di sviluppo di MC3172 è MounRiver Studio, il cui indirizzo di download è:
Dopo aver installato MounRiver Studio, la schermata di avvio è la seguente:
Fare clic su carica progetto/soluzione e selezionare il nostro progetto MC3172. Questo file di progetto si trova all’interno del file MC3172_Template_v1.21 nella raccolta dati MC3172 appena scaricata.
Tutti i programmi demo forniti dal sito Web ufficiale si trovano nel file “GPIO_GPCOM_TIMER_Example.c”. Ci riferiremo anche a questa parte per il nostro porting.
Apri lo strumento di configurazione del thread
Nel file di raccolta dati MC3172 appena scaricato, è presente anche un software di configurazione del chip strumento di configurazione del thread_V1.exe. Si trova nella directory MC3172 data collection_V1.03 \ MC3172_Template \ MC3172.
Il codice corrispondente a questo software è stato reso open source, indirizzo open source: https://gitee.com/gxchip.
Apri il software di download del programma
C’è un software di download del programma del chip nel file MC3172_V1.03 scaricato dal sito Web ufficiale, situato nella directory MC3172_V1.03\\MC3172_Template\\Release.
Programmazione MC3172 - Lampeggio del LED
Con i passaggi precedenti, abbiamo preparato l’ambiente di sviluppo MC3172 e progetteremo il programma di illuminazione LED più basilare.
Configurazione delle risorse mcu
Apri il software Thread Configuration Tool_V1.exe e imposta i parametri come segue:
Clicca su genera codice, quando imposti l’allocazione SRAM, il file di progetto MC3172.lds verrà aggiornato automaticamente, quando imposti l’allocazione del thread thread_config.h verrà aggiornato automaticamente. Nota: la selezione della sorgente di clock deve essere annotata, la sorgente di clock di sistema interna RC 200Mhz è attivata per impostazione predefinita, dopo nessuna configurazione di clock o reset, l’oscillatore RC interno da 200MHz viene utilizzato come clock CPU predefinito, quindi puoi scegliere ulteriormente un cristallo esterno da 4~40MHz (la scheda di valutazione è appesa a un cristallo passivo da 48m) per pilotare, oscillatore RC da 8Mhz o clock di ingresso diretto esterno come clock del kernel. Ciò significa che l’impostazione qui verrà utilizzata direttamente come clock del kernel in seguito.
Scrittura del programma
Aprendo il progetto con lo strumento ide (MounRiver Studio), possiamo innanzitutto fare riferimento al codice del programma nel file 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().
}
}
}
Seguendo quanto sopra, scrivi un programma in void thread0_main(void) in main.c come segue:
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().
}
Scarica il programma su MC3172
Innanzitutto, collega la scheda di sviluppo al computer, quindi apri il software di download del programma della scheda di sviluppo. Questa volta verrà riconosciuto un dispositivo, fai clic su Connetti dispositivo, seleziona il firmware MC3172.hex e fai clic su Masterizza firmware. Quando la barra di avanzamento raggiunge il 100%, il download è completo.
Verifica il programma
Per verificare la programmazione del lampeggio del LED, possiamo seguire questi passaggi:
- Controlla il codice: assicurati che il codice di programmazione sia corretto e abbia la sintassi corretta per il tuo linguaggio di programmazione.
- Collega il LED: collega il LED al pin che hai definito nel tuo codice di programmazione.
- Osserva il LED: se tutto è corretto, il LED dovrebbe iniziare a lampeggiare in base al codice di programmazione.
- Debug: se il LED non lampeggia come previsto, controlla di nuovo il tuo codice e assicurati che tutto sia collegato correttamente.
Test di esecuzione parallela multithread di MC3172
Scriviamo due thread, thread per la stessa configurazione, due thread per ciascuna delle due IO per capovolgere, codice di test come:
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().
}
Masterizza il programma e utilizza un analizzatore logico per acquisire le modifiche del livello dei pin GPIOA_PIN0 e GPIOA_PIN1 come segue:
Come si può vedere dalla figura, le due forme d’onda sono completamente sincronizzate e la CPU sta facendo due cose contemporaneamente, ottenendo lo stesso effetto del multithreading RTOS.
Programmazione MC3172 Vs Programmazione RTOS
Come menzionato sopra, la caratteristica unica del microcontrollore MC3172 è un processore in tempo reale parallelo multithread. Risolve questi problemi come il processo di porting sottostante ingombrante, la pianificazione che richiede tempo, ecc., che si verificano durante lo sviluppo RTOS. Attraverso la risposta in tempo reale a livello hardware, può ottenere una vera “operazione in tempo reale”.
Ecco un esempio di codice di programmazione parallela multithread del microcontrollore 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)
------
Sappiamo tutti che la pianificazione dei thread sottostante RTOS richiederà diversi us (tempo di consumo del processore diverso), ma il processore MC3172 è quasi vicino a 0 tempo di consumo. Ciò significa che i thread MC3172 vengono eseguiti in parallelo alla loro frequenza stabile, senza overhead di commutazione o jitter.
Inoltre, i dati di risposta periferica del processore MC3172 sono più in tempo reale. Ad esempio: la porta seriale UART per ricevere dati esterni, più thread possono ricevere e rispondere ai dati seriali in parallelo. (Il microcontrollore ordinario è generalmente priorità di interrupt, “pausa” per rispondere ai dati seriali a bassa priorità, bloccando il caso, ma anche la perdita di dati)
Conclusione
Il microcontrollore MC3172 è un processore molto particolare che ho visto in Cina. Risolve alcuni dei problemi esistenti con gli RTOS e migliora l’efficienza della programmazione dei chip.
Quindi, se stai utilizzando lo sviluppo RTOS e riscontri problemi come ritardi nella pianificazione tra i thread, puoi provare il microcontrollore MC3172.
