int ow_read_temperature(void)
{
char get[10];
char temp_lsb,temp_msb;
int k;
char temp_c;
//char temp_f;
ow_reset();
ow_write_byte(0xCC); //Skip ROM
ow_write_byte(0x44); // Start Conversion
delay_usec(119); //wait 120us
ow_reset();
ow_write_byte(0xCC); // Skip ROM
ow_write_byte(0xBE); // Read Scratch Pad
for (k=0; k<9; k++) {
get[k] = ow_read_byte();
}
temp_msb = get[1]; // Sign byte + lsbit
temp_lsb = get[0]; // Temp data plus lsb
if (temp_msb <= 0x80){temp_lsb = (temp_lsb/2);} // shift to get whole degree
temp_msb = temp_msb & 0x80; // mask all but the sign bit
if (temp_msb >= 0x80) {temp_lsb = (~temp_lsb)+1;} // twos complement
if (temp_msb >= 0x80) {temp_lsb = (temp_lsb/2);}// shift to get whole degree
if (temp_msb >= 0x80) {temp_lsb = ((-1)*temp_lsb);} // add sign bit
temp_c = temp_lsb; // ready for conversion to Fahrenheit
//temp_f = (((int)temp_c)* 9)/5 + 32;
return temp_c;
}
void ds18b20_recall_eeprom()
{
ow_reset();
ow_write_byte(0xCC);
ow_write_byte(0xB8);
__delay_us(50);
}
void
ow_command(uint8_t cmd, uint8_t pin)
{
ow_reset(pin);
/* To all devices */
ow_write_byte(OW_SKIP_ROM, pin);
ow_write_byte(cmd, pin);
}
void ds18b20_read_scratch(struct ds18b20 *dev)
{
unsigned char i;
//unsigned char data[9];
//ow_init();
ow_reset();
//ow_write_byte(0xCC);
ow_write_byte(0x55);
for(i=0;i<8;i++){
ow_write_byte(dev->romcode[i]);
}
ow_write_byte(0xBE);
dev->scratchpad[0] = ow_read_byte();
dev->scratchpad[1] = ow_read_byte();
dev->scratchpad[2] = ow_read_byte();
dev->scratchpad[3] = ow_read_byte();
dev->scratchpad[4] = ow_read_byte();
dev->scratchpad[5] = ow_read_byte();
dev->scratchpad[6] = ow_read_byte();
dev->scratchpad[7] = ow_read_byte();
dev->scratchpad[8] = ow_read_byte();
//printf("data 1 = %x\r\n", dev->scratchpad[0]);
//printf("data 2 = %x\r\n", dev->scratchpad[1]);
//printf("data 3 = %x\r\n", dev->scratchpad[2]);
//printf("data 4 = %x\r\n", dev->scratchpad[3]);
//printf("data 5 = %x\r\n", dev->scratchpad[4]);
//printf("data 6 = %x\r\n", dev->scratchpad[5]);
//printf("data 7 = %x\r\n", dev->scratchpad[6]);
//printf("data 8 = %x\r\n", dev->scratchpad[7]);
//printf("data 9 = %x\r\n", dev->scratchpad[8]);
dev->config = dev->scratchpad[4];
dev->crc = dev->scratchpad[8];
//printf("TempDS = %d\r\n", ((dev->scratchpad[1] << 8) | (dev->scratchpad[0] >> 4)));
dev->tempi = (((0x07 & dev->scratchpad[1]) << 8) | dev->scratchpad[0]) >> 4;
if(dev->scratchpad[1] & 0xF0)
dev->tempi = -dev->tempi;
dev->tempd = dev->scratchpad[0] & 0x0F;
if( dev->tempd & 0x08 ){
dev->tempd = 5;
}else if( dev->tempd & 0x04 ){
dev->tempd = 25;
}else if( dev->tempd & 0x02 ){
dev->tempd = 125;
}else if( dev->tempd & 0x01 ){
dev->tempd = 625;
}
//printf("TempDS = %d.%d\r\n", dev->tempi, dev->tempd);
}
void OneWireInit(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
ow_reset();
ow_write_byte(0xcc);
ow_write_byte(0x4e);
ow_write_byte(0);
ow_write_byte(0);
ow_write_byte(0x60); // 12 bit
ow_reset();
}
void ds18b20_start_convert(struct ds18b20 *dev)
{
unsigned char i;
ow_reset();
ow_write_byte(0x55);
for(i=0;i<8;i++){
ow_write_byte(dev->romcode[i]);
}
ow_write_byte(0x44);
__delay_ms(750);
}
int8_t ow_eeprom_read(ow_rom_code_t *rom, void *data)
{
#if ONEWIRE_BUSCOUNT > 1
uint8_t busmask = 1 << (ONEWIRE_STARTPIN); // FIXME: currently only on 1st bus
#else
uint8_t busmask = ONEWIRE_BUSMASK;
#endif
int8_t ret;
if (rom == NULL)
ret = ow_skip_rom();
else {
/* check for known family code */
if (!(rom->family == OW_FAMILY_DS2502E48))
return -2;
ret = ow_match_rom(rom);
}
if (ret < 0)
return ret;
/* transmit command byte */
ow_write_byte(busmask, OW_FUNC_READ_MEMORY);
/* transmit address (mac address starts at offset 5 */
ow_write_byte(busmask, 5);
ow_write_byte(busmask, 0);
/* read back crc sum of the command */
uint8_t crc = ow_read_byte(busmask);
/* check crc */
uint8_t crc2 = 0;
crc2 = _crc_ibutton_update(crc2, OW_FUNC_READ_MEMORY);
crc2 = _crc_ibutton_update(crc2, 5);
crc2 = _crc_ibutton_update(crc2, 0);
if (crc != crc2)
return -2;
uint8_t *p = (uint8_t *)data+5;
/* read 6 byte of data */
for (uint8_t i = 0; i < 6; i++)
*p-- = ow_read_byte(busmask);
return 0;
}
static int8_t ds18x_access(uint8_t *id)
{
int i;
if(!ow_reset(0))
return -1;
if(ow_write_byte(0, ROM_MATCH) < 0)
return -1;
for(i=0;i<8;i++)
if(ow_write_byte(0, id[i]) < 0)
return -1;
return 0;
}
void owchip_geteui(uint8_t* eui) { // >= 6000us
uint8_t id[8];
int retry;
int crc;
uint8_t* byte;
uint16_t oldTactl;
retry = 5;
memset(eui,0,8);
// store current value of TACTL
oldTactl = TACTL;
// start timer in continuous mode at 1MHz
TACTL = TASSEL_2 | ID_2 | MC_2;
owpin_init();
while (retry-- > 0) {
crc = 0;
if(ow_reset()) {
ow_write_byte(0x33); //read rom
for(byte=id+7; byte>=id; byte--) {
crc = crc8_byte( crc, *byte=ow_read_byte() );
}
if(crc==0) {
// CRC valid
memcpy(eui,id,8);
}
}
}
// restore value of TACTL
TACTL = oldTactl;
}
/* mid-level functions */
int8_t noinline ow_read_rom(ow_rom_code_t *rom)
{
#if ONEWIRE_BUSCOUNT > 1
uint8_t busmask = 1 << (ONEWIRE_STARTPIN); // FIXME: currently only on 1st bus
#else
uint8_t busmask = ONEWIRE_BUSMASK;
#endif
/* reset the bus */
if (!reset_onewire(busmask))
return -1;
/* transmit command byte */
ow_write_byte(busmask, OW_ROM_READ_ROM);
/* read 64bit rom code */
for (uint8_t i = 0; i < 8; i++) {
/* read byte */
rom->bytewise[i] = ow_read_byte(busmask);
}
/* check CRC (last byte) */
if (rom->crc != crc_checksum(rom->bytewise, 7))
return -2;
return 1;
}
int8_t ow_temp_power(ow_rom_code_t *rom)
{
#if ONEWIRE_BUSCOUNT > 1
uint8_t busmask = 1 << (ONEWIRE_STARTPIN); // FIXME: currently only on 1st bus
#else
uint8_t busmask = ONEWIRE_BUSMASK;
#endif
int8_t ret;
if (rom == NULL)
ret = ow_skip_rom();
else {
if (!ow_temp_sensor(rom))
return -2;
ret = ow_match_rom(rom);
}
if (ret < 0)
return ret;
/* transmit command byte */
ow_write_byte(busmask, OW_FUNC_READ_POWER);
return (int8_t)(ow_read(busmask));
}
void ds18b20_read_rom(struct ds18b20 *dev)
{
//uint8_t romid[8];
//ow_init();
ow_reset();
ow_write_byte(0x33);
dev->romcode[0] = ow_read_byte();
dev->romcode[1] = ow_read_byte();
dev->romcode[2] = ow_read_byte();
dev->romcode[3] = ow_read_byte();
dev->romcode[4] = ow_read_byte();
dev->romcode[5] = ow_read_byte();
dev->romcode[6] = ow_read_byte();
dev->romcode[7] = ow_read_byte();
//printf("id 1 = %x\r\n", dev->romcode[0]);
//printf("id 2 = %x\r\n", dev->romcode[1]);
//printf("id 3 = %x\r\n", dev->romcode[2]);
//printf("id 4 = %x\r\n", dev->romcode[3]);
//printf("id 5 = %x\r\n", dev->romcode[4]);
//printf("id 6 = %x\r\n", dev->romcode[5]);
//printf("id 7 = %x\r\n", dev->romcode[6]);
//printf("id 8 = %x\r\n", dev->romcode[7]);
//*(id) = romid[1] | romid[0];
//*(id + 1) = romid[3] | romid[2];
//dev->address[0] = ((((unsigned long)romid[3] << 8) | (unsigned long)romid[2]) << 16) | (((unsigned long)romid[1] << 8) | romid[0]);
//dev->address[1] = ((((unsigned long)romid[7] << 8) | (unsigned long)romid[6]) << 16) | (((unsigned long)romid[5] << 8) | romid[4]);
//printf("Address 1 = %ld\r\n", dev->address[0]);
//printf("Address 2 = %ld\r\n", dev->address[1]);
}
static void ds18b20_start(void)
{
ow_reset();
ow_skip_rom();
ow_write_byte(DS18B20_CMD_CONVERT_T);
}
int ow_write_block(int port, uint8_t *block, int len)
{
uint32_t i;
for(i=0;i<len;i++)
*block++ = ow_write_byte(port, *block);
return 0;
}
int8_t noinline ow_skip_rom(void)
{
/* reset the bus */
if (!reset_onewire(ONEWIRE_BUSMASK))
return -1;
/* transmit command byte */
ow_write_byte(ONEWIRE_BUSMASK, OW_ROM_SKIP_ROM);
return 1;
}
int8_t ds18x_read_temp(uint8_t *id, int *temp_r)
{
int i, temp;
uint8_t data[9];
if(ds18x_access(id) < 0)
return -1;
mprintf("found.");
ow_write_byte(0, READ_SCRATCHPAD);
for(i=0;i<9;i++) data[i] = ow_read_byte(0);
temp = ((int)data[1] << 8) | ((int)data[0]);
if(temp & 0x1000)
temp = -0x10000 + temp;
ds18x_access(id);
ow_write_byte(0, CONVERT_TEMP);
if(temp_r) *temp_r = temp;
return 0;
}
EOWError ow_write_byte_power(uint8_t config_state, uint8_t write_byte)
{
uint8_t buffer[2], ret;
buffer[0] = ds2482_write_config_cmd;
buffer[1] = (config_state | 0x04) & 0xBF;
i2c_write(ds2482_address, buffer, 2);
ret = i2c_wait();
if ( ret != TW_NO_INFO) {
ERROR(ret);
return eOWNoResponse;
}
return ow_write_byte(write_byte);
}
int8_t ds18x_read_serial(uint8_t *id)
{
uint8_t i;
if(!ow_reset(0))
return -1;
if(ow_write_byte(0, ROM_READ) < 0)
return -1;
for(i=0;i<8;i++)
{
*id = ow_read_byte(0);
id++;
}
return 0;
}
int8_t noinline ow_match_rom(ow_rom_code_t *rom)
{
/* reset the bus */
if (!reset_onewire(ONEWIRE_BUSMASK))
return -1;
/* transmit command byte */
ow_write_byte(ONEWIRE_BUSMASK, OW_ROM_MATCH_ROM);
/* transmit rom code */
for (uint8_t i = 0; i < 8; i++) {
for (uint8_t j = 0; j < 8; j++) {
ow_write(ONEWIRE_BUSMASK, (uint8_t)(rom->bytewise[i] & _BV(j)));
}
}
return 1;
}
int8_t ow_temp_read_scratchpad(ow_rom_code_t *rom, ow_temp_scratchpad_t *scratchpad)
{
uint8_t busmask;
int8_t ret;
if (rom == NULL)
ret = ow_skip_rom();
else {
/* check for known family code */
if (!ow_temp_sensor(rom))
return -3;
ret = ow_match_rom(rom);
}
if (ret < 0)
return ret;
/* transmit command byte */
ow_write_byte(ONEWIRE_BUSMASK, OW_FUNC_READ_SP);
#if ONEWIRE_BUSCOUNT > 1
for (uint8_t bus = 0; bus < ONEWIRE_BUSCOUNT; bus++) {
/* read 9 bytes from each onewire bus */
busmask = (uint8_t)(1 << (bus + ONEWIRE_STARTPIN));
#else
busmask = ONEWIRE_BUSMASK;
#endif
for (uint8_t i = 0; i < 9; i++) {
scratchpad->bytewise[i] = ow_read_byte(busmask);
}
/* check CRC (last byte) */
if (scratchpad->crc == crc_checksum(&scratchpad->bytewise, 8)) {
/* return if we got a valid response from one device */
return 1;
}
#if ONEWIRE_BUSCOUNT > 1
}
#endif
return -2;
}
void ds18b20_write_scratch(struct ds18b20 *dev)
{
unsigned char i;
ow_reset();
//ow_write_byte(0xCC);
ow_write_byte(0x55);
for(i=0;i<8;i++){
ow_write_byte(dev->romcode[i]);
}
ow_write_byte(0x4E);
ow_write_byte(dev->scratchpad[2]);
ow_write_byte(dev->scratchpad[3]);
ow_write_byte(dev->config);
}
void eui64_get(uint8_t* addressToWrite) { // >= 6000us
uint8_t id[8];
int retry;
int crc;
uint8_t* byte;
uint16_t oldTactl;
return;//poipoi
retry = 5;
memset(addressToWrite,0,8);
// store current value of TACTL
oldTactl = TACTL;
// start timer in continuous mode at 1MHz
TACTL = TASSEL_2 | ID_2 | MC_2;
owpin_init();
while (retry-- > 0) {
crc = 0;
if(ow_reset()) {
ow_write_byte(0x33); //read rom
for(byte=id+7; byte>=id; byte--) {
crc = crc8_byte( crc, *byte=ow_read_byte() );
}
if(crc==0) {
// CRC valid
*(addressToWrite+0) = 0x14;
*(addressToWrite+1) = 0x15;
*(addressToWrite+2) = 0x92;
memcpy(addressToWrite+3,id+1,5);
}
}
}
// restore value of TACTL
TACTL = oldTactl;
}
uint8_t ds18b20_ping(void)
{
uint8_t i;
uint8_t n = 0;
int16_t v;
if (!ow_read())
return 0;
for (i = 0; i < ow_n_addrs; i++) {
if (ow_addr(i)[0] == DS18B20_FAMILY_CODE) {
ow_reset();
ow_match_rom(i);
ow_write_byte(DS18B20_CMD_READ_SCRATCHPAD);
v = ow_read_byte();
v |= ow_read_byte() << 8;
if (ds18b20_temps[n]) {
ds18b20_temps[n] -= ds18b20_temps[n] >> 4;
ds18b20_temps[n] += v;
} else {
ds18b20_temps[n] = v << 4;
}
}
int8_t ow_temp_start_convert(ow_rom_code_t *rom, uint8_t wait)
{
int8_t ret;
if (rom == NULL)
ret = ow_skip_rom();
else {
/* check for known family code */
if (!ow_temp_sensor(rom))
return -2;
ret = ow_match_rom(rom);
}
if (ret < 0)
return ret;
/* transmit command byte */
ow_write_byte(ONEWIRE_BUSMASK, OW_FUNC_CONVERT);
OW_CONFIG_OUTPUT(ONEWIRE_BUSMASK);
OW_HIGH(ONEWIRE_BUSMASK);
if (!wait)
return 0;
_delay_ms(800); /* The specification say, that we have to wait at
least 500ms in parasite mode to wait for the
end of the conversion. 800ms works more reliably */
while(!ow_read(ONEWIRE_BUSMASK));
return 1;
}
/* high-level functions */
int8_t noinline ow_search_rom(uint8_t busmask, uint8_t first)
{
/* reset discover state machine */
if (first) {
ow_global.last_discrepancy = -1;
/* reset rom code */
for (uint8_t i = 0; i < 8; i++)
ow_global.current_rom.bytewise[i] = 0;
} else {
/* if last_discrepancy is below zero, discovery is done */
if (ow_global.last_discrepancy < 0)
return 0;
}
int8_t discrepancy = -1;
/* reset the bus */
if (!reset_onewire(busmask))
return -1;
/* transmit command byte */
ow_write_byte(busmask, OW_ROM_SEARCH_ROM);
for (uint8_t i = 0; i <64; i++) {
/* read bits */
uint8_t bit1 = ow_read(busmask);
uint8_t bits = (uint8_t)((ow_read(busmask) << 1) | bit1);
if (bits == 3) {
/* no devices, just return */
return 0;
} else if (bits == 0) {
if (i == ow_global.last_discrepancy) {
/* set one */
ow_set_address_bit(&ow_global.current_rom, i, 1);
/* transmit one next time */
bit1 = 1;
} else if (i > ow_global.last_discrepancy) {
/* set zero */
ow_set_address_bit(&ow_global.current_rom, i, 0);
discrepancy = (int8_t)i;
} else {
uint8_t rom_bit = (uint8_t)(ow_global.current_rom.bytewise[i / 8] & _BV(i % 8));
if (rom_bit == 0)
discrepancy = (int8_t)i;
/* transmit last bit next time */
bit1 = rom_bit;
}
} else {
/* normal case, no discrepancy */
ow_set_address_bit(&ow_global.current_rom, i, bit1);
}
OW_CONFIG_OUTPUT(busmask);
/* select next bit */
ow_write(busmask, bit1);
}
ow_global.last_discrepancy = discrepancy;
/* new device discovered */
return 1;
}
static PT_THREAD(read_temp(struct pt *pt, const ow_addr_t *addr)) {
int err;
uint8_t scratch[9];
uint8_t crc = 0;
PT_BEGIN(pt);
// Reset the bus
err = ow_reset();
if (err != 1) {
shell_output_P(&owtest_command, PSTR("Reset failed.\n"));
PT_EXIT(pt);
}
// Match ROM
err = ow_write_byte(0x55);
if (err) {
shell_output_P(&owtest_command, PSTR("Match ROM failed\n"));
PT_EXIT(pt);
}
for (int i = 0; i < sizeof(*addr); i++) {
err = ow_write_byte(addr->u[i]);
if (err) {
shell_output_P(&owtest_command, PSTR("Match ROM failed\n"));
PT_EXIT(pt);
}
}
// Start temperature conversion
err = ow_write_byte(0x44);
if (err) {
shell_output_P(&owtest_command, PSTR("Convert T failed\n"));
PT_EXIT(pt);
}
// Conversion timeout
timer_set(&timeout, DS18B20_CONV_TIMEOUT);
while (1) {
_delay_ms(10); // for good measure
// Read a bit from the bus
int ret = ow_read_bit();
// Check for stop conditions
if (ret == 1) {
break;
}
else if (ret == -1) {
shell_output_P(&owtest_command, PSTR("Read status failed.\n"));
PT_EXIT(pt);
}
else if (timer_expired(&timeout)) {
shell_output_P(&owtest_command, PSTR("Conversion has taken too long. Giving up.\n"));
PT_EXIT(pt);
}
// Poll the process and yield the thread
process_poll(&shell_owtest_process);
PT_YIELD(pt);
}
// Reset and MATCH ROM again
err = ow_reset();
if (err != 1) {
shell_output_P(&owtest_command, PSTR("Reset failed.\n"));
PT_EXIT(pt);
}
// Match ROM
err = ow_write_byte(0x55);
if (err) {
shell_output_P(&owtest_command, PSTR("Match ROM failed\n"));
PT_EXIT(pt);
}
for (int i = 0; i < sizeof(*addr); i++) {
err = ow_write_byte(addr->u[i]);
if (err) {
shell_output_P(&owtest_command, PSTR("Match ROM failed\n"));
PT_EXIT(pt);
}
}
// Read the scratch pad
err = ow_write_byte(0xBE);
if (err) {
shell_output_P(&owtest_command, PSTR("Read scratch pad failed\n"));
PT_EXIT(pt);
}
for (int i = 0; i < sizeof(scratch); i++) {
err = ow_read_byte();
if (err < 0) {
shell_output_P(&owtest_command, PSTR("Read byte failed\n"));
PT_EXIT(pt);
}
scratch[i] = err;
crc = _crc_ibutton_update(crc, scratch[i]);
}
// Make sure the CRC is valid
if (crc) {
shell_output_P(&owtest_command, PSTR("CRC check failed!\n"));
PT_EXIT(pt);
}
// Convert temperature to floating point
int16_t rawtemp = scratch[0] | (scratch[1] << 8);
float temp = (float)rawtemp * 0.0625;
shell_output_P(&owtest_command,
PSTR("Scratchpad: %02x%02x %02x%02x %02x %02x%02x%02x %02x\n"),
scratch[0], scratch[1], // temperature
scratch[2], scratch[3], // TH,TL alarm thresholds
scratch[4], // config
scratch[5], scratch[6], scratch[7], // reserved
scratch[8]); // CRC
shell_output_P(&owtest_command, PSTR("Reading: %0.2fC\n"), temp);
PT_END(pt);
}
int ow_search()
{
int id_bit_number;
int last_zero, rom_byte_number, search_result;
int id_bit, cmp_id_bit;
unsigned char rom_byte_mask, search_direction;
// initialize for search
id_bit_number = 1;
last_zero = 0;
rom_byte_number = 0;
rom_byte_mask = 1;
search_result = 0;
search_crc8 = 0;
// if the last call was not the last one
if (!search_last_device_flag)
{
// 1-Wire reset
if (!ow_reset())
{
// reset the search
search_last_discrepancy = 0;
search_last_device_flag = FALSE;
search_last_family_discrepancy = 0;
return FALSE;
}
// issue the search command
ow_write_byte(0xF0);
// loop to do the search
do
{
// read a bit and its complement
id_bit = ow_read_bit();
cmp_id_bit = ow_read_bit();
// check for no devices on 1-wire
if ((id_bit == 1) && (cmp_id_bit == 1))
break;
else
{
// all devices coupled have 0 or 1
if (id_bit != cmp_id_bit)
search_direction = id_bit; // bit write value for search
else
{
// if this discrepancy if before the Last Discrepancy
// on a previous next then pick the same as last time
if (id_bit_number < search_last_discrepancy)
search_direction = ((search_romcode[rom_byte_number] & rom_byte_mask) > 0);
else
// if equal to last pick 1, if not then pick 0
search_direction = (id_bit_number == search_last_discrepancy);
// if 0 was picked then record its position in LastZero
if (search_direction == 0)
{
last_zero = id_bit_number;
// check for Last discrepancy in family
if (last_zero < 9)
search_last_family_discrepancy = last_zero;
}
}
// set or clear the bit in the ROM byte rom_byte_number
// with mask rom_byte_mask
if (search_direction == 1)
search_romcode[rom_byte_number] |= rom_byte_mask;
else
search_romcode[rom_byte_number] &= ~rom_byte_mask;
// serial number search direction write bit
ow_write_bit(search_direction);
// increment the byte counter id_bit_number
// and shift the mask rom_byte_mask
id_bit_number++;
rom_byte_mask <<= 1;
// if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
if (rom_byte_mask == 0)
{
docrc8(search_romcode[rom_byte_number]); // accumulate the CRC
rom_byte_number++;
rom_byte_mask = 1;
}
}
}
while(rom_byte_number < 8); // loop until through all ROM bytes 0-7
// if the search was successful then
if (!((id_bit_number < 65) || (search_crc8 != 0)))
{
// search successful so set LastDiscrepancy,search_last_device_flag,search_result
search_last_discrepancy = last_zero;
// check for last device
if (search_last_discrepancy == 0)
search_last_device_flag = TRUE;
search_result = TRUE;
}
}
// if no device found then reset counters so next 'search' will be like a first
if (!search_result || !search_romcode[0])
{
search_last_discrepancy = 0;
search_last_device_flag = FALSE;
search_last_family_discrepancy = 0;
search_result = FALSE;
}
return search_result;
}
void ow_skip_rom(void)
{
ow_write_byte(0xcc);
}
int8_t ow_search(uint8_t reset_search, uint8_t* last_device, uint8_t* device_address)
{
uint8_t result = eOWSuccess;
uint8_t bit_number = 1;
uint8_t last_zero = 0;
uint8_t serial_byte_number = 0;
uint8_t serial_byte_mask = 1;
uint8_t first_bit, second_bit, direction;
uint8_t i = 0;
if (reset_search) {
last_device = 0;
last_discrepancy = 0;
}
if (!(*last_device)) {
result = ow_reset();
if ( result != eOWSuccess) {
last_device = 0;
last_discrepancy = 0;
return result;
}
ow_write_byte(0xF0); // Send "search ROM command"
do {
if (bit_number < last_discrepancy) {
direction = ((search_serial_nbr[serial_byte_number] & serial_byte_mask) != 0);
} else {
direction = (bit_number == last_discrepancy);
}
result = ow_triplet( &direction, &first_bit, &second_bit);
if ( result != eOWSuccess) {
return result;
}
if (first_bit==0 && second_bit==0 && direction==0) {
last_zero = bit_number;
}
if (first_bit==1 && second_bit==1) {
break;
}
if (direction == 1) {
search_serial_nbr[serial_byte_number] |= serial_byte_mask;
} else {
search_serial_nbr[serial_byte_number] &= ~serial_byte_mask;
}
bit_number++;
serial_byte_mask <<= 1;
if (serial_byte_mask == 0) {
serial_byte_number++;
serial_byte_mask = 1;
}
} while (serial_byte_number < 8);
result = eOWFailure;
if (bit_number == 65) {
last_discrepancy = last_zero;
*last_device = last_discrepancy==0 ? TRUE : FALSE;
for (i=0; i<8; i++) {
device_address[i] = search_serial_nbr[i];
}
return eOWSuccess;
}
if (/*result==eOWFailure ||*/ !search_serial_nbr[0]) {
last_discrepancy = 0;
*last_device = 0;
}
}
return result;
}
void ds18b20_copy_scratch()
{
ow_reset();
ow_write_byte(0xCC);
ow_write_byte(0x48);
}
