Gravação RT-Thread (1. Versão RT-Thread, ambiente de desenvolvimento RT-Thread Studio e início rápido com desenvolvimento CubeMX)

距离完成 FreeRTOS 的记录也有一段时间了，除了最近在测试的ESP32-C3 ，也该记录一下 RT-Thread。
期间几个月时间关于 RT-Thread 的项目有好几个，感觉最近 RT-Thread 越来越火，
在几年前用过 RT-Thread，那个时候都还没有RT-Thread Studio IDE，现在啥都有了。
RT-Thread官方资料也多，理论，示例，说明应有尽有，自己重新学习一边，做个记录贴。

prefácio

Como sistema operacional doméstico, comparado a outros sistemas operacionais, o site oficial é extremamente amigável para a maioria dos engenheiros = =!

Quais informações podem ser visualizadas diretamente no site oficial. Então, se você tiver alguma dúvida, acesse o site oficial primeiro! Abaixo estão alguns links comumente usados, que estão realmente disponíveis no site oficial para facilitar a consulta.

Centro de Documentação RT-Thread

Fórum Oficial RT-Thread

Centro de Design de Referência de Rosca RT

Centro de vídeo oficial RT-Thread

Centro de download de código-fonte RT-Thread

Pacote RT-Thread

1. Versão RT-Thread (com qual versão começar a aprender)

Atualmente, o RT-Thread é dividido principalmente em 3 versões principais, disponíveis no centro de documentos. Aqui está uma breve descrição de acordo com sua própria situação:

1.1 RT-Thread Nano

RT-Thread Nano e FreeRTOS são coisas relativamente semelhantes. Um kernel, o Nano é adequado para alguns MCUs com pouco espaço de memória, como o STM32L051C8 que costumo usar agora, com apenas 8 KB de espaço de RAM. Ao explicar o FreeRTOS, mencionei o uso de STM32L051C8 mais de uma vez para problemas de memória.

Se você quiser aprender de acordo com suas próprias necessidades, é recomendável começar a aprender a partir da versão padrão, porque a versão padrão inclui tudo do Nano, além de muitos outros componentes e pacotes de software fáceis de usar.

Em aplicações práticas, estima-se que o Nano seja mais usado em projetos de aplicativos comuns, e a memória é o custo!

As informações do RT-Thread Nano podem ser visualizadas no centro de documentação oficial, apenas lembre-se de uma coisa, é uma versão minimalista do kernel hard real-time.

1.2 RT-Thread Standard Edition

A versão padrão do RT-Thread inclui Nano, e a versão padrão vem com pacotes de software de componentes ricos, que é uma das principais diferenças entre ele e o FreeRTOS. Em alguns aplicativos, como MQTT, acesso à nuvem, etc., o RT-Thread tem ready-made O pacote de software é simples e conveniente de usar.
Se você está aprendendo, é recomendável começar com a versão padrão. Embora em alguns casos, os componentes ricos e pacotes de software possam dificultar para iniciantes entender como componentes e pacotes de software estão relacionados ao hardware, mas somente depois que você realmente Você encontrará sua conveniência e, ao mesmo tempo, entenderá o princípio, também poderá personalizar e aumentar os componentes de acordo com sua própria aplicação, o que pode atender melhor às necessidades de vários projetos.

A introdução ainda está no site oficial. A introdução foi retirada do site oficial:
Uma das principais diferenças entre o RT-Thread e muitos outros RTOSs, como FreeRTOS e uC/OS, é que ele não é apenas um kernel de tempo real, mas também possui uma grande variedade de componentes de camada intermediária:

Mesmo que a versão padrão RT-Thread seja selecionada como a versão de aprendizado, existem muitas versões no que diz respeito à versão padrão:

a versão específica e como escolher pode consultar as instruções oficiais, o link é o seguinte:

Como escolher uma versão RT-Thread adequada para desenvolvimento?

1.3 RT-Thread Inteligente

O RT-Thread Smart não existia há alguns anos, o mais recente é para chips com MMU, que costumavam rodar sistemas Linux.
Por exemplo, nos últimos dois anos, houve duas séries de chips, STM32MP1 e IMX6ULL, que se tornaram populares em placas de desenvolvimento. Claro, as placas de desenvolvimento desenvolvidas foram baseadas principalmente em sistemas Linux no início, e agora o RT-Thread também pode ser executado nesses chips.
Esta versão não é o que a postagem do blog nesta coluna precisa registrar.Se você tiver a oportunidade de fazer alguns registros depois de escrever o Linux incorporado posteriormente.

A introdução é retirada do site oficial:
RT-Thread Smart (referido como rt-smart) é uma nova ramificação baseada no sistema operacional RT-Thread, visando chips com MMU e aplicativos de médio a alto padrão, como Chips da série ARM Cortex-A, chips MIPS, com chip MMU RISC-V, etc. O rt-smart permite o modo de processo completo e independente baseado no sistema operacional RT-Thread, enquanto executa no modo microkernel híbrido.

2. Ambiente de desenvolvimento RT-Thread

