﻿/*
 * main.c
 *
 *  Created on: 10 ����. 2019 �.
 *      Author: Ivan
 */
#include"main.h"
#include<stdio.h>
#include<string.h>
#include "rts_chasi.h"
#define F_APB1 84000000U
#define APBCLK 84000000UL
#define BAUDRATE 48000UL
#define I2C_REQUEST_WRITE                       0x00
#define I2C_REQUEST_READ                        0x01
#define SLAVE_OWN_ADDRESS                       0xA0
#define ds1307WR                                  0b11010000
 #define ds1307READ      
#define SYSCLOCK 168000000U
//#define R 0
#define L 1

static volatile uint16_t delay_counter = 0;
volatile unsigned int pauza=0,pauza_z=0;
volatile unsigned int t[50];
volatile unsigned char f[50];
volatile unsigned int pauza_m=0;
volatile unsigned char flag=0;
volatile unsigned char n=0;
volatile unsigned char menu=0;
volatile unsigned int text;
//char menu=0;
char buf1[50];
char buf2[50];
char buf3[50];
char buf4[50];
char buf5[50];
char buf6[50];
char buf7[50];
char buf8[50];
char buf9[50];
char buf10[50];
char buf11[50];
char buf12[50];
volatile unsigned char sec,min,hour,day,date,month,year;
volatile unsigned char sec1=0,min1=0,hour1=0,day1=0,date1=0,month1=0,year1=0;
 volatile unsigned char menu_en=0;
 volatile unsigned char flag1=0,flag2=0,flag3=0,flag4=0,flag5=0,flag6=0,flag7=0;
 volatile unsigned  int a=0,b=0,b1=0,a1=0;
//uint16_t a=0,b=0,a1=0,b1=0;
 //unsigned  int a1;
volatile unsigned int adc_data=0,R=1;
 void DelayMicro(__IO uint32_t micros);
 // adc_data = ADC1->DR;
uint8_t dt[5];

float temp, hum;
__IO uint32_t tmpreg;
__IO uint32_t SysTick_CNT = 0;
//----------------------------------------------------------
void init_systimer(void)
{
	 MODIFY_REG(SysTick->LOAD,SysTick_LOAD_RELOAD_Msk,SYSCLOCK / 1000 - 1);

  CLEAR_BIT(SysTick->VAL, SysTick_VAL_CURRENT_Msk);
    SET_BIT(SysTick->CTRL, SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_ENABLE_Msk | SysTick_CTRL_TICKINT_Msk);

}

 void delay(__IO uint32_t tck)
{
  while(tck)
  {
    tck--;
  }
}
//----------------------------------------------------------
void delay_ms(uint32_t ms)
{
  MODIFY_REG(SysTick->VAL,SysTick_VAL_CURRENT_Msk,SYSCLOCK / 1000 - 1);
  SysTick_CNT = ms;
  while(SysTick_CNT) {}
}
 void DelayMicro(__IO uint32_t micros)
{
	micros *=(SystemCoreClock / 1000000) / 9;
	while (micros--);
}
int bufer;
void EXTI1_IRQHandler(void)
{
	EXTI->PR |=EXTI_PR_PR1;
	n++;
}
void NMI_Handler(void)
{
  if((RCC->CIR & RCC_CIR_CSSF) != 0) // HSE fail
  {
    RCC->CIR |= RCC_CIR_CSSC; // Clear CSSF flag

  }
}
uint8_t bii [8]=
{
		 0B00000,
		  0B00000,
		  0B01010,
		  0B00100,
		  0B00100,
		  0B00100,
		  0B00100,
		  0B00000
};
uint8_t bk [8]=
{
		0B00000,
		  0B00000,
		  0B01001,
		  0B01010,
		  0B01100,
		  0B01010,
		  0B01001,
		  0B00000
};
uint8_t bj [8]=
{
		 0B00000,
		  0B00000,
		  0B10101,
		  0B01110,
		  0B00100,
		  0B01110,
		  0B10101,
		  0B00000
};
uint8_t bm[]=
{


		    0b00000,
		   0b00000,
		   0b10001,
		   0b11011,
		   0b10101,
		   0b10001,
		   0b10001,
		   0B00000
};
uint8_t bn[]=
{
		0B00000,
		  0B00000,
		  0B10010,
		  0B10010,
		  0B11110,
		  0B10010,
		 0B10010,
		  0B00000
};
uint8_t biu[]=
{
		0B00000,
		  0B00000,
		  0B10111,
		  0B10101,
		  0B11101,
		  0B10101,
		  0B10111,
		  0B00000

};
uint8_t iorp[]=
{
		0b00000,
			0b01100,
			0b11110,
			0b11110,
			0b01111,
			0b00111,
			0b00011,
			0b00001
};
uint8_t ior2p[]=
{
		0b00000,
			0b00110,
			0b01111,
			0b01110,
			0b11110,
			0b11100,
			0b11000,
			0b10000
};
uint8_t bZ[]=
{
		0b01110,
			0b10001,
			0b00001,
			0b00110,
			0b00001,
			0b10001,
			0b01111,
			0b00000,
};
uint8_t bitu[]=
{
		0b00000,
			0b00000,
			0b10001,
			0b10011,
			0b10101,
			0b11001,
			0b10001,
			0b00000,

};
uint8_t bitr[]=
{
		0b00000,
			0b00000,
			0b10001,
			0b10001,
			0b11101,
			0b10101,
			0b11101,
			0b00000,

};
uint8_t bv[]=
{
		0b00000,
			0b00000,
			0b11110,
			0b10001,
			0b11110,
			0b10001,
			0b11110,
			0b00000,

};

uint8_t bg[]=
{
		0b00000,
			0b00000,
			0b11111,
			0b10000,
			0b10000,
			0b10000,
			0b10000,
			0B00000,
};
uint8_t bd[]=
{
		  0b00000,
			0b00000,
			0b00110,
			0b01010,
			0b01010,
			0b01110,
			0b10001,
			0b00000,
};
void program(void)
{
	LCD_SetPos(0,0);
	if(pauza_m==10)
	{
		LCD_Clear_Pos (0,0,0);
		 LCD_PrintMyChar( 2 );
	}
	if(pauza_m==35)
    {
		LCD_Clear_Pos (0,0,1);

		//LCD_Clear_Pos (0,0,0);

		LCD_SendChar('a');

				LCD_PrintMyChar( 2 );

    }
	if(pauza_m==5)
    {

     }
	if(pauza_m==55)
    {

     }
	if(pauza_m==65)
    {

     }
	if(pauza_m==75)
    {

	}
	LCD_SetPos(0,1);
	LCD_String("Mama");
}
void ADC_IRQHandler(void)
{
	// if(ADC1->SR & ADC_SR_EOC) //���� ���� ������ �������������� ����������
	// {
		//		        ADC1->SR &=~ ADC_SR_EOC;
		//		          adc_data = ADC1->DR;

	    //                  if(adc_data > 2024)
		//		         {
	     //               	   GPIOC-> BSRR |=GPIO_BSRR_BS13;
		//		         	  GPIOD->BSRR |= GPIO_BSRR_BS1;
		//		         }
		//		         else
		//		         {
		//		        	 GPIOC-> BSRR |=GPIO_BSRR_BR13;
		//		        	 GPIOD->BSRR |= GPIO_BSRR_BR1;
		//		         }
	// }
}

