/*
 * This example demonstrates using timers to capture input
 * signal
 */
#include <stdio.h>
#include "stm32f0xx_ll_rcc.h"
#include "stm32f0xx_ll_system.h"
#include "stm32f0xx_ll_bus.h"
#include "stm32f0xx_ll_gpio.h"
#include "stm32f0xx_ll_tim.h"

//RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;

#define PORT GPIOC

//RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
//GPIOC->CRL &= ~GPIO_CRL_MODE7;
/*GPIOC->CRL &= ~GPIO_CRL_CNF7;
GPIOC->CRL |= GPIO_CRL_MODE7_1;
GPIOC->CRL |= GPIO_CRL_CNF7_0;*/
//GPIOC->ODR |= 1<<7;
/**
  * System Clock Configuration
  * The system Clock is configured as follow :
  *    System Clock source            = PLL (HSI/2)
  *    SYSCLK(Hz)                     = 48000000
  *    HCLK(Hz)                       = 48000000
  *    AHB Prescaler                  = 1
  *    APB1 Prescaler                 = 1
  *    HSI Frequency(Hz)              = 8000000
  *    PLLMUL                         = 12
  *    Flash Latency(WS)              = 1
  */
static void rcc_config()
{
    /* Set FLASH latency */
    LL_FLASH_SetLatency(LL_FLASH_LATENCY_1);

    /* Enable HSI and wait for activation*/
    LL_RCC_HSI_Enable();
    while (LL_RCC_HSI_IsReady() != 1);

    /* Main PLL configuration and activation */
    LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_HSI_DIV_2,
                                LL_RCC_PLL_MUL_12);

    LL_RCC_PLL_Enable();
    while (LL_RCC_PLL_IsReady() != 1);

    /* Sysclk activation on the main PLL */
    LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
    LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_PLL);
    while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_PLL);

    /* Set APB1 prescaler */
    LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);

    /* Update CMSIS variable (which can be updated also
     * through SystemCoreClockUpdate function) */
    SystemCoreClock = 48000000;
}

/*
 * Clock on GPIOC and set two led pins
 */
static void gpio_config(void)
{
    LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOC);
	LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_8, LL_GPIO_MODE_OUTPUT);
        LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_9, LL_GPIO_MODE_OUTPUT);
	LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_12, LL_GPIO_MODE_OUTPUT);
	LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_11, LL_GPIO_MODE_OUTPUT);
	LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_7, LL_GPIO_MODE_INPUT);
	//LL_GPIO_SetPinPull(GPIOB, LL_GPIO_PIN_7, LL_GPIO_PULL_UP);
    return;
}

static void timers_config(void)
{
	RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
	RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;
	TIM2->PSC = 8000-1;
	TIM2->CR1 = TIM_CR1_OPM;
	TIM3->PSC = 8-1;
	TIM3->ARR = 1000;
	TIM3->CR1 = TIM_CR1_CEN;
}

/*static void port_config(void)
{
	RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
	GPIOB->CRH &= ~GPIO_CRH_MODE7;
	GPIOB->CRH &= ~GPIO_CRL_CNF7;
	GPIOB->CRH |= GPIO_CRL_MODE7_1;
	GPIOB->CRH |= GPIO_CRL_CNF7_0;
	GPIOB->ODR |= 1<<7;
}*/

/*static void timers_config(void)
{
    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM3);
    LL_TIM_SetPrescaler(TIM3, 47999);
    LL_TIM_SetAutoReload(TIM3, 999);
    LL_TIM_SetCounterMode(TIM3, LL_TIM_COUNTERMODE_UP);
    LL_TIM_EnableIT_UPDATE(TIM3);
    LL_TIM_EnableCounter(TIM3);
    NVIC_EnableIRQ(TIM3_IRQn);
    NVIC_SetPriority(TIM3_IRQn, 0);
    return;
}*/

void TIM2_IRQHandler(void)
{
    LL_GPIO_TogglePin(GPIOC, LL_GPIO_PIN_8);
    LL_TIM_ClearFlag_UPDATE(TIM3);
}

