fork download
copy 
  1.  
  2. #include "stm32f4xx_hal.h"
  3. #include "User_Header.h"
  4. #include "Package.h"
  5. #include "stm32f4xx_hal.h"
  6. #include "stm32f4xx_hal_conf.h"
  7. #include "stm32f4xx_hal_tim.h"
  8. #include "main.h"
  9. #include "Package.h"
  10. #include "Address.h"
  11.  
  12. //#define HAL_ERROR_ADDRESS    ((HAL_StatusTypeDef)4);
  13. //#define HAL_ERROR_DATAEXCESS ((HAL_StatusTypeDef)5);
  14. //#include "Address.h"
  15. /* USER CODE BEGIN Includes */
  16. //#define WATCHDOG_ENABLE // разрешение работы вачдога
  17.  
  18. // для проверки работы дебагового UART
  19. //#define TXBUFFERSIZE                      (COUNTOF(aTxBuffer) - 1)
  20. //uint8_t aTxBuffer[] = "Test UART \r\n";
  21. //#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
  22.  
  23.  
  24. /* USER CODE END Includes */
  25. PACKAGE_INFO infoPackage;
  26. PACKAGE_I2C_RX puRX = {0};
  27. PACKAGE_I2C_TX puTX = {0};
  28. BYTE empty[64] = {0};
  29. __IO int flagBlink = 0;
  30. /* Private variables ---------------------------------------------------------*/
  31. IWDG_HandleTypeDef hiwdg;
  32. TIM_HandleTypeDef       hTIMblink;
  33.  
  34. UART_HandleTypeDef hUartMain;
  35. UART_HandleTypeDef hUartDebug;
  36. TIM_HandleTypeDef  hTim3;
  37. TIM_HandleTypeDef  hTIMblink;
  38. TIM_HandleTypeDef  hTimFlash;
  39. SLOT_TABLE slot = {0};
  40.  
  41. int addressGl;
  42.  
  43. int BUTTON_DELAY=200; // задержка импульса нажатия кнопки ВПУ в мс.
  44. int del[16]={0};      // вспомогательный массив для работы функции MAIN_PulseExtension
  45.  
  46. /* USER CODE BEGIN PV */
  47.  
  48. /* USER CODE END PV */
  49.  
  50. /* Private function prototypes -----------------------------------------------*/
  51. void SystemClock_Config(void);
  52. static void MX_GPIO_Init(void);
  53. #ifdef WATCHDOG_ENABLE 
  54. static void MX_IWDG_Init(void); 
  55. #endif
  56. static void MX_USART1_UART_Init(void);
  57. static void MX_USART6_UART_Init(void);
  58.  
  59. #ifdef __GNUC__ // для правильной работы printf
  60.   /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
  61.      set to 'Yes') calls __io_putchar() */
  62.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
  63. #else
  64.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
  65. #endif /* __GNUC__ */
  66. 	PUTCHAR_PROTOTYPE
  67. {
  68.   /* Place your implementation of fputc here */
  69.   /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
  70.   HAL_UART_Transmit(&hUartDebug, (uint8_t *)&ch, 1, 0xFFFF); 
  71. 	//HAL_UART_Transmit_IT(&hUartDebug, (uint8_t *)&ch, 1); 
  72.  
  73.   return ch;
  74. }
  75.  
  76. void TIMblink_IRQHandler(void)
  77. {
  78. 	MAIN_Routine_Blink();
  79.  
  80.   //HAL_TIM_IRQHandler(&hTIMblink);
  81. }
  82.  
  83. void MAIN_Routine_Blink(void)
  84. {
  85. #ifdef WATCHDOG_ENABLE
  86. 	HAL_IWDG_Refresh(&hiwdg);
  87. #endif
  88. 	flagBlink ^= 1;
  89. 	if (flagBlink == 0)
  90. 	{
  91. 		//LED_BOARD_ON;
  92. 	}
  93. 	else
  94. 	{
  95. 		//LED_BOARD_OFF;
  96. 	}	
  97. }
  98. void InitGPIO(GPIO_TypeDef *GPIOx,uint32_t pin,uint32_t mode)
  99. {
  100. 	GPIO_InitTypeDef GPIO_InitStructure;
  101. 	GPIO_InitStructure.Pin = pin;
  102. 	GPIO_InitStructure.Mode = mode;
  103. 	//GPIO_InitStructure.Pull = GPIO_NOPULL;
  104. 	GPIO_InitStructure.Pull = GPIO_PULLUP;
  105. 	GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
  106. 	HAL_GPIO_Init(GPIOx, &GPIO_InitStructure);
  107. }
  108.  
  109. void InitGPIO_Address(GPIO_TypeDef *GPIOx,uint32_t pin,uint32_t mode)
  110. {
  111. 	GPIO_InitTypeDef GPIO_InitStructure;
  112. 	GPIO_InitStructure.Pin = pin;
  113. 	GPIO_InitStructure.Mode = mode;
  114. 	//GPIO_InitStructure.Pull = GPIO_NOPULL;
  115. 	GPIO_InitStructure.Pull = GPIO_PULLDOWN;
  116. 	GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
  117. 	HAL_GPIO_Init(GPIOx, &GPIO_InitStructure);
  118. }
  119. //char stroka[]="ыекщсчечка ";
  120. /* USER CODE BEGIN PFP */
  121. HAL_StatusTypeDef HAL_Receive(uint8_t *pData, uint16_t size, uint32_t timeout)
  122. 	{
  123. 		PLATE_TYPES typePlate;
  124. 		uint8_t address = 0;
  125. 		HAL_StatusTypeDef statusTransmission;
  126. 		static SIZEBUF_RX_PLATE sizebufRX = {0};
  127.  
  128. 		sizebufRX.pu   = I2C_SIZEBUF_RX;  // 4
  129. 		sizebufRX.io   = 3;
  130. 		sizebufRX.vpu  = 4;
  131. 		sizebufRX.pb   = 36;
  132.  
  133. 		//printf("HAL_Recieve################\r\n");
  134.  
  135. 		statusTransmission = HAL_UART_Receive(&hUartMain, &address, 1,timeout/*MAX_TIMEOUT*/);//#################################
  136. 		//printf("address=%d\r\n",address);
  137. 		addressGl=address;
  138. 		if (statusTransmission == HAL_OK)
  139. 		{
  140. 			//printf("address = %d\r\n", address);
  141. 			typePlate = ADDR_GetPlateType(address);
  142. 			//printf("typePlate из траффика= %d adress= %d\r\n",typePlate, address);
  143. 			switch (typePlate)
  144. 			{
  145. 				case PLATE_TYPE_PU:  // Наша плата ПУ?
  146. 				{
  147. 					//if (address == (slot.address))         // Наш адрес
  148. 					//{
  149. 						statusTransmission = HAL_UART_Receive(&hUartMain, empty, size,1);
  150. 						statusTransmission = HAL_ERROR_ADDRESS;
  151. 						//printf("PU Present! \r\n");	
  152. 					//}
  153. 					//else
  154. 					//{
  155. 					//	HAL_UART_Receive(&hUartMain, empty, sizebufRX.pu,1);
  156. 					//	statusTransmission = HAL_ERROR_ADDRESS;
  157. 					//}
  158. 				} break;
  159.  
  160. 				case PLATE_TYPE_IO:
  161. 				{
  162. 					if (address == (slot.address))         // Наш адрес
  163. 						{
  164. 							statusTransmission = HAL_UART_Receive(&hUartMain, pData, sizebufRX.io,1);
  165. 						}	
  166. 					else 
  167. 						{
  168. 							HAL_UART_Receive(&hUartMain, empty, sizebufRX.io,1);
  169. 							statusTransmission = HAL_ERROR_ADDRESS;
  170. 						}
  171. 						//printf("IO Present! \r\n");					
  172. 				} break;
  173.  
  174. 				case PLATE_TYPE_VPU:
  175. 				{
  176. //					int i;
  177. 						statusTransmission = HAL_UART_Receive(&hUartMain, empty,4,1);
  178. 						statusTransmission = HAL_ERROR_ADDRESS;
  179. 						//printf("statusTransmission = %d\r\n", statusTransmission);
  180. 						//printf("VPU Present! adress= %d\r\n",address);
  181. 						//for (i=0;i<sizebufRX.vpu;i++)
  182. 						//for (i=0;i<4;i++)
  183. 						//{
  184. 						//	printf("buffer = %d    0x%02X\r\n",i,empty[i]);
  185. 						//}
  186. 				} break;
  187.  
  188. 				case PLATE_TYPE_PB:
  189. 				{
  190. 						HAL_UART_Receive(&hUartMain, empty, sizebufRX.pb,1);
  191. 						statusTransmission = HAL_ERROR_ADDRESS;	
  192. 						//printf("PB Present! \r\n");	
  193. 						//for (i=0;i<sizebufRX.pb;i++)
  194. 						//{
  195. 						//	printf("bufferPB = %d    0x%02X\r\n",i,empty[i]);
  196. 						//}					
  197. 				} break;				
  198.  
  199. 				default:  // Адреса других плат
  200. 				{
  201. 					statusTransmission = HAL_ERROR_ADDRESS;		
  202. 				} break;
  203. 			}
  204. 		}
  205. 		//if (statusTransmission == HAL_OK) {printf("HALOK!");CONTROL_ON;}
  206. 		return statusTransmission;
  207. 	}
  208.  
  209. 	HAL_StatusTypeDef HAL_Transmit(uint8_t *pData, uint16_t size, uint32_t timeout)
  210. 	{
  211. 		HAL_StatusTypeDef statusTransmission;
  212. 		//__IO int ii = 0;
  213. 		CONTROL_ON;      // Передача
  214. 		//for (ii=0;ii<100;ii++)
  215. 		{
  216. 		}
  217. 		statusTransmission = HAL_UART_Transmit(&hUartMain, pData, size, 1);
  218. 		//for (ii=0;ii<100;ii++)
  219. 		{
  220. 		}
  221. 		CONTROL_OFF;      // Приём
  222. 		return statusTransmission;
  223. 	}
  224.  
  225.  
  226. /* USER CODE END PFP */
  227.  
  228. /* USER CODE BEGIN 0 */
  229. ///*
  230. int MAIN_PulseExtension(int in, int in_ext, int *del)
  231. {
  232. 	// вход in инверсный (см принципиальную схему ВПУ)
  233. 		if(!in){in_ext=1;*del=HAL_GetTick();} // если сигнал входа сработал, взвести флаг запустить таймер его расширения длительности срабатывания
  234. 		if(in_ext&((HAL_GetTick()-*del)>BUTTON_DELAY))in_ext=0; // если есть флаг и вышло время, флаг снять
  235. 		return in_ext;
  236. }
  237. //*/
  238. /* USER CODE END 0 */
  239.  
  240. int main(void)
  241. {
  242. 	int i;
  243. 	int reset = 0;
  244. //	uint32_t tickLight = 0;
  245. //	uint32_t tickTest = 0;
  246. //	uint32_t timeElapsed = 0;
  247. //	int32_t timeDelta = 0;
  248. //	uint32_t tickCurrent = 0;
  249.  
  250. 	STEP_ROUTINE step = STEP_INIT;
  251. //	uint32_t tickCur = 0;
  252. 	//uint32_t timeout = MAX_TIMEOUT;//TRANSFER_TIMEOUT;
  253. 	uint32_t timeout = TRANSFER_TIMEOUT;
  254. //	int reset = 0;
  255.  
  256. 	FUNCTION_RETURN Result;	
  257. 	HAL_StatusTypeDef    statusTransmission;
  258.  
  259. 	infoPackage.sizeRX = 3;//I2C_SIZEBUF_RX;
  260. 	infoPackage.sizeTX = 6;
  261. 	infoPackage.controlChange = CHANGECONTROL_NONE;
  262.  
  263.   /* MCU Configuration----------------------------------------------------------*/
  264.  
  265.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  266.   HAL_Init();
  267.  
  268.   /* Configure the system clock */
  269.   SystemClock_Config();
  270.  
  271.   /* Initialize all configured peripherals */
  272.   MX_GPIO_Init();
  273. 	//slot.address = 0x0E; // адрес платы для проверки кому предназначается пакет
  274. 	slot = ADDR_GetAddress();//################################################################
  275. #ifdef WATCHDOG_ENABLE
  276.   /* Initialize all configured peripherals */
  277. 	MX_IWDG_Init();
  278.   if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET)
  279.   { 
  280.     /* IWDGRST flag set: Turn LED1 on */
  281. 		__HAL_RCC_CLEAR_RESET_FLAGS();          // Clear reset flags
  282.   }
  283. 	HAL_IWDG_Start(&hiwdg);
  284. #endif
  285.   MX_USART1_UART_Init();
  286. 	MX_USART6_UART_Init();
  287. 	step = STEP_RX;
  288.  
  289.   /* USER CODE BEGIN 2 */
  290. 	//MX_TIM_Init(&hTim3,TIMx,5000);
  291. 	//MX_TIM_Init(&hTimFlash,TIMflash,500);
  292.   //tickLight = HAL_GetTick();
  293.   //tickTest = HAL_GetTick();
  294.  
  295. 	__enable_irq();
  296.   /* USER CODE END 2 */
  297.  
  298.   /* USER CODE BEGIN 3 */
  299.   /* Infinite loop */
  300. 	printf("StartIO : Slot = 0x%02X\r\n",slot.address);
  301.   while (1)
  302.   {
  303. 		//printf("while_start\r\n");
  304. 		#ifdef WATCHDOG_ENABLE 
  305. 		HAL_IWDG_Refresh(&hiwdg);
  306. 		#endif
  307.  
  308. 		switch (step)
  309. 		{
  310. 			case STEP_INIT:
  311. 			{
  312.  
  313. 			} break;
  314.  
  315. 			case STEP_RX:
  316. 			{
  317. 				//printf("infoPackage.sizeRX=  %d\r\n",infoPackage.sizeRX);
  318. 				statusTransmission = HAL_Receive((BYTE *)&puRX, infoPackage.sizeRX, timeout);
  319. 				//printf("статус трансмишн после HAL Recieve %d\r\n",statusTransmission);
  320. 				if (statusTransmission == HAL_OK)
  321. 				{
  322. 					//printf("RX\r\n");
  323. 					//for (i=0;i<infoPackage.sizeRX;i++)
  324. 					//if (puRX.bytes[0]==0)LED_MAN_MODE_ON;
  325. 					for (i=0;i<4;i++)
  326. 					{
  327. 						//printf("%d 0x%02X\r\n",i,puRX.bytes[i]);
  328. 						//printf("%d \r\n",addressGl);
  329. 					}
  330. 					//printf (typePlate);
  331. 					Result = PCKG_Check(puRX,&puTX,slot.address);
  332. 					//printf("puTX.bytes[2] = %d\r\n",puTX.bytes[2]);
  333. 				  //printf("puTX.bytes[2] = %d\r\n",puTX.bytes[2]);
  334. 					//if (1)   // Если нет ошибки
  335. 					if (!IsFunctionError(Result))  
  336. 					{
  337. 						puTX.bytes[4]=1; // статус ок приема.
  338. 						switch (Result)
  339. 						{
  340. 							case FUNCTION_SUCCESS:
  341. 							{
  342. 								// зажигаем огоньки, веселимся!
  343. 								//LED_MAN_MODE_ON;
  344. 							}break;
  345. 							case FUNCTION_ERROR:
  346. 							{
  347. 							}break;	
  348. 							case FUNCTION_NONE:
  349. 							{		
  350. 							}	break;
  351.  
  352. 								//PCKG_LightLamp(&puRX,&infoPackage);    // Управление лампами
  353. 						} 
  354.           //reset = 0;
  355. 					timeout = TRANSFER_TIMEOUT;
  356. 					//printf("timeout = %d\r\n",timeout);	
  357. 					//step = STEP_TX;
  358. 					}
  359. 					else 
  360. 					{
  361. 						puTX.bytes[4]=0; // статус приема Bad 
  362. 						//PCKG_SwitchOffAllLeds(); // выключить все лампы
  363. 						//printf("Плохой прием Result= %d\r\n",Result);
  364. 						//step = STEP_TX;
  365. 					}
  366. 					//printf("timeout = %d\r\n",timeout);	
  367. 					reset = 0;
  368. 					timeout = TRANSFER_TIMEOUT;
  369. 					step = STEP_TX;
  370. 				} 	
  371. 				else
  372. 				{
  373. 					step = STEP_RESET;
  374. 					//printf("adressGl = %d\r\n",addressGl);	
  375. 				}
  376. 			}break;
  377. 			case STEP_TX:
  378. 			{
  379. 				//printf("StepTX On\r\n");
  380. 					puTX.bytes[0]=(!IN_1<<0)+
  381. 												(!IN_2<<1)+
  382. 												(!IN_3<<2)+
  383. 												(!IN_4<<3)+
  384. 												(!IN_5<<4)+
  385. 												(!IN_6<<5)+
  386. 												(!IN_7<<6)+
  387. 												(!IN_8<<7);
  388. 					puTX.bytes[1]=(!IN_9<<0)+
  389. 												(!IN_10<<1)+
  390. 												(!IN_11<<2)+
  391. 												(!IN_12<<3)+
  392. 												(!IN_13<<4)+
  393. 												(!IN_14<<5)+
  394. 												(!IN_15<<6)+
  395. 												(!IN_16<<7);
  396. 					puTX.bytes[2]=(!IN_17<<0)+
  397. 												(!IN_18<<1)+
  398. 												(!IN_19<<2)+
  399. 												(!IN_20<<3)+
  400. 												(!IN_21<<4)+
  401. 												(!IN_22<<5)+
  402. 												(!IN_23<<6)+
  403. 												(!IN_24<<7);
  404. 					puTX.bytes[3]=(!IN_25<<0)+
  405. 												(!IN_26<<1)+
  406. 												(!IN_27<<2)+
  407. 												(!IN_28<<3)+
  408. 												(!IN_29<<4)+
  409. 												(!IN_30<<5)+
  410. 												(!IN_31<<6)+
  411. 												(!IN_32<<7);		
  412. 				//puTX.bytes[2]=1;
  413. 				//puTX.bytes[4] = 1; // статус ок приема.//#####################################################################
  414. 				puTX.bytes[5] = PCKG_CheckSum(puTX.bytes,infoPackage.sizeTX);
  415. 				//puTX.bytes[5] = 1;//#############################################################################################
  416. 				//printf("infoPackage.sizeTX = %d\r\n",infoPackage.sizeTX);
  417. 				//printf("puTX.bytes[puTX.data.checkSum] = %d\r\n",puTX.data.checkSum);
  418. 				//printf("puTX.bytes[2] = %d\r\n",puTX.bytes[2]);
  419.  
  420. 				//printf("infoPackage.sizeTX= %d\r\n",infoPackage.sizeTX);
  421. 				statusTransmission = HAL_Transmit((BYTE *)&puTX, infoPackage.sizeTX, TRANSFER_TIMEOUT);
  422. 				//printf("puTX.bytes[3] = %d\r\n",puTX.bytes[3]);
  423. 				if (statusTransmission == HAL_OK)
  424. 				{
  425. 					reset = 0;
  426. 					step = STEP_IDLE;
  427. 				}
  428. 				else
  429. 				{
  430. 					step = STEP_RESET;
  431. 				}
  432.  
  433. 			} break;
  434.  
  435. 			case STEP_RESET:
  436. 			{
  437. 				if (statusTransmission!=HAL_ERROR_ADDRESS && statusTransmission!=HAL_ERROR_DATAEXCESS)
  438. 				{
  439.  
  440. 					if (reset >= 2)
  441. 					{
  442. 						reset = 0;
  443. 						timeout = MAX_TIMEOUT;
  444. 						//PCKG_SwitchOffAllLeds(); // выключить все лампы
  445. 					}
  446. 					else
  447. 					{
  448. 						reset++;
  449. 					}
  450. 				}
  451. 				step = STEP_IDLE;
  452. 			} break;
  453.  
  454. 			case STEP_IDLE:
  455. 			{
  456. 				//printf("%d %d %d %d\r\n",puTX.data.volt.green1,puTX.data.volt.output1,puTX.data.volt.green2,puTX.data.volt.output2);
  457. 				//printf("IDLE!!!!!!!!!!!!!!!\r\n");
  458. 				memset(&puRX,0,infoPackage.sizeRX);
  459. 				memset(&puTX,0,infoPackage.sizeTX);
  460. 				step = STEP_RX;
  461. 			} break;
  462.  
  463. 			default:
  464. 			{
  465. 			} break;
  466. 		}
  467. 		//LED_PH3_ON;
  468. 		//LED_PH4_ON;
  469. 	}
  470.   /* USER CODE END 3 */
  471. }
  472.  
  473.  
  474. /** System Clock Configuration
  475. */
  476. //моя функция 
  477.  
  478.  
  479. void SystemClock_Config(void)
  480. {
  481.   RCC_OscInitTypeDef RCC_OscInitStruct;
  482.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
  483.   __PWR_CLK_ENABLE();
  484.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
  485.  
  486.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE;
  487.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  488.   //RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  489.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  490.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  491.   RCC_OscInitStruct.PLL.PLLM = 8;
  492.   RCC_OscInitStruct.PLL.PLLN = 336;
  493.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  494.   RCC_OscInitStruct.PLL.PLLQ = 7;
  495.   HAL_RCC_OscConfig(&RCC_OscInitStruct);
  496.  
  497.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1;
  498.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  499.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  500.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  501.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  502.   HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);
  503.  
  504. }
  505. //*/
  506. /* IWDG init function */
  507. #ifdef WATCHDOG_ENABLE
  508. void MX_IWDG_Init(void)
  509. {
  510.  
  511.   hiwdg.Instance = IWDG;
  512.   hiwdg.Init.Prescaler = IWDG_PRESCALER_4;
  513.   hiwdg.Init.Reload = 4095;
  514.   HAL_IWDG_Init(&hiwdg);
  515.  
  516. }
  517. #endif
  518. /* USART1 init function */
  519. void MX_USART1_UART_Init(void)
  520. {
  521.  
  522.   hUartMain.Instance = USART1;
  523.   hUartMain.Init.BaudRate = 115200;
  524.   hUartMain.Init.WordLength = UART_WORDLENGTH_8B;
  525.   hUartMain.Init.StopBits = UART_STOPBITS_1;
  526.   hUartMain.Init.Parity = UART_PARITY_NONE;
  527.   hUartMain.Init.Mode = UART_MODE_TX_RX;
  528.   hUartMain.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  529.   hUartMain.Init.OverSampling = UART_OVERSAMPLING_16;
  530.   HAL_UART_Init(&hUartMain);
  531.  
  532. }
  533. void MX_USART6_UART_Init(void)
  534. {
  535.  
  536.   hUartDebug.Instance = USART6;
  537.   hUartDebug.Init.BaudRate = 115200;
  538.   hUartDebug.Init.WordLength = UART_WORDLENGTH_8B;
  539.   hUartDebug.Init.StopBits = UART_STOPBITS_1;
  540.   hUartDebug.Init.Parity = UART_PARITY_NONE;
  541.   hUartDebug.Init.Mode = UART_MODE_TX_RX;
  542.   hUartDebug.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  543.   hUartDebug.Init.OverSampling = UART_OVERSAMPLING_16;
  544.   HAL_UART_Init(&hUartDebug);
  545.  
  546. }
  547. /** Configure pins as 
  548.         * Analog 
  549.         * Input 
  550.         * Output
  551.         * EVENT_OUT
  552.         * EXTI
  553. */
  554. void MX_GPIO_Init(void)
  555. {
  556.  
  557. //  GPIO_InitTypeDef GPIO_InitStruct;
  558.  
  559.   /* GPIO Ports Clock Enable */
  560.   __GPIOH_CLK_ENABLE();	
  561.   __GPIOB_CLK_ENABLE();
  562. 	__GPIOA_CLK_ENABLE();
  563. 	__GPIOC_CLK_ENABLE();
  564.  
  565.   /*Configure GPIO pin : PA5 */
  566.   /*
  567. 	GPIO_InitStruct.Pin = GPIO_PIN_5;
  568.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  569.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  570.   GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
  571.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  572. 	*/
  573.  
  574. 	// Индикаторный диод на плате
  575. 	InitGPIO(LED_BOARD_PORT,LED_BOARD_PIN,GPIO_MODE_OUTPUT_PP);
  576.  
  577. 	// Управляющий выход
  578. 	InitGPIO(GPIOC,CONTROL_PIN,GPIO_MODE_OUTPUT_PP);
  579.  
  580. 	// Светодиоды
  581. 	InitGPIO(GPIOA,LED_1,GPIO_MODE_OUTPUT_PP);
  582. 	InitGPIO(GPIOA,LED_2,GPIO_MODE_OUTPUT_PP);
  583.  
  584. 	// Адресные входы
  585. 	InitGPIO_Address(GPIOA,GPIO_PIN_0,GPIO_MODE_INPUT);  // плата 1 на rack 0 если вход ==1, плата 0 если ==0
  586. 	InitGPIO_Address(GPIOC,GPIO_PIN_15,GPIO_MODE_INPUT); // плата 2 на rack 1
  587. 	InitGPIO_Address(GPIOC,GPIO_PIN_0,GPIO_MODE_INPUT);  // плата 3 на rack 2
  588. 	InitGPIO_Address(GPIOC,GPIO_PIN_13,GPIO_MODE_INPUT); // плата 4 на rack 3
  589.  
  590. 	// Дискретные входы
  591. 	InitGPIO(GPIOB,GPIO_PIN_7,GPIO_MODE_INPUT); //1
  592. 	InitGPIO(GPIOB,GPIO_PIN_6,GPIO_MODE_INPUT);
  593. 	InitGPIO(GPIOB,GPIO_PIN_5,GPIO_MODE_INPUT);
  594. 	InitGPIO(GPIOB,GPIO_PIN_4,GPIO_MODE_INPUT);
  595.  
  596. 	InitGPIO(GPIOC,GPIO_PIN_12,GPIO_MODE_INPUT); //2
  597. 	InitGPIO(GPIOC,GPIO_PIN_11,GPIO_MODE_INPUT);
  598. 	InitGPIO(GPIOC,GPIO_PIN_10,GPIO_MODE_INPUT);
  599. 	InitGPIO(GPIOA,GPIO_PIN_15,GPIO_MODE_INPUT);
  600.  
  601. 	InitGPIO(GPIOA,GPIO_PIN_12,GPIO_MODE_INPUT); //3
  602. 	InitGPIO(GPIOA,GPIO_PIN_11,GPIO_MODE_INPUT);
  603. 	InitGPIO(GPIOA,GPIO_PIN_10,GPIO_MODE_INPUT);
  604. 	InitGPIO(GPIOA,GPIO_PIN_9,GPIO_MODE_INPUT);
  605.  
  606. 	InitGPIO(GPIOA,GPIO_PIN_8,GPIO_MODE_INPUT); //4
  607. 	InitGPIO(GPIOC,GPIO_PIN_9,GPIO_MODE_INPUT);
  608. 	InitGPIO(GPIOC,GPIO_PIN_8,GPIO_MODE_INPUT);
  609. 	InitGPIO(GPIOC,GPIO_PIN_3,GPIO_MODE_INPUT);
  610.  
  611. 	InitGPIO(GPIOC,GPIO_PIN_2,GPIO_MODE_INPUT); //5
  612. 	InitGPIO(GPIOB,GPIO_PIN_15,GPIO_MODE_INPUT);
  613. 	InitGPIO(GPIOB,GPIO_PIN_14,GPIO_MODE_INPUT);
  614. 	InitGPIO(GPIOB,GPIO_PIN_13,GPIO_MODE_INPUT);
  615.  
  616. 	InitGPIO(GPIOB,GPIO_PIN_12,GPIO_MODE_INPUT); //6
  617. 	InitGPIO(GPIOB,GPIO_PIN_10,GPIO_MODE_INPUT);
  618. 	InitGPIO(GPIOB,GPIO_PIN_2,GPIO_MODE_INPUT);
  619. 	InitGPIO(GPIOB,GPIO_PIN_1,GPIO_MODE_INPUT);
  620.  
  621. 	InitGPIO(GPIOB,GPIO_PIN_0,GPIO_MODE_INPUT); //7
  622. 	InitGPIO(GPIOC,GPIO_PIN_5,GPIO_MODE_INPUT);
  623. 	InitGPIO(GPIOC,GPIO_PIN_4,GPIO_MODE_INPUT);
  624. 	InitGPIO(GPIOA,GPIO_PIN_7,GPIO_MODE_INPUT);
  625.  
  626. 	InitGPIO(GPIOA,GPIO_PIN_6,GPIO_MODE_INPUT); //8
  627. 	InitGPIO(GPIOA,GPIO_PIN_5,GPIO_MODE_INPUT);
  628. 	InitGPIO(GPIOA,GPIO_PIN_4,GPIO_MODE_INPUT);
  629. 	InitGPIO(GPIOA,GPIO_PIN_3,GPIO_MODE_INPUT);
  630.  
  631.  
  632.  
  633. }
  634.  
  635. /* USER CODE BEGIN 4 */
  636. /* USER CODE END 4 */
  637.  
  638. #ifdef USE_FULL_ASSERT
  639.  
  640. /**
  641.    * @brief Reports the name of the source file and the source line number
  642.    * where the assert_param error has occurred.
  643.    * @param file: pointer to the source file name
  644.    * @param line: assert_param error line source number
  645.    * @retval None
  646.    */
  647. void assert_failed(uint8_t* file, uint32_t line)
  648. {
  649.   /* USER CODE BEGIN 6 */
  650.   /* User can add his own implementation to report the file name and line number,
  651.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  652.   /* USER CODE END 6 */
  653.  
  654. }
  655.  
  656. #endif
  657.  
  658. /**
  659.   * @}
  660.   */ 
  661.  
  662. /**
  663.   * @}
  664. */ 
  665.  
  666. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  667.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.c:2:10: fatal error: 'stm32f4xx_hal.h' file not found
#include "stm32f4xx_hal.h"
         ^
1 error generated.
stdout
copy 
Standard output is empty
https://ideone.com/V7dhJy
language:
C (clang 8.0)
created:
8 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!