arkhnchul@arkhost-scow:/tmp$ cat tst1.c
#define CNT 10

typedef struct{
   char      about_a[CNT];
   char      about_f[CNT];
   char      about_d[CNT];
   char      about_i[CNT];
   char      about_t[CNT];
} n_t;

typedef struct{
   int      x;
   n_t      y;
}my_t;

my_t var = {
   .x = 12,
   .y = {"1"}
};

int main(){
    return 0;
}
arkhnchul@arkhost-scow:/tmp$ avr-gcc -Wall -Wmissing-braces -c -S tst1.c
arkhnchul@arkhost-scow:/tmp$ avr-gcc --version
avr-gcc (GCC) 5.4.0
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <math.h>

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "LCD.h"
#define ds18b20_DDR  DDRB
#define ds18b20_PORT PORTB
#define ds18b20_PIN  PINB
#define DQ  1
#define BIT_PORT PORTB
#define BIT_DDR  DDRB
#define BIT_PIN  PINB
#define BIT_ANALISATOR 0

#define SEARCH_ROM            0xF0 // ПОИСК РОМ
#define READ1_ROM             0x33 //ЧТЕНИЕ РОМ ПРИ ОДНОМ ДАТЧИКЕ НА ШИНЕ
#define MATCH_ROM             0x55 // СООТВЕТСТВИЕ РОМ
#define SKIP_ROM              0xCC // ПРОПУСК РОМ
#define ALARM_SEARCH_ROM      0xEC //ПОИСК ТРЕВОГ

#define CONVERT_TEMPERATUR    0x44 //КОНВЕРТРВАНИЕ ТЕМПЕРАТУРЫ
#define WRITE_ROM             0x4E //ЗАПИСЬ В ПАМЯТЬ ТРИ БАЙТА

#define READ_MEMORY              0xBE //ЧТЕНИЕ ПАМЯТИ
#define COPY_ROM              0x48 //КОПИРОВАНИЕ ДАНЫХ  ИЗ РОМ В ПЗУ
#define BUS_HIGT              ds18b20_DDR&=~(1<<DQ);
#define BUS_LOW               ds18b20_DDR|=1<<DQ;
#define resolution            0.0625



 
uint8_t bit=0x00;
uint64_t ID_ds18b20=0;
char DATA_ROM_string1[16]={0};
uint8_t DATA_REGISTR = 0;
uint8_t i = 0;
uint64_t MEMORY_ds18b20;
uint8_t CRC_calculate;
int16_t temperatura=0;