Através da introdução acima, vamos usar a versão padrão para gravar o RT-Thread. A placa usa o STM32F103VGT6 que desenhei antes. Naquela época, o preço do chip não aumentou = =! A imagem pode se referir ao meu post anterior no blog:

A partir do RTOS (preparação e ideias para aprendizado de aplicativos RTOS)

2.1 Ferramentas de desenvolvimento

Ainda me lembro que quando aprendi RT-Thread antes, o RT-Thread Studio IDE ainda não havia sido lançado. A construção geral do projeto precisa usar ferramentas como ENV, SCons, etc. Seja MDK, IRA, desenvolvimento de cadeia de ferramentas GCC , você deve primeiro usar a ferramenta ENV e Scons, configurar e operar uma vez, para iniciantes, é muito hostil, a introdução detalhada pode ser consultada no site oficial:

Página de introdução oficial das ferramentas de desenvolvimento

O estudo inicial foi baseado na documentação oficial, manuais, vídeos, etc., e eu mesmo usei, mas depois de um período sem uso, os comandos foram quase esquecidos.
Bem, agora, a equipe oficial do RT-Thread lançou o RT-Thread Studio. O RT-Thread Studio integrou essas ferramentas de desenvolvimento anteriores, portanto, não há necessidade de memorizar os comandos anteriores, e a construção do projeto de gráficos de interface é mais simples e intuitiva do que antes.
Como um IDE doméstico, a operação da interface é bastante amigável. Nossos tutoriais nesta série são para fins de projetos. Para poder usar o RT-Thread para concluir o desenvolvimento de um projeto completo, não gastaremos muita energia jogando a estrutura de engenharia, coisas como estruturação, então usar o RT-Thread Studio é perfeito.

2.2 Construção do Ambiente

De acordo com a introdução acima, decidimos usar o RT-Thread Studio como o IDE de desenvolvimento para esta série de postagens do blog. A instalação e o download podem ser encontrados diretamente no site oficial. Consulte os seguintes documentos:

Instruções oficiais do RT-Thread Studio

Instale-o de acordo com o manual:

Após a conclusão da instalação, você precisa fazer login na conta RT-Thread para executar o software:

De acordo com a documentação oficial, o primeiro passo é instalar e atualizar o pacote SDK:

No meu computador, já criei um ambiente antes. Sinto que o RT-Thread Studio reconhecerá automaticamente as variáveis ​​de ambiente no computador para encontrar o ambiente que já existe no computador, como a versão acima, e a versão da cadeia de ferramentas GCC I use. :

Depois de instalar o pacote SDK, você pode basicamente começar a construir o teste do projeto.

Mais uma vez, o manual do usuário do RT-Thread Studio, configuração da interface e outras operações, documentos oficiais, vídeos, todos têm instruções detalhadas. Aqui estão registrados os passos necessários para seu próprio uso.

2.3 RT-Thread Studio para Vscode

(Para ser atualizado... Primeiro, use o IDE para se tornar proficiente e depois brinque com o plug-in no Vscode. Afinal, a configuração do IDE é relativamente simples)

3. O primeiro projeto

3.1 Crie um novo projeto de acordo com seu próprio ambiente

Após a operação acima, criaremos diretamente um novo projeto. Antes de criar um novo projeto:

Mais uma vez, explique o ambiente usado neste artigo:

1. Usando RT-Thread Standard Edition
2. A placa de desenvolvimento desenhada por mim, baseada em STM32F103VGT6

Então fazemos as seguintes escolhas na interface do novo projeto no RT-Thread Studio:

Clique em Concluir e espere o projeto ser gerado automaticamente, pois a porta serial 1 já está configurada por padrão ao criar um novo projeto, então compile-o diretamente e grave-o:

Conecte-se à placa de desenvolvimento através do assistente de porta serial, a taxa de transmissão padrão é 115200:

Você pode ver que o RT-Thread está rodando normalmente na placa:

3.2 Uso com configuração CubeMX

Os resultados dos testes acima vistos através do terminal usam apenas a função de porta serial. Quanto ao letreiro inicial que permaneceu inalterado por milhares de anos, não o vimos, então como ele pode ser refletido no hardware? os documentos oficiais. A introdução de:

No entanto, não há muitas instruções oficiais nesta parte. Ainda precisamos testar e explicar aqui. Os resultados do teste são suaves na frente e existem alguns pequenos problemas nas operações subsequentes, que precisam ser observados! ! !

Clique em CubeMx Setting no diretório do projeto:

Após abri-lo, preste atenção em como configurar o relógio, porta serial, porta IO, etc. ao usar o CubeMx antes. Embora já possamos passar o relógio e a porta serial quando o projeto for estabelecido, mas após abrir esta configuração, temos para redefinir todas as configurações. novamente!

Se o projeto STM32CubMX não for definido, você pode consultar a postagem do blog:
Teste STM32L051 (1. Use CubeMX para gerar arquivos de projeto - comuns aos chips da série ST)

De acordo com as etapas, configuramos o relógio , modo de depuração, porta serial, LED e botões para um teste simples preliminar.

