Este artigo refere-se ao [Wildfire EmbedFire] "Implementação do kernel RT-Thread e desenvolvimento de aplicativos - com base no STM32", que é usado apenas como uma nota de estudo pessoal. Para obter conteúdo e etapas mais detalhados, verifique o texto original (você pode baixá-lo no Centro de download de dados do Wildfire)

Conceito Básico de Temporizador

Um cronômetro refere-se a iniciar em um horário especificado, após um horário especificado e, em seguida, acionar um evento de tempo limite. Os usuários podem personalizar o período e a frequência do cronômetro. Semelhante ao despertador da vida, podemos definir quando o despertador toca todos os dias e também definir o número de vezes que toca, se ele toca uma vez ou todos os dias.

Os temporizadores são divididos em temporizadores de hardware e temporizadores de software:

os temporizadores de hardware são funções de temporização fornecidas pelo próprio chip. Geralmente, o clock de entrada é fornecido ao chip por um oscilador de cristal externo, e o chip fornece um conjunto de registradores de configuração ao módulo de software para aceitar a entrada de controle. . A precisão dos temporizadores de hardware é geralmente muito alta, podendo atingir o nível de nanossegundos, e é acionada por interrupção.

Software timer, software timer é um tipo de interface de sistema fornecida pelo sistema operacional. Ele é construído com base em temporizadores de hardware, permitindo que o sistema forneça serviços de temporizador que não sejam limitados por recursos de temporizador de hardware. As funções que ele implementa estão relacionadas a temporizadores de hardware.Os temporizadores são semelhantes.

O sistema operacional RT-Thread fornece funções de timer de software.O uso de timers de software é equivalente a expandir o número de timers, permitindo que mais serviços de temporização sejam criados.

--original

Cenários de aplicação de temporizadores

Devido ao número limitado de temporizadores de hardware de microprocessadores ou microcontroladores, quando os usuários precisam de mais temporizadores, eles precisam usar temporizadores de software para concluir.

No entanto, os temporizadores de software são adequados apenas para threads que não exigem alta precisão de tempo, porque comparados aos temporizadores de hardware, os temporizadores de software têm precisão muito baixa e os temporizadores de software são facilmente interrompidos por outros threads (temporizadores de software são um thread , a prioridade padrão é 4).

A precisão do temporizador

No sistema operacional, geralmente o cronômetro de software usa o ciclo de tiques do sistema como unidade de tempo. O batimento do sistema é o batimento cardíaco do sistema, indicando a frequência do relógio do sistema, que é semelhante ao batimento cardíaco humano, quantos batimentos podem ser batidos em 1s, o batimento do sistema é configurado como RT_TICK_PER_SECOND, esta macro é definida em rtconfig .h, o padrão é 1000. Então o ciclo de clock do sistema é de 1ms (1s bate 1000 vezes, cada vez é 1ms). O valor de temporização do timer de software deve ser um múltiplo inteiro do período de batida. Por exemplo, se o período de batida for 10ms, o valor de temporização do timer de software da camada superior só pode ser 10ms, 20ms, 100ms etc., mas não 15ms. Como o tick define a precisão que os temporizadores no sistema podem distinguir, o sistema pode definir um valor apropriado de acordo com a capacidade real de processamento da CPU do sistema e os requisitos em tempo real. Quanto menor o valor do período do tick do sistema, maior a precisão , mas quanto maior a sobrecarga do sistema. Maior, porque mais vezes o sistema entra na interrupção do relógio em 1 segundo.

--original

Como funciona o temporizador

Quando o usuário cria um temporizador de software, o sistema determinará o tempo limite de tempo de ativação do temporizador de acordo com o tempo rt_tick e o tempo definido pelo usuário e pendurará o bloco de controle do temporizador na lista de temporizadores de software rt_soft_timer_list.

rt_tick é uma variável sem sinal de 32 bits usada para registrar o tempo de execução atual do sistema. Cada vez que uma batida do relógio passa, rt_tick é incrementado em 1.

rt_soft_timer_list armazena tarefas de timer, que armazenam todos os timers ativados em ordem crescente de tempo.

Cada vez que um timer é adicionado, seu timeout timeout wake-up time timeout é igual ao tempo atual do sistema rt_tick + time time time.

bloco de controle do temporizador

