#include <iom168.h>
//#include <inavr.h>
#include <ina90.h>
#include "OneWire.h"

#define _1W_CLK 8000000
#define _1W_TKSPer10uS _1W_CLK/100000
#define MILLION 1000000
#define tRSTL 48*_1W_TKSPer10uS //480uS
#define tPDH 65*_1W_CLK/MILLION //65uS
#define tRSTH tRSTL-tPDH
#define tSAMPLE 12*_1W_CLK/MILLION
#define tSLOT 12*_1W_TKSPer10uS //120uS
#define tLOW1 0*_1W_CLK/MILLION //3uS
#define t1uS 1*_1W_CLK/MILLION //3uS
#define tLOW0 10*_1W_TKSPer10uS //120uS
#define tREC 7*_1W_CLK/MILLION //7uS

//==================================================================
//Выходы 1Wire
//1Wire port/ SCK ( D INPUT/OUTPUT)
#define OWIREIOOUT DDRC|=(1<<2)
#define OWIREIOIN DDRC&=~(1<<2)
#define OWIREIOH PORTC|=(1<<2)
#define OWIREIOL PORTC&=~(1<<2)
#define OWIRE (PINC&(1<<2))


//==================================================================
//1wire atmega DRIVERS
//
//-------------------------------------------------------------------------
//This procedure calculates the cumulative Dallas Semiconductor 1ЦWire CRC of all bytes passed to it. The result
//accumulates in the global variable CRC.
unsigned char CRC8(unsigned char inData, unsigned char seed)
{//from AVR318
unsigned char bitsLeft;
unsigned char temp;

for (bitsLeft = 8; bitsLeft > 0; bitsLeft--)
{
temp = ((seed ^ inData) & 0x01);
if (temp == 0)
{
seed >>= 1;
}
else
{
seed ^= 0x18;
seed >>= 1;
seed |= 0x80;
}
inData >>= 1;
}
return seed;
}
//-------------------------------------------------------------------------
//Сброс устройств на шине 1W и чтение Presence Pulse
// Возврат 0- ничего нет
// 1- Есть устройство
// 2- Линия в КЗ
char Reset1W(void)
{
OWIREIOOUT;
__disable_interrupt();
OWIREIOL;
__delay_cycles(tRSTL);
OWIREIOH;
OWIREIOIN;
__delay_cycles(tPDH);
if(!OWIRE)
{ __enable_interrupt();
__delay_cycles(tRSTL);
if(OWIRE)
{ return 1;//Presence pulse
}//if(OWIRE)
else
return 2;//Short circuit
}
__enable_interrupt();
__delay_cycles(tRSTL);
return 0;//Nothing
}
//-------------------------------------------------------------------------
//Проверка наличия 1W устройства
char Check1W(void)
{
if(Reset1W()==1)
{ __delay_cycles(tRSTL);
if(Reset1W()==1)
return 1;
}
return 0;
}
//-------------------------------------------------------------------------
//Передача данных по шине 1Wire
void Write1W(char d)
{ char i;
OWIREIOOUT;
for(i=0;i<8;i++)
{ __disable_interrupt();
OWIREIOL;
__delay_cycles(tLOW1);
if(d&1)
{ OWIREIOH;
__delay_cycles(tSLOT);
}
else
{ __delay_cycles(tLOW0);
OWIREIOH;
}
__enable_interrupt();
__delay_cycles(tREC);
d=d>>1;
}
OWIREIOIN;
}
//-------------------------------------------------------------------------
//Прием данных по шине 1WIRE
char Read1W(void)
{ char i,d=0;
for(i=0;i<8;i++)
{ OWIREIOOUT;
d=d>>1;
__disable_interrupt();
OWIREIOL;
__delay_cycles(t1uS);
OWIREIOH;
OWIREIOIN;
__delay_cycles(tSAMPLE);
if(OWIRE)
d|=0x80;
__enable_interrupt();
__delay_cycles(tSLOT);//tRELEASE 30uS
}
return d;
}

//---------------------------------------------------------------------------
void StartT(char BusNo)//запуск измерения температуры по одной из шин
{ Reset1W();
Write1W(SKIPROM);
Write1W(CONVERTT);
}

//---------------------------------------------------------------------------
float GetT18B20(char *x)//Считывание температуры с датчиков DS18B20,DS1822
{ char i,crc=0;
int j;
char *p;
if(Reset1W()!=1)
return -100;//Нет такого датчика
p=x;
// Write1W(SKIPROM);
Write1W(MATCHROM);
for(i=0;i<8;i++)
{ //OutChar(*p);
Write1W(*p++);//Передача 8 байт адреса
}
Write1W(READSCRATCHPAD);
p=x;
for(i=0;i<8;i++)
{ *p=Read1W();
crc=CRC8(*p,crc);
//OutChar(*p);
*p++;
}
if(Read1W()!=crc)
return -101;//CRC error
p=x;
j=p[1]<<8;
j|=p[0];
return (float)j/16.0;
}

