sensor_cmd.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2019-01-31 flybreak first version
  9. * 2019-07-16 WillianChan Increase the output of sensor information
  10. * 2020-02-22 luhuadong Add vendor info and sensor types for cmd
  11. * 2022-12-17 Meco Man re-implement sensor framework
  12. */
  13. #include <drivers/sensor.h>
  14. #define DBG_TAG "sensor.cmd"
  15. #define DBG_LVL DBG_INFO
  16. #include <rtdbg.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. static rt_sem_t sensor_rx_sem = RT_NULL;
  20. static const char *sensor_get_type_name(rt_sensor_info_t info)
  21. {
  22. switch(info->type)
  23. {
  24. case RT_SENSOR_TYPE_ACCE:
  25. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_ACCE);
  26. case RT_SENSOR_TYPE_GYRO:
  27. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_GYRO);
  28. case RT_SENSOR_TYPE_MAG:
  29. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_MAG);
  30. case RT_SENSOR_TYPE_TEMP:
  31. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_TEMP);
  32. case RT_SENSOR_TYPE_HUMI:
  33. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_HUMI);
  34. case RT_SENSOR_TYPE_BARO:
  35. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_BARO);
  36. case RT_SENSOR_TYPE_LIGHT:
  37. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_LIGHT);
  38. case RT_SENSOR_TYPE_PROXIMITY:
  39. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_PROXIMITY);
  40. case RT_SENSOR_TYPE_HR:
  41. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_HR);
  42. case RT_SENSOR_TYPE_TVOC:
  43. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_TVOC);
  44. case RT_SENSOR_TYPE_NOISE:
  45. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_NOISE);
  46. case RT_SENSOR_TYPE_STEP:
  47. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_STEP);
  48. case RT_SENSOR_TYPE_FORCE:
  49. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_FORCE);
  50. case RT_SENSOR_TYPE_DUST:
  51. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_DUST);
  52. case RT_SENSOR_TYPE_ECO2:
  53. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_ECO2);
  54. case RT_SENSOR_TYPE_GNSS:
  55. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_GNSS);
  56. case RT_SENSOR_TYPE_TOF:
  57. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_TOF);
  58. case RT_SENSOR_TYPE_SPO2:
  59. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_SPO2);
  60. case RT_SENSOR_TYPE_IAQ:
  61. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_IAQ);
  62. case RT_SENSOR_TYPE_ETOH:
  63. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_ETOH);
  64. case RT_SENSOR_TYPE_BP:
  65. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_BP);
  66. case RT_SENSOR_TYPE_VOLTAGE:
  67. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_VOLTAGE);
  68. case RT_SENSOR_TYPE_CURRENT:
  69. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_CURRENT);
  70. case RT_SENSOR_TYPE_NONE:
  71. default:
  72. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_TYPE_NONE);
  73. }
  74. }
  75. static const char *sensor_get_vendor_name(rt_sensor_info_t info)
  76. {
  77. switch(info->vendor)
  78. {
  79. case RT_SENSOR_VENDOR_VIRTUAL:
  80. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_VIRTUAL);
  81. case RT_SENSOR_VENDOR_ONCHIP:
  82. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_ONCHIP);
  83. case RT_SENSOR_VENDOR_STM:
  84. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_STM);
  85. case RT_SENSOR_VENDOR_BOSCH:
  86. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_BOSCH);
  87. case RT_SENSOR_VENDOR_INVENSENSE:
  88. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_INVENSENSE);
  89. case RT_SENSOR_VENDOR_SEMTECH:
  90. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_SEMTECH);
  91. case RT_SENSOR_VENDOR_GOERTEK:
  92. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_GOERTEK);
  93. case RT_SENSOR_VENDOR_MIRAMEMS:
  94. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_MIRAMEMS);
  95. case RT_SENSOR_VENDOR_DALLAS:
  96. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_DALLAS);
  97. case RT_SENSOR_VENDOR_ASAIR:
  98. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_ASAIR);
  99. case RT_SENSOR_VENDOR_SHARP:
  100. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_SHARP);
  101. case RT_SENSOR_VENDOR_SENSIRION:
  102. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_SENSIRION);
  103. case RT_SENSOR_VENDOR_TI:
  104. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_TI);
  105. case RT_SENSOR_VENDOR_PLANTOWER:
  106. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_PLANTOWER);
  107. case RT_SENSOR_VENDOR_AMS:
  108. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_AMS);
  109. case RT_SENSOR_VENDOR_MAXIM:
  110. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_MAXIM);
  111. case RT_SENSOR_VENDOR_MELEXIS:
  112. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_MELEXIS);
  113. case RT_SENSOR_VENDOR_LSC:
  114. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_LSC);
  115. case RT_SENSOR_VENDOR_UNKNOWN:
  116. default:
  117. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_VENDOR_UNKNOWN);
  118. }
  119. }
  120. static const char *sensor_get_unit_name(rt_sensor_info_t info)
  121. {
  122. switch(info->unit)
  123. {
  124. case RT_SENSOR_UNIT_MG:
  125. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MG);
  126. case RT_SENSOR_UNIT_MDPS:
  127. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MDPS);
  128. case RT_SENSOR_UNIT_MGAUSS:
  129. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MGAUSS);
  130. case RT_SENSOR_UNIT_LUX:
  131. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_LUX);
  132. case RT_SENSOR_UNIT_M:
  133. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_M);
  134. case RT_SENSOR_UNIT_CM:
  135. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_CM);
  136. case RT_SENSOR_UNIT_MM:
  137. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MM);
  138. case RT_SENSOR_UNIT_PA:
  139. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_PA);
  140. case RT_SENSOR_UNIT_MMHG:
  141. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MMHG);
  142. case RT_SENSOR_UNIT_PERCENTAGE:
  143. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_PERCENTAGE);
  144. case RT_SENSOR_UNIT_PERMILLAGE:
  145. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_PERMILLAGE);
  146. case RT_SENSOR_UNIT_CELSIUS:
  147. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_CELSIUS);
  148. case RT_SENSOR_UNIT_FAHRENHEIT:
  149. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_FAHRENHEIT);
  150. case RT_SENSOR_UNIT_KELVIN:
  151. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_KELVIN);
  152. case RT_SENSOR_UNIT_HZ:
  153. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_HZ);
  154. case RT_SENSOR_UNIT_V:
  155. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_V);
  156. case RT_SENSOR_UNIT_MV:
  157. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MV);
  158. case RT_SENSOR_UNIT_A:
  159. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_A);
  160. case RT_SENSOR_UNIT_MA:
  161. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MA);
  162. case RT_SENSOR_UNIT_N:
  163. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_N);
  164. case RT_SENSOR_UNIT_MN:
  165. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MN);
  166. case RT_SENSOR_UNIT_BPM:
  167. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_BPM);
  168. case RT_SENSOR_UNIT_PPM:
  169. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_PPM);
  170. case RT_SENSOR_UNIT_PPB:
  171. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_PPB);
  172. case RT_SENSOR_UNIT_DMS:
  173. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_DMS);
  174. case RT_SENSOR_UNIT_DD:
  175. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_DD);
  176. case RT_SENSOR_UNIT_MGM3:
  177. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_MGM3);
  178. case RT_SENSOR_UNIT_NONE:
  179. default:
  180. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_UNIT_NONE);
  181. }
  182. }
  183. static const char* sensor_get_accuracy_mode_name(rt_sensor_info_t info)
  184. {
  185. switch(RT_SENSOR_MODE_GET_ACCURACY(info->mode))
  186. {
  187. case RT_SENSOR_MODE_ACCURACY_HIGHEST:
  188. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_ACCURACY_HIGHEST);
  189. case RT_SENSOR_MODE_ACCURACY_HIGH:
  190. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_ACCURACY_HIGH);
  191. case RT_SENSOR_MODE_ACCURACY_MEDIUM:
  192. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_ACCURACY_MEDIUM);
  193. case RT_SENSOR_MODE_ACCURACY_LOW:
  194. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_ACCURACY_LOW);
  195. case RT_SENSOR_MODE_ACCURACY_LOWEST:
  196. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_ACCURACY_LOWEST);
  197. case RT_SENSOR_MODE_ACCURACY_NOTRUST:
  198. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_ACCURACY_NOTRUST);
  199. default:
  200. LOG_E("accuracy mode illegal!");
  201. return "";
  202. }
  203. }
  204. static const char* sensor_get_power_mode_name(rt_sensor_info_t info)
  205. {
  206. switch(RT_SENSOR_MODE_GET_POWER(info->mode))
  207. {
  208. case RT_SENSOR_MODE_POWER_HIGHEST:
  209. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_POWER_HIGHEST);
  210. case RT_SENSOR_MODE_POWER_HIGH:
  211. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_POWER_HIGH);
  212. case RT_SENSOR_MODE_POWER_MEDIUM:
  213. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_POWER_MEDIUM);
  214. case RT_SENSOR_MODE_POWER_LOW:
  215. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_POWER_LOW);
  216. case RT_SENSOR_MODE_POWER_LOWEST:
  217. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_POWER_LOWEST);
  218. case RT_SENSOR_MODE_POWER_DOWN:
  219. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_POWER_DOWN);
  220. default:
  221. LOG_E("power mode illegal!");
  222. return "";
  223. }
  224. }
  225. static const char* sensor_get_fetch_mode_name(rt_sensor_info_t info)
  226. {
  227. switch(RT_SENSOR_MODE_GET_FETCH(info->mode))
  228. {
  229. case RT_SENSOR_MODE_FETCH_POLLING:
  230. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_FETCH_POLLING);
  231. case RT_SENSOR_MODE_FETCH_INT:
  232. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_FETCH_INT);
  233. case RT_SENSOR_MODE_FETCH_FIFO:
  234. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_MODE_FETCH_FIFO);
  235. default:
  236. LOG_E("fetch data mode illegal!");
  237. return "";
  238. }
  239. }
  240. static void sensor_show_data(rt_size_t num, rt_sensor_t sensor, struct rt_sensor_data *sensor_data)
  241. {
  242. const char *unit_name = sensor_get_unit_name(&sensor->info);
  243. switch (sensor->info.type)
  244. {
  245. case RT_SENSOR_TYPE_ACCE:
  246. LOG_I("num:%d, x:%f, y:%f, z:%f %s, timestamp:%u", num, sensor_data->data.acce.x, sensor_data->data.acce.y, sensor_data->data.acce.z, unit_name, sensor_data->timestamp);
  247. break;
  248. case RT_SENSOR_TYPE_GYRO:
  249. LOG_I("num:%d, x:%f, y:%f, z:%f %s, timestamp:%u", num, sensor_data->data.gyro.x, sensor_data->data.gyro.y, sensor_data->data.gyro.z, unit_name, sensor_data->timestamp);
  250. break;
  251. case RT_SENSOR_TYPE_MAG:
  252. LOG_I("num:%d, x:%f, y:%f, z:%f %s, timestamp:%u", num, sensor_data->data.mag.x, sensor_data->data.mag.y, sensor_data->data.mag.z, unit_name, sensor_data->timestamp);
  253. break;
  254. case RT_SENSOR_TYPE_GNSS:
  255. LOG_I("num:%d, lon:%f, lat:%f %s, timestamp:%u", num, sensor_data->data.coord.longitude, sensor_data->data.coord.latitude, unit_name, sensor_data->timestamp);
  256. break;
  257. case RT_SENSOR_TYPE_TEMP:
  258. LOG_I("num:%d, temp:%f%s, timestamp:%u", num, sensor_data->data.temp, unit_name, sensor_data->timestamp);
  259. break;
  260. case RT_SENSOR_TYPE_HUMI:
  261. LOG_I("num:%d, humi:%f%s, timestamp:%u", num, sensor_data->data.humi, unit_name, sensor_data->timestamp);
  262. break;
  263. case RT_SENSOR_TYPE_BARO:
  264. LOG_I("num:%d, press:%f%s, timestamp:%u", num, sensor_data->data.baro, unit_name, sensor_data->timestamp);
  265. break;
  266. case RT_SENSOR_TYPE_LIGHT:
  267. LOG_I("num:%d, light:%f%s, timestamp:%u", num, sensor_data->data.light, unit_name, sensor_data->timestamp);
  268. break;
  269. case RT_SENSOR_TYPE_PROXIMITY:
  270. case RT_SENSOR_TYPE_TOF:
  271. LOG_I("num:%d, distance:%f%s, timestamp:%u", num, sensor_data->data.proximity, unit_name, sensor_data->timestamp);
  272. break;
  273. case RT_SENSOR_TYPE_HR:
  274. LOG_I("num:%d, heart rate:%f%s, timestamp:%u", num, sensor_data->data.hr, unit_name, sensor_data->timestamp);
  275. break;
  276. case RT_SENSOR_TYPE_TVOC:
  277. LOG_I("num:%d, tvoc:%f%s, timestamp:%u", num, sensor_data->data.tvoc, unit_name, sensor_data->timestamp);
  278. break;
  279. case RT_SENSOR_TYPE_NOISE:
  280. LOG_I("num:%d, noise:%f%s, timestamp:%u", num, sensor_data->data.noise, unit_name, sensor_data->timestamp);
  281. break;
  282. case RT_SENSOR_TYPE_STEP:
  283. LOG_I("num:%d, step:%f%s, timestamp:%u", num, sensor_data->data.step, unit_name, sensor_data->timestamp);
  284. break;
  285. case RT_SENSOR_TYPE_FORCE:
  286. LOG_I("num:%d, force:%f%s, timestamp:%u", num, sensor_data->data.force, unit_name, sensor_data->timestamp);
  287. break;
  288. case RT_SENSOR_TYPE_DUST:
  289. LOG_I("num:%d, dust:%f%s, timestamp:%u", num, sensor_data->data.dust, unit_name, sensor_data->timestamp);
  290. break;
  291. case RT_SENSOR_TYPE_ECO2:
  292. LOG_I("num:%d, eco2:%f%s, timestamp:%u", num, sensor_data->data.eco2, unit_name, sensor_data->timestamp);
  293. break;
  294. case RT_SENSOR_TYPE_IAQ:
  295. LOG_I("num:%d, IAQ:%f%s, timestamp:%u", num, sensor_data->data.iaq, unit_name, sensor_data->timestamp);
  296. break;
  297. case RT_SENSOR_TYPE_ETOH:
  298. LOG_I("num:%d, EtOH:%f%s, timestamp:%u", num, sensor_data->data.etoh, unit_name, sensor_data->timestamp);
  299. break;
  300. case RT_SENSOR_TYPE_BP:
  301. LOG_I("num:%d, bp.sbp:%f, bp.dbp:%f %s, timestamp:%u", num, sensor_data->data.bp.sbp, sensor_data->data.bp.dbp, unit_name, sensor_data->timestamp);
  302. break;
  303. case RT_SENSOR_TYPE_NONE:
  304. default:
  305. LOG_E("Unknown type of sensor!");
  306. break;
  307. }
  308. }
  309. static const char* sensor_get_intf_name(rt_sensor_t sensor)
  310. {
  311. rt_uint8_t type = sensor->config.intf.type;
  312. if (type | RT_SENSOR_INTF_I2C)
  313. {
  314. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_INTF_I2C);
  315. }
  316. else if (type | RT_SENSOR_INTF_SPI)
  317. {
  318. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_INTF_SPI);
  319. }
  320. else if (type | RT_SENSOR_INTF_UART)
  321. {
  322. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_INTF_UART);
  323. }
  324. else if (type | RT_SENSOR_INTF_ONEWIRE)
  325. {
  326. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_INTF_ONEWIRE);
  327. }
  328. else if (type | RT_SENSOR_INTF_CAN)
  329. {
  330. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_INTF_CAN);
  331. }
  332. else if (type | RT_SENSOR_INTF_MODBUS)
  333. {
  334. return RT_SENSOR_MACRO_GET_NAME(RT_SENSOR_INTF_MODBUS);
  335. }
  336. else
  337. {
  338. return "";
  339. }
  340. }
  341. static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
  342. {
  343. rt_sem_release(sensor_rx_sem);
  344. return 0;
  345. }
  346. static void sensor_fifo_rx_entry(void *parameter)
  347. {
  348. rt_sensor_t sensor = (rt_sensor_t)parameter;
  349. struct rt_sensor_data *data = RT_NULL;
  350. rt_size_t res, i;
  351. data = (struct rt_sensor_data *)rt_calloc(sensor->info.fifo_max, sizeof(struct rt_sensor_data));
  352. if (data == RT_NULL)
  353. {
  354. LOG_E("Memory allocation failed!");
  355. }
  356. while (1)
  357. {
  358. rt_sem_take(sensor_rx_sem, RT_WAITING_FOREVER);
  359. res = rt_device_read((rt_device_t)sensor, 0, data, sensor->info.fifo_max);
  360. for (i = 0; i < res; i++)
  361. {
  362. sensor_show_data(i, sensor, &data[i]);
  363. }
  364. }
  365. }
  366. static void sensor_fifo(int argc, char **argv)
  367. {
  368. static rt_thread_t tid1 = RT_NULL;
  369. rt_device_t dev = RT_NULL;
  370. rt_sensor_t sensor;
  371. dev = rt_device_find(argv[1]);
  372. if (dev == RT_NULL)
  373. {
  374. LOG_E("Can't find device:%s", argv[1]);
  375. return;
  376. }
  377. sensor = (rt_sensor_t)dev;
  378. if (rt_device_open(dev, RT_DEVICE_FLAG_FIFO_RX) != RT_EOK)
  379. {
  380. LOG_E("open device failed!");
  381. return;
  382. }
  383. if (sensor_rx_sem == RT_NULL)
  384. {
  385. sensor_rx_sem = rt_sem_create("sen_rx_sem", 0, RT_IPC_FLAG_FIFO);
  386. }
  387. else
  388. {
  389. LOG_E("The thread is running, please reboot and try again");
  390. return;
  391. }
  392. tid1 = rt_thread_create("sen_rx_thread",
  393. sensor_fifo_rx_entry, sensor,
  394. 1024,
  395. 15, 5);
  396. if (tid1 != RT_NULL)
  397. rt_thread_startup(tid1);
  398. rt_device_set_rx_indicate(dev, rx_callback);
  399. }
  400. #ifdef RT_USING_FINSH
  401. MSH_CMD_EXPORT(sensor_fifo, Sensor fifo mode test function);
  402. #endif
  403. static void sensor_irq_rx_entry(void *parameter)
  404. {
  405. rt_device_t dev = (rt_device_t)parameter;
  406. rt_sensor_t sensor = (rt_sensor_t)parameter;
  407. struct rt_sensor_data data;
  408. rt_size_t res, i = 0;
  409. while (1)
  410. {
  411. rt_sem_take(sensor_rx_sem, RT_WAITING_FOREVER);
  412. res = rt_device_read(dev, 0, &data, 1);
  413. if (res == 1)
  414. {
  415. sensor_show_data(i++, sensor, &data);
  416. }
  417. }
  418. }
  419. static void sensor_int(int argc, char **argv)
  420. {
  421. static rt_thread_t tid1 = RT_NULL;
  422. rt_device_t dev = RT_NULL;
  423. rt_sensor_t sensor;
  424. dev = rt_device_find(argv[1]);
  425. if (dev == RT_NULL)
  426. {
  427. LOG_E("Can't find device:%s", argv[1]);
  428. return;
  429. }
  430. sensor = (rt_sensor_t)dev;
  431. if (sensor_rx_sem == RT_NULL)
  432. {
  433. sensor_rx_sem = rt_sem_create("sen_rx_sem", 0, RT_IPC_FLAG_FIFO);
  434. }
  435. else
  436. {
  437. LOG_E("The thread is running, please reboot and try again");
  438. return;
  439. }
  440. tid1 = rt_thread_create("sen_rx_thread",
  441. sensor_irq_rx_entry, sensor,
  442. 1024,
  443. 15, 5);
  444. if (tid1 != RT_NULL)
  445. rt_thread_startup(tid1);
  446. rt_device_set_rx_indicate(dev, rx_callback);
  447. if (rt_device_open(dev, RT_DEVICE_FLAG_INT_RX) != RT_EOK)
  448. {
  449. LOG_E("open device failed!");
  450. return;
  451. }
  452. }
  453. #ifdef RT_USING_FINSH
  454. MSH_CMD_EXPORT(sensor_int, Sensor interrupt mode test function);
  455. #endif
  456. static void sensor_polling(int argc, char **argv)
  457. {
  458. rt_uint16_t num = 10;
  459. rt_device_t dev = RT_NULL;
  460. rt_sensor_t sensor;
  461. struct rt_sensor_data data;
  462. rt_size_t res, i;
  463. rt_int32_t delay;
  464. rt_err_t result;
  465. dev = rt_device_find(argv[1]);
  466. if (dev == RT_NULL)
  467. {
  468. LOG_E("Can't find device:%s", argv[1]);
  469. return;
  470. }
  471. if (argc > 2)
  472. num = atoi(argv[2]);
  473. sensor = (rt_sensor_t)dev;
  474. delay = sensor->info.acquire_min > 100 ? sensor->info.acquire_min : 100;
  475. result = rt_device_open(dev, RT_DEVICE_FLAG_RDONLY);
  476. if (result != RT_EOK)
  477. {
  478. LOG_E("open device failed! error code : %d", result);
  479. return;
  480. }
  481. for (i = 0; i < num; i++)
  482. {
  483. res = rt_device_read(dev, 0, &data, 1);
  484. if (res != 1)
  485. {
  486. LOG_E("read data failed!size is %d", res);
  487. }
  488. else
  489. {
  490. sensor_show_data(i, sensor, &data);
  491. }
  492. rt_thread_mdelay(delay);
  493. }
  494. rt_device_close(dev);
  495. }
  496. #ifdef RT_USING_FINSH
  497. MSH_CMD_EXPORT(sensor_polling, Sensor polling mode test function);
  498. #endif
  499. static void sensor(int argc, char **argv)
  500. {
  501. static rt_device_t dev = RT_NULL;
  502. struct rt_sensor_data data;
  503. rt_sensor_t sensor;
  504. rt_size_t res, i;
  505. rt_int32_t delay;
  506. /* If the number of arguments less than 2 */
  507. if (argc < 2)
  508. {
  509. rt_kprintf("\n");
  510. rt_kprintf("sensor [OPTION] [PARAM]\n");
  511. rt_kprintf(" probe <dev_name> probe sensor by given name\n");
  512. rt_kprintf(" info get sensor information\n");
  513. rt_kprintf(" read [num] read [num] times sensor (default 5)\n");
  514. return ;
  515. }
  516. else if (!strcmp(argv[1], "info"))
  517. {
  518. if (dev == RT_NULL)
  519. {
  520. LOG_W("Please probe sensor device first!");
  521. return ;
  522. }
  523. sensor = (rt_sensor_t)dev;
  524. rt_kprintf("name :%s\n", sensor->info.name);
  525. rt_kprintf("type: :%s\n", sensor_get_type_name(&sensor->info));
  526. rt_kprintf("vendor :%s\n", sensor_get_vendor_name(&sensor->info));
  527. rt_kprintf("unit :%s\n", sensor_get_unit_name(&sensor->info));
  528. rt_kprintf("fetch data:%s\n", sensor_get_fetch_mode_name(&sensor->info));
  529. rt_kprintf("power :%s\n", sensor_get_power_mode_name(&sensor->info));
  530. rt_kprintf("accuracy :%s\n", sensor_get_accuracy_mode_name(&sensor->info));
  531. rt_kprintf("range max :%f\n", sensor->info.scale.range_max);
  532. rt_kprintf("range min :%f\n", sensor->info.scale.range_min);
  533. rt_kprintf("resolution:%f\n", sensor->info.accuracy.resolution);
  534. rt_kprintf("error :%f\n", sensor->info.accuracy.error);
  535. rt_kprintf("acquire min:%fms\n", sensor->info.acquire_min);
  536. rt_kprintf("fifo max :%d\n", sensor->info.fifo_max);
  537. rt_kprintf("interface type :%s\n", sensor_get_intf_name(sensor));
  538. rt_kprintf("interface device :%s\n", sensor->config.intf.dev_name);
  539. }
  540. else if (!strcmp(argv[1], "read"))
  541. {
  542. rt_uint16_t num = 5;
  543. if (dev == RT_NULL)
  544. {
  545. LOG_W("Please probe sensor device first!");
  546. return ;
  547. }
  548. if (argc == 3)
  549. {
  550. num = atoi(argv[2]);
  551. }
  552. sensor = (rt_sensor_t)dev;
  553. delay = sensor->info.acquire_min > 100 ? sensor->info.acquire_min : 100;
  554. for (i = 0; i < num; i++)
  555. {
  556. res = rt_device_read(dev, 0, &data, 1);
  557. if (res != 1)
  558. {
  559. LOG_E("read data failed!size is %d", res);
  560. }
  561. else
  562. {
  563. sensor_show_data(i, sensor, &data);
  564. }
  565. rt_thread_mdelay(delay);
  566. }
  567. }
  568. else if (argc == 3)
  569. {
  570. if (!strcmp(argv[1], "probe"))
  571. {
  572. rt_uint8_t reg = 0xFF;
  573. rt_device_t new_dev;
  574. new_dev = rt_device_find(argv[2]);
  575. if (new_dev == RT_NULL)
  576. {
  577. LOG_E("Can't find device:%s", argv[2]);
  578. return;
  579. }
  580. if (rt_device_open(new_dev, RT_DEVICE_FLAG_RDWR) != RT_EOK)
  581. {
  582. LOG_E("open device failed!");
  583. return;
  584. }
  585. if (rt_device_control(new_dev, RT_SENSOR_CTRL_GET_ID, &reg) == RT_EOK)
  586. {
  587. LOG_I("Sensor Chip ID: %#x", reg);
  588. }
  589. if (dev)
  590. {
  591. rt_device_close(dev);
  592. }
  593. dev = new_dev;
  594. }
  595. else if (dev == RT_NULL)
  596. {
  597. LOG_W("Please probe sensor first!");
  598. return ;
  599. }
  600. else
  601. {
  602. LOG_W("Unknown command, please enter 'sensor' get help information!");
  603. }
  604. }
  605. else
  606. {
  607. LOG_W("Unknown command, please enter 'sensor' get help information!");
  608. }
  609. }
  610. #ifdef RT_USING_FINSH
  611. MSH_CMD_EXPORT(sensor, sensor test function);
  612. #endif