#include "stm32f4xx_hal.h"
#include "User_Header.h"
#include "Package.h"
#include "stm32f4xx_hal.h"
#include "stm32f4xx_hal_conf.h"
#include "stm32f4xx_hal_tim.h"
#include "main.h"
#include "Package.h"
#include "Address.h"

//#define HAL_ERROR_ADDRESS    ((HAL_StatusTypeDef)4);
//#define HAL_ERROR_DATAEXCESS ((HAL_StatusTypeDef)5);
//#include "Address.h"
/* USER CODE BEGIN Includes */
//#define WATCHDOG_ENABLE // разрешение работы вачдога

// для проверки работы дебагового UART
//#define TXBUFFERSIZE                      (COUNTOF(aTxBuffer) - 1)
//uint8_t aTxBuffer[] = "Test UART \r\n";
//#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))


/* USER CODE END Includes */
PACKAGE_INFO infoPackage;
PACKAGE_I2C_RX puRX = {0};
PACKAGE_I2C_TX puTX = {0};
BYTE empty[64] = {0};
__IO int flagBlink = 0;
/* Private variables ---------------------------------------------------------*/
IWDG_HandleTypeDef hiwdg;
TIM_HandleTypeDef       hTIMblink;

UART_HandleTypeDef hUartMain;
UART_HandleTypeDef hUartDebug;
TIM_HandleTypeDef  hTim3;
TIM_HandleTypeDef  hTIMblink;
TIM_HandleTypeDef  hTimFlash;
SLOT_TABLE slot = {0};

int addressGl;

int BUTTON_DELAY=200; // задержка импульса нажатия кнопки ВПУ в мс.
int del[16]={0};      // вспомогательный массив для работы функции MAIN_PulseExtension

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
#ifdef WATCHDOG_ENABLE 
static void MX_IWDG_Init(void); 
#endif
static void MX_USART1_UART_Init(void);
static void MX_USART6_UART_Init(void);

#ifdef __GNUC__ // для правильной работы printf
  /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
     set to 'Yes') calls __io_putchar() */
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
	PUTCHAR_PROTOTYPE
{
  /* Place your implementation of fputc here */
  /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
  HAL_UART_Transmit(&hUartDebug, (uint8_t *)&ch, 1, 0xFFFF); 
	//HAL_UART_Transmit_IT(&hUartDebug, (uint8_t *)&ch, 1); 

  return ch;
}

void TIMblink_IRQHandler(void)
{
	MAIN_Routine_Blink();
	
  //HAL_TIM_IRQHandler(&hTIMblink);
}

void MAIN_Routine_Blink(void)
{
#ifdef WATCHDOG_ENABLE
	HAL_IWDG_Refresh(&hiwdg);
#endif
	flagBlink ^= 1;
	if (flagBlink == 0)
	{
		//LED_BOARD_ON;
	}
	else
	{
		//LED_BOARD_OFF;
	}	
}
void InitGPIO(GPIO_TypeDef *GPIOx,uint32_t pin,uint32_t mode)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.Pin = pin;
	GPIO_InitStructure.Mode = mode;
	//GPIO_InitStructure.Pull = GPIO_NOPULL;
	GPIO_InitStructure.Pull = GPIO_PULLUP;
	GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
	HAL_GPIO_Init(GPIOx, &GPIO_InitStructure);
}

