Кто любит RISC в жизни, заходим, не стесняемся.
Ответить

stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 09:13:38

решил я настраивать параметры a b и выводить на экран.В atolic truestudio всё получалось.А тут загвоздка.Прописываю инкремент в плюсах .При нажатии кнопки у нас a++.А при нажатии другой кнопки в минусах.Вписую один инкремент в обработчики кнопки всё хорошо.Вписую другой в обработчик другой кнопки .И тут глюк.Значения сами идут в минусах.Всегда можно было настроить.А тут ?.Кто может поделиться.Я то решу вопрос.Но это дело времени.Почему в atolic truestodio и microchip studio так а здесь в обновлении 1.8 так

Добавлено after 1 minute 13 seconds:
И как можно решить данную проблему?

Добавлено after 58 minutes 34 seconds:
Ау где вы профи?

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 09:28:42

Традиционно, код в студию. Потому что по описанию ничего не понятно.

Как работают обработчики?
Как часто вызываются?
Какой размер переменной?
Триггеры при изменений значения переменной?

ИМХО, успешно использую у себя код подобного вида:
Код:
int main(void) {
<...> (init)
while (1) {
 SLEEP(); // Засыпаем до аппаратного прерывания SYSTICK'а и просыпаемся каждую милисекунду
 ScanButtons();
 <...>
};
};

void ScanButtons(void) {
 if (GPIOx->IDR & PINx) {
  // Отпущена, висит в воздухе, подтяжка к VCC
  if (ButtonFilter[ButtonNumber]) {
    ButtonFilter[ButtonNumber] = 0;
  };
 } else {
 // Нажата (притянуто к 0)
  if (ButtonFilter[ButtonNumber] == 50) {
    ButtonFilter[ButtonNumber] = 51;
    OnPress(ButtonNumber);
  } else if (ButtonFilter[ButtonNumber] < 50) {
   ButtonFilter[ButtonNumber]++;
  };
 };
};


Позволяет избежать дребезга (так как любая потеря контакта сбрасывает значение фальтра в 0), хотя срабатывание при изношеной кнопке может быть нестабильным.
После обработки нажатия и до отпускания кнопки переменная-фильтр не изменяется.

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 10:58:12

Код:

Рабочий проект в другой среде.

Добавлено after 5 minutes 13 seconds:
Код:

Тут это не работает .А как работает.Нажимаю кнопку ++.Нажимаю другую кнопку - -.

Добавлено after 22 minutes 48 seconds:
Правда я это делал на stm32f103
Вложения
main.c
(11.76 KiB) Скачиваний: 149
main.c
(24.01 KiB) Скачиваний: 149

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 17:34:27

ivan dimir писал(а):
Код:

Рабочий проект в другой среде.
ivan dimir писал(а):
Код:

Тут это не работает.
Как может работать отсутствующий код?

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 19:41:13

[code][/code]
/*
* main.c
*
* Created on: 10 ����. 2019 �.
* Author: Ivan
*/
#include"main.h"
#include<stdio.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
#define PLL_M 4
#define PLL_N 168

#define PLL_P 2
//#define PLL_Q 7
//volatile uint16_t delay_counter = 0; // @suppress("Unused variable declaration in file scope") // @suppress("Unused variable declaration in file scope")
volatile unsigned int pauza=0,pauza_z=0,pauza1=0,a,b;
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];
char buf13[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,flag8=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;
// pauza++;
IWDG->KR = 0xAAAA;
if(flag4==1)
{
pauza++;
}

if(pauza>10)
{
//GPIOD->BSRR |= GPIO_BSRR_BS1;
GPIOC-> BSRR |=GPIO_BSRR_BS13;
}
if(pauza>20)
{

GPIOC-> BSRR |=GPIO_BSRR_BR13;
// GPIOD->BSRR |= GPIO_BSRR_BR1;
pauza=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;



}
}
//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 |= PLL_M>>RCC_PLLCFGR_PLLM_Pos |PLL_N << RCC_PLLCFGR_PLLN_Pos|PLL_P>>RCC_PLLCFGR_PLLP_Pos |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->PUPDR &=~ GPIO_PUPDR_PUPDR9_1;
// GPIOA->PUPDR |= GPIO_PUPDR_PUPDR9_0;
//GPIOA->PUPDR &=~ GPIO_PUPDR_PUPDR10_1;
// GPIOA->PUPDR |= GPIO_PUPDR_PUPDR10_0;
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;
//WRITE_REG(USART1->BRR, ((0x27)<<4)|0x01);
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;

