Toggle navigation
首页
问答
文章
积分商城
专家
专区
更多专区...
文档中心
返回主站
搜索
提问
会员
中心
登录
注册
利用线程间同步-事件集机制及ADC的使用
发布于 2020-03-30 09:45:38 浏览：2378
订阅该版
**作业题目4：利用线程间同步-事件集机制，实现当一个ADC通道采样值大于3V 或者另外一个ADC通道采样值小于0.5V时，实现报警功能。ADC通道自由选择。** 大家提交作业时，直接在本贴下方跟贴即可
查看更多
37
个回答
默认排序
按发布时间排序
瑞尧
2020-03-31
这家伙很懒，什么也没写！
需求：使用事件集对ADC采样数据进行阈值报警 需要用到：事件集，ADC ADC配置，将ADC1的一个或两个通道进行配置（我使用的是两个通道ADC_Channel_11和ADC_Channel_15），配置为顺序转换模式，代码如下： ``` void Adc_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; ADC_InitTypeDef ADC_InitStructure; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOA时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); //使能ADC1时钟 //先初始化ADC1通道11和15 IO口 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_15;//PE11、15 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;//模拟输入 GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;//不带上下拉 GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化 RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1,ENABLE); //ADC1复位 RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1,DISABLE); //复位结束 ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;//独立模式 ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;//两个采样阶段之间的延迟5个时钟 ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled; //DMA失能 ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div4;//预分频4分频。ADCCLK=PCLK2/4=84/4=21Mhz,ADC时钟最好不要超过36Mhz ADC_CommonInit(&ADC_CommonInitStructure);//初始化 ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;//12位模式 ADC_InitStructure.ADC_ScanConvMode = DISABLE;//非扫描模式 ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;//关闭连续转换 ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;//禁止触发检测，使用软件触发 ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;//右对齐 ADC_InitStructure.ADC_NbrOfConversion = 2;//1个转换在规则序列中 也就是只转换规则序列1 ADC_Init(ADC1, &ADC_InitStructure);//ADC初始化 ADC_Cmd(ADC1, ENABLE);//开启AD转换器 } ``` ADC配置完成后就是数据采集滤波函数，我只用了最简单的平均值滤波，采集20次，效果还行，代码就不用放上来了 接下来是线程的配置，需要用到两个线程（数据采集线程，报警线程）和一个事件集，代码如下： ``` <blockquote>#define EVENT_FLAG_HIGH (1 << 1) ``` 将示例代码外部链接到控制台指令中进行调用，在采用线程中实时采集数据，报警线程持续等待接收事件，未使用阻塞等待，接收事件超时直接跳过，执行效果如下： [attach]14372[/attach]
风雨潇潇
2020-03-31
这家伙很懒，什么也没写！
本次课题我开启了四路ADC和DMA传输，两路用来作为判断和发送事件集。 ADC和DMA的外设初始化通过STM32CUBEMX配置，但是后来发现ADC使用失败，检查代码，发现CUBE配置的ADC初始化代码的通道配置只配置了一路，所以没有通过，自己修改后正常。代码如下。 ``` /* ADC1 init function */ void MX_ADC1_Init(void) { ADC_MultiModeTypeDef multimode = {0}; ADC_ChannelConfTypeDef sConfig = {0}; /** Common config */ hadc1.Instance = ADC1; hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1; hadc1.Init.Resolution = ADC_RESOLUTION_12B; hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE; hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV; hadc1.Init.LowPowerAutoWait = DISABLE; hadc1.Init.ContinuousConvMode = ENABLE; hadc1.Init.NbrOfConversion = 4; hadc1.Init.DiscontinuousConvMode = DISABLE; hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; hadc1.Init.DMAContinuousRequests = ENABLE; hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; hadc1.Init.OversamplingMode = DISABLE; if (HAL_ADC_Init(&hadc1) != HAL_OK) { Error_Handler(); } /** Configure the ADC multi-mode */ multimode.Mode = ADC_MODE_INDEPENDENT; if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK) { Error_Handler(); } /** Configure Regular Channel */ sConfig.Channel = ADC_CHANNEL_5; sConfig.Rank = ADC_REGULAR_RANK_1; sConfig.SamplingTime = ADC_SAMPLETIME_2CYCLES_5; sConfig.SingleDiff = ADC_SINGLE_ENDED; sConfig.OffsetNumber = ADC_OFFSET_NONE; sConfig.Offset = 0; if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) { Error_Handler(); } /** Configure Regular Channel */ sConfig.Channel = ADC_CHANNEL_6; sConfig.Rank = ADC_REGULAR_RANK_2; if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) { Error_Handler(); } /** Configure Regular Channel */ sConfig.Channel = ADC_CHANNEL_16; sConfig.Rank = ADC_REGULAR_RANK_3; if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) { Error_Handler(); } /** Configure Regular Channel */ sConfig.Channel = ADC_CHANNEL_15; sConfig.Rank = ADC_REGULAR_RANK_4; if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) { Error_Handler(); } } void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(adcHandle->Instance==ADC1) { /* USER CODE BEGIN ADC1_MspInit 0 */ /* USER CODE END ADC1_MspInit 0 */ /* ADC1 clock enable */ __HAL_RCC_ADC_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**ADC1 GPIO Configuration PA0 ------> ADC1_IN5 PA1 ------> ADC1_IN6 PB0 ------> ADC1_IN15 PB1 ------> ADC1_IN16 */ GPIO_InitStruct.Pin = GPIO_PIN_0|BAT_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG_ADC_CONTROL; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_0|Light_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG_ADC_CONTROL; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* ADC1 DMA Init */ /* ADC1 Init */ hdma_adc1.Instance = DMA1_Channel1; hdma_adc1.Init.Request = DMA_REQUEST_0; hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE; hdma_adc1.Init.MemInc = DMA_MINC_ENABLE; hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_adc1.Init.Mode = DMA_CIRCULAR; hdma_adc1.Init.Priority = DMA_PRIORITY_LOW; if (HAL_DMA_Init(&hdma_adc1) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1); /* USER CODE BEGIN ADC1_MspInit 1 */ /* USER CODE END ADC1_MspInit 1 */ } } ``` 创建线程，ADC采集线程和事件集接收处理线程，初始化事件集，打开ADC。代码如下 ``` #define EVENT_FLAG3 (1 << 3) #define EVENT_FLAG5 (1 << 5) static rt_thread_t adcevet_thread; static rt_thread_t adc_thread; struct rt_event event; static rt_uint16_t ADC_Value[12]; typedef struct { rt_uint16_t PowerCons; rt_uint16_t Bat; rt_uint16_t Light; rt_uint16_t User; }ADC_ChannelValue_t; void Adcevent_Init(void) { rt_err_t result; result = rt_event_init(&event, "event", RT_IPC_FLAG_FIFO); if (result != RT_EOK) { rt_kprintf("init event failed.\n"); return; } adcevet_thread = rt_thread_create("event_thread", adcevent_thread_entry, RT_NULL, 512, 4, 10); if(adcevet_thread != RT_NULL) { rt_thread_startup(adcevet_thread); } adc_thread = rt_thread_create("ADC_thread", adc_thread_entry, RT_NULL, 512, 5, 10); if(adc_thread != RT_NULL) { rt_thread_startup(adc_thread); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)ADC_Value, 12); } } void adcevent_thread_entry(void *parameter) { rt_uint32_t e; while(1) { if (rt_event_recv(&event, (EVENT_FLAG3 | EVENT_FLAG5), RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &e) == RT_EOK) { rt_kprintf("AND recv event 0x%x\n", e); rt_kprintf("Warning LED ON\n"); HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET); //LED_ON } } } void adc_thread_entry(void *parameter) { ADC_ChannelValue_t AD_Value; rt_uint8_t i; while(1) { AD_Value.PowerCons = 0; AD_Value.Bat = 0; AD_Value.Light = 0; AD_Value.User = 0; for(i = 0; i < 12;) { AD_Value.PowerCons += ADC_Value[i++]; AD_Value.Bat += ADC_Value[i++]; AD_Value.Light += ADC_Value[i++]; AD_Value.User += ADC_Value[i++]; } rt_kprintf(" ADC_µç³Ø value = %d\r\n", (AD_Value.Bat/3)); rt_kprintf(" ADC_Óû§ value = %d \r\n", (AD_Value.User/3)); if((AD_Value.User/3) >= 3723) { rt_event_send(&event, EVENT_FLAG3); rt_kprintf("send EVENT_FLAG3\r\n"); } if((AD_Value.Bat/3) <= 620) { rt_event_send(&event, EVENT_FLAG5); rt_kprintf("send EVENT_FLAG5\r\n"); } rt_kprintf("\r\n"); rt_thread_mdelay(2000); //2s } } ``` 效果如图 [attach]14394[/attach]
赵撵猪
2020-04-01
这家伙很懒，什么也没写！
[list=1] [*]adc配置[attach]14441[/attach]选好两个通道，打开DMA [*]代码编写 ``` #include <rtthread.h> #include "adc_thread.h" #include "adc.h" #define adc_thread_PRIORITY 20 #define adc_thread_STACK_SIZE 1024 #define adc_thread_TIMESLICE 5 #define OVER_EVENT (1 << 1) #define BELOW_EVENT (1 << 0) #define include_event(_event,_ned_event) _event&(_ned_event) static rt_thread_t adc_thread_run_tid = RT_NULL; static rt_thread_t adc_print_thread_tid = RT_NULL; /* 事件控制块 */ static struct rt_event adc_event; /* ADC转完标志位 */ static rt_bool_t ADC_IS_OK = RT_FALSE; void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) { ADC_IS_OK = RT_TRUE; } static void adc_thread_entry(void *param) { static uint32_t adc_val[2]; while (1) { ADC_IS_OK = RT_FALSE; HAL_ADC_Start_DMA(&hadc1,adc_val,2); rt_thread_mdelay(20); if(ADC_IS_OK) { adc_val[0] = adc_val[0] *3300/4096; //转换为电压mV adc_val[1] = adc_val[1] *3300/4096; //转换为电压mV if (adc_val[0] > 3000) rt_event_send(&adc_event,OVER_EVENT); if (adc_val[1] < 500) rt_event_send(&adc_event,BELOW_EVENT); } rt_kprintf("adc_val[0]:%8dmv\nadc_val[1]:%8dmv\n",adc_val[0],adc_val[1]); rt_thread_mdelay(2000); } } static void adc_print_thread_entry(void *param) { rt_uint32_t e; while (1) { if (RT_EOK == rt_event_recv(&adc_event, OVER_EVENT|BELOW_EVENT, RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &e)) { if (e == (OVER_EVENT|BELOW_EVENT)) { rt_kprintf("OVER_EVENT AND BELOW_EVENT.\n"); } else if(include_event(e,OVER_EVENT)) { rt_kprintf("OVER_EVENT .\n"); } else if(include_event(e,BELOW_EVENT)) { rt_kprintf("BELOW_EVENT.\n"); } } } } int adc_thread_create(void) { rt_err_t result; /* 初始化事件对象 */ result = rt_event_init(&adc_event, "adc_event", RT_IPC_FLAG_FIFO); if (result != RT_EOK) { rt_kprintf("init event failed.\n"); return -1; } adc_thread_run_tid = rt_thread_create("adc_thread_run", adc_thread_entry, RT_NULL, adc_thread_STACK_SIZE, adc_thread_PRIORITY, adc_thread_TIMESLICE); if (adc_thread_run_tid != RT_NULL) rt_thread_startup(adc_thread_run_tid); adc_print_thread_tid = rt_thread_create("adc_print_thread", adc_print_thread_entry, RT_NULL, adc_thread_STACK_SIZE, adc_thread_PRIORITY - 1, adc_thread_TIMESLICE); if (adc_print_thread_tid != RT_NULL) rt_thread_startup(adc_print_thread_tid); return 0; } INIT_DEVICE_EXPORT(adc_thread_create); MSH_CMD_EXPORT(adc_thread_create, led task create); ``` 当电压高于3000mv时事件send，另一个低于500mv时发布事件 [*]实验结果[attach]14442[/attach] [/list]
ddllxxrr
2020-04-02
这家伙很懒，什么也没写！
先在主线程建立两个线程ADC和接收线程，并定义事件 static rt_event_t test_event = RT_NULL; #define ADC_EVENT (0x01 << 0) test_event = rt_event_create("test_event",RT_IPC_FLAG_PRIO); ADC线程完成电压取值 ： ``` static void ADCProcessSoftTimer_callback(void* parameter) { float middle; printf("\r\n ADC1 CH10(PC0) value = %.2f V \r\n",(float)ADCConvertedValue[0]/4096 * 3.3); middle = (float)ADCConvertedValue[0]/4096 * 3.3; if(middle>3 ) rt_event_send(test_event,ADC_EVENT); } ``` 接收线程完成报警： ``` static void receive_thread_entry(void* parameter) { rt_uint32_t recved; while(1){ rt_event_recv( test_event, ADC_EVENT, RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved); if(recved == (ADC_EVENT)) LED1_TOGGLE; } ```
shenlan
2020-04-03
这个人很勤快，没空留下点什么
1.初始化adc 2.创建线程1查询adc的值 大于3v发事件1 小于0.5v发事件2 3.创建线程2阻塞等待事件1和事件2 有事件触发后 查询 如果是事件1 则提醒电压过高发送 高压警告 如果是事件2 则提醒电压过低 发送 欠压警告 注意 1.阻塞式等待 使用不慎可能会导致线程无法 得到执行 2.线程内都要有一个死循环 不然只执行一次就不再执行了 3. 判断事件的时候 比较的数字前要加0x 否则会发生看起来打印的数值一模一样却不进入判断条件的情况
奔跑的蜗牛大大
2020-04-03
这家伙很懒，什么也没写！
1，创建一个事件集，并定义报警事件。 2，在定时器采集ADC 值，并换算为电压值，判断电压值，然后发送对应的事件 3，创建一个解析事件的任务，等待事件的发生，接受到事件后判断事件的上报类型，并做相应处理
guangying
2020-04-04
这家伙很懒，什么也没写！
[md]# 利用事件集机制及ADC的使用 **标准库函数(STD)版** ## 硬件平台介绍 正点原子 NanoSTM32F103RBT6 ，本程序中 Finsh 组件使用 USART1 ；板载一个可调电位器；用杜邦线再连接一个电位器。 ## 事件集 介绍 事件集也是线程间同步的机制之一，一个事件集可以包含多个事件，利用事件集可以完成一对多，多对多的线程间同步。事件集主要用于线程间的同步，与信号量不同，它的特点是可以实现一对多，多对多的同步。 ## 设计思路 要达到题目要求，要实现一下几个方面 1. ADC功能实现，本例程使用DMA功能读取ADC转换结果。 2. 创建事件集 3. 创建ADC读取线程，用于发送事件集。 4. 创建ADC报警线程，用于接收事件集。 ## 实现过程 - ADC 的GPIO配置 - ADC 功能配置 - DMA 功能配置 - 创建事件集 - 创建 ADC 读取线程 - 创建 ADC 报警线程 ### ADC 的GPIO配置 STM32 的 ADC 通道与 GPIO 对应表： 通道 | ADC1 | 使用的 --------| ----- | ----- 通道0 | PA0 | 通道1 | PA1 | 通道2 | PA2 | 通道3 | PA3 | 通道4 | PA4 | 通道5 | PA5 | 通道6 | PA6 | 通道7 | PA7 | <----- 通道8 | PB0 | 通道9 | PB1 | <----- 通道10 | PC0 | 通道11 | PC1 | 通道12 | PC2 | 通道13 | PC3 | 通道14 | PC4 | 通道15 | PC5 | 通道16 | 温度传感器 | 通道17 | 内部参照电压 | ``` c //使用到的PB1(通道9)、PA7(通道7) GPIO_InitTypeDef GPIO_InitStructure; /* 使能 GPIOA 和 GPIOB 时钟 */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE); /* 配置 PB.01 (ADC Channel9) 为模拟输入 -------------------------*/ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOB, &GPIO_InitStructure); /* 配置 PA.07 (ADC Channel7) 为模拟输入 -------------------------*/ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); ``` ### ADC 功能配置 ``` c void AdcModeInit(void) { ADC_InitTypeDef ADC_InitStructure; //设置 ADC 分频因子 6 即72M/6=12,ADC 最大时间不能超过 14M RCC_ADCCLKConfig(RCC_PCLK2_Div6); /* 使能 ADC1 时钟 */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); /* ADC1 配置 ------------------------------------------------------*/ ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //独立模式 ADC_InitStructure.ADC_ScanConvMode = ENABLE; //开启扫描模式 ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; //开启连续转换模式 ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; //软件触发 ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; //右对齐 ADC_InitStructure.ADC_NbrOfChannel = 2; //通道数量 ADC_Init(ADC1, &ADC_InitStructure); /* 配置 ADC1 规则采样顺序 */ ADC_RegularChannelConfig(ADC1, ADC_Channel_9, 1, ADC_SampleTime_239Cycles5); ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 2, ADC_SampleTime_239Cycles5); /* 使能 ADC1 DMA */ ADC_DMACmd(ADC1, ENABLE); /* 使能 ADC1 */ ADC_Cmd(ADC1, ENABLE); ADC_ResetCalibration(ADC1); /* 开启复位校准 */ while(ADC_GetResetCalibrationStatus(ADC1)); //等待复位校准结束 ADC_StartCalibration(ADC1); //开启 AD 校准 while(ADC_GetCalibrationStatus(ADC1)); //等待校准结束 /* 由于没有采用外部触发，所以使用软件触发ADC转换 */ ADC_SoftwareStartConvCmd(ADC1,ENABLE); } ``` ### DMA 功能配置 ``` c //使用 __IO 修饰符 __IO uint16_t ADCConvertedValue[2]; void AdcDMAInit(void) { DMA_InitTypeDef DMA_InitStructure; //使能 DMA1 时钟 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); /* DMA1 channel1 配置 ----------------------------------------------*/ DMA_DeInit(DMA1_Channel1); //DMA1 外设ADC1 转换结果地址 DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR; //DMA 内存基地址 DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADCConvertedValue; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; //从外设读取发送到内存 DMA_InitStructure.DMA_BufferSize = 2; // DMA 通道的 DMA 缓存的大小 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA1_Channel1, &DMA_InitStructure); /* 使能 DMA1 通道1 */ DMA_Cmd(DMA1_Channel1, ENABLE); } ``` ### 创建事件集 ``` c //事件集控制块定义-------------------------------------- rt_event_t ADC_event = RT_NULL; //事件集创建------------------------------------------- ADC_event = rt_event_create("ADC_alarm_event",RT_IPC_FLAG_FIFO); if(ADC_event == RT_NULL) rt_kprintf("ADC_alarm_event create failed\n"); ``` ### 创建 ADC 读取线程 ``` c //动态线程控制块指针 static rt_thread_t dynamic_TH; //线程入口函数声明 static void ADC_Get_entry(void *parameter); //创建 ADC 读取线程 dynamic_TH = rt_thread_create("ADC_Get_TH",ADC_Get_entry,RT_NULL,256,10,10); if(dynamic_TH != RT_NULL) { rt_thread_startup(dynamic_TH); } //线程入口函数 static void ADC_Get_entry(void *parameter) { uint16_t vol[2]={0}; while(1) { //因为ADC一直不停的进行转换，所以先将ADCConvertedValue数组中的值读出 vol[0]=ADCConvertedValue[0]; //通道 9 的转换结果 vol[1]=ADCConvertedValue[1]; //通道 7 的转换结果 // ADC 转换值计算，将转换值扩大 10 倍，成为整数。 vol[0] = vol[0] * 330 / 4096; vol[1] = vol[1] * 330 / 4096; if(vol[0] > 300) //通道 9 大于 3V 时报警 { //输出电压大小，只有报警时才输出 rt_kprintf("ADC1 CH9 = %d.%02d V\n",vol[0]/100,vol[0]%100); //发送事件集 rt_event_send( ADC_event, //事件集控制块 1 << 0); //第 0 位 } else if(vol[1] < 50) //通道 7 大于 3V 时报警 { //输出电压大小，只有报警时才输出 rt_kprintf("ADC1 CH7 = %d.%02d V\n",vol[1]/100,vol[1]%100); //发送事件集 rt_event_send( ADC_event, //事件控制块 1 << 1); //第 1 位 } else BeepOff(); //关闭蜂鸣器 rt_thread_mdelay(800); } } ``` ### 创建 ADC 报警线程 ``` c //线程入口函数声明 static void ADC_Alarm_entry(void *parameter); //创建 ADC 读取线程 dynamic_TH = rt_thread_create("ADC_Alarm_TH",ADC_Alarm_entry,RT_NULL,256,9,10); if(dynamic_TH != RT_NULL) { rt_thread_startup(dynamic_TH); } //线程入口函数 static void ADC_Alarm_entry(void *parameter) { rt_uint32_t e; rt_err_t uwRet = RT_EOK; while(1) { uwRet = rt_event_recv( ADC_event, //事件集控制块 (1 << 0 | 1 << 1), //第 0 位和第 1 位 RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, //或关系，并清标志 RT_WAITING_FOREVER, //等待 &e) //接收到的事件 if(uwRet == RT_EOK) { if(e == 1) //通道9 { //ADC1通道9的电压大于3V rt_kprintf("ADC1 Channel 9 voltage is higher than 3V\n"); BeepOn(); //蜂鸣器报警 } else if(e == 2) //通道7 { //ADC1通道7的电压低于0.5V rt_kprintf("ADC1 Channel 7 voltage is lower than 0.5V\n"); BeepOn(); //蜂鸣器报警 } } rt_thread_mdelay(300); } } ``` ## 下载验证 ### 查看线程  ### 查看事件集  ### 调节电位器 因为板子上只有一个电位器，所以另外一个通道直接接到 3.3V 或 GND 进行测试  #### 调节通道 9 的电位器  #### 将通道 9 连接 GND 模拟小于 0.5V 情况 [/md]
。。。
2020-04-04
这家伙很懒，什么也没写！
学习何老师的RT-Thread Nano-ADC（时钟管理之软件定时器）视频，以及阅读PT-Thread官方文档中有关线程间同步的事件集的资料，完成本次作业。 移植何老师的ADC的相关代码然后进行修改。 本次利用定时器每隔1秒进行ADC采集值，然后在ADC_thread_entry线程中进行接收事件的相关处理。 定时器的创建和线程的创建代码如下： ``` static rt_timer_t ADCProcessSoftTimer = RT_NULL;//软件定时器控制块指针 static rt_event_t ADC_event = RT_NULL; int ADCProcessInit() { rt_thread_t tid; AdcInit();//ADC初始化 ADC_event = rt_event_create("ADC_event", RT_IPC_FLAG_FIFO);//创建事件 if (ADC_event == RT_EOK) { rt_kprintf("Event created successfully.\n"); } ADCProcessSoftTimer = rt_timer_create("ADCProcessSoftTimer", /* 软件定时器的名称 */ ADCProcessSoftTimer_callback,/* 软件定时器的回调函数 */ 0, /* 定时器超时函数的入口参数 */ RT_TICK_PER_SECOND, /* 软件定时器的超时时间(周期回调时间) */ RT_TIMER_FLAG_PERIODIC ); /* 软件定时器模式 周期模式 */ /* 启动定时器 */ if (ADCProcessSoftTimer != RT_NULL) rt_timer_start(ADCProcessSoftTimer); tid = rt_thread_create("ADC_monitoring", ADC_thread_entry, RT_NULL, 256, 2, 10); if (tid != NULL) rt_thread_startup(tid); return 0; } INIT_APP_EXPORT(ADCProcessInit); ``` 有关3个事件的宏定义： ``` #define EVENT_FLAG0 (1 << 0) #define EVENT_FLAG1 (1 << 1) #define EVENT_FLAG2 (1 << 2) ``` 定时器的回调函数定义代码如下： ``` static void ADCProcessSoftTimer_callback(void* parameter) { float ADC1_value,ADC2_value; ADC1_value = (float)ADCConvertedValue[0]/4096 * 3.3; ADC2_value = (float)ADCConvertedValue[1]/4096 * 3.3; if(ADC1_value > 3.0 && ADC2_value < 0.5) rt_event_send(ADC_event, EVENT_FLAG0); //发送事件0:通道10（PC.0）采集值大于3V，通道11（PC.1）采集值小于0.5V else if(ADC1_value > 3.0) rt_event_send(ADC_event, EVENT_FLAG1); //发送事件1:通道10（PC.0）采集值大于3V else if(ADC2_value < 0.5) rt_event_send(ADC_event, EVENT_FLAG2); //发送事件2:通道11（PC.1）采集值小于0.5V } ``` 线程的入口函数如下： ``` void ADC_thread_entry(void *parameter) { rt_err_t uwRet = RT_EOK; rt_uint32_t e; while(1) { uwRet = rt_event_recv(ADC_event, (EVENT_FLAG0 |EVENT_FLAG1 | EVENT_FLAG2), RT_EVENT_FLAG_OR| RT_EVENT_FLAG_CLEAR , RT_WAITING_FOREVER, &e); if ( uwRet == RT_EOK) { if(e == EVENT_FLAG0 ) { rt_kprintf("\n警报：ADC1(PC.0)采集值大于3V，ADC2(PC.1)采集值小于0.5V。\n"); } else if( e == EVENT_FLAG1) { rt_kprintf("\n警报：ADC1(PC.0)采集值大于3V。\n"); } else { rt_kprintf("\n警报：ADC2(PC.1)采集值小于0.5V。\n"); } } } } ``` 本次采用软件仿真： 第一个通道为10，其判断该采集值是否大于3V；第二个通道11，其判断采集值是否小于0.5V。 已创建线程的信息： [attach]14583[/attach] 当通道10采集值小于3V，通道11采集值小于0.5V，仿真结果如下： [attach]14584[/attach] 当通道10采集值大于3V，通道11采集值小于0.5V，仿真结果如下： [attach]14585[/attach] 当通道10采集值大于3V，通道11采集值大于0.5V，仿真结果如下： [attach]14586[/attach]
BruceTan
2020-04-04
这家伙很懒，什么也没写！
[i=s] 本帖最后由 谭卓琳 于 2020-4-4 16:10 编辑 [/i] 帖子不好排版，这里直接贴一个CSDN链接吧，一样的。 [https://blog.csdn.net/qq_22902757/article/details/105310933](https://blog.csdn.net/qq_22902757/article/details/105310933)
yoowiwi
2020-04-04
这家伙很懒，什么也没写！
[md]# 学习笔记（接上次作业） ## 软件定时器的使用 > 硬件定时器：在中断上下文环境中执行，执行时间应该尽量短，执行时不应导致当前上下文挂起、等待。例如在中断上下文中执行的超时函数它不应该试图去申请动态内存、释放动态内存。 * 软件定时器的启用：使能rtconfig.h中的`RT_USING_TIMER_SOFT` * RT-Thread跳表索引相关宏：`RT_TIMER_SKIP_LIST_LEVEL` ，默认配置为1，理论上数值越大，查找越快，但是会占用内存空间 * 定时器控制块 ```C struct rt_timer { struct rt_object parent; 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; /* 定时器实际超时时的节拍数 */ }; typedef struct rt_timer *rt_timer_t; ``` * 相关宏定义 ```C #define RT_TIMER_FLAG_ONE_SHOT 0x0 /* 单次定时 */ #define RT_TIMER_FLAG_PERIODIC 0x2 /* 周期定时 */ #define RT_TIMER_FLAG_HARD_TIMER 0x0 /* 硬件定时器 */ #define RT_TIMER_FLAG_SOFT_TIMER 0x4 /* 软件定时器 */ #define RT_TIMER_CTRL_SET_TIME 0x0 /* 设置定时器超时时间 */ #define RT_TIMER_CTRL_GET_TIME 0x1 /* 获得定时器超时时间 */ #define RT_TIMER_CTRL_SET_ONESHOT 0x2 /* 设置定时器为单次定时器 */ #define RT_TIMER_CTRL_SET_PERIODIC 0x3 /* 设置定时器为周期型定时器 */ ``` * 静态创建定时器及删除定时器 ```C void rt_timer_init(rt_timer_t timer, const char* name, void (*timeout)(void* parameter), void* parameter, rt_tick_t time, rt_uint8_t flag); rt_err_t rt_timer_detach(rt_timer_t timer); ``` * 启动和停止定时器 ```C rt_err_t rt_timer_start(rt_timer_t timer); rt_err_t rt_timer_stop(rt_timer_t timer); ``` * 控制定时器，可用于修改定时器的定时时间 ```C rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void* arg); ``` ## 小作业：利用线程间同步-事件集机制及ADC的使用 * 事件集 * 特点：**一对多**或**多对多**同步 * 每个线程可拥有 32 个事件标志，采用一个 32 bit 无符号整型数进行记录，每一个 bit 代表一个事件； ```C // 动态创建事件集和删除事件集 rt_event_t rt_event_create(const char* name, rt_uint8_t flag); //flag参数: RT_IPC_FLAG_FIFO 或 RT_IPC_FLAG_PRIO rt_err_t rt_event_delete(rt_event_t event); //静态创建事件集和脱离事件集 rt_err_t rt_event_init(rt_event_t event, const char* name, rt_uint8_t flag); rt_err_t rt_event_detach(rt_event_t event); //发送事件集 rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set); //set参数:发送的事件集，可使用“&”“|”符号 //接收事件集 rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option, rt_int32_t timeout, rt_uint32_t* recved); //set参数：感兴趣的事件集 //option参数：RT_EVENT_FLAG_OR、RT_EVENT_FLAG_AND、RT_EVENT_FLAG_CLEAR ``` * 代码实现 * 相关宏、枚举类型定义 ```C enum{ EVENT_ADC_HIGH = 0x01, EVENT_ADC_LOW = 0x02 }adc_t; // 定义电压过低或过高时所对应的事件集 ``` * adc硬件采集、软件定时器、报警线程初始化 ```C __IO float ADC_ConvertedValue; struct rt_timer timer_adc; void timer_adc_callback(void *paramter); static struct rt_thread tadc; static rt_uint8_t detect_adc_stack[512]; void thread_detect_adc(void *paramter); static struct rt_event event_adc; static int ADCx_Mode_Config(void) { ADC_InitTypeDef ADC_InitStructure; ADC_APBxClock_FUN ( ADC_CLK, ENABLE ); GPIO_InitTypeDef GPIO_InitStructure; ADC_GPIO_APBxClock_FUN ( ADC_GPIO_CLK, ENABLE ); GPIO_InitStructure.GPIO_Pin = ADC_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(ADC_PORT, &GPIO_InitStructure); ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; ADC_InitStructure.ADC_ScanConvMode = DISABLE ; ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = 1; ADC_Init(ADCx, &ADC_InitStructure); RCC_ADCCLKConfig(RCC_PCLK2_Div8); ADC_RegularChannelConfig(ADCx, ADC_CHANNEL, 1,ADC_SampleTime_55Cycles5); ADC_Cmd(ADCx, ENABLE); ADC_ResetCalibration(ADCx); while(ADC_GetResetCalibrationStatus(ADCx)); ADC_StartCalibration(ADCx); while(ADC_GetCalibrationStatus(ADCx)); ADC_SoftwareStartConvCmd(ADCx, ENABLE); // ADC读值定时器创建 rt_timer_init(&timer_adc,"time_adc",timer_adc_callback,RT_NULL,1000, RT_TIMER_FLAG_PERIODIC|RT_TIMER_FLAG_SOFT_TIMER); rt_timer_start(&timer_adc); // ADC报警线程创建 rt_thread_init(&tadc,"detect_adc",thread_detect_adc,RT_NULL,detect_adc_stack, sizeof(detect_adc_stack),5,10); rt_thread_startup(&tadc); // 事件集创建 rt_event_init(&event_adc,"event_adc",RT_IPC_FLAG_FIFO); return 0; } INIT_APP_EXPORT(ADCx_Mode_Config); ``` * 软件定时器实时采集adc电压值，若电压值异常时发送事件集 ```C void timer_adc_callback(void *paramter) // 软件定时器回调函数 { if(ADC_GetFlagStatus(ADCx,ADC_FLAG_EOC) == SET) { // 电压转换 ADC_ConvertedValue = (3.3 * ADC_GetConversionValue(ADCx))/ 4096.0; ADC_ClearFlag(ADCx,ADC_FLAG_EOC); if(ADC_ConvertedValue > 3.0) // 电压高于3.0v { rt_event_send(&event_adc,EVENT_ADC_HIGH); // 发送电压值过高事件 } else if (ADC_ConvertedValue < 0.5) //电压低于0.5v { rt_event_send(&event_adc,EVENT_ADC_LOW); // 发送电压值过低事件 } // rt_kprintf无法打印浮点数，改用printf打印 printf("value:%.3fv\r\n", ADC_ConvertedValue); } } ``` * 报警线程函数则一直等待事件集的接收，并根据接收到的事件集判断是电压过低或者电压过高 ```C void thread_detect_adc(void *paramter) { rt_uint32_t event_rec; while(1) { // 此处使用的option参数使用 逻辑或 和 清除标志，并一直等待事件的发生 rt_event_recv(&event_adc,(EVENT_ADC_HIGH|EVENT_ADC_LOW), RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER,&event_rec); if(event_rec == EVENT_ADC_HIGH) // 接收到的事件为 EVENT_ADC_HIGH { rt_kprintf("WARNING:电压值超过3.0v\n"); } else if(event_rec == EVENT_ADC_LOW) // 接收到的事件为 EVENT_ADC_LOW { rt_kprintf("WARNING:电压值低于0.5v\n"); } rt_thread_mdelay(100); } } ```[/md] 效果截图： [attach]14606[/attach]
撰写答案
登录
注册新账号
关注者
0
被浏览
2.4k
关于作者
RT-Thread小喇叭
这家伙很懒，什么也没写！
提问
29
回答
54
被采纳
1
关注TA
发私信
相关问题
推荐文章
1
RT-Thread应用项目汇总
2
玩转RT-Thread系列教程
3
国产MCU移植系列教程汇总，欢迎查看！
4
机器人操作系统 (ROS2) 和 RT-Thread 通信
5
五分钟玩转RT-Thread新社区
6
【技术三千问】之《玩转ART-Pi》，看这篇就够了！干货汇总
7
关于STM32H7开发板上使用SDIO接口驱动SD卡挂载文件系统的问题总结
8
STM32的“GPU”——DMA2D实例详解
9
RT-Thread隐藏的宝藏之completion
10
【ART-PI】RT-Thread 开启RTC 与 Alarm组件
最新文章
1
使用百度AI助手辅助编写一个rt-thread下的ONVIF设备发现功能的功能代码
2
RT-Thread 发布 EtherKit开源以太网硬件！
3
rt-thread使用cherryusb实现虚拟串口
4
《C++20 图形界面程序：速度与渲染效率的双重优化秘籍》
5
《原子操作：程序世界里的“最小魔法单位”解析》
热门标签
RT-Thread Studio
串口
Env
LWIP
SPI
AT
Bootloader
Hardfault
CAN总线
FinSH
ART-Pi
USB
DMA
文件系统
RT-Thread
SCons
RT-Thread Nano
线程
MQTT
STM32
RTC
FAL
rt-smart
ESP8266
I2C_IIC
WIZnet_W5500
UART
ota在线升级
PWM
cubemx
freemodbus
flash
packages_软件包
BSP
潘多拉开发板_Pandora
定时器
ADC
GD32
flashDB
socket
中断
Debug
编译报错
msh
SFUD
keil_MDK
rt_mq_消息队列_msg_queue
ulog
C++_cpp
at_device
本月问答贡献
踩姑娘的小蘑菇
7
个答案
3
次被采纳
a1012112796
13
个答案
2
次被采纳
张世争
9
个答案
2
次被采纳
rv666
5
个答案
2
次被采纳
用户名由3_15位
11
个答案
1
次被采纳
本月文章贡献
程序员阿伟
8
篇文章
2
次点赞
hhart
3
篇文章
4
次点赞
大龄码农
1
篇文章
3
次点赞
ThinkCode
1
篇文章
1
次点赞
Betrayer
1
篇文章
1
次点赞
回到
顶部
发布
问题
分享
好友
手机
浏览
扫码手机浏览
投诉
建议
回到
底部