void InitGPIO_Address(GPIO_TypeDef *GPIOx,uint32_t pin,uint32_t mode)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.Pin = pin;
	GPIO_InitStructure.Mode = mode;
	//GPIO_InitStructure.Pull = GPIO_NOPULL;
	GPIO_InitStructure.Pull = GPIO_PULLDOWN;
	GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
	HAL_GPIO_Init(GPIOx, &GPIO_InitStructure);
}
//char stroka[]="ыекщсчечка ";
/* USER CODE BEGIN PFP */
HAL_StatusTypeDef HAL_Receive(uint8_t *pData, uint16_t size, uint32_t timeout)
	{
		PLATE_TYPES typePlate;
		uint8_t address = 0;
		HAL_StatusTypeDef statusTransmission;
		static SIZEBUF_RX_PLATE sizebufRX = {0};
		
		sizebufRX.pu   = I2C_SIZEBUF_RX;  // 4
		sizebufRX.io   = 3;
		sizebufRX.vpu  = 4;
		sizebufRX.pb   = 36;
		
		//printf("HAL_Recieve################\r\n");
		
		statusTransmission = HAL_UART_Receive(&hUartMain, &address, 1,timeout/*MAX_TIMEOUT*/);//#################################
		//printf("address=%d\r\n",address);
		addressGl=address;
		if (statusTransmission == HAL_OK)
		{
			//printf("address = %d\r\n", address);
			typePlate = ADDR_GetPlateType(address);
			//printf("typePlate из траффика= %d adress= %d\r\n",typePlate, address);
			switch (typePlate)
			{
				case PLATE_TYPE_PU:  // Наша плата ПУ?
				{
					//if (address == (slot.address))         // Наш адрес
					//{
						statusTransmission = HAL_UART_Receive(&hUartMain, empty, size,1);
						statusTransmission = HAL_ERROR_ADDRESS;
						//printf("PU Present! \r\n");	
					//}
					//else
					//{
					//	HAL_UART_Receive(&hUartMain, empty, sizebufRX.pu,1);
					//	statusTransmission = HAL_ERROR_ADDRESS;
					//}
				} break;
				
				case PLATE_TYPE_IO:
				{
					if (address == (slot.address))         // Наш адрес
						{
							statusTransmission = HAL_UART_Receive(&hUartMain, pData, sizebufRX.io,1);
						}	
					else 
						{
							HAL_UART_Receive(&hUartMain, empty, sizebufRX.io,1);
							statusTransmission = HAL_ERROR_ADDRESS;
						}
						//printf("IO Present! \r\n");					
				} break;

				case PLATE_TYPE_VPU:
				{
//					int i;
						statusTransmission = HAL_UART_Receive(&hUartMain, empty,4,1);
						statusTransmission = HAL_ERROR_ADDRESS;
						//printf("statusTransmission = %d\r\n", statusTransmission);
						//printf("VPU Present! adress= %d\r\n",address);
						//for (i=0;i<sizebufRX.vpu;i++)
						//for (i=0;i<4;i++)
						//{
						//	printf("buffer = %d    0x%02X\r\n",i,empty[i]);
						//}
				} break;

				case PLATE_TYPE_PB:
				{
						HAL_UART_Receive(&hUartMain, empty, sizebufRX.pb,1);
						statusTransmission = HAL_ERROR_ADDRESS;	
						//printf("PB Present! \r\n");	
						//for (i=0;i<sizebufRX.pb;i++)
						//{
						//	printf("bufferPB = %d    0x%02X\r\n",i,empty[i]);
						//}					
				} break;				
				
				default:  // Адреса других плат
				{
					statusTransmission = HAL_ERROR_ADDRESS;		
				} break;
			}
		}
		//if (statusTransmission == HAL_OK) {printf("HALOK!");CONTROL_ON;}
		return statusTransmission;
	}
	
	HAL_StatusTypeDef HAL_Transmit(uint8_t *pData, uint16_t size, uint32_t timeout)
	{
		HAL_StatusTypeDef statusTransmission;
		//__IO int ii = 0;
		CONTROL_ON;      // Передача
		//for (ii=0;ii<100;ii++)
		{
		}
		statusTransmission = HAL_UART_Transmit(&hUartMain, pData, size, 1);
		//for (ii=0;ii<100;ii++)
		{
		}
		CONTROL_OFF;      // Приём
		return statusTransmission;
	}
	
	
/* USER CODE END PFP */

/* USER CODE BEGIN 0 */
///*
int MAIN_PulseExtension(int in, int in_ext, int *del)
{
	// вход in инверсный (см принципиальную схему ВПУ)
		if(!in){in_ext=1;*del=HAL_GetTick();} // если сигнал входа сработал, взвести флаг запустить таймер его расширения длительности срабатывания
		if(in_ext&((HAL_GetTick()-*del)>BUTTON_DELAY))in_ext=0; // если есть флаг и вышло время, флаг снять
		return in_ext;
}
//*/
/* USER CODE END 0 */

int main(void)
{
	int i;
	int reset = 0;
//	uint32_t tickLight = 0;
//	uint32_t tickTest = 0;
//	uint32_t timeElapsed = 0;
//	int32_t timeDelta = 0;
//	uint32_t tickCurrent = 0;
	
	STEP_ROUTINE step = STEP_INIT;
//	uint32_t tickCur = 0;
	//uint32_t timeout = MAX_TIMEOUT;//TRANSFER_TIMEOUT;
	uint32_t timeout = TRANSFER_TIMEOUT;
//	int reset = 0;
	
	FUNCTION_RETURN Result;	
	HAL_StatusTypeDef    statusTransmission;
	
	infoPackage.sizeRX = 3;//I2C_SIZEBUF_RX;
	infoPackage.sizeTX = 6;
	infoPackage.controlChange = CHANGECONTROL_NONE;

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
	//slot.address = 0x0E; // адрес платы для проверки кому предназначается пакет
	slot = ADDR_GetAddress();//################################################################
#ifdef WATCHDOG_ENABLE
  /* Initialize all configured peripherals */
	MX_IWDG_Init();
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET)
  { 
    /* IWDGRST flag set: Turn LED1 on */
		__HAL_RCC_CLEAR_RESET_FLAGS();          // Clear reset flags
  }
	HAL_IWDG_Start(&hiwdg);
