【嵌入式开源库】timeslice的使用，完全解耦的时间片轮询框架构

news2024/11/18 8:52:17

完全解耦的时间片轮询框架构

  • 简介
  • 项目代码
    • timeslice.h
    • timeslice.c
    • list.h
    • list.c
  • 创建工程
  • 移植代码
  • 实验
  • 函数说明
    • timeslice_task_init
    • timeslice_task_add
    • timeslice_tak_del
    • timeslice_get_task_num
  • 结尾

简介

timeslice是一个时间片轮询框架，他是一个完全解耦的时间片轮询框架，他的使用非常方便，该项目一共有四个文件分别是tieslice的头文件和源文件以及list的头文件和源文件，tieslice是负责轮询任务，list是一个双向链表负责任务的管理，在Linux内核中使用非常广泛也很经典，该框架是参考rtt实时操作系统的侵入式链表实现的，本章文章是将该框架移植到stm32单片机上实验，使用也非常容易，单片机只需要启用一个定时器作为时钟即可；

本章使用环境：

stm32f407vet6
代码工程使用cubemx创建

项目代码

该项目的代码是我在微信公众号上看到的一个文章，代码并没有上传在github上，这里直接贴上源代码；

timeslice.h

#ifndef _TIMESLICE_H
#define _TIMESLICE_H

#include "list.h"

typedef enum {
    TASK_STOP,
    TASK_RUN
} IsTaskRun;

typedef struct timesilce
{
    unsigned int id;
    void (*task_hdl)(void);
    IsTaskRun is_run;
    unsigned int timer;
    unsigned int timeslice_len;
    ListObj timeslice_task_list;
} TimesilceTaskObj;

void timeslice_exec(void);
void timeslice_tick(void);
void timeslice_task_init(TimesilceTaskObj* obj, void (*task_hdl)(void), unsigned int id, unsigned int timeslice_len);
void timeslice_task_add(TimesilceTaskObj* obj);
void timeslice_task_del(TimesilceTaskObj* obj);
unsigned int timeslice_get_task_timeslice_len(TimesilceTaskObj* obj);
unsigned int timeslice_get_task_num(void);
unsigned char timeslice_task_isexist(TimesilceTaskObj* obj);

#endif

timeslice.c


#include "timeslice.h"

static LIST_HEAD(timeslice_task_list);

void timeslice_exec()
{
    ListObj* node;
    TimesilceTaskObj* task;

    list_for_each(node, &timeslice_task_list)
    {

        task = list_entry(node, TimesilceTaskObj, timeslice_task_list);
        if (task->is_run == TASK_RUN)
        {
            task->task_hdl();
            task->is_run = TASK_STOP;
        }
    }
}

void timeslice_tick()
{
    ListObj* node;
    TimesilceTaskObj* task;

    list_for_each(node, &timeslice_task_list)
    {
        task = list_entry(node, TimesilceTaskObj, timeslice_task_list);
        if (task->timer != 0)
        {
            task->timer--;
            if (task->timer == 0)
            {
                task->is_run = TASK_RUN;
                task->timer = task->timeslice_len;
            }
        }
    }
}

unsigned int timeslice_get_task_num()
{
    return list_len(&timeslice_task_list);
}

void timeslice_task_init(TimesilceTaskObj* obj, void (*task_hdl)(void), unsigned int id, unsigned int timeslice_len)
{
    obj->id = id;
    obj->is_run = TASK_STOP;
    obj->task_hdl = task_hdl;
    obj->timer = timeslice_len;
    obj->timeslice_len = timeslice_len;
}

void timeslice_task_add(TimesilceTaskObj* obj)
{
    list_insert_before(&timeslice_task_list, &obj->timeslice_task_list);
}

void timeslice_task_del(TimesilceTaskObj* obj)
{
    if (timeslice_task_isexist(obj))
        list_remove(&obj->timeslice_task_list);
    else
        return;
}


unsigned char timeslice_task_isexist(TimesilceTaskObj* obj)
{
    unsigned char isexist = 0;
    ListObj* node;
    TimesilceTaskObj* task;

    list_for_each(node, &timeslice_task_list)
    {
        task = list_entry(node, TimesilceTaskObj, timeslice_task_list);
        if (obj->id == task->id)
            isexist = 1;
    }

    return isexist;
}

