Прочитать строку из буфера и преобразовать в int

#include <mega16a.h>
 
#include <delay.h>
 
// 1 Wire Bus interface functions
#include <1wire.h>
 
// DS1820 Temperature Sensor functions
#include <ds18b20.h>
 
//===========================//
 
//#define RXB8 1
//#define TXB8 0
//#define UPE 2
#define OVR 3
//#define FE 4
//#define UDRE 5 
//#define RXC 7   
      
 
#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)
 
// USART Receiver buffer
#define RX_BUFFER_SIZE 60
char rx_buffer[RX_BUFFER_SIZE];
 
 
#if RX_BUFFER_SIZE<256
unsigned char rx_wr_index,rx_rd_index,rx_counter;
#else
unsigned int rx_wr_index,rx_rd_index,rx_counter;
#endif
 
// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow; 
 
unsigned char buffer[17];
unsigned char Ttime[4],Ttermo[4], Tdenat[4], Tdenat_temp[4], Totg[4], Totg_temp[4], Telong[4], Telong_temp[4], end_term[4], end_term_temp[4], cukl[4] ; // массивы для данных от UART
unsigned char timer_power=20, timer_power_on=20;
 
eeprom unsigned char Ttime_eep,Ttermo_eep, Tdenat_eep, Tdenat_temp_eep, Totg_eep, Totg_temp_eep, Telong_eep, Telong_temp_eep, end_term_eep, end_term_temp_eep, cukl_eep; // массивы для данных от UART   
eeprom unsigned int Kp_eep = 200, Ki_eep = 200, Kd_eep = 200; 
 
  volatile char c[9];  
  volatile unsigned int temp_buff[9]; 
  volatile char data_rx_app[16];
    
//++++++++++++++++++++++++++++++++++++++++++++++++
 
// Функция обработчик прерывания 12 - завершение приема символа в USART
// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
char data;
 //status=UCSRA;
data=UDR;
 
   rx_buffer[rx_wr_index]=data; 
   
   if (++rx_wr_index == RX_BUFFER_SIZE) {
   rx_wr_index=0;
   }; 
   
   if (++rx_counter == RX_BUFFER_SIZE)
      {
      rx_counter=0;
      rx_buffer_overflow=1;
      };
  // }; 
      
  PORTB.0 = ~PORTB.0; 
}
 
 
//++++++++++++++++++++++++++++++++++++++++++++++++
 
// Новая Функция getchar()
 
#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index];
if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif         
 
 
 #include <stdio.h>
//++++++++++++++++++++++++++++++++++++++++++++++++
 // Alphanumeric LCD functions
#include <alcd.h>
 
 
 
// maximum number of DS1820 devices
// connected to the 1 Wire bus
#define MAX_DS1820 8
// number of DS1820 devices
// connected to the 1 Wire bus
unsigned char ds1820_devices;
// DS1820 devices ROM code storage area,
// 9 bytes are used for each device
// (see the w1_search function description in the help)
 
 
 
float Kp_,Ki_,Kd_;
 unsigned int temp0,temp1,temp2,temp;
unsigned int  set_temp, data_power; // power out 
 
      unsigned char rom_code[MAX_DS1820][9]; 
 
 bit flags_start=0;
 
 
 
 
 
#define ADC_VREF_TYPE 0x20
 
// input 
 
#define  START PINB.5
#define  RESET PINB.6
#define  ON PINB.7
#define  OPTO ADC0
 
// Output
 
#define  LED_DISP PORTD.6
#define  LAMP PORTD.2
#define  TEN PORTB.1
 
#define INTERVAL 20
 
 bit power=0, flags_button=0;
 
 
// Read the 8 most significant bits
// of the AD conversion result
unsigned char read_adc(unsigned char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCH;
}
 
void key_detect_func()
{
  if(START==0) 
  {
      flags_start=1;
  }   
  
  if(RESET==0) 
  {
      flags_start=0;
  } 
  
  if(ON==0 && flags_button==0) 
  {
        if(power) power=0; else power=1; // power on/off
    flags_button=1;
  }
 
}
 