#endif
  MX_USART1_UART_Init();
	MX_USART6_UART_Init();
	step = STEP_RX;

  /* USER CODE BEGIN 2 */
	//MX_TIM_Init(&hTim3,TIMx,5000);
	//MX_TIM_Init(&hTimFlash,TIMflash,500);
  //tickLight = HAL_GetTick();
  //tickTest = HAL_GetTick();
	
	__enable_irq();
  /* USER CODE END 2 */

  /* USER CODE BEGIN 3 */
  /* Infinite loop */
	printf("StartIO : Slot = 0x%02X\r\n",slot.address);
  while (1)
  {
		//printf("while_start\r\n");
		#ifdef WATCHDOG_ENABLE 
		HAL_IWDG_Refresh(&hiwdg);
		#endif

		switch (step)
		{
			case STEP_INIT:
			{
        
			} break;
				
			case STEP_RX:
			{
				//printf("infoPackage.sizeRX=  %d\r\n",infoPackage.sizeRX);
				statusTransmission = HAL_Receive((BYTE *)&puRX, infoPackage.sizeRX, timeout);
				//printf("статус трансмишн после HAL Recieve %d\r\n",statusTransmission);
				if (statusTransmission == HAL_OK)
				{
					//printf("RX\r\n");
					//for (i=0;i<infoPackage.sizeRX;i++)
					//if (puRX.bytes[0]==0)LED_MAN_MODE_ON;
					for (i=0;i<4;i++)
					{
						//printf("%d 0x%02X\r\n",i,puRX.bytes[i]);
						//printf("%d \r\n",addressGl);
					}
					//printf (typePlate);
					Result = PCKG_Check(puRX,&puTX,slot.address);
					//printf("puTX.bytes[2] = %d\r\n",puTX.bytes[2]);
				  //printf("puTX.bytes[2] = %d\r\n",puTX.bytes[2]);
					//if (1)   // Если нет ошибки
					if (!IsFunctionError(Result))  
					{
						puTX.bytes[4]=1; // статус ок приема.
						switch (Result)
						{
							case FUNCTION_SUCCESS:
							{
								// зажигаем огоньки, веселимся!
								//LED_MAN_MODE_ON;
							}break;
							case FUNCTION_ERROR:
							{
							}break;	
							case FUNCTION_NONE:
							{		
							}	break;
								
								//PCKG_LightLamp(&puRX,&infoPackage);    // Управление лампами
						} 
          //reset = 0;
					timeout = TRANSFER_TIMEOUT;
					//printf("timeout = %d\r\n",timeout);	
					//step = STEP_TX;
					}
					else 
					{
						puTX.bytes[4]=0; // статус приема Bad 
						//PCKG_SwitchOffAllLeds(); // выключить все лампы
						//printf("Плохой прием Result= %d\r\n",Result);
						//step = STEP_TX;
					}
					//printf("timeout = %d\r\n",timeout);	
					reset = 0;
					timeout = TRANSFER_TIMEOUT;
					step = STEP_TX;
				} 	
				else
				{
					step = STEP_RESET;
					//printf("adressGl = %d\r\n",addressGl);	
				}
			}break;
			case STEP_TX:
			{
				//printf("StepTX On\r\n");
					puTX.bytes[0]=(!IN_1<<0)+
												(!IN_2<<1)+
												(!IN_3<<2)+
												(!IN_4<<3)+
												(!IN_5<<4)+
												(!IN_6<<5)+
												(!IN_7<<6)+
												(!IN_8<<7);
					puTX.bytes[1]=(!IN_9<<0)+
												(!IN_10<<1)+
												(!IN_11<<2)+
												(!IN_12<<3)+
												(!IN_13<<4)+
												(!IN_14<<5)+
												(!IN_15<<6)+
												(!IN_16<<7);
					puTX.bytes[2]=(!IN_17<<0)+
												(!IN_18<<1)+
												(!IN_19<<2)+
												(!IN_20<<3)+
												(!IN_21<<4)+
												(!IN_22<<5)+
												(!IN_23<<6)+
												(!IN_24<<7);
					puTX.bytes[3]=(!IN_25<<0)+
												(!IN_26<<1)+
												(!IN_27<<2)+
												(!IN_28<<3)+
												(!IN_29<<4)+
												(!IN_30<<5)+
												(!IN_31<<6)+
												(!IN_32<<7);		
				//puTX.bytes[2]=1;
				//puTX.bytes[4] = 1; // статус ок приема.//#####################################################################
				puTX.bytes[5] = PCKG_CheckSum(puTX.bytes,infoPackage.sizeTX);
				//puTX.bytes[5] = 1;//#############################################################################################
				//printf("infoPackage.sizeTX = %d\r\n",infoPackage.sizeTX);
				//printf("puTX.bytes[puTX.data.checkSum] = %d\r\n",puTX.data.checkSum);
				//printf("puTX.bytes[2] = %d\r\n",puTX.bytes[2]);
				
				//printf("infoPackage.sizeTX= %d\r\n",infoPackage.sizeTX);
				statusTransmission = HAL_Transmit((BYTE *)&puTX, infoPackage.sizeTX, TRANSFER_TIMEOUT);
				//printf("puTX.bytes[3] = %d\r\n",puTX.bytes[3]);
				if (statusTransmission == HAL_OK)
				{
					reset = 0;
					step = STEP_IDLE;
				}
				else
				{
					step = STEP_RESET;
				}
				
			} break;
			
			case STEP_RESET:
			{
				if (statusTransmission!=HAL_ERROR_ADDRESS && statusTransmission!=HAL_ERROR_DATAEXCESS)
				{
					
					if (reset >= 2)
					{
						reset = 0;
						timeout = MAX_TIMEOUT;
						//PCKG_SwitchOffAllLeds(); // выключить все лампы
					}
					else
					{
						reset++;
					}
				}
				step = STEP_IDLE;
			} break;
				
			case STEP_IDLE:
			{
				//printf("%d %d %d %d\r\n",puTX.data.volt.green1,puTX.data.volt.output1,puTX.data.volt.green2,puTX.data.volt.output2);
				//printf("IDLE!!!!!!!!!!!!!!!\r\n");
				memset(&puRX,0,infoPackage.sizeRX);
				memset(&puTX,0,infoPackage.sizeTX);
				step = STEP_RX;
			} break;
			
			default:
			{
			} break;
		}
		//LED_PH3_ON;
		//LED_PH4_ON;
	}
  /* USER CODE END 3 */
}


