API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 22nd, 2019
148
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.60 KB | None | 0 0
raw download clone embed print report
  1. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  2.  
  3.  
  4. /*/* USER CODE BEGIN Header */
  5. /**
  6. ******************************************************************************
  7. * @file : main.c
  8. * @brief : Main program body
  9. ******************************************************************************
  10. ** This notice applies to any and all portions of this file
  11. * that are not between comment pairs USER CODE BEGIN and
  12. * USER CODE END. Other portions of this file, whether
  13. * inserted by the user or by software development tools
  14. * are owned by their respective copyright owners.
  15. *
  16. * COPYRIGHT(c) 2018 STMicroelectronics
  17. *
  18. * Redistribution and use in source and binary forms, with or without modification,
  19. * are permitted provided that the following conditions are met:
  20. * 1. Redistributions of source code must retain the above copyright notice,
  21. * this list of conditions and the following disclaimer.
  22. * 2. Redistributions in binary form must reproduce the above copyright notice,
  23. * this list of conditions and the following disclaimer in the documentation
  24. * and/or other materials provided with the distribution.
  25. * 3. Neither the name of STMicroelectronics nor the names of its contributors
  26. * may be used to endorse or promote products derived from this software
  27. * without specific prior written permission.
  28. *
  29. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  30. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  32. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  33. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  35. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  36. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  37. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  38. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39. *
  40. ******************************************************************************
  41. */
  42. /* USER CODE END Header */
  43.  
  44. /* Includes ------------------------------------------------------------------*/
  45. #include "main.h"
  46. #include "i2c.h"
  47. #include "usart.h"
  48. #include "gpio.h"
  49. #include "spi.h"
  50.  
  51. #define MCU_ADDRESS (0x30 << 1)
  52. #define I2C_DELAY 100
  53. #define I2C_TRA_REC_TIMEOUT 100
  54.  
  55. #define MAG_M_THRESHOLD_0 10
  56. #define MAG_M_THRESHOLD_1 10
  57. #define MAG_M_THRESHOLD_2 10
  58. #define NOT_USING_COUNT 1
  59. #define COUNT_THRESHOLD 2
  60.  
  61. #define CS_LORA_GPIO GPIOC
  62. #define CS_LORA_PIN_N GPIO_PIN_8
  63.  
  64. #define NUMBER_OF_INITIAL_RUNS_INIT_MAG 10
  65.  
  66. int8_t spi_status = 1;
  67.  
  68. void SystemClock_Config(void);
  69.  
  70. /**
  71. * @brief The application entry point.
  72. * @retval int
  73. */
  74. int main(void)
  75. {
  76.  
  77. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  78. HAL_Init();
  79.  
  80. SystemClock_Config();
  81.  
  82. MX_GPIO_Init();
  83. MX_USART2_UART_Init();
  84. MX_I2C1_Init();
  85. MX_SPI2_Init();
  86. MX_CRC_Init();
  87.  
  88. HAL_I2C_MspInit(&hi2c1);
  89. HAL_SPI_MspInit(&hspi2);
  90.  
  91. HAL_Delay(1000);
  92.  
  93. uint8_t msg_buf[1000];
  94.  
  95. uint8_t i2c_buff[8];
  96. uint8_t spi_buffer[64];
  97.  
  98. // LoRa
  99. // temperature
  100. uint8_t lora_temp;
  101.  
  102. // Magnetic sensor
  103. int16_t mag_setval[3];
  104. char mag_status[2];
  105. int16_t mag_setval_average[3];
  106.  
  107. // motion detected
  108. uint8_t motion_count = 0;
  109. char motion[2];
  110.  
  111. // temperature values
  112. uint8_t mag_raw_temperature;
  113.  
  114. // status values
  115. uint8_t mag_raw_status;
  116.  
  117. // Reset
  118. i2c_buff[0] = 0x08;
  119. i2c_buff[1] = 0x10; // 0b00010000
  120. HAL_I2C_Master_Transmit(&hi2c1, MCU_ADDRESS, i2c_buff, 2, I2C_TRA_REC_TIMEOUT);
  121. HAL_Delay(I2C_DELAY);
  122.  
  123. //init_magnetometer_average(mag_setval_average);
  124.  
  125. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_SET);
  126. HAL_Delay(100);
  127.  
  128. // Select LoRa mode
  129. init_lora_module();
  130. /*set_frequency(868.0);
  131.  
  132. sprintf(msg_buf, "SET LORA FREQ: ");
  133. HAL_UART_Transmit(&huart2, msg_buf, strlen(msg_buf), 1000);
  134. print_status(spi_status);*/
  135.  
  136. while(1) {
  137. // Start temperature, magnetic and motion detection
  138. /*i2c_buff[0] = 0x08;
  139. i2c_buff[1] = 0x07; // 0b00000111
  140. HAL_I2C_Master_Transmit(&hi2c1, MCU_ADDRESS, i2c_buff, 2, I2C_TRA_REC_TIMEOUT);
  141. HAL_Delay(I2C_DELAY);
  142.  
  143. // Read status
  144. i2c_buff[0] = 0x07;
  145. HAL_I2C_Master_Transmit(&hi2c1, MCU_ADDRESS, i2c_buff, 1, I2C_TRA_REC_TIMEOUT);
  146. HAL_I2C_Master_Receive(&hi2c1, MCU_ADDRESS, i2c_buff, 1, I2C_TRA_REC_TIMEOUT);
  147. raw_status = i2c_buff[0];
  148.  
  149. if (raw_status == 0x13) {
  150. snprintf(status, sizeof(status), "OK");
  151. } else {
  152. snprintf(status, sizeof(status), "FL");
  153. }
  154.  
  155. // Read temperature and magnet
  156. i2c_buff[0] = 0x00;
  157. HAL_I2C_Master_Transmit(&hi2c1, MCU_ADDRESS, i2c_buff, 1, I2C_TRA_REC_TIMEOUT);
  158. HAL_I2C_Master_Receive(&hi2c1, MCU_ADDRESS, i2c_buff, 7, I2C_TRA_REC_TIMEOUT);
  159.  
  160. setval[0] = *((uint16_t *) &i2c_buff[0])-32768; // X
  161. setval[1] = *((uint16_t *) &i2c_buff[2])-32768; // Y
  162. setval[2] = *((uint16_t *) &i2c_buff[4])-32768; // Z
  163. raw_temperature = i2c_buff[6]; // Temp
  164.  
  165. // Calculate compass average
  166. setval_average[0] = (setval_average[0] + setval[0]) / 2;
  167. setval_average[1] = (setval_average[1] + setval[1]) / 2;
  168. setval_average[2] = (setval_average[2] + setval[2]) / 2;
  169.  
  170. if ((abs(setval_average[0] - setval[0]) > MAG_M_THRESHOLD_0) ||
  171. (abs(setval_average[1] - setval[1]) > MAG_M_THRESHOLD_1) ||
  172. (abs(setval_average[2] - setval[2]) > MAG_M_THRESHOLD_2)) {
  173.  
  174. motion_count++;
  175. if (motion_count >= COUNT_THRESHOLD || NOT_USING_COUNT) {
  176. snprintf(motion, sizeof(status), "DE");
  177. }
  178. } else {
  179. snprintf(motion, sizeof(status), "ND");
  180. motion_count = 0;
  181. }
  182.  
  183. sprintf(msg_buf, "Set DATA: %6d %6d %6d \r\n AVG VALUES %6d %6d %6d\r\nTemperature %d \r\nStatus %02x/%s \r\nDetected motion %s\r\n",
  184. setval[0], setval[1], setval[2],
  185. setval_average[0], setval_average[1], setval_average[2],
  186. i2ctemp_to_degc(raw_temperature),
  187. raw_status, status, motion);
  188. HAL_UART_Transmit(&huart2, msg_buf, strlen(msg_buf), 1000);*/
  189.  
  190. HAL_Delay(1000);
  191.  
  192. /*sprintf(msg_buf, "FREQ: %d \n\r", get_frequency());
  193. HAL_UART_Transmit(&huart2, msg_buf, strlen(msg_buf), 1000);*/
  194. }
  195. }
  196.  
  197. uint8_t i2ctemp_to_degc(uint8_t i2c_temp)
  198. {
  199. return ((uint8_t)(i2c_temp*0.7)-75);
  200. }
  201.  
  202. void init_lora_module()
  203. {
  204. uint8_t _spi_buffer[8];
  205. uint8_t msg_buf[64];
  206.  
  207. _spi_buffer[0] = RH_RF95_REG_01_OP_MODE | RH_SPI_WRITE_MASK;
  208. _spi_buffer[1] = RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE;
  209. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_RESET);
  210. spi_status = HAL_SPI_Transmit(&hspi2, _spi_buffer, 2, 1);
  211. print_status(spi_status);
  212. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_SET);
  213.  
  214. HAL_Delay(100);
  215.  
  216. _spi_buffer[0] = RH_RF95_REG_01_OP_MODE & ~RH_SPI_WRITE_MASK;
  217. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_RESET);
  218. spi_status = HAL_SPI_Transmit(&hspi2, _spi_buffer, 1, 1);
  219. print_status(spi_status);
  220. spi_status = HAL_SPI_Receive(&hspi2, _spi_buffer, 1, 1);
  221. print_status(spi_status);
  222. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_SET);
  223.  
  224. if (_spi_buffer[0] != (RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE))
  225. {
  226. sprintf(msg_buf, "DATA: %d\n\r", _spi_buffer[0]);
  227. HAL_UART_Transmit(&huart2, msg_buf, strlen(msg_buf), 1000);
  228. }
  229. }
  230.  
  231. // in Mhz
  232. uint32_t get_frequency()
  233. {
  234. uint8_t _spi_buffer[8];
  235. uint32_t _lora_module_frequency = 0;
  236.  
  237. for (uint8_t i = 0; i < 3; i++)
  238. {
  239. _spi_buffer[0] = 0x06 + i;
  240. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_RESET);
  241. spi_status = HAL_SPI_Transmit(&hspi2, _spi_buffer, 1, 100);
  242. spi_status = HAL_SPI_Transmit(&hspi2, _spi_buffer, 1, 100);
  243. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_SET);
  244. _lora_module_frequency |= _spi_buffer[0];
  245. /*
  246. uint8_t msg[10];
  247. sprintf(msg, "%d ", _spi_buffer[0]);
  248. HAL_UART_Transmit(&huart2, msg, strlen(msg), 100);*/
  249. _lora_module_frequency = _lora_module_frequency << 8;
  250. }
  251.  
  252. _lora_module_frequency = _lora_module_frequency >> 8;
  253.  
  254. return ((_lora_module_frequency) * RH_RF96_FSTEP) / 1000000;
  255. }
  256.  
  257. // in Mhz
  258. void set_frequency(float center)
  259. {
  260. uint8_t _spi_buffer[8];
  261. uint32_t frf = (center * 1000000.0) / RH_RF96_FSTEP;
  262.  
  263. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_RESET);
  264. _spi_buffer[0] = (0x06 << 1) | 1;
  265. _spi_buffer[1] = (frf >> 16) & 0xff;
  266. _spi_buffer[2] = (frf >> 8) & 0xff;
  267. _spi_buffer[3] = frf & 0xff;
  268. spi_status = HAL_SPI_Transmit(&hspi2, _spi_buffer, 4, 1000);
  269. HAL_GPIO_WritePin(CS_LORA_GPIO, CS_LORA_PIN_N, GPIO_PIN_SET);
  270. }
  271.  
  272. void print_status(int8_t status)
  273. {
  274. uint8_t _msg_buf[10];
  275. switch (status)
  276. {
  277. case HAL_OK:
  278. sprintf(_msg_buf, "HAL_OK \n\r");
  279. break;
  280. case HAL_ERROR:
  281. sprintf(_msg_buf, "HAL_ERROR \n\r");
  282. break;
  283. case HAL_BUSY:
  284. sprintf(_msg_buf, "HAL_BUSE \n\r");
  285. break;
  286. case HAL_TIMEOUT:
  287. sprintf(_msg_buf, "HAL_TIMEOUT \n\r");
  288. break;
  289. default:
  290. sprintf(_msg_buf, "HAL_? \n\r");
  291. break;
  292. }
  293. HAL_UART_Transmit(&huart2, _msg_buf, strlen(_msg_buf), 1000);
  294. }
  295.  
  296. void init_magnetometer_average(int16_t *setval_average) {
  297. uint8_t average_first_measurement_flag = 1;
  298. uint8_t i2c_buff[8];
  299. uint8_t msg_buffer[64];
  300. int16_t _setval_average[3];
  301.  
  302. for (uint8_t i = 0; i < NUMBER_OF_INITIAL_RUNS_INIT_MAG; i++) {
  303. // Start temperature, magnetic and motion detection
  304. i2c_buff[0] = 0x08;
  305. i2c_buff[1] = 0x07; // 0b00000111
  306. HAL_I2C_Master_Transmit(&hi2c1, MCU_ADDRESS, i2c_buff, 2, I2C_TRA_REC_TIMEOUT);
  307. HAL_Delay(I2C_DELAY);
  308.  
  309. // Read temperature and magnet
  310. i2c_buff[0] = 0x00;
  311. HAL_I2C_Master_Transmit(&hi2c1, MCU_ADDRESS, i2c_buff, 1, I2C_TRA_REC_TIMEOUT);
  312. HAL_I2C_Master_Receive(&hi2c1, MCU_ADDRESS, i2c_buff, 7, I2C_TRA_REC_TIMEOUT);
  313. _setval_average[0] = *((uint16_t *)&i2c_buff[0])-32768;
  314. _setval_average[1] = *((uint16_t *)&i2c_buff[2])-32768;
  315. _setval_average[2] = *((uint16_t *)&i2c_buff[4])-32768;
  316.  
  317. if (average_first_measurement_flag) {
  318. setval_average[0] = _setval_average[0];
  319. setval_average[1] = _setval_average[1];
  320. setval_average[2] = _setval_average[2];
  321. average_first_measurement_flag = 0;
  322. } else {
  323. setval_average[0] = (setval_average[0] + _setval_average[0]) / 2;
  324. setval_average[1] = (setval_average[1] + _setval_average[1]) / 2;
  325. setval_average[2] = (setval_average[2] + _setval_average[2]) / 2;
  326. }
  327.  
  328. snprintf(msg_buffer, sizeof(msg_buffer),"%d AVG VALUES %6d %6d %6d\r\n\r\n", i,
  329. setval_average[0], setval_average[1], setval_average[2]);
  330. HAL_UART_Transmit(&huart2, msg_buffer, strlen(msg_buffer), 1000);
  331. }
  332. }
  333.  
  334. /**
  335. * @brief System Clock Configuration
  336. * @retval None
  337. */
  338. void SystemClock_Config(void)
  339. {
  340. RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  341. RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  342. RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  343.  
  344. /**Initializes the CPU, AHB and APB busses clocks
  345. */
  346. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  347. RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  348. RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  349. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  350. RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  351. RCC_OscInitStruct.PLL.PLLM = 1;
  352. RCC_OscInitStruct.PLL.PLLN = 10;
  353. RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  354. RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  355. RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  356. if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  357. {
  358. Error_Handler();
  359. }
  360. /**Initializes the CPU, AHB and APB busses clocks
  361. */
  362. RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  363. |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  364. RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  365. RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  366. RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  367. RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  368.  
  369. if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  370. {
  371. Error_Handler();
  372. }
  373. PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2|RCC_PERIPHCLK_I2C1;
  374. PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
  375. PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_PCLK1;
  376. if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  377. {
  378. Error_Handler();
  379. }
  380. /**Configure the main internal regulator output voltage
  381. */
  382. if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
  383. {
  384. Error_Handler();
  385. }
  386. }
  387.  
  388. /* USER CODE BEGIN 4 */
  389.  
  390. /* USER CODE END 4 */
  391.  
  392. /**
  393. * @brief This function is executed in case of error occurrence.
  394. * @retval None
  395. */
  396. void Error_Handler(void)
  397. {
  398. /* USER CODE BEGIN Error_Handler_Debug */
  399. /* User can add his own implementation to report the HAL error return state */
  400.  
  401. /* USER CODE END Error_Handler_Debug */
  402. }
  403.  
  404. #ifdef USE_FULL_ASSERT
  405. /**
  406. * @brief Reports the name of the source file and the source line number
  407. * where the assert_param error has occurred.
  408. * @param file: pointer to the source file name
  409. * @param line: assert_param error line source number
  410. * @retval None
  411. */
  412. void assert_failed(char *file, uint32_t line)
  413. {
  414. /* USER CODE BEGIN 6 */
  415. /* User can add his own implementation to report the file name and line number,
  416. tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  417. /* USER CODE END 6 */
  418. }
  419. #endif /* USE_FULL_ASSERT */
  420.  
  421. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  422.  
  423. */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!