sensor.c 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306
  1. #include "stdint.h"
  2. #include "string.h"
  3. #include "main.h"
  4. #include "sensor.h"
  5. #include "usart.h"
  6. #include "stdio.h"
  7. #include "crc.h"
  8. #include "pm.h"
  9. #include "..\Core\Inc\adc.h"
  10. #include "dma.h"
  11. #include "rec.h"
  12. #include "app_rtc.h"
  13. #include "spi.h"
  14. #define ADC_BUF_SZ (50ul)
  15. typedef enum
  16. {
  17. BUS_STA_DISABLE = 0,
  18. BUS_STA_TX = 1,
  19. BUS_STA_RX = 2,
  20. } bus_sta_t;
  21. typedef enum
  22. {
  23. SENSOR_STA_IDLE = 0,
  24. SENSOR_STA_START,
  25. SENSOR_STA_WAIT_PWR,
  26. SENSOR_STA_TX,
  27. SENSOR_STA_WAIT_ACK,
  28. SENSOR_STA_STOP,
  29. } sensor_sta_t;
  30. struct
  31. {
  32. sensor_sta_t tsk_sta;
  33. uint32_t timestamp;
  34. uint32_t tsk_timer;
  35. int retry;
  36. volatile int rx_len;
  37. uint32_t rx_timer;
  38. uint8_t rx_buf[128];
  39. } sensor_ctx;
  40. volatile uint16_t adc_buf[ADC_BUF_SZ][2];
  41. sensor_data_t sensor_data;
  42. void sensor_set_bus_sta(bus_sta_t sta)
  43. {
  44. switch (sta)
  45. {
  46. default:
  47. case BUS_STA_DISABLE:
  48. HAL_GPIO_WritePin(RS485_DE_GPIO_Port, RS485_DE_Pin, GPIO_PIN_RESET);
  49. HAL_GPIO_WritePin(RS485_RE_GPIO_Port, RS485_RE_Pin, GPIO_PIN_SET);
  50. break;
  51. case BUS_STA_TX:
  52. HAL_GPIO_WritePin(RS485_DE_GPIO_Port, RS485_DE_Pin, GPIO_PIN_SET);
  53. HAL_GPIO_WritePin(RS485_RE_GPIO_Port, RS485_RE_Pin, GPIO_PIN_SET);
  54. break;
  55. case BUS_STA_RX:
  56. HAL_GPIO_WritePin(RS485_DE_GPIO_Port, RS485_DE_Pin, GPIO_PIN_RESET);
  57. HAL_GPIO_WritePin(RS485_RE_GPIO_Port, RS485_RE_Pin, GPIO_PIN_RESET);
  58. break;
  59. }
  60. }
  61. static void sensor_write(uint8_t *buf, int sz)
  62. {
  63. if (sz)
  64. {
  65. for (int i = 0; i < sz; i++)
  66. {
  67. LL_USART_TransmitData8(COM_RS485, buf[i]);
  68. while (!LL_USART_IsActiveFlag_TC(COM_RS485))
  69. ;
  70. }
  71. }
  72. }
  73. void sensor_init(uint32_t timestamp)
  74. {
  75. if (pm_get_lock("sensor") < 0)
  76. {
  77. return;
  78. }
  79. MX_SPI2_Init();
  80. MX_USART3_UART_Init();
  81. memset(&sensor_ctx, 0, sizeof(sensor_ctx));
  82. memset(&sensor_data, 0, sizeof(sensor_data));
  83. LL_USART_Enable(COM_RS485);
  84. LL_USART_EnableIT_RXNE(COM_RS485);
  85. MX_DMA_Init();
  86. MX_ADC1_Init();
  87. HAL_ADCEx_Calibration_Start(&hadc1);
  88. sensor_ctx.tsk_sta = SENSOR_STA_START;
  89. sensor_ctx.timestamp = timestamp;
  90. }
  91. void sensor_deinit(void)
  92. {
  93. LL_USART_DisableIT_RXNE(COM_RS485);
  94. LL_USART_Disable(COM_RS485);
  95. LL_USART_DeInit(COM_RS485);
  96. LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_USART3);
  97. extern DMA_HandleTypeDef hdma_adc1;
  98. HAL_ADC_Stop(&hadc1);
  99. HAL_ADC_Stop_DMA(&hadc1);
  100. HAL_ADC_DeInit(&hadc1);
  101. HAL_DMA_DeInit(&hdma_adc1);
  102. ADC_Disable(&hadc1);
  103. }
  104. void sensor_task(void)
  105. {
  106. switch (sensor_ctx.tsk_sta)
  107. {
  108. default:
  109. case SENSOR_STA_IDLE:
  110. break;
  111. case SENSOR_STA_START: // 传感器上电,等待一段时间后发送查询命令
  112. // 使能传感器电源
  113. HAL_GPIO_WritePin(PWR_RS485_GPIO_Port, PWR_RS485_Pin, GPIO_PIN_SET);
  114. // 250930 增加ADC分压电阻电源控制
  115. HAL_GPIO_WritePin(PWR_ADC_GPIO_Port, PWR_ADC_Pin, GPIO_PIN_SET);
  116. HAL_ADC_Start_DMA(&hadc1, (uint32_t *)adc_buf, sizeof(adc_buf) / sizeof(uint16_t));
  117. sensor_ctx.tsk_timer = HAL_GetTick();
  118. sensor_ctx.tsk_sta = SENSOR_STA_WAIT_PWR;
  119. break;
  120. case SENSOR_STA_WAIT_PWR: // 等待传感器上电完成
  121. if (HAL_GetTick() - sensor_ctx.tsk_timer > 3000)
  122. {
  123. sensor_ctx.tsk_sta = SENSOR_STA_TX;
  124. }
  125. break;
  126. case SENSOR_STA_TX:
  127. {
  128. const uint8_t read_cmd[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0xC4, 0x0B};
  129. sensor_set_bus_sta(BUS_STA_TX);
  130. sensor_write((uint8_t *)read_cmd, sizeof(read_cmd));
  131. sensor_set_bus_sta(BUS_STA_RX);
  132. sensor_ctx.rx_len = 0;
  133. sensor_ctx.tsk_timer = HAL_GetTick();
  134. sensor_ctx.retry++;
  135. sensor_ctx.tsk_sta = SENSOR_STA_WAIT_ACK;
  136. }
  137. break;
  138. case SENSOR_STA_WAIT_ACK: // 等待传感器应答
  139. {
  140. int need_retry = 0;
  141. if (sensor_ctx.rx_len >= 9)
  142. {
  143. if(CRC16(sensor_ctx.rx_buf, 9) == 0)
  144. {
  145. int16_t temperature = (int16_t)(((uint16_t)sensor_ctx.rx_buf[3] << 8) | sensor_ctx.rx_buf[4]);
  146. int16_t humidity = (int16_t)(((uint16_t)sensor_ctx.rx_buf[5] << 8) | sensor_ctx.rx_buf[6]);
  147. if (temperature == 0x7FFF || humidity == 0x7FFF)
  148. { // 传感器还没准备好
  149. dbg_log("read sensor invalid: temperature=0x%04X, humidity=0x%04X", temperature, humidity);
  150. sensor_ctx.rx_len = 0; sensor_ctx.tsk_timer = HAL_GetTick();
  151. }
  152. else
  153. { // 传感器读到正确值
  154. sensor_data.temperature = temperature;
  155. sensor_data.humidity = humidity;
  156. sensor_data.illuminance = 0;
  157. sensor_ctx.retry = 0;
  158. dbg_log("read sensor success: temperature=0x%04X, humidity=0x%04X", temperature, humidity);
  159. }
  160. }
  161. else
  162. {
  163. need_retry = 1;
  164. }
  165. }
  166. else
  167. {
  168. if (HAL_GetTick() - sensor_ctx.tsk_timer < 1000)
  169. {
  170. break;
  171. }
  172. need_retry = 1;
  173. }
  174. if (need_retry)
  175. {
  176. if (sensor_ctx.retry < 5)
  177. {
  178. sensor_ctx.tsk_sta = SENSOR_STA_TX;
  179. break;
  180. }
  181. }
  182. // 成功采集到数据或达到最大重试次数
  183. // 保存数据
  184. rec_data_t rec_data;
  185. rec_data.humidity = sensor_data.humidity;
  186. rec_data.illuminance = sensor_data.illuminance;
  187. rec_data.temperature = sensor_data.temperature;
  188. rec_data.voltage = sensor_data.voltage;
  189. if (sensor_ctx.timestamp == 0)
  190. {
  191. rtc_time_t time;
  192. rtc_get_time(&time);
  193. rec_data.timestamp = rtc_mktime(&time);
  194. }
  195. else
  196. {
  197. rec_data.timestamp = sensor_ctx.timestamp;
  198. }
  199. rec_write(&rec_data);
  200. sensor_ctx.tsk_sta = SENSOR_STA_STOP;
  201. HAL_GPIO_WritePin(PWR_RS485_GPIO_Port, PWR_RS485_Pin, GPIO_PIN_RESET);
  202. // 250930 增加ADC分压电阻电源控制
  203. HAL_GPIO_WritePin(PWR_ADC_GPIO_Port, PWR_ADC_Pin, GPIO_PIN_RESET);
  204. sensor_set_bus_sta(BUS_STA_DISABLE);
  205. }
  206. break;
  207. case SENSOR_STA_STOP: // 读取完成或达到最大重试次数
  208. sensor_deinit();
  209. sensor_ctx.tsk_sta = SENSOR_STA_IDLE;
  210. pm_release_lock("sensor");
  211. break;
  212. }
  213. }
  214. int sensor_is_busy(void)
  215. {
  216. return sensor_ctx.tsk_sta != SENSOR_STA_IDLE;
  217. }
  218. void sensor_irq_handle(void)
  219. {
  220. if (LL_USART_IsEnabledIT_RXNE(COM_RS485) && LL_USART_IsActiveFlag_RXNE(COM_RS485))
  221. {
  222. uint8_t tmp;
  223. tmp = LL_USART_ReceiveData8(COM_RS485);
  224. if (sensor_ctx.rx_len < sizeof(sensor_ctx.rx_buf))
  225. {
  226. sensor_ctx.rx_buf[sensor_ctx.rx_len] = tmp;
  227. sensor_ctx.rx_len++;
  228. }
  229. sensor_ctx.rx_timer = HAL_GetTick();
  230. }
  231. if (LL_USART_IsActiveFlag_ORE(COM_RS485))
  232. {
  233. LL_USART_ClearFlag_ORE(COM_RS485);
  234. LL_USART_DisableIT_ERROR(COM_RS485);
  235. }
  236. if (LL_USART_IsEnabledIT_TC(COM_RS485) && LL_USART_IsActiveFlag_TC(COM_RS485))
  237. {
  238. LL_USART_ClearFlag_TC(COM_RS485);
  239. LL_USART_DisableIT_TC(COM_RS485);
  240. }
  241. }
  242. /*
  243. 分压电阻R1=47K,R2=10K
  244. VCC------|||||------|||||------GND
  245. | | |
  246. R1 V R2
  247. */
  248. void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
  249. {
  250. uint32_t sum = 0;
  251. uint32_t vref = 0;
  252. for (int i = 0; i < ADC_BUF_SZ; i++)
  253. {
  254. vref += adc_buf[i][0];
  255. sum += adc_buf[i][1];
  256. }
  257. sum = sum / ADC_BUF_SZ;
  258. vref = __HAL_ADC_CALC_VREFANALOG_VOLTAGE(vref/ADC_BUF_SZ, ADC_RESOLUTION_12B);
  259. sensor_data.voltage = __HAL_ADC_CALC_DATA_TO_VOLTAGE(vref, sum, ADC_RESOLUTION_12B)*57/10ul;
  260. // 250927 电压单位转换以及防反接二极管的电压补偿统一在这里操作
  261. sensor_data.voltage = (sensor_data.voltage + 360) / 100;
  262. }
  263. void sensor_get_data(sensor_data_t *data)
  264. {
  265. if(data)
  266. {
  267. memcpy(data, &sensor_data, sizeof(sensor_data));
  268. }
  269. }