//---------------------------------------------------------------------------
float GetT18S20(char *x)//Считывание температуры с датчика DS18S20
{ char i,crc=0;
int j;
char *p=x;
if(Reset1W()!=1)
return -100;//Нет такого датчика
Write1W(SKIPROM);
// for(i=0;i<8;i++)
// Write1W(*p++);//Передача 8 байт адреса
Write1W(READSCRATCHPAD);
p=x;
for(i=0;i<8;i++)
{ *p=Read1W();
crc=CRC8(*p,crc);
*p++;
}
if(Read1W()!=crc)
return -101;//CRC error
p=x;
j=p[0];
return (float)j/2.0;
}

#include "therm_ds18b20.h"
#include "ascii_conv.h"
#include <avr/interrupt.h>

volatile char THERM_DQ = 0;
/*
void therm_delay(uint16_t delay)
{
while(delay--) asm volatile("nop");
}
*/

uint8_t therm_reset()
{
uint8_t i;
//Pull line low and wait for 480uS
cli();
ds_cbi(THERM_PORT,THERM_DQ);
ds_sbi(THERM_DDR,THERM_DQ);
sei();
_delay_us(480);
cli();
//Release line and wait for 60uS
ds_cbi(THERM_DDR,THERM_DQ);
sei();
_delay_us(60);
//Store line value and wait until the completion of 480uS period
cli();
i=(THERM_PIN & (1<<THERM_DQ));
sei();
_delay_us(420);
//Return the value read from the presence pulse (0=OK, 1=WRONG)
return i;
}

void therm_write_bit(uint8_t bit)
{
//Pull line low for 1uS
cli();
ds_cbi(THERM_PORT,THERM_DQ);
ds_sbi(THERM_DDR,THERM_DQ);
_delay_us(1);
//If we want to write 1, release the line (if not will keep low)
if(bit) ds_cbi(THERM_DDR,THERM_DQ);
//Wait for 60uS and release the line
sei();
_delay_us(60);
ds_cbi(THERM_DDR,THERM_DQ);
}

uint8_t therm_read_bit(void)
{
uint8_t bit=0;
cli();
//Pull line low for 1uS
ds_cbi(THERM_PORT,THERM_DQ);
ds_sbi(THERM_DDR,THERM_DQ);
_delay_us(1);
//Release line and wait for 14uS
ds_cbi(THERM_DDR,THERM_DQ);
_delay_us(14);
//Read line value
if(THERM_PIN&(1<<THERM_DQ)) bit=1;
//Wait for 45uS to end and return read value
_delay_us(45);
sei();
return bit;
}

uint8_t therm_read_byte(void)
{
uint8_t i=8, n=0;
cli();
while(i--)
{
//Shift one position right and store read value
n>>=1;
n|=(therm_read_bit()<<7);
}
sei();
return n;
}

void therm_write_byte(uint8_t byte)
{
uint8_t i=8;
cli();
while(i--)
{
//Write actual bit and shift one position right to make the next bit ready
therm_write_bit(byte&1);
byte>>=1;
}
sei();
}

void therm_read_temperature(char *buffer, volatile char PIN_DS)
{
THERM_DQ = PIN_DS;
// Buffer length must be at least 12bytes long! ["+XXX.XXXX C"]
uint8_t temperature[2];
// uint16_t temper_16bit;
int8_t digit;
uint16_t decimal;
//Reset, skip ROM and start temperature conversion
therm_reset();
therm_write_byte(THERM_CMD_SKIPROM);
therm_write_byte(THERM_CMD_CONVERTTEMP);
//Wait until conversion is complete
//while(!therm_read_bit());
_delay_ms(750);
//Reset, skip ROM and send command to read Scratchpad
therm_reset();
therm_write_byte(THERM_CMD_SKIPROM);
therm_write_byte(THERM_CMD_RSCRATCHPAD);
//Read Scratchpad (only 2 first bytes)
temperature[0]=therm_read_byte();
temperature[1]=therm_read_byte();
therm_reset();
//Store temperature integer digits and decimal digits
digit=temperature[0]>>4;
digit|=(temperature[1]&0x07)<<4;
//Store decimal digits
decimal=temperature[0]&0xf;
decimal*=5;
if (temperature[1]>0xFB)
{
digit = 127-digit;
buffer[0] = '-';
} else buffer[0] = '+';



buffer[1] = to_ascii(digit/100);
buffer[2] = to_ascii((digit%100)/10);
buffer[3] = to_ascii(digit%10);
buffer[4] = '.';
buffer[5] = to_ascii((decimal%100)/10);

}

#include <avr/io.h>
#include "therm_ds18b20.h"
#include "ascii_conv.h"

volatile char THERM_DQ = 0;
/*
void therm_delay(uint16_t delay)
{
while(delay--) asm volatile("nop");
}
*/

uint8_t therm_reset()
{
uint8_t i;
//Pull line low and wait for 480uS
ds_cbi(THERM_PORT,THERM_DQ);
ds_sbi(THERM_DDR,THERM_DQ);
//_delay_us(480);
TCNT1 = 0;
while(TCNT1<(480*12));
//Release line and wait for 60uS
ds_cbi(THERM_DDR,THERM_DQ);
//_delay_us(60);
TCNT1 = 0;
while(TCNT1<(60*12));
//Store line value and wait until the completion of 480uS period
i=(THERM_PIN & (1<<THERM_DQ));
//_delay_us(420);
TCNT1 = 0;
while(TCNT1<(420*12));
//Return the value read from the presence pulse (0=OK, 1=WRONG)
return i;
}

void therm_write_bit(uint8_t bit)
{
//Pull line low for 1uS
ds_cbi(THERM_PORT,THERM_DQ);
ds_sbi(THERM_DDR,THERM_DQ);
//_delay_us(1);
TCNT1 = 0;
while(TCNT1<12);
//If we want to write 1, release the line (if not will keep low)
if(bit) ds_cbi(THERM_DDR,THERM_DQ);
//Wait for 60uS and release the line
//_delay_us(60);
TCNT1 = 0;
while(TCNT1<(60*12));
ds_cbi(THERM_DDR,THERM_DQ);
}

uint8_t therm_read_bit(void)
{
uint8_t bit=0;
//Pull line low for 1uS
ds_cbi(THERM_PORT,THERM_DQ);
ds_sbi(THERM_DDR,THERM_DQ);
//_delay_us(1);
TCNT1 = 0;
while(TCNT1<12);
//Release line and wait for 14uS
ds_cbi(THERM_DDR,THERM_DQ);
//_delay_us(14);
TCNT1 = 0;
while(TCNT1<(14*12));
//Read line value
if(THERM_PIN&(1<<THERM_DQ)) bit=1;
//Wait for 45uS to end and return read value
//_delay_us(45);
TCNT1 = 0;
while(TCNT1<(45*12));
return bit;
}

uint8_t therm_read_byte(void)
{
uint8_t i=8, n=0;
while(i--)
{
//Shift one position right and store read value
n>>=1;
n|=(therm_read_bit()<<7);
}
return n;
}

void therm_write_byte(uint8_t byte)
{
uint8_t i=8;
while(i--)
{
//Write actual bit and shift one position right to make the next bit ready
therm_write_bit(byte&1);
byte>>=1;
}
}

void therm_read_temperature(char *buffer, volatile char PIN_DS)
{
THERM_DQ = PIN_DS;
// Buffer length must be at least 12bytes long! ["+XXX.XXXX C"]
uint8_t temperature[2];
// uint16_t temper_16bit;
int8_t digit;
uint16_t decimal;
//Reset, skip ROM and start temperature conversion
therm_reset();
therm_write_byte(THERM_CMD_SKIPROM);
therm_write_byte(THERM_CMD_CONVERTTEMP);
//Wait until conversion is complete
//while(!therm_read_bit());
//_delay_ms(750);
for (volatile char gggg=0;gggg<151;gggg++)
{
TCNT1 = 0;
while(TCNT1<(5000*12));
}
//Reset, skip ROM and send command to read Scratchpad
therm_reset();
therm_write_byte(THERM_CMD_SKIPROM);
therm_write_byte(THERM_CMD_RSCRATCHPAD);
//Read Scratchpad (only 2 first bytes)
temperature[0]=therm_read_byte();
temperature[1]=therm_read_byte();
therm_reset();
//Store temperature integer digits and decimal digits
digit=temperature[0]>>4;
digit|=(temperature[1]&0x07)<<4;
//Store decimal digits
decimal=temperature[0]&0xf;
decimal*=5;
if (temperature[1]>0xFB) digit = 127-digit;

buffer[0] = to_ascii(digit/100);
buffer[1] = to_ascii((digit%100)/10);
buffer[2] = to_ascii(digit%10);
buffer[3] = '.';
buffer[4] = to_ascii((decimal%100)/10);

}

void therm_write_bit(uint8_t bit)
{
cli();
if(bit)
{
ds_cbi(THERM_PORT,THERM_DQ);
_delay_us(4);
ds_sbi(THERM_PORT,THERM_DQ);
sei();
_delay_us(60);
}
else
{
ds_cbi(THERM_PORT,THERM_DQ);
sei();
_delay_us(60);
ds_sbi(THERM_PORT,THERM_DQ);
}
}

uint8_t therm_read_bit(void)
{
uint8_t bit=0;

cli();
ds_cbi(THERM_PORT,THERM_DQ);
_delay_us(4);
ds_sbi(THERM_DDR,THERM_DQ);
_delay_us(8);
if(THERM_PIN&(1<<THERM_DQ)) bit=1;
sei();
_delay_us(45);
return bit;
}

static UREG OWByte(UREG b )
{
UREG i=8;
UBRR0=10; //115200
do
{
UREG d=0x00;
if (b&1) d=0xFF;
__disable_interrupt();
UDR0=d;
UCSR0A=(1<<TXC0);
__enable_interrupt();
while(!UCSR0A_TXC0);
b>>=1;
if (UDR0>0xFE) b|=128;
}
while(--i);
return b&255;
}

static UREG OWReset(void)
{
UREG c;
UCSR0B=(1<<RXEN0)|(1<<TXEN0);
UBRR0=129; //9600
while(UCSR0A_RXC0) UDR0; //Зачистка буферов
__disable_interrupt();
UDR0=0xF0;
UCSR0A=(1<<TXC0);
__enable_interrupt();
while(!UCSR0A_TXC0);
c=UDR0;
if (c!=0xF0) return 1;
return 0;
}

void StartMeasureTemp(void)
{
if (!OWReset()) return;
OWByte(0xCC); //Skip ROM
OWByte(0x44); //Convert Temperature
}

REG16 ExtractMeasureTemp_one(void)
{
if (!OWReset()) return -273*16;
OWByte(0xCC); //Skip ROM
OWByte(0xBE); //Read scratchpad
REG16 v=OWByte(0xFF);
v|=OWByte(0xFF)<<8;
return v;
}

static unsigned char OWByte(unsigned char b )
{
unsigned char i=8;
//UBRR0=10; //115200
UBRRH = 0;
UBRRL = 12;
UCSRA |= (1<<U2X);

do
{
unsigned char d=0x00;
if (b&1) d=0xFF;
cli();
UDR=d;
UCSRA=(1<<TXC);
sei();
//while(!UCSRA_TXC);
while(!(UCSRA&(1<<TXC)));
b>>=1;
if (UDR>0xFE) b|=128;
}
while(--i);
return b&255;
}

static unsigned char OWReset(void)
{
unsigned char c;
UCSRB=(1<<RXEN)|(1<<TXEN);
//UBRR0=129; //9600
UBRRH = 0;
UBRRL = 77;
UCSRA &= ~(1<<U2X);

//while(UCSRA_RXC) UDR; //Зачистка буферов
while(UCSRA&(1<<RXC)) UDR; //Зачистка буферов
cli();
UDR=0xF0;
UCSRA=(1<<TXC);
sei();
//while(!UCSRA_TXC);
while(!(UCSRA&(1<<TXC)));
c=UDR;
if (c!=0xF0) return 1;
return 0;
}

void StartMeasureTemp(void)
{
if (!OWReset()) return;
OWByte(0xCC); //Skip ROM
OWByte(0x44); //Convert Temperature
}

int ExtractMeasureTemp_one(void)
{
if (!OWReset()) return -273*16;
OWByte(0xCC); //Skip ROM
OWByte(0xBE); //Read scratchpad
int v=OWByte(0xFF);
v|=OWByte(0xFF)<<8;
return v;
}

void showTemperature(char *ds_buffer)
{
unsigned char ds_temp[2]; // массив для хранения возвращаемой температуры
unsigned char ds_digit; // целое значение
unsigned char ds_decimal; //десятичное значение
unsigned int ds_data = ExtractMeasureTemp_one();// считавыем значение температуры и записываем в переменную
ds_temp[0]=(ds_data>>8);// старший байт
ds_temp[1]=(ds_data<<8);// младший байт
ds_digit=ds_temp[0]>>4;// сюда пишем старшие 4 бита старшего байта
ds_digit|=(ds_temp[1]&0x07)<<4;// сюда пишем младшие 4 бита младшего байта
ds_decimal=ds_temp[0]&0xf;//
ds_decimal*=5; // десятичное значение
if (ds_temp[1]>0xFB) // еси датчик показывает меньше -55С
{
ds_digit = 127-ds_digit; //
ds_buffer[0] = '-'; // ставим минус
} else ds_buffer[0] = '+'; // в противоположном случает - плюс
ds_buffer[1] = to_ascii(ds_digit/100); //
ds_buffer[2] = to_ascii((ds_digit%100)/10); //
ds_buffer[3] = to_ascii(ds_digit%10); //
ds_buffer[4] = '.'; //
ds_buffer[5] = to_ascii((ds_decimal%100)/10);//
}