xpower napisał(a):
najpierw kopiowałem te ID do struktury ram, a dopiero cała strukturę ram zapisywałem do eeprom.
No i ja też tak robię (co widać w kodzie), tylko korzystam z innej biblioteki i nie mogę sobie poradzić.
[syntax=c]#include<util/delay.h>
#ifndef ONE_WIRE_H
#define ONE_WIRE_H
#define PRZERWANIA_ON
#ifdef PRZERWANIA_ON
#include<avr/interrupt.h>
#endif
#define NULL 0
#define wire_1() W_DDR&=~_BV(W_BIT)
#define wire_0() W_DDR|=_BV(W_BIT)
#define wire() bit_is_set(W_PIN,W_BIT)
#define ERROR_CRC 175
// 1 Wire Commands
#define CONVERT_T 0x44
#define READ_SCRATCHPAD 0xBE
#define WRITE_SCRATCHPAD 0x4E
#define COPY_SCRATCHPAD 0x48
#define RECALL_E2 0xB8
#define READ_POWER_SUPPLY 0xB4
#define SKIP_ROM 0xCC
#define SEARCH_ROM 0xF0
#define READ_ROM 0x33
#define MATCH_ROM 0x55
#define ALARM_SEARCH 0xEC
/* Return codes for OWFirst()/OWNext() */
#define OW_BADWIRE8
#define OW_BADCRC4
#define OW_NOPRESENCE2
#define OW_NOMODULES0
#define OW_FOUND1
#define BIT_9 0x1F
#define BIT_10 0x3F
#define BIT_11 0x5F
#define BIT_12 0x7F
/*deklaracje zmiennych*/
static uint8_t OW_LastDevice = 0;
static uint8_t OW_LastDiscrepancy = 0;
static uint8_t OW_LastFamilyDiscrepancy = 0;
/*deklaracje funkcji*/
static uint8_t OWFirst(uint8_t *ROM, uint8_t do_reset, uint8_t alarm_only);
static uint8_t OWNext(uint8_t *ROM, uint8_t do_reset, uint8_t alarm_only);
static void OWSendCmd(uint8_t *ROM, uint8_t cmd);
uint8_t wire_reset(void)
{
uint8_t ack;
wire_0();
_delay_us(600);
wire_1();
_delay_us(100);
ack=wire();
_delay_us(500);
return ack;
}
void wire_send_bit(uint8_t bit)
{
#ifdef PRZERWANIA_ON
uint8_t sreg=SREG;
cli();
#endif
wire_0();
_delay_us(10);
if(bit)
{
wire_1();
_delay_us(60);
}
else
{
_delay_us(80);
wire_1();
}
_delay_us(5);
#ifdef PRZERWANIA_ON
SREG=sreg;
#endif
}
uint8_t wire_receive_bit(void)
{
#ifdef PRZERWANIA_ON
uint8_t sreg=SREG;
cli();
#endif
uint8_t bit;
wire_0();
_delay_us(5);
wire_1();
_delay_us(10);
bit=wire();
//while(!wire()){};
_delay_us(50);
#ifdef PRZERWANIA_ON
SREG=sreg;
#endif
return (bit?1:0);
}
void wire_write_byte(uint8_t command)
{
for (uint8_t i = 0; i < 8; i++)
{
wire_send_bit(command & 0x01);
command >>= 1; //shift to next bit
}
}
uint8_t wire_read_byte(void)
{
uint8_t i, result = 0;
for (i = 0; i < 8; i++)
{
result >>= 1;
if (wire_receive_bit())result |= 0x80;
}
return(result);
}
static void wire_init(uint8_t* adr,uint8_t rozdz,uint8_t tmin,uint8_t tmax)
{
OWSendCmd(adr,WRITE_SCRATCHPAD);
wire_write_byte(tmax);
wire_write_byte(tmin);
wire_write_byte(rozdz);
OWSendCmd(adr,COPY_SCRATCHPAD);
_delay_ms(10);
}
/*********************************************************************************************
* Function name : OW_ComputeCRC8
*
* Purpose :Compute the CRC8 value of a data set.
* This function will compute the CRC8 or DOW-CRC of inData using seed
* as inital value for the CRC.
*
* Parameters: inData One byte of data to compute CRC from.
*
* seed The starting value of the CRC.
*
* Return: The CRC8 of inData with seed as initial value.
*
* Note: Setting seed to 0 computes the crc8 of the inData.
* Constantly passing the return value of this function
* As the seed argument computes the CRC8 value of a
* longer string of data.
************************************************************************************************ */
unsigned char wire_compute_CRC8(unsigned char inData, unsigned char seed)
{
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;
}
/*-----------------------------------------------------------------------------
* Send a 1 wire command to a device, or all if no ROM ID provided
*/
static void OWSendCmd(uint8_t *ROM, uint8_t cmd)
{
uint8_ti;
wire_reset();
wire_write_byte(MATCH_ROM);
for (i = 0; i < 8; i++)
wire_write_byte(ROM[i]);
wire_write_byte(cmd);
}
/*-----------------------------------------------------------------------------
* Search algorithm from App note 187 (and 162)
*
* OWFirst/OWNext return..
* 1 when something is found,
* 0 no more modules
* -1 if no presense pulse,
* -2 if bad CRC,
* -3 if bad wiring.
*/
static uint8_t OWFirst(uint8_t *ROM, uint8_t do_reset, uint8_t alarm_only)
{
/* Reset state */
OW_LastDiscrepancy = 0;
OW_LastDevice = 0;
OW_LastFamilyDiscrepancy = 0;
/* Go looking */
return (OWNext(ROM, do_reset, alarm_only));
}
/* Returns 1 when something is found, 0 if nothing left */
static uint8_t OWNext(uint8_t *ROM, uint8_t do_reset, uint8_t alarm_only)
{
uint8_tbit_test, search_direction, bit_number;
uint8_tlast_zero, rom_byte_number, rom_byte_mask;
uint8_tlastcrc8, crcaccum;
int8_tnext_result;
/* Init for search */
bit_number = 1;
last_zero = 0;
rom_byte_number = 0;
rom_byte_mask = 1;
next_result = OW_NOMODULES;
lastcrc8 = 0;
crcaccum = 0;
/* if the last call was not the last one */
if (!OW_LastDevice)
{
/* check if reset first is requested */
if (do_reset)
{
/* reset the 1-wire * if there are no parts on 1-wire, return 0 */
if (wire_reset())
{
/* reset the search */
OW_LastDiscrepancy = 0;
OW_LastFamilyDiscrepancy = 0;
return OW_NOPRESENCE;
}
}
/* If finding alarming devices issue a different command */
if (alarm_only)
wire_write_byte(ALARM_SEARCH);/* issue the alarming search command */
else
wire_write_byte(SEARCH_ROM);/* issue the search command */
/* pause before beginning the search */
_delay_us(210);
/* loop to do the search */
do
{
/* read a bit and its compliment */
bit_test = wire_receive_bit() << 1;
bit_test |= wire_receive_bit();
/* check for no devices on 1-wire */
if (bit_test == 3)
{
return(OW_BADWIRE);
}
else
{
/* all devices coupled have 0 or 1 */
if (bit_test > 0)
search_direction = !(bit_test & 0x01); /* bit write value for search */
else
{
/* if this discrepancy is before the Last Discrepancy
* on a previous OWNext then pick the same as last time */
if (bit_number < OW_LastDiscrepancy)
search_direction = ((ROM[rom_byte_number] & rom_byte_mask) > 0);
else
/* if equal to last pick 1, if not then pick 0 */
search_direction = (bit_number == OW_LastDiscrepancy);
/* if 0 was picked then record its position in LastZero */
if (search_direction == 0)
{
last_zero = bit_number;
/* check for Last discrepancy in family */
if (last_zero < 9)
OW_LastFamilyDiscrepancy = last_zero;
}
}
/* set or clear the bit in the ROM byte rom_byte_number
* with mask rom_byte_mask */
if (search_direction == 1)
ROM[rom_byte_number] |= rom_byte_mask;
else
ROM[rom_byte_number] &= ~rom_byte_mask;
/* serial number search direction write bit */
wire_send_bit(search_direction);
/* increment the byte counter bit_number
* and shift the mask rom_byte_mask */
bit_number++;
rom_byte_mask <<= 1;
/* if the mask is 0 then go to new ROM byte rom_byte_number
* and reset mask */
if (rom_byte_mask == 0)
{
crcaccum=wire_compute_CRC8(ROM[rom_byte_number],crcaccum); /* accumulate the CRC */
lastcrc8 = crcaccum;
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 (!(bit_number < 65) || lastcrc8)
{
if (lastcrc8)
{
next_result = OW_BADCRC;
}
else
{
/* search successful so set LastDiscrepancy,LastDevice,next_result */
OW_LastDiscrepancy = last_zero;
OW_LastDevice = (OW_LastDiscrepancy == 0);
next_result = OW_FOUND;
}
}
}
/* if no device found then reset counters so next 'next' will be
* like a first */
if (next_result != OW_FOUND || ROM[0] == 0)
{
OW_LastDiscrepancy = 0;
OW_LastDevice = 0;
OW_LastFamilyDiscrepancy = 0;
}
if (next_result == OW_FOUND && ROM[0] == 0x00)
next_result = OW_BADWIRE;
return next_result;
}
#endif[/syntax]Statystyki: Napisane przez luqasz1 — 5 lip 2014, o 11:14
]]>