unsigned int timeslice_get_task_timeslice_len(TimesilceTaskObj* obj)
{
    return obj->timeslice_len;
}

list.h


#ifndef _LIST_H
#define _LIST_H

#define offset_of(type, member)             (unsigned long) &((type*)0)->member
#define container_of(ptr, type, member)     ((type *)((char *)(ptr) - offset_of(type, member)))

typedef struct list_structure
{
    struct list_structure* next;
    struct list_structure* prev;
} ListObj;

#define LIST_HEAD_INIT(name)    {&(name), &(name)}
#define LIST_HEAD(name)         ListObj name = LIST_HEAD_INIT(name)

void list_init(ListObj* list);
void list_insert_after(ListObj* list, ListObj* node);
void list_insert_before(ListObj* list, ListObj* node);
void list_remove(ListObj* node);
int list_isempty(const ListObj* list);
unsigned int list_len(const ListObj* list);

#define list_entry(node, type, member) \
    container_of(node, type, member)

#define list_for_each(pos, head) \
    for (pos = (head)->next; pos != (head); pos = pos->next)

#define list_for_each_safe(pos, n, head) \
  for (pos = (head)->next, n = pos->next; pos != (head); \
    pos = n, n = pos->next)

#endif

list.c

#include "list.h"

void list_init(ListObj* list)
{
    list->next = list->prev = list;
}

void list_insert_after(ListObj* list, ListObj* node)
{
    list->next->prev = node;
    node->next = list->next;

    list->next = node;
    node->prev = list;
}

void list_insert_before(ListObj* list, ListObj* node)
{
    list->prev->next = node;
    node->prev = list->prev;

    list->prev = node;
    node->next = list;
}

void list_remove(ListObj* node)
{
    node->next->prev = node->prev;
    node->prev->next = node->next;

    node->next = node->prev = node;
}

int list_isempty(const ListObj* list)
{
    return list->next == list;
}

unsigned int list_len(const ListObj* list)
{
    unsigned int len = 0;
    const ListObj* p = list;
    while (p->next != list)
    {
        p = p->next;
        len++;
    }

    return len;
}

创建工程

配置高速时钟和低速时钟为外部晶振提供
在这里插入图片描述
配置调试模式为sw调试模式

在这里插入图片描述配置时钟频率
在这里插入图片描述配置led，这里我的板子是这三个io接入的是led
在这里插入图片描述
配置一个10ms的定时器（1000000hz / 1000ms == 1ms = 1khz 就得到10ms需要计数10000重载）记得打开中断
在这里插入图片描述
在这里插入图片描述

配置工程并生成，工程名设置，单独生成.c.h文件拷贝库文件
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
下面开始代码的移植工作；

移植代码

首先我们需要将该开源项目的代码添加到工程中
在这里插入图片描述在定时器中断服务函数中添加timeslice轮询函数
在这里插入图片描述在这里插入图片描述

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM3)
	{
		timeslice_tick();
	}
}

然后我们需要在main函数中启动定时器并在while1中调用exec函数调度时间片

 HAL_TIM_Base_Start_IT(&htim3);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
	  
	  timeslice_exec();
  }

到这里我们的移植工作就做完了，该项目的解耦效果真的非常好，移植相当简单，然后我们创建几个任务实验一下效果；

实验

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "timeslice.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM3)
	{
		timeslice_tick();
	}
}


// 创建3个任务对象
TimesilceTaskObj task_1, task_2, task_3;

// 具体的任务函数
void task1_hdl()
{
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_13);
}

void task2_hdl()
{
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_14 );
}

void task3_hdl()
{
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_15);
}

// 初始化任务对象，并且将任务添加到时间片轮询调度中
void task_init()
{
    timeslice_task_init(&task_1, task1_hdl, 1, 1);
    timeslice_task_init(&task_2, task2_hdl, 2, 1);
    timeslice_task_init(&task_3, task3_hdl, 3, 1);

    timeslice_task_add(&task_1);
    timeslice_task_add(&task_2);
    timeslice_task_add(&task_3);
}
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM3_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT(&htim3);
	task_init();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
	  
	  timeslice_exec();
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 25;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

