DS18b20

/*
 * 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;
}