void eep_temp_time_save()
{       
         Ttime_eep = Ttime[3];
         Ttermo_eep = Ttermo[3];
         Tdenat_eep = Tdenat[3];
         Tdenat_temp_eep = Tdenat_temp[3];
         Totg_eep = Totg[3];
         Totg_temp_eep = Totg_temp[3];  
         Telong_eep = Telong[3];
         Telong_temp_eep = Telong_temp[3];
         end_term_eep = end_term[3];
         end_term_temp_eep = end_term_temp[3];
         cukl_eep = cukl[3];
}
 
void eep_PID_save()
{       
         Kp_eep = Kp_;
         Ki_eep = Ki_;
         Kd_eep = Kd_;
                  
         Kp_ = Kp_ - 200;    // выполняем преобразование коеффициентов ПИД
         Kp_ = Kp_ / 10; 
         Ki_ = Ki_ - 200;
         Ki_ = Ki_ / 10;
         Kd_ = Kd_ - 200;
         Kd_ = Kd_ / 10; 
}
 
 
void rx_tx_func()   // функция обработки приема/передачи данных
{
   unsigned char x; 
 
   
  if(power)
  {
    if(temp0>1000) temp0=1000;
    if(temp0==0) temp0=1; 
    if(temp1>1000) temp1=1000;
    if(temp1==0) temp1=1;
    if(temp2>1000) temp2=1000;
    if(temp2==0) temp2=1;
    if(temp>1000) temp=1000;
    if(temp==0) temp=1;
    
    temp_buff[0]= (int)temp0/10;  
    temp_buff[1]= (int)temp0%10; 
    temp_buff[2]= (int)temp1/10; 
    temp_buff[3]= (int)temp1%10; 
    temp_buff[4]= (int)temp2/10; 
    temp_buff[5]= (int)temp2%10; 
    temp_buff[6]= (int)temp/10; 
    temp_buff[7]= (int)temp%10;
     
    if(read_adc(0)==0) temp_buff[8]=1;
    else   temp_buff[8]= read_adc(0);
    
    printf("T= ");     
    for(x=0; x<9; x++)
    {
     c[x] = temp_buff[x];
     printf("%c", c[x]);
    }  
    printf(" END\n\r");    
  } 
       
       printf("W \n\r");     // отправляем запрос данных
       delay_ms(450);  // ждем пока получим
       
  #asm("cli")                                    
     if(rx_buffer[0] == 'S')
     {
       printf("OK");    // 1
        x=1;  
       
       for(x=1; x<15; x++) 
       {
        data_rx_app[x] =  rx_buffer[x];  // данные  
        printf("%c", data_rx_app[x]); // отправляем на проверку, что приняли.
       }
        printf(" END\n\r"); // отправляем в терминал данные!                            
         //=======================================================//     
     }
     else if(rx_buffer[0] == 'X')  // нет данных для сохранения (ПК не хочет отправлять настройки)
     { 
        printf("OK ARTOS! \n\r");// устройство подключено к ПК и синхронизировано
     }
     else if(rx_buffer[0] == 'D')  // ответ ПК "Данные корректны!"  Температура и время циклов
     {
        printf("OK ARTOS! SETTING TEMP\n\r");// подтверждаем что приняли ответ  
        eep_temp_time_save(); // сохраняем данные 
        eep_PID_save();           
     }
     else if(rx_buffer[0] == 'O')  // включаем устройство
     {
        printf("OK ARTOS! POWER ON DEVICES \n\r");// подтверждаем что приняли ответ  
        
        if(power) power=0; else power=1;
     }
     else if(rx_buffer[0] == 'R')  // сбрасываем / анулируем работу
     {
         printf("OK ARTOS! RESET DEVICES \n\r");// подтверждаем что приняли ответ  
         
         flags_start=0;    
     }
     else if(rx_buffer[0] == 'E')  // стартуем !
     {
        printf("OK ARTOS! START DEVICES \n\r");// подтверждаем что приняли ответ  
        
         flags_start=1;
     }
     else if(rx_buffer[0] == 'A')
     {
        printf("Devices connect! \n\r");  //  устройство подключено к ПК!
     }
     else
     {
         printf("Devices disconnect! \n\r");  // ERROR устройство не подключено к ПК!
     }
                                                                               
                                    for(x=0; x<59; x++)  rx_buffer[x] = 0;  // стираем буфер и обнуляем счетчик
                                    rx_wr_index=0;
                                    #asm("sei")    
}
 