核心部分

// 创建3个任务对象
TimesilceTaskObj task_1, task_2, task_3;

// 具体的任务函数
void task1_hdl()
{
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_13);
}

void task2_hdl()
{
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_14 );
}

void task3_hdl()
{
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_15);
}

// 初始化任务对象，并且将任务添加到时间片轮询调度中
void task_init()
{
    timeslice_task_init(&task_1, task1_hdl, 1, 1);
    timeslice_task_init(&task_2, task2_hdl, 2, 2);
    timeslice_task_init(&task_3, task3_hdl, 3, 3);

    timeslice_task_add(&task_1);
    timeslice_task_add(&task_2);
    timeslice_task_add(&task_3);
}

需要注意的是必须要有一个任务是需要在exec前创建，这样才能保证运行，其他的任务可以在这个任务中再创建，上面的实验是实现三个任务，三个任务分别为一个中断触发一次，第二个任务是每隔两个中断触发一次，第三个任务是每隔三个中断触发一次任务；

函数说明

timeslice_task_init

初始化任务函数

void timeslice_task_init(TimesilceTaskObj* obj, void (*task_hdl)(void), unsigned int id, unsigned int timeslice_len)
{
    obj->id = id;
    obj->is_run = TASK_STOP;
    obj->task_hdl = task_hdl;
    obj->timer = timeslice_len;
    obj->timeslice_len = timeslice_len;
}

在这个函数中将任务结构体参数初始化，id类似于任务名称用于区分任务，is_run是一个标志位用于判断该任务在该次中断是否需要执行，task_hd1表示函数指针也就是我们的任务函数，timer表示每多少次中断触发一次计数，timeslice_len 表示没多少次中断触发一次计数初始值，在timeslice_tick中当timer的值减到0任务将触发并会重新复位timer的值为 timeslice_len ；
在这里插入图片描述

timeslice_task_add

添加任务到双向链表中

void timeslice_task_add(TimesilceTaskObj* obj)
{
    list_insert_before(&timeslice_task_list, &obj->timeslice_task_list);
}

void list_insert_before(ListObj* list, ListObj* node)
{
    list->prev->next = node;
    node->prev = list->prev;

    list->prev = node;
    node->next = list;
}

该链表（timeslice_task_list）在timeslice_tick中会轮询进行遍历

timeslice_tak_del

删除正在运行的任务链表

void timeslice_task_del(TimesilceTaskObj* obj)
{
    if (timeslice_task_isexist(obj))
        list_remove(&obj->timeslice_task_list);
    else
        return;
}

在该函数中会通过timeslice_task_isexist函数去判断链表中是否存在该任务的id，如果存在将返回退出允许，这里涉及到一个Linux中的函数list_entry->container_of,该函数是通过结构体的某个变量获取整个结构体的指针位置，有兴趣可以去学习一下该项目代码的实现；

timeslice_get_task_num

获取当前任务数量，也就是链表的长度

unsigned int timeslice_get_task_num()
{
    return list_len(&timeslice_task_list);
}

unsigned int list_len(const ListObj* list)
{
    unsigned int len = 0;
    const ListObj* p = list;
    while (p->next != list)
    {
        p = p->next;
        len++;
    }

    return len;
}

结尾

整体的代码不算复杂但是是值得学习的一个项目，我是凉开水白菜祝各位程序员们节日快乐~ 咱们下文见~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1129491.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

力扣刷题 day54：10-24

力扣刷题 day54：10-24

1.十进制整数的反码 每个非负整数 N 都有其二进制表示。例如， 5 可以被表示为二进制 "101"，11 可以用二进制 "1011" 表示，依此类推。注意，除 N 0 外，任何二进制表示中都不含前导零。 二进制的反…
阅读更多...
【Java 进阶篇】使用 Java 和 Jsoup 进行 XML 处理

【Java 进阶篇】使用 Java 和 Jsoup 进行 XML 处理