uint8_t ds_reset_pulse(uint16_t PinMask)
{
	uint16_t result;
	//if((GPIOC->IDR & PinMask)==0) return 2; //проверить линию на отсутствие замыкания
	PORT->ODR &= ~PinMask; //потянуть шину к земле
	TIM3->CNT=0;
	while(TIM3->CNT<480){}; //ждать 480 микросекунд
	PORT->ODR |= PinMask; //отпустить шину
	while(TIM3->CNT<550){}; //ждать 70 микросекунд
	result = PORT->IDR & PinMask; //прочитать шину
	while(TIM3->CNT<960){}; //дождаться окончания инициализации
	if(result) return 1; //датчик не обнаружен
	return 0; //датчик обнаружен
}

void ds_write_bit(uint8_t bit,uint16_t PinMask)
{
	TIM3->CNT=0;
	PORT->ODR &= ~PinMask; //потянуть шину к земле
	while(TIM3->CNT<2){}; //ждать 1 микросекунду
	if(bit) PORT->ODR |= PinMask; //если передаем 1, то отпускаем шину
	while(TIM3->CNT<60){}; //задержка 60 микросекунд
	PORT->ODR |= PinMask; //отпускаем шину
}

void ds_write_byte(uint8_t byte, uint16_t PinMask)
{
	uint8_t i;
	for(i=0;i<8;i++) ds_write_bit(byte&(1<<i), PinMask);
}

uint16_t ds_read_bit(uint16_t PinMask)
{
	uint16_t result;
	TIM3->CNT=0;
	PORT->ODR &= ~PinMask; //потянуть шину к земле
	while(TIM3->CNT<2){};
	PORT->ODR |= PinMask; //отпускаем шину
	while(TIM3->CNT<15){}; //задержка 15 микросекунд
	result = PORT->IDR & PinMask; //прочитать шину
	while(TIM3->CNT<60){}; //оставшееся время
	return result; //возвратить результат
}

uint8_t ds_read_byte(uint16_t PinMask)
{
	uint8_t i,result = 0;
	for(i=0;i<8;i++)
	if(ds_read_bit(PinMask)) result |= 1<<i;
	return result;
}

uint8_t ds_start_convert_single(uint8_t PinNumb)
{
	uint8_t result;
	result = ds_reset_pulse(1<<PinNumb); //послать импульс сброса
	if(result) return result; //если ошибка - возвращаем ее код
	ds_write_byte(0xCC,1<<PinNumb); //разрешить доступ к датчику не используя адрес
	ds_write_byte(0x44,1<<PinNumb); //запустить преобразование
	return 0;
}

uint8_t ds_read_data_single(uint8_t *buff, uint8_t PinNumb)
{
	uint8_t result,i;
	result = ds_reset_pulse(1<<PinNumb); //послать импульс сброса
	if(result) return result; //если ошибка - возвращаем ее код
	ds_write_byte(0xCC,1<<PinNumb); //разрешить доступ к датчику не используя адрес
	ds_write_byte(0xBE,1<<PinNumb); //запрос 9 байт памяти
	for( i=0; i<8; i++)
	buff[i] = ds_read_byte(1<<PinNumb); //прочитать 9 байт
	return 0;
}

uint8_t ds_read_data_single2(uint8_t *buff, uint8_t PinNumb)
{
	uint8_t crc = 0;
	uint8_t data;
	uint8_t i,j;
	uint8_t tmp;

	tmp = ds_reset_pulse(1<<PinNumb); //послать импульс сброса
	if(tmp) return tmp; //если ошибка - возвращаем ее код
	ds_write_byte(0xCC,1<<PinNumb); //разрешить доступ к датчику не используя адрес

	ds_write_byte(0xBE,1<<PinNumb); //запрос 9 байт памяти

	//прочитать 8 байт и вычислить CRC
	for( i=0; i<8; i++)
	{
		data = ds_read_byte(1<<PinNumb); //прочитать очередной байт
		buff[i] = data; //сохранить его в массиве

		//вычисление CRC - обрабатываем каждый бит принятого байта
		for( j=0; j<8; j++)
		{
			tmp = (crc ^ data) & 0x01;
			if (tmp==0x01) crc = crc ^ 0x18;
			crc = (crc >> 1) & 0x7F;
			if (tmp==0x01) crc = crc | 0x80;
			data = data >> 1;
		}
	}

	data = ds_read_byte(1<<PinNumb); //прочитать CRC датчика
	if(crc==data) return 0; //если CRC совпали - значит ошибки нет
	return 3; //CRC не совпали, ошибка принятых данных
}