void lcd_shou_func()
{       
  // исправить температуру чтобы не более 100 градусов выдавало!
  
       sprintf(buffer, " T=%d.%d\xdfC       ",temp/10, temp % 10); // колл. этапов
       lcd_gotoxy(0,0);
       lcd_puts(buffer);  
       
       sprintf(buffer, " Td=%d\x25           ", read_adc(0)); // колл. этапов
       lcd_gotoxy(0,1);
       lcd_puts(buffer);  
                                    
       key_detect_func(); 
}
 
void shou_power_off()
{
        lcd_gotoxy(0,0);
       lcd_putsf("   \xA8\xB8\xBFa\xBDue "); 
      
       lcd_gotoxy(0,1);
       lcd_putsf("  B\xC3\xBA\xBB\xC6\xC0e\xBDo!  ");  // Питание выключено!
}
 
void shou_power_on()
{
        lcd_gotoxy(0,0);
      lcd_putsf(" 3\xE3pa\xB3c\xBF\xB3y\xA6\xBFe!  "); // здравствуйте!
      
      lcd_gotoxy(0,1);
      lcd_putsf("                ");  
}
 
void power_func()
{
 
 
   if(power)  // if power on
   {
     if(timer_power_on<11)  
     { 
       if (timer_power==0) lcd_clear();      
       
             shou_power_on();
       
       flags_start=0; // останавливаем процесс   
       timer_power_on++; 
     }    
     else 
      {
          if(flags_start==0)
          {
              if (temp<40)
              {
               TEN=1;   
               
                    lcd_gotoxy(0,0);
                  lcd_putsf("   \xA8po\xB4pe\xB3!     "); 
                  
                  lcd_gotoxy(0,1);
                  lcd_putsf("                ");            
               }
              if (temp>39) 
              {
               TEN=0;   
                   lcd_gotoxy(0,0);
                  lcd_putsf("  \xA8p\xB8\xB2op  k     "); 
                  
                  lcd_gotoxy(0,1);
                  lcd_putsf(" pa\xB2o\xBFe \xB4o\xBFo\xB3!  ");          
              }
          }
          else
          {
            lcd_shou_func();
          }
      }
      
     timer_power=0;  
     LED_DISP=1;
   }
   else   // if power off
   { 
       timer_power_on=0;
     if(timer_power<11)  
     { 
       if (timer_power==0) lcd_clear();      
       
             shou_power_off();
       
       flags_start=0; // останавливаем процесс   
       timer_power++; 
     }
     else
     {
        LED_DISP=0; 
         lcd_clear();
     }  
   }
   
          rx_tx_func();
}
 
   signed int pid_control(signed char setpoint, signed char currentpoint)
    {
        static signed int last_error;
        signed int P;
        signed int D;
        static signed int I;
        signed int PID;    
        
        Ki_=Kp_=Kd_=1.2;
        
        P = (setpoint - currentpoint);  
        if(P>341) P=341;
        if(P<0) P=0;
                
        I = (I + (setpoint - currentpoint) * INTERVAL);
        if(I>341) I=341;
        if(I<0) I=0;   
            
        D = (((setpoint - currentpoint) - last_error) / INTERVAL); 
        if(D>341) D=341;
        if(D<0) D=0;         
        
        last_error = setpoint - currentpoint;
        PID = (Kp_ * P) + (Ki_ * I) + (Kd_ * D); 
        if(PID>1023) PID=1023;
        if(PID<0) PID=0; 
        
        return (PID); 
                
    }
    
    void read_temp() 
    {
      //char data; 
     // char a;         
       #asm("cli")      
                              key_detect_func(); 
                               temp0=ds18b20_temperature(&rom_code[0][0])*10; // читаем температуру першого датчика
                              if (temp0>1000)
                                     {          //якщо перший датчик видає більше 1000 
                                           temp0=4096-temp0;//віднімаєм від данних 4096 
                                           temp0=-temp0;      //і ставим знак "мінус" 
                                     } 
                                                                         
                                 key_detect_func();    
                         
                                temp1=ds18b20_temperature(&rom_code[1][0])*10;  //читаем температуру першого датчика
                              if (temp1>1000)
                                     {          //якщо перший датчик видає більше 1000 
                                           temp1=4096 - temp1;//віднімаєм від данних 4096 
                                           temp1=-temp1;      //і ставим знак "мінус" 
                                     }
                                                                              
                                 key_detect_func(); 
                                      
                               temp2=ds18b20_temperature(&rom_code[2][0])*10; // читаем температуру першого датчика    
                               
                              if (temp2>1000)
                                     {          //якщо перший датчик видає більше 1000 
                                           temp2=40960-temp2;//віднімаєм від данних 4096 
                                           temp2=-temp2;      //і ставим знак "мінус" 
                                     }
                                     
                                     temp = (temp0 + temp1 + temp2) / 3;
           #asm("sei")
    }
 
 