void TIM2_IRQHandler (void)
{
	if(TIM2->SR & TIM_SR_UIF)
	{
		TIM2->SR &= ~ TIM_SR_UIF;
		IWDG->KR = 0xAAAA;
		f[0]=1;
       if(flag==1)
       {
    	 pauza++;
      }


       if(!(GPIOC->IDR&GPIO_IDR_ID3 ))
        {

     			        		//	IWDG->KR = 0xAAAA;
     		        	  flag4=1;
     						 flag=1;
     						 flag5=1;
     					   //delay_ms(10);
     						TIM3->CNT=0;
     					    //pauza=0;
     }

      if(flag4==1&&GPIOC->IDR&GPIO_IDR_ID3&&pauza>1&&pauza<25)
      {
     	flag4=0;
     	flag=0;

     											 pauza=0;

     	 menu++;
     	  menu_en++;
     						    						    												// pauza=0;


       }

     					if(flag5==1&&GPIOC->IDR&GPIO_IDR_ID3&&pauza>25)
     		         {
     					    						flag=0;
     					    						flag5=0;

     					    														//delay_ms(10);
     					    pauza=0;

     					  menu=0;
     					   menu_en=0;

     				}
	}
}
void TIM5_IRQHandler (void)
{
	if(TIM5->SR & TIM_SR_UIF)
	{
		TIM5->SR &= ~ TIM_SR_UIF;
		//IWDG->KR = 0xAAAA;
		pauza_m++;
		        if(pauza_m>10)
				{
					GPIOD->BSRR |= GPIO_BSRR_BS1;
				//	GPIOC-> BSRR |=GPIO_BSRR_BS13;
				}
				if(pauza_m>20)
				{

				//	GPIOC-> BSRR |=GPIO_BSRR_BR13;
					 GPIOD->BSRR |= GPIO_BSRR_BR1;
							pauza_m=0;
				}


	}
}
void TIM6_DAC_IRQHandler(void)
{
	    if(TIM6->SR & TIM_SR_UIF)
		{
			TIM6->SR &= ~ TIM_SR_UIF;
          if(f[0]==1)
          {
			t[0]++;
          }
          if(f[1]==1)
          {
			t[1]++;
          }
          if(f[2]==1)
          {
			t[2]++;
          }
          if(f[3]==1)
           {
             t[3]++;
            }
          if(f[4]==1)
           {
             t[4]++;
            }
	    }
}
//void TIM3_IRQHandler (void)
//{
 // if(TIM3->SR & TIM_SR_UIF)
//  {
	//TIM3->SR &= ~ TIM_SR_UIF;
	// IWDG->KR = 0xAAAA;
	//pauza++;
	//if(pauza>10)
	//{

		// GPIOD->BSRR |= GPIO_BSRR_BS1;
		//GPIOC-> BSRR |=GPIO_BSRR_BS13;
	//}
	//if(pauza>20)
//	{
		// GPIOD->BSRR |= GPIO_BSRR_BR1;
	   //  GPIOC-> BSRR |=GPIO_BSRR_BR13;
		//pauza=0;
	//}
 //  }
	//TIM2->SR &= ~ TIM_SR_UIF;
//}



void RCC_init(void)
{
	FLASH->ACR |= FLASH_ACR_PRFTEN ;
		//FLASH->ACR &=~ (FLASH_ACR_LATENCY_2WS) ;
	FLASH->ACR |= FLASH_ACR_LATENCY_3WS ;

	//PWR->CR|= PWR_CR_VOS;
	RCC->CR|=RCC_CR_HSEON;											// Enable HSE
    while (!(RCC->CR & RCC_CR_HSERDY));


    RCC->CR|=RCC_CR_CSSON;

	 RCC->PLLCFGR |=RCC_PLLCFGR_PLLSRC_HSE  ;
	    RCC->PLLCFGR |=_VAL2FLD(RCC_PLLCFGR_PLLM,4);
	  //  RCC->PLLCFGR |=RCC_PLLCFGR_PLLM_1;
	  //  RCC->PLLCFGR |=_VAL2FLD(RCC_PLLCFGR_PLLM,2);
	    RCC->PLLCFGR |=_VAL2FLD(RCC_PLLCFGR_PLLN,168);
	   // RCC->PLLCFGR|=_VAL2FLD(RCC_PLLCFGR_PLLQ,9);
	     RCC->PLLCFGR&=~RCC_PLLCFGR_PLLP_0 ;
	     RCC->PLLCFGR&=~RCC_PLLCFGR_PLLP_1 ;
	    // RCC->PLLCFGR |=_VAL2FLD(RCC_PLLCFGR_PLLP,0);
	     RCC->CFGR |= RCC_CFGR_HPRE_DIV1;//	��������� ����  AHB
	   			        RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;//	��������� ����  APB1

	   				   RCC->CFGR |= RCC_CFGR_PPRE2_DIV2;

			RCC->CR |= RCC_CR_PLLON;                      							// enable PLL
			while(!(RCC->CR & RCC_CR_PLLRDY))
			{

			}

		    RCC->CFGR |= RCC_CFGR_SW_PLL;                 							// select source SYSCLK = PLL
			while(!(RCC->CFGR&  RCC_CFGR_SWS_PLL))

				{

				}



}
void USART_TX (uint8_t* dt, uint16_t sz)
{
  uint16_t ind = 0;
  while (ind<sz)
  {
    while (READ_BIT(USART1->SR, USART_SR_TXE) != (USART_SR_TXE)) {}
    USART1->DR = (uint16_t)dt[ind];
    ind++;
  }
}
// ������� ���������� ���� � USART
void tx_uart1( char data)
{
	//while ((USART1->SR & USART_SR_TXE) == 0) {}
  // USART1->DR = data;
   while (!(USART1->SR & USART_SR_TC ));                     // ���� ���� ��� TC � �������� SR ������ 1
   USART1->DR=data;                                    // �������� ���� ����� UART
}