/** System Clock Configuration
*/
//моя функция 


void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  __PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  //RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);

}
//*/
/* IWDG init function */
#ifdef WATCHDOG_ENABLE
void MX_IWDG_Init(void)
{

  hiwdg.Instance = IWDG;
  hiwdg.Init.Prescaler = IWDG_PRESCALER_4;
  hiwdg.Init.Reload = 4095;
  HAL_IWDG_Init(&hiwdg);

}
#endif
/* USART1 init function */
void MX_USART1_UART_Init(void)
{

  hUartMain.Instance = USART1;
  hUartMain.Init.BaudRate = 115200;
  hUartMain.Init.WordLength = UART_WORDLENGTH_8B;
  hUartMain.Init.StopBits = UART_STOPBITS_1;
  hUartMain.Init.Parity = UART_PARITY_NONE;
  hUartMain.Init.Mode = UART_MODE_TX_RX;
  hUartMain.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  hUartMain.Init.OverSampling = UART_OVERSAMPLING_16;
  HAL_UART_Init(&hUartMain);
	
}
void MX_USART6_UART_Init(void)
{

  hUartDebug.Instance = USART6;
  hUartDebug.Init.BaudRate = 115200;
  hUartDebug.Init.WordLength = UART_WORDLENGTH_8B;
  hUartDebug.Init.StopBits = UART_STOPBITS_1;
  hUartDebug.Init.Parity = UART_PARITY_NONE;
  hUartDebug.Init.Mode = UART_MODE_TX_RX;
  hUartDebug.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  hUartDebug.Init.OverSampling = UART_OVERSAMPLING_16;
  HAL_UART_Init(&hUartDebug);

}
/** Configure pins as 
        * Analog 
        * Input 
        * Output
        * EVENT_OUT
        * EXTI
*/
void MX_GPIO_Init(void)
{

//  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __GPIOH_CLK_ENABLE();	
  __GPIOB_CLK_ENABLE();
	__GPIOA_CLK_ENABLE();
	__GPIOC_CLK_ENABLE();

  /*Configure GPIO pin : PA5 */
  /*
	GPIO_InitStruct.Pin = GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
	*/
	
	// Индикаторный диод на плате
	InitGPIO(LED_BOARD_PORT,LED_BOARD_PIN,GPIO_MODE_OUTPUT_PP);
	
	// Управляющий выход
	InitGPIO(GPIOC,CONTROL_PIN,GPIO_MODE_OUTPUT_PP);
	
	// Светодиоды
	InitGPIO(GPIOA,LED_1,GPIO_MODE_OUTPUT_PP);
	InitGPIO(GPIOA,LED_2,GPIO_MODE_OUTPUT_PP);
	
	// Адресные входы
	InitGPIO_Address(GPIOA,GPIO_PIN_0,GPIO_MODE_INPUT);  // плата 1 на rack 0 если вход ==1, плата 0 если ==0
	InitGPIO_Address(GPIOC,GPIO_PIN_15,GPIO_MODE_INPUT); // плата 2 на rack 1
	InitGPIO_Address(GPIOC,GPIO_PIN_0,GPIO_MODE_INPUT);  // плата 3 на rack 2
	InitGPIO_Address(GPIOC,GPIO_PIN_13,GPIO_MODE_INPUT); // плата 4 на rack 3
	
	// Дискретные входы
	InitGPIO(GPIOB,GPIO_PIN_7,GPIO_MODE_INPUT); //1
	InitGPIO(GPIOB,GPIO_PIN_6,GPIO_MODE_INPUT);
	InitGPIO(GPIOB,GPIO_PIN_5,GPIO_MODE_INPUT);
	InitGPIO(GPIOB,GPIO_PIN_4,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOC,GPIO_PIN_12,GPIO_MODE_INPUT); //2
	InitGPIO(GPIOC,GPIO_PIN_11,GPIO_MODE_INPUT);
	InitGPIO(GPIOC,GPIO_PIN_10,GPIO_MODE_INPUT);
	InitGPIO(GPIOA,GPIO_PIN_15,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOA,GPIO_PIN_12,GPIO_MODE_INPUT); //3
	InitGPIO(GPIOA,GPIO_PIN_11,GPIO_MODE_INPUT);
	InitGPIO(GPIOA,GPIO_PIN_10,GPIO_MODE_INPUT);
	InitGPIO(GPIOA,GPIO_PIN_9,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOA,GPIO_PIN_8,GPIO_MODE_INPUT); //4
	InitGPIO(GPIOC,GPIO_PIN_9,GPIO_MODE_INPUT);
	InitGPIO(GPIOC,GPIO_PIN_8,GPIO_MODE_INPUT);
	InitGPIO(GPIOC,GPIO_PIN_3,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOC,GPIO_PIN_2,GPIO_MODE_INPUT); //5
	InitGPIO(GPIOB,GPIO_PIN_15,GPIO_MODE_INPUT);
	InitGPIO(GPIOB,GPIO_PIN_14,GPIO_MODE_INPUT);
	InitGPIO(GPIOB,GPIO_PIN_13,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOB,GPIO_PIN_12,GPIO_MODE_INPUT); //6
	InitGPIO(GPIOB,GPIO_PIN_10,GPIO_MODE_INPUT);
	InitGPIO(GPIOB,GPIO_PIN_2,GPIO_MODE_INPUT);
	InitGPIO(GPIOB,GPIO_PIN_1,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOB,GPIO_PIN_0,GPIO_MODE_INPUT); //7
	InitGPIO(GPIOC,GPIO_PIN_5,GPIO_MODE_INPUT);
	InitGPIO(GPIOC,GPIO_PIN_4,GPIO_MODE_INPUT);
	InitGPIO(GPIOA,GPIO_PIN_7,GPIO_MODE_INPUT);
	
	InitGPIO(GPIOA,GPIO_PIN_6,GPIO_MODE_INPUT); //8
	InitGPIO(GPIOA,GPIO_PIN_5,GPIO_MODE_INPUT);
	InitGPIO(GPIOA,GPIO_PIN_4,GPIO_MODE_INPUT);
	InitGPIO(GPIOA,GPIO_PIN_3,GPIO_MODE_INPUT);
	
	

}

/* USER CODE BEGIN 4 */
/* USER CODE END 4 */

#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

/**
  * @}
  */ 

/**
  * @}
*/ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/