struct rt_timer
{
    
    
    struct rt_object parent;                            /**< 继承自rt_object */

    rt_list_t        row[RT_TIMER_SKIP_LIST_LEVEL];     /**< 定时器列表算法用到的队列 */

    void (*timeout_func)(void *parameter);              /**< 定时器超时调用的函数 */
    void            *parameter;                         /**< 超时函数用到的入口参数 */

    rt_tick_t        init_tick;                         /**< 定时器初始超时节拍数 */
    rt_tick_t        timeout_tick;                      /**< 定时器实际超时时的节拍数 */
};

função de tempo limite

A função timer timeout é uma função que o timer irá executar automaticamente quando o valor da contagem atingir o valor definido. Esta função precisa ser definida por si mesma. Existem duas situações na função timer timeout:

A função timeout é executada no contexto de interrupção (relógio do sistema) (temporizador de hardware), e RT_TIMER_FLAG_HARD_TIMER precisa ser especificado no bloco de controle do temporizador;
A função timeout é executada no contexto da thread e precisa especificar RT_TIMER_FLAG_SOFT_TIMER no bloco de controle do timer.

Interface de função do temporizador

Criar temporizador rt_timer_create

rt_timer_t rt_timer_create(const char* nome,
void (*timeout)(void* parâmetro), void* parâmetro,
rt_tick_t time, rt_uint8_t flag);

Depois de chamar essa interface de função, o kernel primeiro aloca um bloco de controle de timer do heap de memória dinâmica e, em seguida, executa a inicialização básica do bloco de controle.
Quando o sinalizador especificado é RT_IMER_FLAG_HARD_TIMER, se o temporizador expirar, a função de retorno de chamada do temporizador será chamada no contexto da rotina de serviço da interrupção do relógio; quando o sinalizador especificado for RT_TIMER_FLAG_SOFT_TIMER, se o temporizador expirar, a função de retorno de chamada do temporizador será ser chamado Chamado no contexto do thread do timer do relógio do sistema.

parâmetro	descrever
nome	o nome do temporizador
tempo esgotado	Ponteiro de função de supermercado do temporizador
parâmetro	Parâmetros de entrada da função de tempo limite do temporizador
Tempo	Tempo limite, a unidade é batida do sistema
bandeira	opções de parâmetros

excluir temporizador rt_timer_delete

rt_err_t rt_timer_delete(rt_timer_t temporizador);

Após chamar esta interface de função, o sistema excluirá o temporizador da lista vinculada rt_timer_list e, em seguida, liberará a memória ocupada pelo bloco de controle do temporizador correspondente.

parâmetro	descrever
cronômetro	punho do temporizador

Inicialize o temporizador rt_timer_init

void rt_timer_init(rt_timer_t timer,
const char* nome, void (*timeout)(void* parâmetro), void* parâmetro,
rt_tick_t time, rt_uint8_t flag);

Ao usar esta interface de função, o bloco de controle do temporizador correspondente será inicializado, o nome do temporizador correspondente, a função de tempo limite do temporizador, etc.
Quando o sinalizador especificado é RT_IMER_FLAG_HARD_TIMER, se o temporizador expirar, a função de retorno de chamada do temporizador será chamada no contexto da rotina de serviço da interrupção do relógio; quando o sinalizador especificado for RT_TIMER_FLAG_SOFT_TIMER, se o temporizador expirar, a função de retorno de chamada do temporizador será ser chamado Chamado no contexto do thread do timer do relógio do sistema.

parâmetro	descrever
cronômetro	punho do temporizador
nome	o nome do temporizador
tempo esgotado	Ponteiro de função de supermercado do temporizador
parâmetro	Parâmetros de entrada da função de tempo limite do temporizador
Tempo	Tempo limite, a unidade é batida do sistema
bandeira	opções de parâmetros

Iniciar temporizador rt_timer_start

rt_err_t rt_timer_start(rt_timer_t temporizador);

Após chamar a interface da função de início do temporizador, o estado do temporizador será alterado para o estado ativo (RT_TIMER_FLAG_ACTIVATED) e inserido na lista vinculada da fila rt_timer_list na ordem do tempo limite.

parâmetro	descrever
cronômetro	punho do temporizador

Parar temporizador rt_timer_stop

rt_err_t rt_timer_stop(rt_timer_t temporizador);