// ������� ���������� ������ � USART
void tx_str1(char * string)
{
  // uint8_t i=0;
   int i=0;
   while (string[i])
   {
      tx_uart1(string[i]);
      i++;
     // tx_uart(string[i++]);
   }
   tx_uart1('\r');
   tx_uart1('\n');
}
void EXTI_Init(void)
{

	 // RCC->AHB1ENR|=RCC_AHB1ENR_GPIOAEN;
	  GPIOA->MODER &=~ GPIO_MODER_MODER1_1;
	  GPIOA->MODER &=~ GPIO_MODER_MODER1_0;
	  GPIOA->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR1_1; //���1
	 GPIOA->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR1_0;
	   GPIOA->PUPDR &=~GPIO_PUPDR_PUPDR1_1;
	    GPIOA->PUPDR |= GPIO_PUPDR_PUPDR1_0;
	    RCC->APB2ENR |=RCC_APB2ENR_SYSCFGEN ;
	    SYSCFG->EXTICR[1] |= SYSCFG_EXTICR1_EXTI1_PA;
	    EXTI->IMR|=EXTI_IMR_MR1;
	    EXTI->RTSR|=EXTI_RTSR_TR1;
	    EXTI->FTSR&=~EXTI_FTSR_TR1 ;
	    NVIC_EnableIRQ (EXTI1_IRQn);
	  //  SYSCFG->EXTICR[3] |= SYSCFG_EXTICR1_EXTI1_PB;
 //RCC->AHB1ENR |=
}
void USART1_init(void)
{
	 GPIOA->MODER  |= GPIO_MODER_MODE9_1 | GPIO_MODER_MODE10_1;
	 GPIOA->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR9;
	 GPIOA->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR10;
	GPIOA->AFR[1]|=_VAL2FLD(GPIO_AFRH_AFSEL9,7);
	GPIOA->AFR[1]|=_VAL2FLD(GPIO_AFRH_AFSEL10,7);


	RCC->APB2ENR  |= RCC_APB2ENR_USART1EN;
	//  USART1->CR1   |= USART_CR1_UE;
	   USART1->BRR  =0x222E ;
	   // USART1->BRR =(APBCLK+BAUDRATE/2)/BAUDRATE;
	   USART1->CR1   |= USART_CR1_TE;                            // ��������� ����������
	   USART1->CR1   |= USART_CR1_RE;
	  // USART2->CR1 |= USART_CR1_RE | USART_CR1_TE | USART_CR1_M | USART_CR1_PCE | USART_CR1_PS;
	   // ��������� �������
	   USART1->CR1     |= USART_CR1_RXNEIE;
	   USART1->CR1   |= USART_CR1_UE;                            // ��������� USART
	                           // ��������� ���������� �� ������ ������
	   NVIC_EnableIRQ (USART1_IRQn);

}
void init_IWDGtimer(void)
{
	RCC->CSR|= RCC_CSR_LSION;



	   IWDG->KR = 0x5555; // Access to registers
	   IWDG->PR&= ~(IWDG_PR_PR_0 | IWDG_PR_PR_1 | IWDG_PR_PR_2); // 4096
	   IWDG->RLR =  2000;//0x7FF;
	   while (!((IWDG->SR & IWDG_SR_PVU) && (IWDG->SR & IWDG_SR_RVU))){} // wait while bist of PVU and RVU will be set.
	   IWDG->KR = 0xCCCC; // Start count down;
}
void USART2_init(void)
{

}
void DMA1_init(void)
{
	RCC->AHB1ENR|= RCC_AHB1ENR_DMA1EN;
	DMA1_Stream0->CR = 0;
	DMA1_Stream0->M0AR |=(uint32_t)& bufer;
	DMA1_Stream0->PAR |=(uint32_t)&TIM4->CCR1 ;
	DMA1_Stream0->NDTR = 1;
	DMA1_Stream0->CR&= ~DMA_SxCR_PINC;
	DMA1_Stream0->CR&= ~DMA_SxCR_MINC;
	DMA1_Stream0->CR|= DMA_SxCR_PSIZE_0;
	DMA1_Stream0->CR|= DMA_SxCR_MSIZE_0;

	       DMA1_Stream0->CR&=~ DMA_SxCR_CHSEL_0 ;
	       DMA1_Stream0->CR|= DMA_SxCR_CHSEL_1;
	       DMA1_Stream0->CR&=~ DMA_SxCR_CHSEL_2 ;
	       DMA1_Stream0->CR&=~ DMA_SxCR_PFCTRL;//DMA ma
	             DMA1_Stream0->CR|= DMA_SxCR_PL; //DMA ma
	             DMA1_Stream0->FCR|=DMA_SxFCR_DMDIS;//��������� fIFO
	             DMA1_Stream0->CR|= DMA_SxCR_DIR_0;
	             DMA1_Stream0->CR|= DMA_SxCR_CIRC;
	             DMA1_Stream0->CR|= DMA_SxCR_EN;//��
}
 void DMA2_init(void)
 {

      RCC->AHB1ENR|= RCC_AHB1ENR_DMA2EN;
      DMA2_Stream0->CR = 0;

      DMA2_Stream0->PAR |=(uint32_t)& ADC1->DR;
       DMA2_Stream0->M0AR |=(uint32_t)& bufer;
     //  TIM4->CCR1= bufer;
       DMA2_Stream0->NDTR = 1;

       DMA2_Stream0->CR&= ~DMA_SxCR_PINC;
       DMA2_Stream0->CR&= ~DMA_SxCR_MINC;
       DMA2_Stream0->CR|= DMA_SxCR_PSIZE_0;
       DMA2_Stream0->CR|= DMA_SxCR_MSIZE_0;
       DMA2_Stream0->CR&=~ DMA_SxCR_CHSEL_0 ;
       DMA2_Stream0->CR&=~ DMA_SxCR_CHSEL_1;
       DMA2_Stream0->CR&=~ DMA_SxCR_CHSEL_2 ;
     DMA2_Stream0->CR&=~ DMA_SxCR_PFCTRL;//DMA ma
       DMA2_Stream0->CR|= DMA_SxCR_PL; //DMA ma
       DMA2_Stream0->FCR|=DMA_SxFCR_DMDIS;//��������� fIFO
       DMA2_Stream0->CR&=~ DMA_SxCR_DIR;
       DMA2_Stream0->CR|= DMA_SxCR_CIRC;
       DMA2_Stream0->CR|= DMA_SxCR_EN;//���   DMA2_Stream0
       ADC1->CR2|=ADC_CR2_DMA;

 }
void adc_init(void)
{

		  RCC->APB2ENR|=RCC_APB2ENR_ADC1EN;
		  ADC1->CR2 |=ADC_CR2_CONT;//�������� ���
		  	// ADC1->CR2|=ADC_CR2_EXTSEL;
		    // 	 ADC1->CR2 |=ADC_CR2_EXTEN;
		  ADC1->SMPR2 &=~ ADC_SMPR2_SMP1_0; //1
		 ADC1->SMPR2&=~ADC_SMPR2_SMP1_1; //1
		  ADC1->SMPR2 &=~ ADC_SMPR2_SMP1_2; //1


		 // ADC1->JSQR|=ADC_JSQR_JSQ1_0;;

		     ADC1->SQR3   |=ADC_SQR3_SQ1_0;   //1 IN1
		  	  ADC1->SQR3   &= ~ ADC_SQR3_SQ1_1;     //0
		  	  ADC1->SQR3   &= ~ADC_SQR3_SQ1_2;   //0
		  	  ADC1->SQR3   &=~  ADC_SQR3_SQ1_3;     //0
		  	  ADC1->SQR3   &= ~ADC_SQR3_SQ1_4;
		 	 ADC1->CR2 |=  ADC_CR2_ADON;
		 	ADC1->CR2 |= ADC_CR2_SWSTART;
}
void AHB1ER_init(void)
{
	RCC->AHB1ENR|=RCC_AHB1ENR_GPIOAEN;
	RCC->AHB1ENR|=RCC_AHB1ENR_GPIOBEN;
	RCC->AHB1ENR|=RCC_AHB1ENR_GPIOCEN;
	RCC->AHB1ENR|=RCC_AHB1ENR_GPIODEN;
}

