#include "stdint.h" #include "string.h" #include "main.h" #include "sensor.h" #include "usart.h" #include "stdio.h" #include "crc.h" #include "pm.h" #include "..\Core\Inc\adc.h" #include "dma.h" #include "rec.h" #include "app_rtc.h" #include "spi.h" #define ADC_BUF_SZ (50ul) typedef enum { BUS_STA_DISABLE = 0, BUS_STA_TX = 1, BUS_STA_RX = 2, } bus_sta_t; typedef enum { SENSOR_STA_IDLE = 0, SENSOR_STA_START, SENSOR_STA_WAIT_PWR, SENSOR_STA_TX, SENSOR_STA_WAIT_ACK, SENSOR_STA_STOP, } sensor_sta_t; struct { sensor_sta_t tsk_sta; uint32_t timestamp; uint32_t tsk_timer; int retry; int rx_len; uint32_t rx_timer; uint8_t rx_buf[128]; } sensor_ctx; volatile uint16_t adc_buf[ADC_BUF_SZ][2]; sensor_data_t sensor_data; void sensor_set_bus_sta(bus_sta_t sta) { switch (sta) { default: case BUS_STA_DISABLE: HAL_GPIO_WritePin(RS485_DE_GPIO_Port, RS485_DE_Pin, GPIO_PIN_RESET); HAL_GPIO_WritePin(RS485_RE_GPIO_Port, RS485_RE_Pin, GPIO_PIN_SET); break; case BUS_STA_TX: HAL_GPIO_WritePin(RS485_DE_GPIO_Port, RS485_DE_Pin, GPIO_PIN_SET); HAL_GPIO_WritePin(RS485_RE_GPIO_Port, RS485_RE_Pin, GPIO_PIN_SET); break; case BUS_STA_RX: HAL_GPIO_WritePin(RS485_DE_GPIO_Port, RS485_DE_Pin, GPIO_PIN_RESET); HAL_GPIO_WritePin(RS485_RE_GPIO_Port, RS485_RE_Pin, GPIO_PIN_RESET); break; } } static void sensor_write(uint8_t *buf, int sz) { if (sz) { for (int i = 0; i < sz; i++) { LL_USART_TransmitData8(COM_RS485, buf[i]); while (!LL_USART_IsActiveFlag_TC(COM_RS485)) ; } } } void sensor_init(uint32_t timestamp) { if (pm_get_lock("sensor") < 0) { return; } MX_SPI2_Init(); MX_USART3_UART_Init(); memset(&sensor_ctx, 0, sizeof(sensor_ctx)); memset(&sensor_data, 0, sizeof(sensor_data)); LL_USART_Enable(COM_RS485); LL_USART_EnableIT_RXNE(COM_RS485); MX_DMA_Init(); MX_ADC1_Init(); HAL_ADCEx_Calibration_Start(&hadc1); sensor_ctx.tsk_sta = SENSOR_STA_START; sensor_ctx.timestamp = timestamp; } void sensor_deinit(void) { LL_USART_DisableIT_RXNE(COM_RS485); LL_USART_Disable(COM_RS485); LL_USART_DeInit(COM_RS485); LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_USART3); extern DMA_HandleTypeDef hdma_adc1; HAL_ADC_Stop(&hadc1); HAL_ADC_Stop_DMA(&hadc1); HAL_ADC_DeInit(&hadc1); HAL_DMA_DeInit(&hdma_adc1); ADC_Disable(&hadc1); } void sensor_task(void) { switch (sensor_ctx.tsk_sta) { default: case SENSOR_STA_IDLE: break; case SENSOR_STA_START: // 传感器上电,等待一段时间后发送查询命令 // 使能传感器电源 HAL_GPIO_WritePin(PWR_RS485_GPIO_Port, PWR_RS485_Pin, GPIO_PIN_SET); // 250930 增加ADC分压电阻电源控制 HAL_GPIO_WritePin(PWR_ADC_GPIO_Port, PWR_ADC_Pin, GPIO_PIN_SET); HAL_ADC_Start_DMA(&hadc1, (uint32_t *)adc_buf, sizeof(adc_buf) / sizeof(uint16_t)); sensor_ctx.tsk_timer = HAL_GetTick(); sensor_ctx.tsk_sta = SENSOR_STA_WAIT_PWR; break; case SENSOR_STA_WAIT_PWR: // 等待传感器上电完成 if (HAL_GetTick() - sensor_ctx.tsk_timer > 1000) { sensor_ctx.tsk_sta = SENSOR_STA_TX; } break; case SENSOR_STA_TX: { const uint8_t read_cmd[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x07, 0x04, 0x08}; sensor_set_bus_sta(BUS_STA_TX); sensor_write((uint8_t *)read_cmd, sizeof(read_cmd)); sensor_set_bus_sta(BUS_STA_RX); sensor_ctx.tsk_sta = SENSOR_STA_WAIT_ACK; sensor_ctx.tsk_timer = HAL_GetTick(); sensor_ctx.retry++; } break; case SENSOR_STA_WAIT_ACK: // 等待传感器应答 { int need_retry = 0; if (sensor_ctx.rx_len >= 19) { if (CRC16(sensor_ctx.rx_buf, 19) == 0) { sensor_data.temperature = ((uint16_t)sensor_ctx.rx_buf[7] << 8) + sensor_ctx.rx_buf[8]; sensor_data.humidity = (uint16_t)(sensor_ctx.rx_buf[9] << 8) + sensor_ctx.rx_buf[10]; sensor_data.illuminance = ((uint32_t)(sensor_ctx.rx_buf[13] << 8) + sensor_ctx.rx_buf[14]) * 10 + ((uint32_t)(sensor_ctx.rx_buf[15] << 8) + sensor_ctx.rx_buf[16]); } else { need_retry = 1; } } else if (HAL_GetTick() - sensor_ctx.tsk_timer < 500) { break; } else { need_retry = 1; } if (need_retry) { if (sensor_ctx.retry < 3) { sensor_ctx.rx_len = 0; sensor_ctx.tsk_timer = 0; sensor_ctx.tsk_sta = SENSOR_STA_TX; break; } } // 成功采集到数据或达到最大重试次数 // 保存数据 rec_data_t rec_data; rec_data.humidity = sensor_data.humidity; rec_data.illuminance = sensor_data.illuminance; rec_data.temperature = sensor_data.temperature; rec_data.voltage = sensor_data.voltage; if (sensor_ctx.timestamp == 0) { rtc_time_t time; rtc_get_time(&time); rec_data.timestamp = rtc_mktime(&time); } else { rec_data.timestamp = sensor_ctx.timestamp; rec_write(&rec_data); } sensor_ctx.tsk_sta = SENSOR_STA_STOP; HAL_GPIO_WritePin(PWR_RS485_GPIO_Port, PWR_RS485_Pin, GPIO_PIN_RESET); // 250930 增加ADC分压电阻电源控制 HAL_GPIO_WritePin(PWR_ADC_GPIO_Port, PWR_ADC_Pin, GPIO_PIN_RESET); sensor_set_bus_sta(BUS_STA_DISABLE); } break; case SENSOR_STA_STOP: // 读取完成或达到最大重试次数 sensor_deinit(); sensor_ctx.tsk_sta = SENSOR_STA_IDLE; pm_release_lock("sensor"); break; } } int sensor_is_busy(void) { return sensor_ctx.tsk_sta != SENSOR_STA_IDLE; } void sensor_irq_handle(void) { if (LL_USART_IsEnabledIT_RXNE(COM_RS485) && LL_USART_IsActiveFlag_RXNE(COM_RS485)) { uint8_t tmp; tmp = LL_USART_ReceiveData8(COM_RS485); if (sensor_ctx.rx_len < sizeof(sensor_ctx.rx_buf)) { sensor_ctx.rx_buf[sensor_ctx.rx_len] = tmp; sensor_ctx.rx_len++; } sensor_ctx.rx_timer = HAL_GetTick(); } if (LL_USART_IsActiveFlag_ORE(COM_RS485)) { LL_USART_ClearFlag_ORE(COM_RS485); LL_USART_DisableIT_ERROR(COM_RS485); } if (LL_USART_IsEnabledIT_TC(COM_RS485) && LL_USART_IsActiveFlag_TC(COM_RS485)) { LL_USART_ClearFlag_TC(COM_RS485); LL_USART_DisableIT_TC(COM_RS485); } } /* 分压电阻R1=47K,R2=10K VCC------|||||------|||||------GND | | | R1 V R2 */ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { uint32_t sum = 0; uint32_t vref = 0; for (int i = 0; i < ADC_BUF_SZ; i++) { vref += adc_buf[i][0]; sum += adc_buf[i][1]; } sum = sum / ADC_BUF_SZ; vref = __HAL_ADC_CALC_VREFANALOG_VOLTAGE(vref/ADC_BUF_SZ, ADC_RESOLUTION_12B); sensor_data.voltage = __HAL_ADC_CALC_DATA_TO_VOLTAGE(vref, sum, ADC_RESOLUTION_12B)*57/10ul; // 250927 电压单位转换以及防反接二极管的电压补偿统一在这里操作 sensor_data.voltage = (sensor_data.voltage + 360) / 100; } void sensor_get_data(sensor_data_t *data) { if(data) { memcpy(data, &sensor_data, sizeof(sensor_data)); } }