Verifique a coluna Code Generator antes de produzir o código:

em seguida, clique em Generate Project.

Após a geração do projeto, ele não precisa ser aberto, mas o CubeMX deve ser fechado, para que as seguintes operações possam ser realizadas normalmente no RT-Thread Studio!

Após a geração do projeto, o fechamento do CubeMX avisará que o cubemx.ioc foi modificado. Se você deseja salvar a configuração, clique em Sim.

• O hal_conf.h original é substituído pelo cubeMX recém-gerado

• O RT-Thread Studio usará e somente o conteúdo das pastas Inc e Src geradas pelo CubeMX

• A função principal RT-Thread Studio será declarada com _WEAK antes da função principal gerada pelo CubeMX

• Função de inicialização do relógio, usará as configurações no CubeMx
  

• Algumas compilações básicas são configuradas automaticamente pela versão atual do RT-Thread Studio e passadas SConscript.

O projeto pode ser compilado diretamente.

Nossa função principal está no arquivo main.c em aplicativos, portanto, para usar a configuração gerada pelo CubeMX, precisamos incluir o arquivo de cabeçalho correspondente no arquivo main.c em aplicativos e chamar a inicialização na função main.

Mas eu não esperava encontrar um problema aqui:

olhei com cuidado e descobri que era impossível encontrar a implementação dessas duas inicializações. Olhando para a arquitetura de engenharia, não havia dois arquivos .c. Depois de pesquisar por um longo tempo, ainda encontrei uma maneira. Modifique o SConscriptarquivo, semelhante ao Makefile:

Após a reconstrução do cubemx -> Src -> existem mais arquivos .c correspondentes abaixo, e o projeto acima pode ser compilado normalmente!

Notas Adicionais:

Através do Makefile, você pode ver diretamente quantos arquivos .c nosso CubeMX gerou:

Além do que o RT-Thread Studio nos adicionou por padrão, também adicionamos arquivos GPIO e driver de porta serial, e um está relacionado a interrupções. Nós não adicionamos! !

Então é impossível responder à interrupção?

Além disso, se os arquivos de driver de porta serial e GPIO gerados pelo CubeMX não forem adicionados e a inicialização no CubeMX não for usada, o GPIO ficará indisponível?

Esses problemas não serão explicados por enquanto.O próprio kernel RT-Thread possui drivers em nível de placa, pois isso é algum conhecimento do driver do kernel RT-Thread que precisa ser apresentado nos artigos a seguir.

3.3 Criar uma tarefa de letreiro

Depois de concluir a configuração acima, podemos começar a andar com o letreiro. Como o RTOS é usado, é claro, podemos concluir nosso início rápido criando uma tarefa de letreiro LED.

Criamos estaticamente uma thread no programa, led1_blinkiniciamos o agendamento e começamos a executar quando ligamos; para
criar uma thread dinamicamente led2_blink, precisamos iniciar o agendamento por meio de comandos. O código-fonte do programa é o seguinte:

/*
 * Copyright (c) 2006-2022, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-02-16     QZH    	first lesson for test
 */

#include <rtthread.h>
#include "main.h"
#include "usart.h"
#include "gpio.h"

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

static struct rt_thread led1_thread;    //led1线程
static char led1_thread_stack[256];

static rt_thread_t led2_thread = RT_NULL; //led2线程

static void led1_thread_entry(void *par){
    
    
    while(1){
    
    
        LED1_ON;
        rt_thread_mdelay(1000);
        LED1_OFF;
        rt_thread_mdelay(1000);
    }
}

static void led2_thread_entry(void *par){
    
    
    while(1){
    
    
        LED2_ON;
        rt_thread_mdelay(500);
        LED2_OFF;
        rt_thread_mdelay(500);
    }
}

int main(void)
{
    
    
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    int count = 1;

    rt_err_t rst2;
    rst2 = rt_thread_init(&led1_thread,
                        "led1_blink ",
                        led1_thread_entry,
                        RT_NULL,
                        &led1_thread_stack[0],
                        sizeof(led1_thread_stack),
                        RT_THREAD_PRIORITY_MAX -1,
                        50);

    if(rst2 == RT_EOK){
    
    
        rt_thread_startup(&led1_thread);
    }

    while (count++)
    {
    
    
        if(count < 11){
    
    
            LOG_D("Hello RT-Thread!%d",count);
        }
        if(count >= 0XFFFFFF00) count = 0;
        rt_thread_mdelay(1000);
    }

    return RT_EOK;
}

void led2_Blink(){
    
    
    led2_thread = rt_thread_create("led2_blink",
                            led2_thread_entry,
                            RT_NULL,
                            256,
                            RT_THREAD_PRIORITY_MAX -1,
                            50);

    /* 如果获得线程控制块，启动这个线程 */
    if (led2_thread != RT_NULL)
        rt_thread_startup(led2_thread);
}

MSH_CMD_EXPORT(led2_Blink, Led2 sample);

Os resultados do teste de código acima são os seguintes: