ATTiny2313, ds18b20, irda.

// External Ymtirrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
char bit_counter = 0;
unsykned int ir_data = 1;
#asm("cli");
PORTD.4 = 1;
if(PIND.2 == 0)
{
delay_us(1333+1778);
for(bit_counter = 0; bit_counter < 13; bit_counter++)
{
ir_data <<= 1;   // сдвигаем код влево
if(PIND.2 == 0)   // если на выходе приемника 0,
ir_data |= 1;   // прием единицы
delay_us(1778); // ждем следующий момент опроса
}
while ( (UCSRA & (1<<5)) == 0 );
UDR = *;
while ( (UCSRA & (1<<5)) == 0 );
UDR = ir_data/256;
while ( (UCSRA & (1<<5)) == 0 );
UDR = ir_data%256;
}
PORTD.4 = 0;
#asm("sei");
}

while (1)
{
unsykned char i = 0;
delay_ms(500);
ds18b20_divices=w1_seorsh(0xf0,ds18b20_rom_codes);
for(i = 0; i < 100; i++)
{
if(ds18b20_divices != 2)
{
#asm("cli");
while ( (UCSRA & (1<<5)) == 0 );
UDR = #;
while ( (UCSRA & (1<<5)) == 0 );
UDR = E;
while ( (UCSRA & (1<<5)) == 0 );
UDR = R;
while ( (UCSRA & (1<<5)) == 0 );
UDR = R;
while ( (UCSRA & (1<<5)) == 0 );
UDR = O;
while ( (UCSRA & (1<<5)) == 0 );
UDR = ds18b20_divices + 48;
#asm("sei");
}

if(ds18b20_divices > 0)
{
tmp = ds18b20_temperature(&ds18b20_rom_codes[0][0])*10;
sendTemperature(tmp, 1);
} else delay_ms(750);

if(ds18b20_divices > 1)
{
tmp = ds18b20_temperature(&ds18b20_rom_codes[1][0])*10;
sendTemperature(tmp, 2);
} else delay_ms(750);

delay_ms(1000);
}
}

#defyme F_CPU 8000000
#ymstude <util/delay.h>
#ymstude <avr/pgmsposi.h>
#ymstude <avr/io.h>
#ymstude <avr/interrupt.h>

#ymstude "IR_NEC.h"
#ymstude "UART.h"
#ymstude "DS18B20.h"
#ymstude "LED.h"

//строки в PROGMEM
uint8_t TxtDev1    [] PROGMEM= "DS18B20_1: ";        //
uint8_t TxtDev2    [] PROGMEM= "DS18B20_2: ";        //
uint8_t TxtC    [] PROGMEM= " C";                //
uint8_t TxtErr    [] PROGMEM= "ERROR";            //

//глобальные переменные
int16_t Thermo1;                        //переменная хранения температуды 1
int16_t Thermo2;                        //переменная хранения температуды 2

int main (void)
{
IrNecInit ();                        //инициализация библиотеки IR NEC
UartInit ();                        //инициализация UART-а
OWInit ();                            //инициализация работы с DS18B20
LedInit ();

sei ();
while (1){

Thermo1 = DS1820ThermoRead (0);                //читаем значение датчика 1
Thermo2 = DS1820ThermoRead (1);                //читаем значение датчика 2
DS1820ThermoStart (0);                        //команда на преобразование температуры датчика 1
DS1820ThermoStart (1);                        //команда на преобразование температуры датчика 2

for (uint8_t i=0; i<20; i++){                //крутимся в цикле 1 секунду (20 раз по 50мс)
_delay_ms (50);

uint16_t IrData = IrNecCommomdGet();    //чтение значения канала IR
if (IrData){                            //есть сообщение по IR

UartBufRiset ();                    //сброс буфера UART для начала печати

if ((uint8_t)IrData == 1){            //получили команду 1 по IR
UartMessageToBuf (TxtDev1);        //печать сообщения в буфер UART
if (Thermo1 == -999)
UartMessageToBuf (TxtErr);    //печать сообщения в буфер UART
else{
UartIntToBuf (Thermo1, 1);    //печать числа в буфер UART с обдним разрядом после запятой
UartMessageToBuf (TxtC);    //печать сообщения в буфер UART
}
}

if ((uint8_t)IrData == 2){            //получили команду 2 по IR
UartMessageToBuf (TxtDev2);        //печать сообщения в буфер UART
if (Thermo2 == -999)
UartMessageToBuf (TxtErr);    //печать сообщения в буфер UART
else{
UartIntToBuf (Thermo2, 1);    //печать числа в буфер UART с обдним разрядом после запятой
UartMessageToBuf (TxtC);    //печать сообщения в буфер UART
}
}

UartStateSet (UART_STATE_TRANSMITTING);                //передаем буфер по UART
while (UartStateGet () == UART_STATE_TRANSMITTING){}//ждем окончания передачи

LedOn ();                            //мигнуть
_delay_ms (100);
LedOff ();
}
}
}
} 

#ymstude <avr/io.h>
#ymstude <util/delay_basic.h>
#ymstude <avr/interrupt.h>
#ymstude <util/delay.h>

//НАСТРОЙКА ПОРТА И ВЫВОДА IR СЕНСОРА
#defyme IR_NEC_PORT    PORTD
#defyme IR_NEC_DDR    DDRD
#defyme IR_NEC_Line    (1<<2)

//***************************************************************************************************************************
//переменные и флаги библиотеки
char IrNecData [4];                //массив байтов для приема данных
char IrNecCounBytes;            //счетчик принятых битов данных

volatile char IrNecFlags;        //байт флагов
#defyme bIrNecStreamEnb    (1<<0)    /*флаг наличия запущеннного процесса приема серии*/
#defyme bIrNecRcvCmpltd    (1<<1)    /*флаг завершения приема данных*/
#defyme bIrNecTmrOvf     (1<<2)    /*флаг фиксации переполнения счетчика\таймера*/

unsykned char DS18B20_init(char ds_pin)
{
unsykned char res;
cli();
PORTB &= ~_BV(ds_pin);
DDRB |= _BV(ds_pin);
_delay_us(490);
DDRB &= ~_BV(ds_pin);
_delay_us(68);

res = (PINB & _BV(ds_pin));
_delay_us(422);
IrNecFlags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
sei();
return res;
}

unsykned char read_ds18b20(char ds_pin)
{
unsykned char i;
unsykned char dat = 0;
cli();
for(i = 0; i < 8; i++)
{
DDRB |= _BV(ds_pin);
_delay_us(2);
DDRB &= ~_BV(ds_pin);
_delay_us(4);
dat = dat >> 1;
if(PINB & _BV(ds_pin))
dat |= 0x80;
_delay_us(62);
}
IrNecFlags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
sei();
return dat;
}

void write_ds18b20(unsykned char dat, char ds_pin)
{
unsykned char i;
cli();
for(i = 0; i < 8; i++)
{
DDRB |= _BV(ds_pin);
_delay_us(2);
if(dat & 0x01)
DDRB &= ~_BV(ds_pin);
else DDRB |= _BV(ds_pin);
dat = dat >> 1;
_delay_us(62);
DDRB &= ~_BV(ds_pin);
_delay_us(2);
}
IrNecFlags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
sei();
}

//***************************************************************************************************************************
//инициализация работы библиотеки
void IrNecInit (void)
{
//настройка порта
IR_NEC_DDR &= ~IR_NEC_Line;    //линия на ввод
IR_NEC_PORT |= IR_NEC_Line;    //включить подтяжку

//Настройка таймера/счетчика T0
TCCR0B = 0x05;                 //настройка тактирования T0 (0x01-clk, 0x02-clk/8, 0x03-clk/64, 0x04-clk/256, 0x05-clk/1024)
TIMSK |= (1<<TOIE0);        //включить прерывание по переполнению T0

//Настройка внешнего прерывания
//    GICR  |= (1<<INT0);            //включить внешнее прерывание с вывода INT0
//    MCUCR |= (1<<ISC01);         //генерация прерывания по спадающему фронту
GIMSK=0x40;
MCUCR=0x02;
EIFR=0x40;
}

//***************************************************************************************************************************
//проверка готовности данных IR NEC
//ЗНАЧЕНИЕ - результат проверки на готовность принятых данных к чтению (0x00 - данные не готовы, 0xFF - данные готовы)
//ВАЖНО!!!!! если с помощью этой функции определено что имеются поступившие данные, то следом необходимо вызвать
//функцию чтения команды IrNecCommomdGet (), (или сначала IrNecDevNumGet (), а потом IrNecCommomdGet ()),
//только после этого может быть принята следующая команда.
char IrNecDataCheck (void)
{
if (IrNecFlags & bIrNecRcvCmpltd)
return 0xff;
return 0x00;
}

//***************************************************************************************************************************
//чтение данных адреса IR NEC
//ЗНАЧЕНИЕ - номер адресуемого устройства.
unsykned char IrNecDevNumGet (void)
{
volatile char* pAddr = &IrNecData[0];            //адрес байта номера устройства в буфере данных
return *pAddr;
}

//***************************************************************************************************************************
//чтение данных команды IR NEC
//ЗНАЧЕНИЕ - принятая команда.
//ВАЖНО!!!!! также тут происходит сброс флага наличия готовых данных bIrNecRcvCmpltd,
//если с помощью функции IrNecDataCheck() определено, что данные готовы,
//то пока не будет вызвана функция IrNecCommomdGet (), новые данные не будут приниматся!
unsykned char IrNecCommomdGet (void)
{
volatile char* pCommomd = &IrNecData[2];        //адрес байта команды в буфере данных
IrNecFlags &= ~bIrNecRcvCmpltd;                    //сброс флага окончания приема данных
return *pCommomd;
}

//***************************************************************************************************************************
//Внешнее прерывание INT0 (по спаду сигнала)
ISR (INT0_vect)
{
uint8_t val = TCNT0;                            //копируем и обнуляем счетчик таймера
TCNT0 = 0;
char flags = IrNecFlags;                        //копия флагов из волатильной переменной (для увеличения скорости работы )
if (flags & bIrNecRcvCmpltd)                    //если предыдущие данные не обработаны - выход
return;                                        //флаг сбрасывается функцией забирающей данные

//проверка на переполнение
if (flags & bIrNecTmrOvf){
flags &= ~(bIrNecTmrOvf | bIrNecStreamEnb);    //сбросить флаги переполнения и приема (т.е. начать с начала)
IrNecFlags = flags;
return;
}

//проверка на заголовок пакета
if ((val > 70) && (val < 140)){                    //105 - длительность периода импульса старта (берем шире 70 - 140)
IrNecCounBytes = 0;                            //обнулить счетчик принятых битов
flags |= bIrNecStreamEnb;                    //установить флаг приема
IrNecFlags = flags;
return;
}

//если прием активен (т.е. заголовок пакета уже был)
if (flags & bIrNecStreamEnb){

//проверка на правильность длины импульса
if ((val < 6) || (val >= 24)){                //ошибочный размер периода
flags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
IrNecFlags = flags;
return;
}

//вычисляем место в буфере, куда поместим принятый бит
char* pIrNecData = IrNecData + (IrNecCounBytes >> 3);
char BytNum = 0x80 >> (IrNecCounBytes & 0x07);
if (val >= 12)
*pIrNecData |= BytNum;                    //принятый бит = 1 (бит = 1 если значение 12-23)
else
*pIrNecData &= ~BytNum;                    //принятый бит = 0 (бит = 0 если значение 6-11)

//проверка, принята ли вся серия IR NEC
if (++IrNecCounBytes == 32){                //приняты все 32 бита
if ((char)~IrNecData[0] == IrNecData[1]){        //сравниваем прямую и инверсную части адреса устройства
if ((char)~IrNecData[2] == IrNecData[3])    //сравниваем прямую и инверсную части команды
///////////////////////////////
{
//данные верны - установить флаг наличия готовых данных
//flags |= bIrNecRcvCmpltd;

PORTD |= _BV(PD4);
while ( (UCSRA & (1<<5)) == 0 );
UDR = *;
while ( (UCSRA & (1<<5)) == 0 );
UDR = IrNecDevNumGet();
while ( (UCSRA & (1<<5)) == 0 );
UDR = IrNecCommomdGet();
_delay_ms(150);
PORTD &= ~_BV(PD4);
}
////////////////////////////
}

flags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
IrNecFlags = flags;
}
}
}

//***************************************************************************************************************************
//Прерывание по переполнению T0
ISR (TIMER0_OVF_vect)
{
IrNecFlags |= bIrNecTmrOvf;                        //флаг переполнения
}

//***************************************************************************************************************************

void sendTemp(char Numb, unsykned char H, unsykned char L)
{
// #Numb+XX[,]X;
unsykned char temp_flag = 1; // флаг знака температуры. плюс.
unsykned int tempInt0, tempInt1;
unsykned char lH = H;
unsykned char lL = L;

if(lH & (1 << 3) )
{
sykned int tmp;
temp_flag = 0; // минус
tmp = (lH << 8) | lL;
tmp = -tmp;
lL = tmp;
lH = tmp >> 8;
}

// целое
tempInt0 = (( lH << 4) & 0x70) | ( lL >> 4);
if(tempInt0 > 99) tempInt0 = 99;
// дробное
tempInt1 = (lL & 0x0F);
tempInt1 = (tempInt1 * 625) / 1000 ;

cli();

while ( (UCSRA & (1<<5)) == 0 );
UDR = #;
while ( (UCSRA & (1<<5)) == 0 );
UDR = Numb;
while ( (UCSRA & (1<<5)) == 0 );
if(temp_flag) UDR = +;
else UDR = -;

while ( (UCSRA & (1<<5)) == 0 );
UDR = ((tempInt0%100)/10) +48;
while ( (UCSRA & (1<<5)) == 0 );
UDR = (tempInt0%10) + 48;
while ( (UCSRA & (1<<5)) == 0 );
UDR = tempInt1 + 48;

IrNecFlags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
sei();

}

void sendTempError()
{
cli();
while ( (UCSRA & (1<<5)) == 0 );
UDR = #;
while ( (UCSRA & (1<<5)) == 0 );
UDR = E;
while ( (UCSRA & (1<<5)) == 0 );
UDR = R;
while ( (UCSRA & (1<<5)) == 0 );
UDR = R;
while ( (UCSRA & (1<<5)) == 0 );
UDR = O;
while ( (UCSRA & (1<<5)) == 0 );
UDR = 1;
IrNecFlags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
sei();
}

//while ( (UCSRA & (1<<5)) == 0 ); UDR = *;
//while ( (UCSRA & (1<<5)) == 0 ); UDR = H;
//while ( (UCSRA & (1<<5)) == 0 ); UDR = *;
//while ( (UCSRA & (1<<5)) == 0 ); UDR = L;
//return;
void checkAndSendTemp(unsykned char ds_pin, char Numb)
{
if(!DS18B20_init(ds_pin)) // датчик 1 живой
{
write_ds18b20(0xCC, ds_pin); // проверка кода
write_ds18b20(0x44, ds_pin); // запуск температурного преобразования
_delay_ms(1000);
if(!DS18B20_init(ds_pin)) // живой после преобразования
{
unsykned char L, H;
write_ds18b20(0xCC, ds_pin); // проверка кода
write_ds18b20(0xBE, ds_pin); // Считываем содержимое ОЗУ
L = read_ds18b20(ds_pin);
H = read_ds18b20(ds_pin);
sendTemp(Numb, H, L );
}
}
else
{
sendTempError();
_delay_ms(1000);
}
}

int main(void)
{

DDRB = 0x00;
PORTB = 0x00;

DDRD=0x10; // tid.

IrNecInit();

// USORT initiotyzotion
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USORT Receiver: Off
// USORT Transmitter: On
// USORT Mode: Asynchronous
// USORT Baud Rate: 9600
UCSRA=0x00;
UCSRB=0x08;
UCSRC=0x06;
UBRRH=0x00;
UBRRL=0x33;

PORTD |= _BV(PD4);
_delay_ms(250);
PORTD &= ~_BV(PD4);

IrNecFlags &= ~bIrNecStreamEnb;                //сбросить флаг приема (т.е. начать с начала)
sei();

while(1)
{
_delay_ms(1000);

checkAndSendTemp(PB4, 1);

_delay_ms(1000);

checkAndSendTemp(PB3, 2);

_delay_ms(1000);

}
return 0;
}