MC3172 Introdução
O MC3172 é um processador RISC de 32 bits, multithreaded paralelo e em tempo real, desenvolvido pela GXchip na China. Ele utiliza um novo modo de funcionamento da CPU e um novo modo de desenvolvimento de software. Ao contrário do modo de programação single-threaded, os vários threads do multithreading paralelo funcionam de forma síncrona, sem interferirem uns nos outros, e não existe o conceito de prioridade.
Pinagem do MC3172
Características do MC3172
Este microcontrolador MC3172 tem muito em comum com os microcontroladores comuns que usamos, como GPIO, UART, SPI, USB, CAN e outros periféricos comuns.
Mas ele tem uma característica muito única: é um processador paralelo multithread em tempo real baseado no conjunto de instruções RISC-V RV32IMC.
Em outras palavras, ele tem capacidade multithreading RTOS, mas em vez do agendamento regular de software RTOS, ele responde em tempo real no nível do hardware sem rotinas de serviço de interrupção.
- Suporta combinação do conjunto de instruções RV32IMC, multiplicação de ciclo único
- 64 threads executando em paralelo sem serviço de interrupção
- Os recursos de thread podem ser configurados sob demanda e não é necessário um sistema operacional em tempo real
- 100% de instruções de ciclo único, sem previsão de ramificação
- Suporte a USART, interface SPI, interface host/dispositivo USB 2.0, CAN 2.0B
- Até 4 canais para captura de entrada/comparação de saída/PWM/contagem de pulsos
- Temporizador de tempo do sistema: contador autoincremental de 32 bits
Especificação 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 programação da placa de desenvolvimento MC3172
Antes de programar o microcontrolador MC3172, precisamos baixar a ferramenta de desenvolvimento – MounRiver Studio e o Pacote de Projetos MC3172.
Faça o download e instale o MounRiver Studio
O software de desenvolvimento do MC3172 é o MounRiver Studio, cujo endereço para download é:
Após instalar o MounRiver Studio, a tela inicial é a seguinte:
Clique em carregar projeto/solução e selecione nosso projeto MC3172. Esse arquivo de projeto está dentro do arquivo MC3172_Template_v1.21 na coleção de dados MC3172 que acabamos de baixar.
Todos os programas de demonstração fornecidos pelo site oficial estão localizados no arquivo “GPIO_GPCOM_TIMER_Example.c”. Também nos referiremos a essa parte para nossa portabilidade.
Abra a ferramenta de configuração de thread
No arquivo de coleta de dados MC3172 recém-baixado, há também uma ferramenta de configuração de thread do software de configuração do chip_V1.exe. Ela está localizada no diretório MC3172 data collection_V1.03 \ MC3172_Template \ MC3172.
O código correspondente a este software é de código aberto, endereço do código aberto: https://gitee.com/gxchip.
Abra o software de download do programa
Existe um software de download do programa do chip no arquivo MC3172_V1.03 baixado do site oficial, localizado no diretório MC3172_V1.03\MC3172_Template\Release.
Programação MC3172 - LED piscando
Com as etapas acima, preparamos o ambiente de desenvolvimento MC3172 e projetaremos o programa de iluminação LED mais básico.
Configurando recursos mcu
Abra o software Thread Configuration Tool_V1.exe e defina os parâmetros da seguinte forma:
Clique em gerar código. Ao definir a alocação de SRAM, o arquivo de projeto MC3172.lds será atualizado automaticamente. Ao definir a alocação de thread, o arquivo thread_config.h será atualizado automaticamente. Observação: a seleção da fonte do relógio deve ser observada. A fonte do relógio do sistema RC interno de 200 MHz é ativada por padrão. Após nenhuma configuração ou reinicialização do relógio, o oscilador RC interno de 200 MHz é usado como o relógio padrão da CPU. Em seguida, você pode escolher adicionalmente um cristal externo de 4 a 40 MHz (a placa de avaliação é conectada a um cristal passivo de 48 m) para acionar oscilador RC de 8 MHz ou relógio de entrada direta externa como relógio do kernel. Isso significa que a configuração aqui será usada diretamente como relógio do kernel posteriormente.
Escrevendo o programa
Ao abrir o projeto com a ferramenta ide (MounRiver Studio), podemos primeiro consultar o código do programa no arquivo 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().
}
}
}
Seguindo o acima exposto, escreva um programa em void thread0_main(void) em main.c da seguinte forma:
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().
}
Faça o download do programa para o MC3172
Primeiro, conecte a placa de desenvolvimento ao computador e, em seguida, abra o software de download do programa da placa de desenvolvimento. Desta vez, um dispositivo será reconhecido. Clique em Conectar dispositivo, selecione o firmware MC3172.hex e clique em Gravar firmware. Quando a barra de progresso atingir 100%, o download estará concluído.
Verifique o programa
Para verificar a programação do LED piscando, podemos seguir estas etapas:
- Verifique o código: Certifique-se de que o código de programação está correto e que tem a sintaxe correta para a sua linguagem de programação.
- Conecte o LED: Conecte o LED ao pino que você definiu no seu código de programação.
- Observe o LED: se tudo estiver correto, o LED deve começar a piscar de acordo com o código de programação.
- Depurar: Se o LED não estiver piscando como esperado, verifique seu código novamente e certifique-se de que tudo esteja conectado corretamente.
Teste de execução paralela multithread MC3172
Escrevemos dois threads, threads para a mesma configuração, dois threads para cada uma das duas IOs a serem invertidas, código de teste 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().
}
Grave o programa e use um analisador lógico para capturar as alterações no nível dos pinos GPIOA_PIN0 e GPIOA_PIN1 da seguinte maneira:
Como pode ser visto na figura, as duas formas de onda estão totalmente sincronizadas e a CPU está realizando duas tarefas simultaneamente, alcançando o mesmo efeito que o multithreading do RTOS.
Programação MC3172 vs. Programação RTOS
Como mencionado acima, a característica única do microcontrolador MC3172 é um processador paralelo multithread em tempo real. Ele resolve problemas como o processo de portabilidade complicado, o agendamento demorado, etc., que ocorrem durante o desenvolvimento do RTOS. Através da resposta em tempo real no nível do hardware, ele pode alcançar uma verdadeira "operação em tempo real".
Aqui está um exemplo de código de programação multithread paralela do 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 os threads de agendamento subjacentes ao RTOS levam vários us (consumo de tempo diferente do processador), mas o processador MC3172 tem um consumo de tempo quase próximo de 0. Isso significa que os threads do MC3172 estão sendo executados em paralelo em sua própria frequência estável, sem sobrecarga de comutação ou instabilidade.
Além disso, os dados de resposta periférica do processador MC3172 são mais em tempo real. Por exemplo: porta serial UART para receber dados externos, várias threads podem receber e responder aos dados seriais em paralelo. (O microcontrolador comum geralmente tem prioridade de interrupção, irá "pausar" para responder a dados seriais de baixa prioridade, bloqueando o caso, mas também perdendo dados)
Conclusão
O microcontrolador MC3172 é um processador muito exclusivo que eu vi na China. Ele resolve alguns dos problemas que existem com o RTOS e melhora a eficiência da programação do chip.
Portanto, se você estiver usando desenvolvimento RTOS e enfrentando problemas como atrasos de agendamento entre threads, pode experimentar o microcontrolador MC3172.
