MC3172 Introducción
El MC3172 es un procesador en tiempo real multihilo paralelo RISC de 32 bits desarrollado por GXchip en China. Utiliza un nuevo modo de funcionamiento de la CPU y un nuevo modo de desarrollo de software. A diferencia del modo de programación de un solo hilo, los distintos hilos del multihilo paralelo se ejecutan de forma sincrónica sin interferir entre sí, y no existe el concepto de prioridad.
MC3172 Pinout
Características del MC3172
Este microcontrolador MC3172 tiene mucho en común con los microcontroladores habituales que utilizamos, como GPIO, UART, SPI, USB, CAN y otros periféricos comunes.
Pero tiene una característica muy singular: es un procesador en tiempo real multihilo paralelo basado en el conjunto de instrucciones RISC-V RV32IMC.
En otras palabras, tiene capacidad multihilo RTOS, pero en lugar de la programación habitual del software RTOS, responde en tiempo real a nivel de hardware sin rutinas de servicio de interrupción.
- Admite la combinación del conjunto de instrucciones RV32IMC y la multiplicación de ciclo único.
- 64 subprocesos ejecutándose en paralelo sin servicio de interrupción
- Los recursos de subprocesos se pueden configurar bajo demanda y no se requiere un sistema operativo en tiempo real
- Instrucciones 100 % de ciclo único, sin predicción de ramificación
- Compatible con USART, interfaz SPI, interfaz host/dispositivo USB 2.0, CAN 2.0B
- Hasta 4 canales para captura de entrada/comparación de salida/PWM/recuento de pulsos
- Temporizador de tiempo del sistema: contador autoincremental de 32 bits
Especificación 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 de programación de la placa de desarrollo MC3172
Antes de programar el microcontrolador MC3172, debemos descargar la herramienta de desarrollo MounRiver Studio y el paquete de proyectos MC3172.
Descargar e instalar MounRiver Studio
El software de desarrollo del MC3172 es MounRiver Studio, cuya dirección de descarga es:
Después de instalar MounRiver Studio, la pantalla de inicio es la siguiente:
Haga clic en «Cargar proyecto/solución» y seleccione nuestro proyecto MC3172. Este archivo de proyecto se encuentra dentro del archivo MC3172_Template_v1.21, en la recopilación de datos MC3172 que acabamos de descargar.
Todos los programas de demostración proporcionados por el sitio web oficial se encuentran en el archivo «GPIO_GPCOM_TIMER_Example.c». También nos referiremos a esta parte para nuestra migración.
Abre la herramienta de configuración de hilos.
En el archivo de recopilación de datos MC3172 que acaba de descargar, también hay una herramienta de configuración de hilos del software de configuración del chip_V1.exe. Se encuentra en el directorio MC3172 data collection_V1.03 \ MC3172_Template \ MC3172.
El código correspondiente a este software es de código abierto, dirección de código abierto: https://gitee.com/gxchip.
Abre el programa de descarga de software.
Hay un software de descarga del programa del chip en el archivo MC3172_V1.03 descargado del sitio web oficial, ubicado en el directorio MC3172_V1.03\MC3172_Template\Release.
Programación MC3172 - Parpadeo de LED
Con los pasos anteriores, hemos preparado el entorno de desarrollo MC3172 y diseñaremos el programa de iluminación LED más básico.
Configuración de los recursos de la MCU
Abra el software Thread Configuration Tool_V1.exe y configure los parámetros de la siguiente manera:
Haga clic en «Generar código». Cuando configure la asignación de SRAM, el archivo de proyecto MC3172.lds se actualizará automáticamente; cuando configure la asignación de subprocesos, thread_config.h se actualizará automáticamente. Nota: Debe tenerse en cuenta la selección de la fuente de reloj. La fuente de reloj del sistema RC interno de 200 MHz está activada de forma predeterminada. Si no se configura el reloj ni se reinicia, el oscilador RC interno de 200 MHz se utiliza como reloj predeterminado de la CPU. A continuación, puede elegir adicionalmente un cristal externo de 4 a 40 MHz (la placa de evaluación lleva un cristal pasivo de 48 m) para el control. oscilador RC de 8 MHz o reloj de entrada directa externo como reloj del núcleo. Esto significa que la configuración aquí se utilizará directamente como reloj del núcleo más adelante.
Escribir el programa
Al abrir el proyecto con la herramienta ide (MounRiver Studio), primero podemos consultar el código del programa en el archivo 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().
}
}
}
Siguiendo lo anterior, escriba un programa en void thread0_main(void) en main.c de la siguiente manera:
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().
}
Descargar el programa al MC3172
Primero conecte la placa de desarrollo al ordenador y, a continuación, abra el software de descarga de programas de la placa de desarrollo. En este momento se reconocerá un dispositivo, haga clic en «Conectar dispositivo», seleccione el firmware MC3172.hex y haga clic en «Grabar firmware». Cuando la barra de progreso alcance el 100 %, la descarga habrá finalizado.
Verificar el programa
Para verificar la programación del parpadeo del LED, podemos seguir estos pasos:
- Comprueba el código: asegúrate de que el código de programación es correcto y que tiene la sintaxis adecuada para tu lenguaje de programación.
- Conecte el LED: conecte el LED al pin que ha definido en su código de programación.
- Observe el LED: si todo es correcto, el LED debería empezar a parpadear según el código de programación.
- Depurar: si el LED no parpadea como se esperaba, compruebe de nuevo el código y asegúrese de que todo está correctamente conectado.
Prueba de ejecución paralela multihilo MC3172
Escribimos dos subprocesos, subprocesos para la misma configuración, dos subprocesos para cada una de las dos E/S que se van a invertir, código de prueba como:
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().
}
Grabe el programa y utilice un analizador lógico para capturar los cambios de nivel de los pines GPIOA_PIN0 y GPIOA_PIN1 de la siguiente manera:
Como se puede observar en la figura, las dos formas de onda están totalmente sincronizadas y la CPU está realizando dos tareas al mismo tiempo, logrando el mismo efecto que el multithreading de RTOS.
Programación MC3172 frente a programación RTOS
Como se ha mencionado anteriormente, la característica única del microcontrolador MC3172 es un procesador en tiempo real multihilo paralelo. Resuelve problemas como el engorroso proceso de portabilidad subyacente, la programación que requiere mucho tiempo, etc., que se producen durante el desarrollo de RTOS. A través de la respuesta en tiempo real a nivel de hardware subyacente, puede lograr un verdadero «funcionamiento en tiempo real».
A continuación se muestra un ejemplo de código de programación multihilo paralelo del microcontrolador 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)
------
Todos sabemos que los subprocesos de programación subyacentes al RTOS tardarán varios us (diferente consumo de tiempo del procesador), pero el procesador MC3172 tiene un consumo de tiempo casi cercano a 0. Esto significa que los subprocesos del MC3172 se ejecutan en paralelo a su propia frecuencia estable, sin sobrecarga de conmutación ni fluctuaciones.
Además, los datos de respuesta periférica del procesador MC3172 son más en tiempo real. Por ejemplo: el puerto serie UART para recibir datos externos, múltiples subprocesos pueden recibir y responder a los datos serie en paralelo. (Los microcontroladores normales suelen tener prioridad de interrupción, se «pausan» para responder a datos serie de baja prioridad, bloqueando el caso, pero también se pierden datos).
Conclusión
El microcontrolador MC3172 es un procesador muy singular que he visto en China. Resuelve algunos de los problemas que existen con RTOS y mejora la eficiencia de la programación de chips.
Por lo tanto, si está utilizando el desarrollo RTOS y se encuentra con problemas como retrasos en la programación entre subprocesos, puede probar el microcontrolador MC3172.