signed int ds_read_temperature(uint8_t PinNumb)
{
	signed int integer = 0;
	signed int frac;
	signed int result;
	uint8_t buff[8];

	//прочитать данные из датчика
	if(ds_read_data_single(&buff[0],PinNumb)) return 1280;

	frac = buff[0] & 0x0f; //получить дробную часть
	integer = (buff[0]>>4) | ((buff[1] & 0x0f)<<4); //получить целую часть

	//если температура отрицательная
	if(integer<0)
	{
		integer = 0 - integer - 1;
		result = integer; //учитываем целую часть
		frac = frac | 0xf0;
		frac = 0 - frac ;
	}
	//если температура положительная
	else result = integer; //учитываем целую часть

	result = result + (frac/16); //учитываем дробную часть

	return result;
}

static void delayt(void)
{
	TIM2->CNT = 0;
	while(TIM2->CNT < 1000){};
}

__attribute__((naked)) static void delay(void)
{
    asm ("push {r7, lr}");
    asm ("ldr r6, [pc, #8]");
    asm ("sub r6, #1");
    asm ("cmp r6, #0");
    asm ("bne delay+0x4");
    asm ("pop {r7, pc}");
    asm (".word 0x927C0"); //6000000
}

void delay_ms(uint16_t value)
{
	TIM2->ARR = value;
	TIM2->CNT = 0;
	TIM2->CR1 = TIM_CR1_CEN;
	while((TIM2->SR & TIM_SR_UIF) == 0){}
	TIM2->SR &= ~TIM_SR_UIF;
}

__attribute__((naked)) static void delay1(void)
{
    asm ("push {r7, lr}");
    asm ("ldr r6, [pc, #8]");
    asm ("sub r6, #1");
    asm ("cmp r6, #0");
    asm ("bne delay+0x4");
    asm ("pop {r7, pc}");
    asm (".word 0x5B8D80"); //6000000
}
/*
 * Configure timer to input capture mode
 */
int main(void)
{
    	rcc_config();
    	gpio_config();
	timers_config();
	//port_config();
        signed int result, i;
	uint8_t buff[9];
	signed int p = 0;
	uint8_t frac = 0, integer = 0;
	while(1)
	{
		ds_reset_pulse(1<<7);
		ds_write_byte(0xCC,1<<7);
		ds_write_byte(0x44,1<<7);
		//LL_GPIO_WriteOutputPort(GPIOC, LL_GPIO_PIN_12);
		//если поменять местами delay и включение диода, то ничего не сработает. почему?
		//LL_GPIO_WriteOutputPort(GPIOC, LL_GPIO_PIN_12);
		delay_ms(1000);
		/*ds_reset_pulse(1<<7);
		ds_write_byte(0xCC,1<<7);
		ds_write_byte(0xBE,1<<7);
		for(i=0;i<9;i++)
			buff[i] = ds_read_byte(1<<7);
		frac = buff[0] & 0x0f;
		integer = (buff[0]>>4) | ((buff[1] & 0x0f)<<4);*/
		result = ds_read_temperature(7);
		if (result < 100){
			LL_GPIO_WriteOutputPort(GPIOC, LL_GPIO_PIN_12);
		}else{
			LL_GPIO_WriteOutputPort(GPIOC, LL_GPIO_PIN_9);//оказывается больше 100, что если я работаю с набором функций, которые закомментированы, что если единой.
		}
		p++;
	}
	return 0;
}