XML（可扩展标记语言）是一种常用的数据交换格式，它被广泛用于在不同系统之间传递和存储数据。Java作为一种强大的编程语言，提供了多种方式来处理XML数据。其中，Jsoup 是一个流行的Java库，用于解析和操作XML文…
阅读更多...
【数据结构练习题】消失的数字 --- 三种解法超详解

【数据结构练习题】消失的数字 --- 三种解法超详解

✨博客主页：小钱编程成长记 🎈博客专栏：数据结构练习题 🎈相关博文：添加逗号 消失的数字 1. 🎈题目2. 🎈解题思路✨方法一：先排序，再找缺失的值✨方法二：按位…
阅读更多...
怎么禁止员工上班追剧

怎么禁止员工上班追剧

怎么禁止员工上班追剧 安企神终端安全管理软件下载使用 说到员工上班追究打游戏摸鱼，其实是一种不负责任的行为，这样的行为不仅会影响到工作效率，还会给周围的同事带来不好的工作氛围，会造成恶性循环，所以&#xff0…
阅读更多...
windows下安装配置CGAL

windows下安装配置CGAL

一、下载安装Boost、CGAL 下载地址：https://sourceforge.net/projects/boost/files/boost-binaries/ Boost是CGAL的强制依赖项。SourceForge上提供了Boost的二进制版本（此版本无须编译，可直接使用）。Boost安装程序会同时安装Boos…
阅读更多...
30天精通Nodejs--第二天：模块系统与npm

30天精通Nodejs--第二天：模块系统与npm

深入了解Node.js：模块系统与npm Node.js作为一款强大的服务器端JavaScript运行环境，模块系统和npm（Node Package Manager）是其成功的重要组成部分。为我们平时提供了便捷的工具和资源，使得在Node.js平台上构建应用变得…
阅读更多...
五、Qt中的常用类

五、Qt中的常用类

1. QString 字符串类 QString是Qt中的字符串类，与C/C不同的是，不再使用ASCII编码，而使用Unicode编码。因此一个字符不是8位的char，而是16位的QChar，这就是为什么之前一个汉字占用一个字符的原因。、 QString几乎向前兼…
阅读更多...
使用jdbc技术连接数据库

使用jdbc技术连接数据库

连接数据库 <dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version><scope>compile</scope></dependency> </dependencies> g…
阅读更多...
腾讯云阿里云服务器mongdb数据库设置密码

腾讯云阿里云服务器mongdb数据库设置密码

避坑点 数据库绑定ip一定要设置0.0.0.0 设置超级管理员账号密码 1、可以使用navicat15连接mongodb数据库&#xff0c;进入命令行界面&#xff0c;输入以下命令 如出现找不到MongoDB shell为可执行文件&#xff0c;选择设置路径&#xff0c;路径为&#xff1a;MongoDB shell是…
阅读更多...
【底层服务/编程功底系列】「网络通信体系」深入探索和分析TCP协议的运输连接管理的核心原理和技术要点

【底层服务/编程功底系列】「网络通信体系」深入探索和分析TCP协议的运输连接管理的核心原理和技术要点

【底层服务/编程功底系列】「网络通信体系」深入探索和分析TCP协议的运输连接管理的核心原理和技术要点 TCP的运输连接管理TCP三次握手三次握手流程分析注意要点 TCP四次挥手TCP之保活计时器&#xff08;keepalive timer&#xff09;保活计时器&#xff08;keepalive timer&…
阅读更多...
入门人工智能 —— 学习数据持久化、使用 Python 将数据保存到mysql（7）

入门人工智能 —— 学习数据持久化、使用 Python 将数据保存到mysql（7）

入门人工智能 —— 学习数据持久化、使用 Python 将数据保存到mysql 什么是数据持久化&#xff1f;使用 Python 进行数据持久化步骤 1: 安装 MySQL步骤 2: 安装必要的 Python 库步骤 3: 连接到 MySQL 数据库步骤 4: 创建数据表步骤 5: 插入数据步骤 6: 查询数据步骤 7: 关闭连接…
阅读更多...
管理类联考——英语二——翻译篇——定语从句的翻译方法

管理类联考——英语二——翻译篇——定语从句的翻译方法