static void GPIO_init(void)
{

	   // RCC->AHB1ENR|=RCC_AHB1ENR_GPIOAEN;
			  GPIOA->MODER |= GPIO_MODER_MODER1;
			  GPIOA->MODER |= GPIO_MODER_MODER2;

			  //   RCC->AHB1ENR|=RCC_AHB1ENR_GPIOCEN;

		       // GPIOC->MODER &=~ GPIO_MODER_MODER13;
			 	  GPIOC->MODER &=~ GPIO_MODER_MODER13_1;
			 	  GPIOC->MODER |= GPIO_MODER_MODER13_0;
			 	  GPIOC ->OTYPER &=~GPIO_OTYPER_OT13;
			 	  //���0 ���������� �������� ������ GPIO
			 	   GPIOC->OSPEEDR |=GPIO_OSPEEDER_OSPEEDR13; //���1

			 	  GPIOC->PUPDR |=GPIO_PUPDR_PUPDR13_1;
			 	    GPIOC->PUPDR &=~ GPIO_PUPDR_PUPDR13_0;

			 	   GPIOC->MODER &=~ GPIO_MODER_MODER0_1;
			 	   	GPIOC->MODER |= GPIO_MODER_MODER0_0;
			 	   	GPIOC ->OTYPER &=~GPIO_OTYPER_OT0;
			 	   			 	 	 	  //���0 ���������� �������� ������ GPIO
			 	    GPIOC->OSPEEDR &=~ GPIO_OSPEEDER_OSPEEDR0_1; //���1
			 	   GPIOC->OSPEEDR &=~ GPIO_OSPEEDER_OSPEEDR0_0;
			 	   GPIOC->PUPDR |= GPIO_PUPDR_PUPDR0_1;
			 	   GPIOC->PUPDR &=~ GPIO_PUPDR_PUPDR0_0;


			 	 			 	   	GPIOC->MODER |= GPIO_MODER_MODER2_0;
			 	 			 	   	GPIOC ->OTYPER &=~GPIO_OTYPER_OT2;
			 	 			 	   			 	 	 	  //���0 ���������� �������� ������ GPIO
			 	 			 	    GPIOC->OSPEEDR &=~ GPIO_OSPEEDER_OSPEEDR2_1; //���1
			 	 			 	   GPIOC->OSPEEDR &=~ GPIO_OSPEEDER_OSPEEDR2_0;
			 	 			 	   GPIOC->PUPDR |= GPIO_PUPDR_PUPDR2_1;
			 	 			 	   GPIOC->PUPDR &=~ GPIO_PUPDR_PUPDR2_0;
			 	 			 	   GPIOC->MODER &=~ GPIO_MODER_MODER2_1;

			 	 			   	GPIOC->MODER &=~ GPIO_MODER_MODER3;
			 	 			  GPIOC->PUPDR &=~GPIO_PUPDR_PUPDR3_1;
			 	 			 GPIOC->PUPDR |= GPIO_PUPDR_PUPDR3_0;

			 	 			  GPIOC->MODER &=~ GPIO_MODER_MODER4;
			 	 			  GPIOC->PUPDR &=~GPIO_PUPDR_PUPDR4_1;
			 	 			 GPIOC->PUPDR |= GPIO_PUPDR_PUPDR4_0;

}
void GPIOD_init(void)
{
	// RCC->AHB1ENR|=RCC_AHB1ENR_GPIODEN;
				 	 			 	 GPIOD->MODER &=~ GPIO_MODER_MODER0_1;
				 	 			 	GPIOD->MODER |= GPIO_MODER_MODER0_0;
				 	 			 	GPIOD ->OTYPER &=~GPIO_OTYPER_OT0;
				 	 			 				 	   			 	 	 	  //���0 ���������� �������� ������ GPIO
				 	 			 	GPIOD->OSPEEDR &=~ GPIO_OSPEEDER_OSPEEDR0_1; //���1
				 	 			 	GPIOD->OSPEEDR &=~ GPIO_OSPEEDER_OSPEEDR0_0;
				 	 			 	GPIOD->PUPDR |= GPIO_PUPDR_PUPDR0_1;
				 	 			 	GPIOD->PUPDR &=~ GPIO_PUPDR_PUPDR0_0;
				 	 				 GPIOD->MODER &=~ GPIO_MODER_MODER1_1;
				 	 				GPIOD->MODER |= GPIO_MODER_MODER1_0;
				 	 				GPIOD ->OTYPER &=~GPIO_OTYPER_OT1;
				 	 							 	 			 				 	   			 	 	 	  //���0 ���������� �������� ������ GPIO
				 	 				GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR1_1; //���1
				 	 				GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR1_0;
				 	 				GPIOD->PUPDR |= GPIO_PUPDR_PUPDR1_1;
				 	 				GPIOD->PUPDR &=~ GPIO_PUPDR_PUPDR1_0;


}

void SysTick_Handler(void)
{
  if(SysTick_CNT > 0)  SysTick_CNT--;
}

void timer_1_init(void)
{

	 RCC->APB2ENR |=RCC_APB2ENR_TIM1EN;

}
void timer_2_init(void)
{

	RCC->APB1ENR |=RCC_APB1ENR_TIM2EN;

	TIM2->PSC =3500 ; // ����������� �������� ��� ������ ����� 1000 ��� � �������
	TIM2->ARR =100 ; //65535

	TIM2->EGR|= TIM_EGR_UG;
	 TIM2->DIER |= TIM_DIER_UIE;
	TIM2->CR1|=TIM_CR1_CEN;
	 NVIC_EnableIRQ(TIM2_IRQn);
}