GPIOC->MODER &=~ GPIO_MODER_MODER5;
GPIOC->PUPDR &=~GPIO_PUPDR_PUPDR5_1;
GPIOC->PUPDR |= GPIO_PUPDR_PUPDR5_0;

GPIOC->MODER &=~ GPIO_MODER_MODER6;
GPIOC->PUPDR &=~GPIO_PUPDR_PUPDR6_1;
GPIOC->PUPDR |= GPIO_PUPDR_PUPDR6_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_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();
init_IWDGtimer();
// 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)
{
if(!(GPIOC->IDR&GPIO_IDR_ID3 ))
{
delay_ms(10);
// pauza++; // 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>2)
{
delay_ms(10);
flag4=0;
//flag=0;

//pauza=0;

menu++;
menu_en++;
// pauza=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((GPIOC->IDR&GPIO_IDR_ID5)==0)
{
a++;
delay_ms(10);

}
if((GPIOC->IDR&GPIO_IDR_ID6)==0)
{
a--;
delay_ms(10);
}
}
if(menu_en==10)
{
menu_en=0;
}
if(menu==0)
{


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(' ');
//USART_TX((uint16_t),"MAMA");
//sprint(buf10,"text");
USART_TX((uint8_t*)"Mama",13);
//tx_str1(buf10);
//USART_TX ("MAMA");
// tx_uart1(0xF0);
}
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)
{

//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= 0x00 ;
while (!(I2C2->SR1 & I2C_SR1_TXE)){};
I2C2->DR=RTC_ConvertFromBinDec(sec=0);
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 )
{
//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 )
{
//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 )
{
// 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 )
{
//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 )
{
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)
{
sprintf(buf10,"a=%2d ",a);
LCD_SetPos(0,0);
LCD_String(buf10);
LCD_SetPos(0,1);
LCD_String(" ");
}
if(menu==10)
{
menu=0;
}
//IWDG->KR = 0xAAAA;
}
}

Добавлено after 5 minutes 7 seconds:
Я глобоко извиняюсь но это рабочий код.Дело в проекте том. Здесь всё работает.Правда контроллер другой stm32 f407vet.А там был stm32f103c8t

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 20:57:32

И где эти инкременты?

А вот это может не работать:
Код:
void DelayMicro(__IO uint32_t micros)
{
micros *=(SystemCoreClock / 1000000) / 9;
while (micros--);
}

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 22:37:56

ivan dimir, суд присяжных оправдал его! :)
p.s. "Драма" Чехов.

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 23:13:59

f(menu_en==9)
{
if((GPIOC->IDR&GPIO_IDR_ID5)==0)
{
a++;
delay_ms(10);

}
if((GPIOC->IDR&GPIO_IDR_ID6)==0)
{
a--;
delay_ms(10);
}
}

Re: stm32 cubeide два инкремента не совместимы.

Вс янв 16, 2022 23:54:34

ivan dimir,
//if((GPIOA->IDR&GPIO_IDR_IDR5)==0)
Так будет лучше!

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 06:09:40

ivan dimir,
//if((GPIOA->IDR&GPIO_IDR_IDR5)==0)
Так будет лучше!

это другой контроллер

Добавлено after 15 minutes 41 second:
ivan dimir,
//if((GPIOA->IDR&GPIO_IDR_IDR5)==0)
Так будет лучше!

Так выдаёт ошибку компилятор.
Может не так .А вот так
//if((GPIOA->IDR&GPIO_IDR_IDR_5)==0)

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 06:55:00

Немного "почистил" и привёл в порядок отступы "нерабочего" кода на stm32f103.


Всё же, я бы сделал иначе обработку нажатий. В таком варианте возможны множественные срабатывания кнопок, поскольку ожидания отпускания кнопки нет, но есть опрос их в бесконечном цикле и постоянные перерисовки меню на экране.
Не удивлён, что код работает, по меньшей мере странно.

Переменная (a) (именно в скобках) не инициализируется явным образом, хотя объявлена как volatile.
Задержки в главном цикле используются только после опроса состояния кнопок.
Судя по рабочей частоте кристалла в 72МГц (#define SYSCLOCK 72000000U), что можно узнать только из файла system_stm32f103xx.c, циклы могут проходить крайне быстро.

Процедура задержки... странная, ну да ладно.

Вы не поверите, но на f103 имеется встроенный блок отладки, который может считать микросекундные интервалы достаточно точно.

Приблизительно так:

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 07:15:08

[code][/code]
void TIM2_IRQHandler (void)
{
if(TIM2->SR & TIM_SR_UIF)
{
TIM2->SR &= ~ TIM_SR_UIF;
// pauza++;
IWDG->KR = 0xAAAA;

pauza++;
if(menu_en==9)
{
if(!(GPIOC->IDR&GPIO_IDR_IDR_5))
{
if (pauza>5)
{
pauza=0;
TIM2->CNT=0;
if ( a==1023)
{
a=0;
}
a++;
}

// delay_ms(2);

}
if(!(GPIOC->IDR&GPIO_IDR_IDR_6))
{
if (pauza>5)
{
pauza=0;
TIM2->CNT=0;
if (a==0)
{
a=1023;
}
a--;
}



// delay_ms(2);
}
}

if(pauza>10)
{
//GPIOD->BSRR |= GPIO_BSRR_BS1;
GPIOC-> BSRR |=GPIO_BSRR_BS13;
}
if(pauza>20)
{

GPIOC-> BSRR |=GPIO_BSRR_BR13;
// GPIOD->BSRR |= GPIO_BSRR_BR1;
pauza=0;
}






}
}
Вот так лучше работает.Небольшой опыт avr мне позволил написать эту програмку.

Добавлено after 6 minutes 20 seconds:
Да насчёт переключения каналов вы правы.Иногда зависает.А можно ли использовать в качестве задержки обычный таймер а не системный.А вот настройка в прерывании по мне лучший вариант..Может я не прав.?

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 07:24:15

В грамотной программе сочетания "delay" быть не должно. Впрочем, о чём я? ivan dimir не знает ключевое слово "volatile", а мы ему тут про дебезг и задержки.
Вот это понравилось:
Код:
while (!(I2C2->SR1& I2C_SR1_RXNE)){};

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 08:14:17

В грамотной программе сочетания "delay" быть не должно. Впрочем, о чём я? ivan dimir не знает ключевое слово "volatile", а мы ему тут про дебезг и задержки.
Вот это понравилось:
Код:
while (!(I2C2->SR1& I2C_SR1_RXNE)){};

Я использовал переключение каналов.Может не корректно.Но работает лучше чем чем в прерывании по таймеру.Не знаю почему. "volatile"-это маленький кличь который позволит переменной выполнять работу в основном цикле и в прерывании.Дребезг контактов можно выполнить прграммно а также аппаратно.Включив ёмкость 0.1 мкф между пином и землёй.Вы спецы лучше знаете как программно.

Добавлено after 3 minutes 45 seconds:
Код:

while (!(I2C2->SR1& I2C_SR1_RXNE)){};
А что вас смущет?.Это просто полигон часы.

Добавлено after 5 minutes 41 second:
Если я неправильно прописываю.То это другое дело.Это я на вашем и другом форуме присмотрнл.По поводу делей полностью с вами согласен.При прочтении числа двухбайтного я его убрал.При отжатти кнопки тоже.

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 12:49:49

"volatile"-это маленький кличь который позволит переменной выполнять работу в основном цикле и в прерывании.

volatile - это квалификатор переменной, который запрещает компилятору проводить оптимизации по переменной и КАЖДЫЙ раз читать её значение, поскольку переменная может измениться [неожиданно].

Для компилятора:
Код:
Y = 0;
X = 1;
if (X == 1) {
 Y = 1;
};

Код будет сокращён (при уровне оптимизации отличному от -O0) до:
Код:
X = 1;
Y = 1;

А в случае volatile переменной все строки будут транслированы.

Собственно, все переменные в __IO области (все адреса периферийных блоков контроллера) помечены как volatile.

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 12:58:34

ivan dimir писал(а):while (!(I2C2->SR1& I2C_SR1_RXNE)){};
А что вас смущет?.Это просто полигон часы.

А кто тебе сказал, что это условие ВСЕГДА выполняется? И что будет с твоей программой, когда оно не_выполнится, представляешь?

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 13:09:44

наверное подвисать так это после цыкла.А как правильно?

Добавлено after 2 minutes 6 seconds:
А по поводу volatile я точной инфы не имею.А в нете куча мусора.

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 13:20:43

ivan dimir писал(а):while (!(I2C2->SR1& I2C_SR1_RXNE)){};
А что вас смущет?.Это просто полигон часы.

А кто тебе сказал, что это условие ВСЕГДА выполняется? И что будет с твоей программой, когда оно не_выполнится, представляешь?


Пока условие не выполняется - процессор молотит бесконечный цикл внутри фигурных скобок. Проще говоря, делает ничего и повторно проверяет условие. Распространённый вариант ленивого ожидания установки флага.
Хотя если флаг таки не выставится - то процессор и не выйдет из цикла и программа зависнет.

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 13:22:53

"volatile"-это маленький кличь который позволит переменной выполнять работу в основном цикле и в прерывании.

volatile - это квалификатор переменной, который запрещает компилятору проводить оптимизации по переменной и КАЖДЫЙ раз читать её значение, поскольку переменная может измениться [неожиданно].

Для компилятора:
Код:
Y = 0;
X = 1;
if (X == 1) {
 Y = 1;
};

Код будет сокращён (при уровне оптимизации отличному от -O0) до:
Код:
X = 1;
Y = 1;

А в случае volatile переменной все строки будут транслированы.

Собственно, все переменные в __IO области (все адреса периферийных блоков контроллера) помечены как volatile.

Ну а если флаги и тики находятся в прерывании.И в основном цикле.Писать volatile не нужно.А программа ка будет работать?

Re: stm32 cubeide два инкремента не совместимы.

Пн янв 17, 2022 13:31:43

Если переменная изменяется в прерывании - нужно. Иначе компилятор оптимизирует её проверку.

Рекомендую неспешно прочитать вот эту страницу.
То есть volatile - это указание всегда проверять переменную. Цитата:
Оно говорит компилятору, что значение переменной может быть изменено в любой момент времени - без каких-либо видимых для компилятора действий кода, окружающего переменную.

Ключевая часть здесь - "Для компилятора".

Потому как "Я положил на стол бутерброд, затем отошёл от стола, развернулся, повернулся обратно, взял бутерброд и с удосольствием его укусил".
Только вот когда "я отвернулся" - по столу пробежал кот, смахнул бутерброд со стола, а на его место уронил чашку. Например.
И что будет с пользователем, укусившим чашку?

Компиляторы оптимизируют код для последовательного выполнения, старательно игнорируя наличие прерываний, а так же многопоточность на уровне кода. Даже когда вы указываете им, что код может исполняться в разных потоках, на разных ядрах, они всё равно будут стараться делать его линейным. И из-за этого, играя с указателями, можно наступить на кучу граблей.
Ответить