第三节　定语从句的翻译方法 定语从句的翻译主要分为限制性定语从句和非限制性定语从句的翻译。主要可以分为三种方法&#xff1a;合译法、分译法和转译法。 一、限制性定语从句的翻译方法 限制性定语从句所修饰的先行词自身意义不明确&#xff0c;被定语从句修饰限定后其意…
阅读更多...
很多技术人就是会存在自己技术能力不错但是是茶壶里煮饺子倒不出来，如何解决？可以用笔和纸去画一画？

很多技术人就是会存在自己技术能力不错但是是茶壶里煮饺子倒不出来，如何解决？可以用笔和纸去画一画？

所描述的情况通常指的是一些技术人员虽然拥有丰富的技术知识和实践经验&#xff0c;但在表达和沟通方面存在困难&#xff0c;无法有效地将自己的思考和解决方案传达给他人。这种情况在技术领域相对常见&#xff0c;因为技术人员往往更注重技术深度而非沟通技巧。为了解决这个问…
阅读更多...
Azure - 机器学习企业级服务概述与介绍

Azure - 机器学习企业级服务概述与介绍

目录 一、什么是 Azure 机器学习&#xff1f;大规模生成业务关键型机器学习模型 二、Azure 机器学习适合哪些人群&#xff1f;三、Azure 机器学习的价值点加快价值实现速度协作并简化 MLOps信心十足地开发负责任地设计 四、端到端机器学习生命周期的支持准备数据生成和训练模型…
阅读更多...
基于LiteOS的智慧农业案例实验分享

基于LiteOS的智慧农业案例实验分享

最近在指导一位读者朋友做毕业设计&#xff0c;该毕设是关于端云互通的&#xff0c;基于小熊派LiteOS华为云。 在指导他的过程中我也学到了不少东西&#xff0c;这里通过一个案例实验&#xff08;智慧农业&#xff09;给大家分享一些知识。 实验框图 相关模块简介 1、STM32L4…
阅读更多...
管理类联考——英语二——翻译篇——名词性从句的译法

管理类联考——英语二——翻译篇——名词性从句的译法

第四节　名词性从句的译法 英语的名词性从句有四种&#xff0c;分别是主语从句&#xff0c;宾语从句&#xff0c;表语从句和同位语从句。整体而言&#xff0c;名词性从句的理解和中文语序的理解大致相同&#xff0c;因此在英译汉时&#xff0c;它无须作太大的调整&#xff08;…
阅读更多...
Centos安装gitlabce

Centos安装gitlabce

服务器配置要求&#xff08;2c4g&#xff09; 1、 安装其他组件 yum install -y curl policycoreutils-python openssh perl2、 安装Postfix服务以发送电子邮件通知&#xff0c;启动服务并自启 yum -y install postfix systemctl enable postfix --now3、 安装gitlab&#xf…
阅读更多...
Linux C语言开发-D5常量

Linux C语言开发-D5常量

指数形式的实数一般由尾数部分、字母e或E和指数部分组成。格式如下&#xff1a; 字符常量 常见的字符常量的ASCII码的值为&#xff1a; A&#xff1a;65&#xff1b;Z&#xff1a;90&#xff1b; &#xff1a;32&#xff1b;0&#xff1a;48&#xff1b; a&#xff1a;97&…
阅读更多...
怎么进行设备维护与保养？智能巡检系统有什么用？

怎么进行设备维护与保养？智能巡检系统有什么用？

设备维护与保养需要遵循三个原则&#xff1a;故障设备全面分析的原则、故障设备深入检查的原则以及故障设备分析排查的原则。 一、故障设备全面分析的原则 　　检修人员在对设备维护与保养时&#xff0c;如果看到设备在运行中出现了异常的现象&#xff0c;要立刻停止设备的工作…
阅读更多...
有一门课不及格的学生

有一门课不及格的学生

系列文章目录 进阶的卡莎C_睡觉觉觉得的博客-CSDN博客数1的个数_睡觉觉觉得的博客-CSDN博客双精度浮点数的输入输出_睡觉觉觉得的博客-CSDN博客足球联赛积分_睡觉觉觉得的博客-CSDN博客大减价(一级)_睡觉觉觉得的博客-CSDN博客小写字母的判断_睡觉觉觉得的博客-CSDN博客纸币(C…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023