void timer3_encoder(void)
{
	GPIOA->MODER|=GPIO_MODER_MODER6_1;
			GPIOA->MODER|=GPIO_MODER_MODER7_1;
			GPIOA->PUPDR|=GPIO_PUPDR_PUPDR6_0;
				GPIOA->PUPDR|=GPIO_PUPDR_PUPDR7_0 ;

				GPIOA->AFR[0]|=_VAL2FLD(GPIO_AFRL_AFSEL6,2);
					GPIOA->AFR[0]|=	_VAL2FLD(GPIO_AFRL_AFSEL7,2);

	  RCC->APB1ENR |=RCC_APB1ENR_TIM3EN;

	  TIM3->CCMR1|=TIM_CCMR1_IC1F| TIM_CCMR1_IC2F ;
	   TIM3->CCMR1|=TIM_CCMR1_CC1S_0 |TIM_CCMR1_CC2S_0 ;
	   TIM3->CCER&=~(TIM_CCER_CC1P|TIM_CCER_CC2P);
	   TIM3->SMCR|=TIM_SMCR_SMS_1|TIM_SMCR_SMS_0;

	   	TIM3->ARR  = 100;



	     TIM3->CR1|=   TIM_CR1_CEN;

	     TIM3->CNT=0;
}
void AFR_init(void)
{
	   GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL12_0 ;
		GPIOD->AFR[1]|=GPIO_AFRH_AFSEL12_1 ;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL12_2 ;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL12_3 ;

		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL13_0 ;
		GPIOD->AFR[1]|=GPIO_AFRH_AFSEL13_1 ;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL13_2 ;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL13_3 ;

		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL14_0 ;
		GPIOD->AFR[1]|=GPIO_AFRH_AFSEL14_1 ;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL14_2 ;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL14_3 ;

		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL15_0;
		GPIOD->AFR[1]|=GPIO_AFRH_AFSEL15_1;
		GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL15_2;
	    GPIOD->AFR[1]&=~GPIO_AFRH_AFSEL15_3;
}
void timer4(void)
{
	//RCC->AHB1ENR|=RCC_AHB1ENR_GPIODEN;

	GPIOD->MODER|=GPIO_MODER_MODER12_1 ;
	GPIOD->MODER&=~GPIO_MODER_MODER12_0 ;
	GPIOD->MODER|=GPIO_MODER_MODER13_1 ;
	GPIOD->MODER&=~GPIO_MODER_MODER13_0 ;
    GPIOD->MODER|=GPIO_MODER_MODER14_1 ;
	GPIOD->MODER&=~GPIO_MODER_MODER14_0 ;
	GPIOD->MODER|=GPIO_MODER_MODER15_1 ;
	GPIOD->MODER&=~GPIO_MODER_MODER15_0 ;
	//GPIOD->AFR[1]|=0x02 ;

	RCC->APB1ENR|=RCC_APB1ENR_TIM4EN;
	TIM4->PSC=0;
	 TIM4->ARR=4095;


	TIM4->CCMR1&=~TIM_CCMR1_CC1S;//
	TIM4->CCMR1&=~TIM_CCMR1_CC2S;//
	TIM4->CCMR2&=~TIM_CCMR2_CC3S;//
	TIM4->CCMR2&=~TIM_CCMR2_CC4S;//
	TIM4->CR1&=~TIM_CR1_DIR;
    TIM4->CCMR1|=TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1;
    TIM4->CCMR1|=TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2M_1;
    TIM4->CCMR2|=TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_1;
    TIM4->CCMR2|=TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4M_1;
    TIM4->CCMR1|=TIM_CCMR1_OC1PE;
    TIM4->CCMR1|=TIM_CCMR1_OC2PE;
    TIM4->CCMR2|=TIM_CCMR2_OC3PE;
    TIM4->CCMR2|=TIM_CCMR2_OC4PE;

    TIM4->CCER|=TIM_CCER_CC1E;
    TIM4->CCER|=TIM_CCER_CC2E;
    TIM4->CCER|=TIM_CCER_CC3E;
    TIM4->CCER|=TIM_CCER_CC4E;
	TIM4->CCER&=~TIM_CCER_CC1P;
	TIM4->CR1|=TIM_CR1_ARPE;
	TIM4->EGR|= TIM_EGR_UG;
	TIM4->CR1|=  TIM_CR1_CEN;
}
void timer5(void)
{
	RCC->APB1ENR|=RCC_APB1ENR_TIM5EN;
		TIM5->PSC=3500;
		 TIM5->ARR=100;
		 TIM5->EGR|= TIM_EGR_UG;
		 TIM5->DIER |= TIM_DIER_UIE;
			TIM5->CR1|=  TIM_CR1_CEN;
			 NVIC_EnableIRQ(TIM5_IRQn);
}
void timer6_init(void)
{
	RCC->APB1ENR|=RCC_APB1ENR_TIM6EN;
			TIM6->PSC=840;
			 TIM6->ARR=100;
			 TIM6->EGR|= TIM_EGR_UG;
			 TIM6->DIER|= TIM_DIER_UIE;
				TIM6->CR1|=TIM_CR1_CEN;
				 NVIC_EnableIRQ(TIM6_DAC_IRQn);
}