// Declare your global variables here
 
void main(void)
{
// Declare your local variables here
  int i;
// Input/Output Ports initialization
// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTA=0x00;
DDRA=0x00;
 
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=Out Func0=In 
// State7=P State6=P State5=P State4=T State3=T State2=T State1=0 State0=T 
PORTB=0xE0;
DDRB=0x03;
 
// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTC=0x00;
DDRC=0x00;
 
// Port D initialization
// Func7=In Func6=Out Func5=In Func4=Out Func3=Out Func2=Out Func1=Out Func0=In 
// State7=T State6=0 State5=T State4=0 State3=0 State2=0 State1=0 State0=T 
PORTD=0x00;
DDRD=0x5E;
 
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
 
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFFFF
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
 
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped
// Mode: Normal top=0xFF
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
 
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: Off
MCUCR=0x00;
MCUCSR=0x00;
 
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;
//// USART initialization
//// Communication Parameters: 8 Data, 1 Stop, No Parity
//// USART Receiver: On
//// USART Transmitter: On
//// USART Mode: Asynchronous
//// USART Baud Rate: 9600
//UCSRA=0x00;
//UCSRB=0x18;
//UCSRC=0x86;
//UBRRH=0x00;
//UBRRL=0x33;
 
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud Rate: 9600
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x33; // 8mHz
 
//UBRRL=0x4D; // 12mHz
 
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
 
// ADC initialization
// ADC Clock frequency: 375,000 kHz
// ADC Voltage Reference: AREF pin
// ADC Auto Trigger Source: ADC Stopped
// Only the 8 most significant bits of
// the AD conversion result are used
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x85;
 
// SPI initialization
// SPI disabled
SPCR=0x00;
 
// TWI initialization
// TWI disabled
TWCR=0x00;
 
// 1 Wire Bus initialization
// 1 Wire Data port: PORTD
// 1 Wire Data bit: 7
// Note: 1 Wire port settings are specified in the
// Project|Configure|C Compiler|Libraries|1 Wire menu.
 
w1_init();
 
printf("Project 22.01.2014 \n\r autor: Artos \n\r Ugrimov Artem Alexandrovich \n\r [email]artyombooster@mail.ru[/email] \n\r TEL:+380993172885 \n\r");
 
 
ds1820_devices=w1_search(0xf0, rom_code);
delay_ms(500);
 printf("OK\n\r"); 
 delay_ms(300);  
  
     for (i=0;i<3;i++)
    {
      printf("INITIALIZING DEVICE #%-u ",i+1);
      if (ds18b20_init(&rom_code[i][0],25,35,DS18B20_12BIT_RES))
       putsf("OK"); else putsf("ERROR");
    };
 
      
// Alphanumeric LCD initialization
// Connections are specified in the
// Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu:
// RS - PORTA Bit 5
// RD - PORTA Bit 7
// EN - PORTA Bit 6
// D4 - PORTA Bit 3
// D5 - PORTA Bit 4
// D6 - PORTA Bit 2
// D7 - PORTA Bit 1
// Characters/line: 16
lcd_init(16);
 
 LED_DISP=1;
       
shou_power_on();
 
      delay_ms(1000);  
      lcd_clear();  
 
 shou_power_off();
 
      delay_ms(1000);  
      lcd_clear();
      LED_DISP=0;        
      
        #asm("sei")
while (1)
      {
            key_detect_func();         
           read_temp();  
            power_func();
            data_power = pid_control(set_temp, temp);
            
         //delay_ms(50);
      }
}