void print (char *data)
{
   write_command(clear_display);
   write_command(0x80);
   
   for(uint8_t x=0; data[x]!=&#39;\0&#39;;x++)
   {
      write_data(data[x]);
   }
   _delay_ms(100);
}

void convert_data(uint8_t massiv)                                 
{
   
sprintf(DATA_ROM_string1, "%x", massiv);
print(DATA_ROM_string1);

}

uint64_t read_bit(void)                                         
{
   
   bit=0x00;
   
   BUS_LOW;
   _delay_us(3);
   BUS_HIGT;
   _delay_us(15);
   
   if(ds18b20_PIN&(1<<DQ))
    bit=0x01;
   _delay_us(60);
   
   return bit;
}   

void ds18b20_init(void)
{
   ds18b20_PORT&=~(1<<DQ);
   BUS_LOW;
   _delay_us(480);
   BUS_HIGT;
   _delay_us(35);
   
   if((ds18b20_PIN&(1<<1))==0)
   {
      
      _delay_us(480);
   }
   else
   {
      _delay_us(480);
   }
}

void write_ds18b20(uint8_t data)
{
   ds18b20_PORT&=~(1<<DQ);
   
   for (uint8_t i=0;i<=7;i++)
   {
      
      BUS_HIGT;
      _delay_us(15);
      
      if(data&(1<<i))
      {
         BUS_LOW;
         _delay_us(5);//////
         BUS_HIGT;
      }
      else
      {
         BUS_LOW;
        _delay_us(5);
      }
        _delay_us(50);
   }
   
   BUS_HIGT;
      _delay_us(15);
}

int reverse_CRC(uint8_t data_CRC)
{
   uint8_t buff = data_CRC;
   uint8_t CRC = 0;
   

   for (uint8_t i = 7; i >= 0; i--)
   {
      CRC|=((buff>>i) & 0x01)<<(7-i);
   }

   return CRC;
}

int calculation_CRC8 (uint64_t seen_CRC1,uint8_t cvanto_byt) // вычисление CRC ID
{
   uint64_t seen_CRC=seen_CRC1;
   
   int DATA_REGISTR = 0;
   
   uint8_t i = 0; // количество обработанных бит
   
   while (i<=((8*cvanto_byt)+7))
   {
      if (DATA_REGISTR&(0x01 << 7))
      {
         
         DATA_REGISTR <<= 0x01;
         DATA_REGISTR |=(seen_CRC&(1ULL<<i))>>i;
         DATA_REGISTR ^= 0x131;
      }
      else
      {
         DATA_REGISTR <<= 0x01;
         DATA_REGISTR |=(seen_CRC&(1ULL<<i))>>i;
      }
      i++;
   }
   
   return DATA_REGISTR;
}

int READ_MEMORY_ds18b20 (void)
{
   MEMORY_ds18b20=0;
   uint8_t CRC_MEMORY=0;
   
   ds18b20_init();
   write_ds18b20(SKIP_ROM);
   write_ds18b20(READ_MEMORY);
   BUS_HIGT;
   _delay_us(15);

   for(int i=0;i<=63;i++)
   {
      MEMORY_ds18b20|=(read_bit()<<i); // считываем побитово ID датчика
   }
   
   for(int i=0;i<=7;i++)
   {
      CRC_MEMORY|=(read_bit()<<i); // считываем побитово ID датчика
   }
   
   int CRC_calculate=calculation_CRC8 (MEMORY_ds18b20,8);
   
   if( reverse_CRC(CRC_calculate)==CRC_MEMORY)
   {
      for(uint8_t i=0;i<=15;i++)
      temperatura|=MEMORY_ds18b20&(1<<i);
   }
   int TEMP=(temperatura/16.0)*10;
   char data_temperatura[5]={0};
   sprintf(data_temperatura,"%d.%d",TEMP/10,TEMP%10);
   print(data_temperatura);
   return 0;
}
 
void WRITE_MEMORY_CONFIG_byte (void)
{
   
   ds18b20_init();
   write_ds18b20(SKIP_ROM);
   write_ds18b20(WRITE_ROM);
    write_ds18b20(0x4b); // Th=45 градусам
    write_ds18b20(0x46); // Tl=45 градусам
    write_ds18b20(0x7F); // 10 bit градусам
   write_ds18b20(COPY_ROM);

}
 
void conversion_temperature(void)
 {
   
     ds18b20_init();
     write_ds18b20(SKIP_ROM);
     write_ds18b20(CONVERT_TEMPERATUR);
     while(!(ds18b20_PIN&(1<<DQ))) { }
   
}
 
void read_ID (void)// чтение ID ds18b20
{
   
    uint8_t CRC_ID=0;
   ds18b20_init();
   write_ds18b20(READ1_ROM);
   BUS_HIGT;
   _delay_us(15);

   for(uint8_t i=0;i<=55;i++)
   {
    ID_ds18b20|=(read_bit()<<i); // считываем побитово ID датчика
   }
   
   for(uint8_t i=0;i<=7;i++)
   {
    CRC_ID|=(read_bit()<<i); // считываем побитово ID датчика
   }
   
     calculation_CRC8 (ID_ds18b20,7);

}
 
 
int main(void)
{
   LCD_init();
   WRITE_MEMORY_CONFIG_byte();
   //read_ID();
while(1)
{
   
conversion_temperature();
READ_MEMORY_ds18b20();
   
}

}