int main(void)
{

	//init_systimer();
    	RCC_init();
	init_systimer();
   init_IWDGtimer();

	//init_systimer();
	//RCC->AHB1ENR|=RCC_AHB1ENR_GPIODEN;
	 AHB1ER_init();
	 AFR_init();


	           GPIO_init();
	           GPIOD_init();
	          // USART1_init();
	          // I2C_Init();
		 	   EXTI_Init();
	           timer_2_init();
	         //  dht22_init();
	           timer3_encoder();
		 	  timer4();
		 	 timer5();

		 	timer6_init();
		 	//ds18b20_init();
		 	USART1_init();
		 	// adc_init();
		 	 I2C_Init();
		 	 I2C2_Init();
		//	  USART1_init();
		 	LCD_ini();
		 	LCD_Clear();
		 //	LCD_SetPos(0,0);
		 	     LCD_CreateChar(bZ,0 );
		 	      LCD_CreateChar( bitr,1);
		 	      LCD_CreateChar( bitu,2);
		 	     LCD_CreateChar( bv,3);
		 	      LCD_CreateChar( bm,4);

		 	   //  LCD_CreateChar( br,5);
		 	     LCD_CreateChar( bk,5);
		 	    LCD_CreateChar( bg,6);
		 	   LCD_CreateChar( bd,7);
		 	//DMA2_init();
		 	// DMA1_init();
		// USART1_init();
		// ADC1->CR1|= ADC_CR1_EOCIE;-00000000000		// ADC1->CR2 |=  ADC_CR2_ADON;
		// NVIC_EnableIRQ ( ADC_IRQn);
		//  ADC1->CR2 |= ADC_CR2_SWSTART;

		 				   // I2C_SendByteByADDR1(I2C2,0,0b11010000);



	while(1)
	{

		f[0]=1;
		   if(f[0]==1&&t[0]>20&&f[0]<1000)
		   {

			GPIOC->BSRR|=GPIO_BSRR_BS13;
			f[0]=0;
			t[0]=0;
			f[1]=1;
		   }
            if(f[1]==1&&t[1]>100&&t[1]<200)
		 {
			  GPIOC->BSRR|=GPIO_BSRR_BR13;
			  f[1]=0;
			  t[1]=0;
			  f[2]=1;
		    }
        if(f[2]==1&&t[2]>100&&t[2]<200)
		{

        	GPIOC->MODER &=~ GPIO_MODER_MODER13_1;
        				 	  GPIOC->MODER &=~GPIO_MODER_MODER13_0;
        				 	  GPIOC ->OTYPER &=~GPIO_OTYPER_OT13;
        				 	 f[2]=0;
        				 	t[2]=0;
        				 	f[3]=1;
		}
        if(f[3]==1&&t[3]>100&&t[3]<200)
       {
        	GPIOC->MODER &=~ GPIO_MODER_MODER13_1;
        	        				 	  GPIOC->MODER |=GPIO_MODER_MODER13_0;
        	        				 	  GPIOC ->OTYPER &=~GPIO_OTYPER_OT13;
        	        				 	 GPIOC->BSRR|=GPIO_BSRR_BS13;
        	        				 	t[3]=0;
        	        				 	f[3]=0;
        	        				 	f[4]=1;

        }
        if(f[4]==1&&t[4]>200&&t[4]<500)
        {
        	GPIOC->BSRR|=GPIO_BSRR_BR13;
        	t[4]=0;
        	f[4]=0;

        }



		                                   if(menu_en==1)
											{

										       // if(TIM3->CNT>50)
										  		//{
										  	//		GPIOC-> BSRR |=GPIO_BSRR_BS13;
										  			//GPIOD->BSRR |= GPIO_BSRR_BS1;
										  	//	}
										  //		else
										  	//	{
										  	//		GPIOC-> BSRR |=GPIO_BSRR_BR13;
										  			//GPIOD->BSRR |= GPIO_BSRR_BR1;
										  		//}
											}
											if(menu_en==2)
											{

									            //a++;

											}
											if(menu_en==3)
										     {

												//  TIM3->CNT=0;
												min1= TIM3->CNT;

										     }
											if(menu_en==4)
											{
												  //TIM3->CNT=0;

												 hour1=TIM3->CNT;
											}
											if(menu_en==5)
											{
												day1=TIM3->CNT;
										     }
											if(menu_en==6)
									        {
												date1=TIM3->CNT;
											}
											if(menu_en==7)
											{
												month1=TIM3->CNT;
											}
											if(menu_en==8)
											{
												year1=TIM3->CNT;
											}
											if(menu_en==9)
											{

											}
											if(menu_en==10)
											{
												menu_en=0;
											}
      if(menu==0)
      {
    	 // IWDG->KR = 0xAAAA;
    	  I2C2->CR1|=I2C_CR1_ACK;

    	  		 				  I2C2->CR1|= I2C_CR1_START;
    	  		 				  while (!(I2C2->SR1& I2C_SR1_SB)){};
    	  		 				  	(void) I2C2->SR1;
    	  		 				  	 I2C2->DR =  0b11010000 ;
    	  		 				  	 while (!(I2C2->SR1& I2C_SR1_ADDR)){};
    	  		 				  	  (void) I2C2->SR1;
    	  		 				  	  (void) I2C2->SR2;
    	  		 				  	// I2C2->DR= 0  ;
    	  		 				  	//while (!(I2C2->SR1 & I2C_SR1_TXE)){};

    	  		 				 I2C2->DR=0x00;//0b00000000  ;
    	  		 				  while (!(I2C2->SR1 & I2C_SR1_TXE)){};
    	  		 					     I2C2->CR1|= I2C_CR1_START;
    	  		 			             while (!(I2C2->SR1& I2C_SR1_SB)){};
    	  		 				  		(void) I2C2->SR1;
    	  		 			              I2C2->DR= 0b11010001   ;
    	  		 				  	      while (!(I2C2->SR1& I2C_SR1_ADDR)){};
    	  		 				  			(void) I2C2->SR1;
    	  		 			                  (void) I2C2->SR2;
    	  		 				          while (!(I2C2->SR1& I2C_SR1_RXNE)){};

    	  		 				  			sec= I2C2->DR;
    	  		 				  		 while (!(I2C2->SR1& I2C_SR1_RXNE)){};
    	  		 				  			min= I2C2->DR;
    	  		 				  		while (!(I2C2->SR1& I2C_SR1_RXNE)){};
    	  		 				  		   hour=I2C2->DR;

    	  		 				  			 while (!(I2C2->SR1& I2C_SR1_RXNE)){};
    	  		 				  		    day=I2C2->DR;
    	  		 			              while (!(I2C2->SR1& I2C_SR1_RXNE)){};
    	  		 				  			 date=I2C2->DR;
    	  		 				         while (!(I2C2->SR1& I2C_SR1_RXNE)){};
    	  		 				  			 month=I2C2->DR;
    	  		 				  			 			     	            	 		//I2C2->CR1&=~I2C_CR1_ACK;
    	  		 				  			while (!(I2C2->SR1& I2C_SR1_RXNE)){};
    	  		 				  			 year = I2C2->DR;
    	  		 				           I2C2->CR1&=~I2C_CR1_ACK;
    	  		 				           I2C2->CR1|= I2C_CR1_STOP;

    	  sec = RTC_ConvertFromDec(sec); //����������� � ���������� ������
    			 	  min = RTC_ConvertFromDec(min); //����������� � ���������� ������
    			 	  hour = RTC_ConvertFromDec(hour); //����������� � ���������� ������
    			 	  day = RTC_ConvertFromDec(day); //����������� � ���������� ������
    			 	 year = RTC_ConvertFromDec(year); //����������� � ���������� ������
    			 	 month = RTC_ConvertFromDec(month); //����������� � ���������� ������

    			 	 date = RTC_ConvertFromDec(date); //����������� � ���������� ������ uart_transmit ()

    			 	 LCD_SetPos(0,0);

    	  LCD_SendChar( date/10 + 0x30);
    	  		 				 		      LCD_SendChar( date%10 + 0x30);
    	  		 				 		      LCD_SendChar('.');
    	  		 				 		     LCD_SendChar( month/10 + 0x30);
    	  		 				 		   LCD_SendChar( month%10 + 0x30);
    	  		 				 		  LCD_SendChar('.');
    	  		 				 		 LCD_SendChar('2');
    	  		 				 		LCD_SendChar('0');
    	  		 				 		  LCD_SendChar(year/10 + 0x30);
    	  		 				 		 LCD_SendChar(year%10 + 0x30);
    	  		 				 		 LCD_SendChar(' ');
    	  		 				 	       LCD_SendChar(' ');
    	  		 				 	      LCD_SendChar(' ');
    	  		 				 		 LCD_SendChar('-');
    	  		 				 		LCD_SendChar(day + 0x30);
    	  		 				 	     // LCD_SendChar((char) (day%10) + 0x30);
    	  		 				 		 LCD_SetPos(0,1);
    	  		 				 		 LCD_SendChar(hour/10 + 0x30);
    	  		 				 		LCD_SendChar(hour%10 + 0x30);
    	  		 				 		LCD_SendChar(':');
    	  		 				 		 LCD_SendChar(min/10 + 0x30);
    	  		 				 		LCD_SendChar(min%10 + 0x30);
    	  		 				 		LCD_SendChar(':');
    	  		 				 		// sec = RTC_ConvertFromDec(sec);
    	  		 				 		 LCD_SendChar(sec/10 + 0x30);
    	  		 				 		LCD_SendChar(sec%10 + 0x30);
    	  		 				 	LCD_SendChar(' ');
    	  		 				     LCD_SendChar(' ');
    	  		 				    LCD_SendChar(' ');
    	  		 				 LCD_SendChar(' ');
    	  		 				LCD_SendChar(' ');
    	  		 				//sprintf(buf10,"text");
    	  		 				//tx_str1(buf10);

      }
       if(menu==1)
       {
		  LCD_SetPos(0,0);
		 // LCD_SendChar('3');
		  LCD_PrintMyChar(0);
		  LCD_SendChar(' ');
		  LCD_SendChar('H');
		  LCD_SendChar('o');
		  LCD_PrintMyChar(3);
		  LCD_PrintMyChar(2);
		  LCD_PrintMyChar(4);
		  LCD_SendChar(' ');
		  LCD_SendChar('p');
		//  LCD_PrintMyChar(5);
		  LCD_SendChar('o');
		  LCD_PrintMyChar(5);
		  LCD_SendChar('o');
		  LCD_PrintMyChar(4);
		  LCD_SendChar(' ');
		  LCD_SendChar(' ');
		  LCD_SetPos(0,1);
		  LCD_SendChar('C');
		  LCD_SendChar(' ');
		  LCD_SendChar('H');
		  LCD_SendChar('o');
		  LCD_PrintMyChar(3);
		  LCD_PrintMyChar(1);
		  LCD_PrintMyChar(4);
		  LCD_SendChar(' ');
		  LCD_PrintMyChar(6);
		  LCD_SendChar('o');
		  LCD_PrintMyChar(7);
		 LCD_SendChar('o');
	     LCD_PrintMyChar(4);
		//  LCD_SendChar(' ');
	  //   tx_str1("MAMA");
	     tx_uart1('M');
	  //   delay_ms(100);
       }
       if(menu==2)
       {

     	  I2C2->CR1|=I2C_CR1_ACK;

     	  		 				  I2C2->CR1|= I2C_CR1_START;
     	  		 				  while (!(I2C2->SR1& I2C_SR1_SB)){};
     	  		 				  	(void) I2C2->SR1;
     	  		 				  	 I2C2->DR =  0b11010000 ;
     	  		 				  	 while (!(I2C2->SR1& I2C_SR1_ADDR)){};
     	  		 				  	  (void) I2C2->SR1;
     	  		 				  	  (void) I2C2->SR2;
     	  		 				  	// I2C2->DR= 0  ;
     	  		 				  	//while (!(I2C2->SR1 & I2C_SR1_TXE)){};
     	  		 				  	I2C2->DR= 0b00000000  ;
     	  		 				  	while (!(I2C2->SR1 & I2C_SR1_TXE)){};
     	  		 					     I2C2->CR1|= I2C_CR1_START;
     	  		 			             while (!(I2C2->SR1& I2C_SR1_SB)){};
     	  		 				  		(void) I2C2->SR1;
     	  		 			              I2C2->DR= 0b11010001   ;
     	  		 				  	      while (!(I2C2->SR1& I2C_SR1_ADDR)){};
     	  		 				  			(void) I2C2->SR1;
     	  		 			                  (void) I2C2->SR2;
     	  		 				          while (!(I2C2->SR1& I2C_SR1_RXNE)){};

     	  		 				  			sec= I2C2->DR;
     	  		 				  		 while (!(I2C2->SR1& I2C_SR1_RXNE)){};
     	  		 				  			min= I2C2->DR;
     	  		 				  		while (!(I2C2->SR1& I2C_SR1_RXNE)){};
     	  		 				  		   hour=I2C2->DR;

     	  		 				  			 while (!(I2C2->SR1& I2C_SR1_RXNE)){};
     	  		 				  		    day=I2C2->DR;
     	  		 			              while (!(I2C2->SR1& I2C_SR1_RXNE)){};
     	  		 				  			 date=I2C2->DR;
     	  		 				         while (!(I2C2->SR1& I2C_SR1_RXNE)){};
     	  		 				  			 month=I2C2->DR;
     	  		 				  			 			     	            	 		//I2C2->CR1&=~I2C_CR1_ACK;
     	  		 				  			while (!(I2C2->SR1& I2C_SR1_RXNE)){};
     	  		 				  			 year = I2C2->DR;
     	  		 				           I2C2->CR1&=~I2C_CR1_ACK;
     	  		 				           I2C2->CR1|= I2C_CR1_STOP;

     	  sec = RTC_ConvertFromDec(sec); //����������� � ���������� ������
     			 	  min = RTC_ConvertFromDec(min); //����������� � ���������� ������
     			 	  hour = RTC_ConvertFromDec(hour); //����������� � ���������� ������
     			 	  day = RTC_ConvertFromDec(day); //����������� � ���������� ������
     			 	 year = RTC_ConvertFromDec(year); //����������� � ���������� ������
     			 	 month = RTC_ConvertFromDec(month); //����������� � ���������� ������
     			 	 date = RTC_ConvertFromDec(date); //����������� � ���������� ������ uart_transmit ()
    	   sprintf(buf1,"%02d.%02d.20%02d  -%d     ", date, month,year,day);
    	   LCD_SetPos(0,0);
    	   LCD_String(buf1);
    	 sprintf(buf2,"%02d:%02d:%02d       ",hour,min,sec);
    	 LCD_SetPos(0,1);
    	 LCD_String(buf2);

       }
       if(menu==3)
       {

    	   sprintf(buf4,"min1=%2d   %2d      ",min1,min);

    	     	   LCD_SetPos(0,0);
    	     	   LCD_String(buf4);

    	     	 LCD_SetPos(0,1);

    	     	LCD_String("             ");
    	      if(!(GPIOC->IDR&GPIO_IDR_ID4 ))
    	       	 {
    	       		flag=1;
    	       		flag1=1 ;
    	       	 }
    	       	 if(flag1==1&&GPIOC->IDR&GPIO_IDR_ID4&&pauza>1&&pauza<=20 )
    	       	 {

    	       		flag=0;
    	       		 flag1=0;
    	       		pauza=0;
    	          	 min=min1;
    	          	  I2C2->CR1|=I2C_CR1_ACK;
    	        	 I2C2->CR1|= I2C_CR1_START;
    	        	  while (!(I2C2->SR1& I2C_SR1_SB)){};
    	        	 (void) I2C2->SR1;
    	        	 I2C2->DR =  0b11010000 ;
    	        	 while (!(I2C2->SR1& I2C_SR1_ADDR)){};
    	        	  (void) I2C2->SR1;
    	              (void) I2C2->SR2;
    	        	    I2C2->DR= 0x01  ;
    	        	  while (!(I2C2->SR1 & I2C_SR1_TXE)){};
    	        	  	I2C2->DR=RTC_ConvertFromBinDec(min);
    	        	  while (!(I2C2->SR1 & I2C_SR1_TXE)){};
    	        	  I2C2->CR1|= I2C_CR1_STOP;

    	       	 }
        }
       if(menu==4)
        {

    	   sprintf(buf5,"hour1=%2d %2d     ",hour1,hour);

    	      	     	   LCD_SetPos(0,0);
    	      	     	   LCD_String(buf5);

    	       	     	 LCD_SetPos(0,1);

    	       	     	LCD_String("             ");
    	      	     	  if(!(GPIOC->IDR&GPIO_IDR_ID4 ))
    	      	     	 {
    	      	     	    	       		flag=1;
    	      	     	    	       	flag1=1;

    	      	     	  }
    	        if(flag1==1&&GPIOC->IDR&GPIO_IDR_ID4&&pauza>1&&pauza<=20  )
    	       	 {
    	        	flag=0;
    	       		 flag1=0;
    	       		pauza=0;
                            hour=hour1;

                            I2C2->CR1|=I2C_CR1_ACK;

                          I2C2->CR1|= I2C_CR1_START;
                         while (!(I2C2->SR1& I2C_SR1_SB)){};
                             (void) I2C2->SR1;
                          I2C2->DR =  0b11010000 ;
                        while (!(I2C2->SR1& I2C_SR1_ADDR)){};
                          (void) I2C2->SR1;
                          (void) I2C2->SR2;
                          I2C2->DR= 0x02  ;
                         while (!(I2C2->SR1 & I2C_SR1_TXE)){};

                         I2C2->DR=RTC_ConvertFromBinDec(hour);
                         while (!(I2C2->SR1 & I2C_SR1_TXE)){};
                       I2C2->CR1|= I2C_CR1_STOP;
    	       	 }
        }
       if(menu==5)
       {
    	   sprintf(buf6,"day1=%d   %d      ",day1,day);
    	   LCD_SetPos(0,0);
    	   LCD_String(buf6);
    	   LCD_SetPos(0,1);
    	   LCD_String("             ");
	     	  if(!(GPIOC->IDR&GPIO_IDR_ID4 ))
	     	 {
	     	    	         flag=1;
	     	    	       	 flag1=1;
	     	  }
          if(flag1==1&&GPIOC->IDR&GPIO_IDR_ID4&&pauza>1&&pauza<=20  )
	      {
        	  flag=0;
		      flag1=0;
		      pauza=0;
		      day=day1;

               I2C2->CR1|=I2C_CR1_ACK;

                I2C2->CR1|= I2C_CR1_START;
               while (!(I2C2->SR1& I2C_SR1_SB)){};
                (void) I2C2->SR1;
               I2C2->DR =  0b11010000 ;
               while (!(I2C2->SR1& I2C_SR1_ADDR)){};
                (void) I2C2->SR1;
                (void) I2C2->SR2;
                I2C2->DR= 0x03  ;
               while (!(I2C2->SR1 & I2C_SR1_TXE)){};

               I2C2->DR=RTC_ConvertFromBinDec(day);
               while (!(I2C2->SR1 & I2C_SR1_TXE)){};
              I2C2->CR1|= I2C_CR1_STOP;
	        }
       }
      if(menu==6)
       {
   	     sprintf(buf7,"date1=%2d   %2d      ",date1,date);
   	     LCD_SetPos(0,0);
   	     LCD_String(buf7);
   	     LCD_SetPos(0,1);
   	     LCD_String("             ");
	     	  if(!(GPIOC->IDR&GPIO_IDR_ID4 ))
	     	 {
	     		 flag=1;
	     	     flag1=1;

	     	  }
           if(flag1==1&&GPIOC->IDR&GPIO_IDR_ID4&&pauza>1&&pauza<=20  )
	       {
        	   flag=0;
		       flag1=0;
		       pauza=0;
		      date =date1;

              I2C2->CR1|=I2C_CR1_ACK;

               I2C2->CR1|= I2C_CR1_START;
                while (!(I2C2->SR1& I2C_SR1_SB)){};
              (void) I2C2->SR1;
              I2C2->DR =  0b11010000 ;
               while (!(I2C2->SR1& I2C_SR1_ADDR)){};
              (void) I2C2->SR1;
              (void) I2C2->SR2;
              I2C2->DR= 0x04  ;
               while (!(I2C2->SR1 & I2C_SR1_TXE)){};

               I2C2->DR=RTC_ConvertFromBinDec(date);
               while (!(I2C2->SR1 & I2C_SR1_TXE)){};
                I2C2->CR1|= I2C_CR1_STOP;
	        }
      }
      if(menu==7)
      {
   	     sprintf(buf8,"month1=%2d  %2d      ",month1,month);
   	     LCD_SetPos(0,0);
   	     LCD_String(buf8);
   	     LCD_SetPos(0,1);
   	     LCD_String("             ");
    	  if(!(GPIOC->IDR&GPIO_IDR_ID4 ))
    	 {
    	    	       		flag=1;
    	    	       		flag1=1;
    	  }
          if(flag1==1&&GPIOC->IDR&GPIO_IDR_ID4&&pauza>1&&pauza<=20  )
          {
        	flag=0;
	        flag1=0;
	        pauza=0;
	        month=month1;

            I2C2->CR1|=I2C_CR1_ACK;

            I2C2->CR1|= I2C_CR1_START;
            while (!(I2C2->SR1& I2C_SR1_SB)){};
             (void) I2C2->SR1;
             I2C2->DR =  0b11010000 ;
             while (!(I2C2->SR1& I2C_SR1_ADDR)){};
            (void) I2C2->SR1;
            (void) I2C2->SR2;
            I2C2->DR= 0x05  ;
            while (!(I2C2->SR1 & I2C_SR1_TXE)){};

             I2C2->DR=RTC_ConvertFromBinDec(month);
              while (!(I2C2->SR1 & I2C_SR1_TXE)){};
              I2C2->CR1|= I2C_CR1_STOP;
        }
      }
      if(menu==8)
      {
   	     sprintf(buf9,"year1=20%02d,20%02d      ",year1,year);
   	     LCD_SetPos(0,0);
   	     LCD_String(buf9);
   	     LCD_SetPos(0,1);
   	     LCD_String("             ");
 	    if(!(GPIOC->IDR&GPIO_IDR_ID4 ))
 	    {
 	    	       		flag=1;
 	    	       	flag1=1;

 	     }
          if(flag1==1&&GPIOC->IDR&GPIO_IDR_ID4&&pauza>1&&pauza<=20  )
          {
        	  flag=0;
	          flag1=0;
	          pauza=0;
	          year =year1;

            I2C2->CR1|=I2C_CR1_ACK;

             I2C2->CR1|= I2C_CR1_START;
            while (!(I2C2->SR1& I2C_SR1_SB)){};
            (void) I2C2->SR1;
              I2C2->DR =  0b11010000 ;
              while (!(I2C2->SR1& I2C_SR1_ADDR)){};
             (void) I2C2->SR1;
             (void) I2C2->SR2;
             I2C2->DR= 0x06  ;
              while (!(I2C2->SR1 & I2C_SR1_TXE)){};

              I2C2->DR=RTC_ConvertFromBinDec(year);
              while (!(I2C2->SR1 & I2C_SR1_TXE)){};
              I2C2->CR1|= I2C_CR1_STOP;
         }
      }
      if(menu==9)
      {

      }
      if(menu==10)
      {
    	  menu=0;
      }
	}
}
