MC3172 Einführung
MC3172 ist ein 32-Bit-RISC-Parallel-Multithread-Echtzeitprozessor, der von GXchip in China entwickelt wurde. Er verwendet einen neuen CPU-Arbeitsmodus und Softwareentwicklungsmodus. Im Gegensatz zum Single-Thread-Programmiermodus laufen die verschiedenen Threads des Parallel-Multithreading synchron, ohne sich gegenseitig zu beeinträchtigen, und es gibt kein Prioritätskonzept.
MC3172 Pinbelegung
MC3172 Funktionen
Dieser Mikrocontroller MC3172 hat viele Gemeinsamkeiten mit den gängigen Mikrocontrollern, die wir verwenden, wie GPIO, UART, SPI, USB, CAN und anderen gängigen Peripheriegeräten.
Er verfügt jedoch über eine ganz besondere Eigenschaft: Es handelt sich um einen parallelen Multithread-Echtzeitprozessor, der auf dem RISC-V RV32IMC-Befehlssatz basiert.
Mit anderen Worten: Er verfügt über RTOS-Multithreading-Fähigkeiten, reagiert jedoch anstelle der regulären RTOS-Softwareplanung in Echtzeit auf Hardwareebene ohne Interrupt-Service-Routinen.
- Unterstützt RV32IMC-Befehlssatzkombination, Single-Cycle-Multiplikation
- 64 parallel laufende Threads ohne Interrupt-Service
- Thread-Ressourcen können nach Bedarf konfiguriert werden, und es ist kein Echtzeit-Betriebssystem erforderlich
- 100 % Single-Cycle-Befehle, keine Verzweigungsvorhersage
- Unterstützt USART, SPI-Schnittstelle, USB2.0-Host-/Geräteschnittstelle, CAN2.0B
- Bis zu 4 Kanäle für Eingangsabtastung/Ausgangsvergleich/PWM/Impulszählung
- Systemzeittimer: 32-Bit-Selbstinkrementierzähler
MC3172 Spezifikation
| 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 |
MC3172 Entwicklungsboard-Programmierhandbuch
Bevor wir den Mikrocontroller MC3172 programmieren können, müssen wir das Entwicklungstool MounRiver Studio und das MC3172 Project Pack herunterladen.
MounRiver Studio herunterladen und installieren
Die Entwicklungssoftware für den MC3172 ist MounRiver Studio, die Download-Adresse lautet:
Nach der Installation von MounRiver Studio sieht der Startbildschirm wie folgt aus:
Klicken Sie auf „Projekt/Lösung laden“ und wählen Sie unser MC3172-Projekt aus. Diese Projektdatei befindet sich in der Datei „MC3172_Template_v1.21“ in der soeben heruntergeladenen MC3172-Datensammlung.
Alle auf der offiziellen Website bereitgestellten Demoprogramme befinden sich in der Datei „GPIO_GPCOM_TIMER_Example.c”. Wir werden uns für unsere Portierung ebenfalls auf diesen Teil beziehen.
Öffnen Sie das Thread-Konfigurationstool.
In der soeben heruntergeladenen MC3172-Datenerfassungsdatei befindet sich auch ein Chip-Konfigurationssoftware-Thread-Konfigurationstool_V1.exe. Es befindet sich im Verzeichnis MC3172-Datenerfassung_V1.03 \ MC3172_Template \ MC3172.
Der entsprechende Code für diese Software ist Open Source, Open-Source-Adresse: https://gitee.com/gxchip.
Öffnen Sie die Programm-Download-Software.
In der Datei MC3172_V1.03, die von der offiziellen Website heruntergeladen wurde, befindet sich eine Chip-Programm-Download-Software im Verzeichnis MC3172_V1.03\MC3172_Template\Release.
MC3172 Programmierung – LED blinkt
Mit den oben genannten Schritten haben wir die MC3172-Entwicklungsumgebung vorbereitet und werden nun das grundlegendste LED-Beleuchtungsprogramm entwerfen.
Konfigurieren von MCU-Ressourcen
Öffnen Sie die Software „Thread Configuration Tool_V1.exe“ und stellen Sie die Parameter wie folgt ein:
Klicken Sie auf „Code generieren“. Wenn Sie die SRAM-Zuweisung festlegen, wird die Projektdatei MC3172.lds automatisch aktualisiert. Wenn Sie die Thread-Zuweisung festlegen, wird thread_config.h automatisch aktualisiert. Hinweis: Beachten Sie die Auswahl der Taktquelle. Die interne RC-Taktquelle mit 200 MHz ist standardmäßig aktiviert. Wenn keine Taktkonfiguration oder kein Reset erfolgt, wird der interne 200-MHz-RC-Oszillator als Standard-CPU-Takt verwendet. Sie können zusätzlich einen externen 4- bis 40-MHz-Quarz (das Evaluierungsboard ist mit einem passiven 48-MHz-Quarz bestückt) zum Antrieb auswählen. einen 8-MHz-RC-Oszillator oder einen externen Direkt-Eingangstakt als Kernel-Takt verwenden. Das bedeutet, dass die hier vorgenommene Einstellung später direkt als Kernel-Takt verwendet wird.
Das Programm schreiben
Wenn wir das Projekt mit dem ide-Tool (MounRiver Studio) öffnen, können wir zunächst den Programmcode in der Datei GPIO_GPCOM_TIMER_Example.c aufrufen:
//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().
}
}
}
Schreiben Sie anschließend ein Programm in void thread0_main(void) in main.c wie folgt:
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().
}
Laden Sie das Programm auf den MC3172 herunter.
Verbinden Sie zunächst die Entwicklungsplatine mit dem Computer und öffnen Sie dann die Software zum Herunterladen des Programms für die Entwicklungsplatine. Nun wird ein Gerät erkannt. Klicken Sie auf „Gerät verbinden“, wählen Sie die Firmware „MC3172.hex“ aus und klicken Sie auf „Firmware brennen“. Wenn der Fortschrittsbalken 100 % erreicht hat, ist der Download abgeschlossen.
Überprüfen Sie das Programm
Um die Programmierung des LED-Blinkens zu überprüfen, können wir folgende Schritte ausführen:
- Überprüfen Sie den Code: Vergewissern Sie sich, dass der Programmiercode korrekt ist und die richtige Syntax für Ihre Programmiersprache aufweist.
- Schließen Sie die LED an: Schließen Sie die LED an den Pin an, den Sie in Ihrem Programmiercode definiert haben.
- Beobachten Sie die LED: Wenn alles korrekt ist, sollte die LED gemäß dem Programmiercode zu blinken beginnen.
- Debuggen: Wenn die LED nicht wie erwartet blinkt, überprüfen Sie Ihren Code erneut und stellen Sie sicher, dass alles korrekt angeschlossen ist.
MC3172 Multithreaded Parallel Execution Test
Wir schreiben zwei Threads, Threads für dieselbe Konfiguration, zwei Threads für jede der beiden umzuschaltenden IOs, Testcode wie zum Beispiel:
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().
}
Brennen Sie das Programm und verwenden Sie einen Logikanalysator, um die Änderungen des Pin-Pegels von GPIOA_PIN0 und GPIOA_PIN1 wie folgt zu erfassen:
Wie in der Abbildung zu sehen ist, sind die beiden Wellenformen vollständig synchronisiert, und die CPU führt zwei Aufgaben gleichzeitig aus, wodurch derselbe Effekt wie beim Multithreading eines Echtzeitbetriebssystems erzielt wird.
MC3172-Programmierung vs. RTOS-Programmierung
Wie oben erwähnt, ist die einzigartige Funktion des Mikrocontrollers MC3172 ein paralleler Multithread-Echtzeitprozessor. Er löst Probleme wie den zugrunde liegenden umständlichen Portierungsprozess, zeitaufwändige Zeitplanung usw., die bei der RTOS-Entwicklung auftreten. Durch die zugrunde liegende Echtzeitreaktion auf Hardwareebene kann er einen echten „Echtzeitbetrieb” erreichen.
Hier ist ein Code-Beispiel für die parallele Multithread-Programmierung des Mikrocontrollers 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)
------
Wir alle wissen, dass die dem RTOS zugrunde liegenden Scheduling-Threads mehrere us (unterschiedlicher Prozessorzeitverbrauch) benötigen, aber der MC3172-Prozessor hat einen Zeitverbrauch von fast 0. Das bedeutet, dass die MC3172-Threads parallel mit ihrer eigenen stabilen Frequenz laufen, ohne Switching-Overhead oder Jitter.
Außerdem sind die Peripherie-Antwortdaten des MC3172-Prozessors zeitnaher. Beispiel: UART-Seriellport zum Empfang externer Daten, mehrere Threads können die seriellen Daten parallel empfangen und darauf reagieren. (Gewöhnliche Mikrocontroller haben in der Regel Interrupt-Priorität, „pausieren“, um auf serielle Daten mit niedriger Priorität zu reagieren, blockieren den Fall, verlieren aber auch Daten.
Fazit
Der Mikrocontroller MC3172 ist ein einzigartiger Prozessor, den ich in China kennengelernt habe. Er löst einige der Probleme, die bei RTOS auftreten, und verbessert die Effizienz der Chip-Programmierung.
Wenn Sie also RTOS-Entwicklung einsetzen und Probleme wie Verzögerungen bei der Ablaufplanung zwischen Threads haben, können Sie den Mikrocontroller MC3172 ausprobieren.