Após chamar a interface da função de parada do temporizador, o estado do temporizador será alterado para o estado de parada e será separado da lista rt_timer_list e não participará da verificação de tempo limite do temporizador. Quando um temporizador (periódico) expira, esta interface de função também pode ser chamada para parar o próprio temporizador (periódico).

parâmetro	descrever
cronômetro	punho do temporizador

Temporizador de controle rt_timer_control

rt_err_t rt_timer_control(rt_timer_t temporizador, rt_uint8_t cmd, void* arg);

A interface da função do temporizador de controle pode visualizar ou alterar as configurações do temporizador de acordo com o parâmetro do tipo de comando. Atualmente suporta quatro interfaces de comando, a saber, definir tempo de tempo, visualizar tempo de tempo, definir gatilho único e definir gatilho de ciclo;

parâmetro	descrever
cronômetro	punho do temporizador
cmd	Comandos para controlar o temporizador
argumento	Parâmetros de comando de controle correspondentes ao cmd

experimento do temporizador

O experimento é relativamente simples, defina dois temporizadores, use o modo de temporização simples e o modo de temporização periódica, respectivamente.

#include "board.h"
#include "rtthread.h"


// 定义软件定时器控制块
static rt_timer_t tmr1 = RT_NULL;
static rt_timer_t tmr2 = RT_NULL;

// 可能用到的全局变量
static rt_uint32_t TmrCb_Cnt1 = 0;
static rt_uint32_t TmrCb_Cnt2 = 0;



/******************************************************************************
* @ 函数名  ： timer1_callback
* @ 功  能  ： 定时器1回调函数
* @ 参  数  ： parameter 外部传入的参数
* @ 返回值  ： 无
******************************************************************************/
static void timer1_callback(void *parameter)
{
    
    
	rt_uint32_t tick_num1 = 0;
	
	TmrCb_Cnt1++;
	
	tick_num1 = (rt_uint32_t)rt_tick_get();   // 获取滴答定时器的计数值
	
	rt_kprintf("timer1_callback 函数被执行%d次\n", TmrCb_Cnt1);
	rt_kprintf("滴答定时器的数值=%d\n", tick_num1);
}

/******************************************************************************
* @ 函数名  ： timer2_callback
* @ 功  能  ： 定时器2回调函数
* @ 参  数  ： parameter 外部传入的参数
* @ 返回值  ： 无
******************************************************************************/
static void timer2_callback(void *parameter)
{
    
    
		rt_uint32_t tick_num2 = 0;
	
	TmrCb_Cnt2++;
	
	tick_num2 = (rt_uint32_t)rt_tick_get();   // 获取滴答定时器的计数值
	
	rt_kprintf("timer2_callback 函数被执行%d次\n", TmrCb_Cnt2);
	rt_kprintf("滴答定时器的数值=%d\n", tick_num2);
}

int main(void)
{
    
    
	// 硬件初始化和RTT的初始化已经在component.c中的rtthread_startup()完成

	// 创建一个软件定时器
	tmr1 =  rt_timer_create("tmr1",                 // 软件定时器名称       
						timer1_callback,            // 软件定时器超时函数
						RT_NULL,                    // 超时函数参数
						3000,                       // 超时时间
						RT_TIMER_FLAG_ONE_SHOT |   
						RT_TIMER_FLAG_SOFT_TIMER);  // 软件定时器模式，一次模式
					
	
	// 启动定时器
	if(tmr1 != RT_NULL)
		rt_timer_start(tmr1);
							
	// 创建一个软件定时器
	tmr2 =  rt_timer_create("tmr2",                 // 软件定时器名称       
						timer2_callback,            // 软件定时器超时函数
						RT_NULL,                    // 超时函数参数
						1000,                       // 超时时间
						RT_TIMER_FLAG_PERIODIC |   
						RT_TIMER_FLAG_SOFT_TIMER);  // 软件定时器模式，周期模式
					
	
	// 启动定时器
	if(tmr2 != RT_NULL)
		rt_timer_start(tmr2);
}

fenômeno experimental

A função timer 1 timeout é executada apenas uma vez, enquanto a função timer 2 timeout é executada periodicamente.

insira a descrição da imagem aqui

Temporizador de software RT-Thread (notas de estudo)