OWI.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include <ioavr.h>
#include <inavr.h>

#include "OWI.h"


//******************************************************************************
// Functions
//******************************************************************************
void OWI_Init(unsigned char pins){
        OWI_RELEASE_BUS(pins);
        // The first rising edge can be interpreted by a slave as the end of a
        // Reset-pulse. Delay for the required reset recovery time (H) to be 
        // sure that the real reset is interpreted correctly.
        __delay_cycles(OWI_DELAY_H_STD_MODE);
}


void OWI_WriteBit1(unsigned char pins){
        unsigned char intState;
        
        // Disable interrupts.
        intState = __save_interrupt();
        __disable_interrupt();
        
        // Drive bus low and delay.
        OWI_PULL_BUS_LOW(pins);
        __delay_cycles(OWI_DELAY_A_STD_MODE);
        
        // Release bus and delay.
        OWI_RELEASE_BUS(pins);
        __delay_cycles(OWI_DELAY_B_STD_MODE);
        
        // Restore interrupts.
        __restore_interrupt(intState);
}

void OWI_WriteBit0(unsigned char pins)
{
        unsigned char intState;
        
        // Disable interrupts.
        intState = __save_interrupt();
        __disable_interrupt();
        
        // Drive bus low and delay.
        OWI_PULL_BUS_LOW(pins);
        __delay_cycles(OWI_DELAY_C_STD_MODE);
        
        // Release bus and delay.
        OWI_RELEASE_BUS(pins);
        __delay_cycles(OWI_DELAY_D_STD_MODE);
        
        // Restore interrupts.
        __restore_interrupt(intState);
}

unsigned char OWI_ReadBit(unsigned char pins)
{
        unsigned char intState;
        unsigned char bitsRead;
        
        // Disable interrupts.
        intState = __save_interrupt();
        __disable_interrupt();
        
        // Drive bus low and delay.
        OWI_PULL_BUS_LOW(pins);
        __delay_cycles(OWI_DELAY_A_STD_MODE);
        
        // Release bus and delay.
        OWI_RELEASE_BUS(pins);
        __delay_cycles(OWI_DELAY_E_STD_MODE);
        
        // Sample bus and delay.
        bitsRead = OWI_PIN & pins;
        __delay_cycles(OWI_DELAY_F_STD_MODE);
        
        // Restore interrupts.
        __restore_interrupt(intState);
        
        return bitsRead;
}


unsigned char OWI_DetectPresence(unsigned char pins)
{
        unsigned char intState;
        unsigned char presenceDetected;
        
        // Disable interrupts.
        intState = __save_interrupt();
        __disable_interrupt();
        
        // Drive bus low and delay.
        OWI_PULL_BUS_LOW(pins);
        __delay_cycles(OWI_DELAY_H_STD_MODE);
        
        // Release bus and delay.
        OWI_RELEASE_BUS(pins);
        __delay_cycles(OWI_DELAY_I_STD_MODE);
        
        // Sample bus to detect presence signal and delay.
        presenceDetected = ((~OWI_PIN) & pins);
        __delay_cycles(OWI_DELAY_J_STD_MODE);
        
        // Restore interrupts.
        __restore_interrupt(intState);
        
        return presenceDetected;
}


void OWI_SendByte(unsigned char data, unsigned char pins)
{
        unsigned char temp;
        unsigned char i;
        
        // Do once for each bit
        for (i = 0; i < 8; i++) {
                // Determine if LSB is '0' or '1' and transmit corresponding
                // waveform on the bus.
                temp = data & 0x01;
                
                if (temp) {
                        OWI_WriteBit1(pins);
                } else {
                        OWI_WriteBit0(pins);
                }
        
                data >>= 1;  // Right shift the data to get next bit.
        }
}


unsigned char OWI_ReceiveByte(unsigned char pin)
{
        unsigned char data;
        unsigned char i;
        
        // Clear the temporary input variable.
        data = 0x00;
        
        // Do once for each bit
        for (i = 0; i < 8; i++) {
                // Shift temporary input variable right.
                data >>= 1;
                
                // Set the MSB if a '1' value is read from the bus.
                // Leave as it is ('0') else.
                if (OWI_ReadBit(pin)) {
                        data |= 0x80;
                }
        }
        
        return data;
}


void OWI_SkipRom(unsigned char pins)
{
        // Send the SKIP ROM command on the bus.
        OWI_SendByte(OWI_ROM_SKIP, pins);
}


void OWI_ReadRom(unsigned char * romValue, unsigned char pin)
{
        unsigned char bytesLeft = 8;
        
        // Send the READ ROM command on the bus.
        OWI_SendByte(OWI_ROM_READ, pin);
        
        // Do 8 times.
        while (bytesLeft > 0) {
                // Place the received data in memory.
                *romValue++ = OWI_ReceiveByte(pin);
                bytesLeft--;
        }
}


void OWI_MatchRom(unsigned char * romValue, unsigned char pins)
{
        unsigned char bytesLeft = 8;   
        
        // Send the MATCH ROM command.
        OWI_SendByte(OWI_ROM_MATCH, pins);
        
        // Do once for each byte.
        while (bytesLeft > 0) {
                // Transmit 1 byte of the ID to match.
                OWI_SendByte(*romValue++, pins);
                bytesLeft--;
        }
}


unsigned char OWI_SearchRom(unsigned char * bitPattern,
                                                unsigned char lastDeviation, unsigned char pin)
{
        unsigned char currentBit = 1;
        unsigned char newDeviation = 0;
        unsigned char bitMask = 0x01;
        unsigned char bitA;
        unsigned char bitB;
        
        // Send SEARCH ROM command on the bus.
        OWI_SendByte(OWI_ROM_SEARCH, pin);
        
        // Walk through all 64 bits.
        while (currentBit <= 64) {
                // Read bit from bus twice.
                bitA = OWI_ReadBit(pin);
                bitB = OWI_ReadBit(pin);
                
                if (bitA && bitB) {
                        // Both bits 1 (Error).
                        newDeviation = OWI_ROM_SEARCH_FAILED;
                        return newDeviation;
                } else if (bitA ^ bitB) {
                        // Bits A and B are different. All devices have the same bit here.
                        // Set the bit in bitPattern to this value.
                        if (bitA) {
                                (*bitPattern) |= bitMask;
                        } else {
                                (*bitPattern) &= ~bitMask;
                        }
                } else {
                        // If this is where a choice was made the last time,
                        // a '1' bit is selected this time.
                        if (currentBit == lastDeviation) {
                                (*bitPattern) |= bitMask;
                        }
                        
                        // For the rest of the id, '0' bits are selected when
                        // discrepancies occur.
                        else if (currentBit > lastDeviation) {
                                (*bitPattern) &= ~bitMask;
                                newDeviation = currentBit;
                        }
                        
                        // If current bit in bit pattern = 0, then this is
                        // out new deviation.
                        else if ( !(*bitPattern & bitMask)) {
                                newDeviation = currentBit;
                        }
                        
                // IF the bit is already 1, do nothing.
                        else {
                        }
                }
                
                // Send the selected bit to the bus.
                if ((*bitPattern) & bitMask) {
                        OWI_WriteBit1(pin);
                } else {
                        OWI_WriteBit0(pin);
                }
                
                // Increment current bit.    
                currentBit++;
                
                // Adjust bitMask and bitPattern pointer.    
                bitMask <<= 1;
                if (!bitMask) {
                        bitMask = 0x01;
                        bitPattern++;
                }
        }
        
        return newDeviation;
}


/* Functions for handling CRC */
unsigned char OWI_ComputeCRC8(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;    
}


unsigned int OWI_ComputeCRC16(unsigned char inData, unsigned int seed)
{
        unsigned char bitsLeft;
        unsigned char temp;
        
        for (bitsLeft = 8; bitsLeft > 0; bitsLeft--) {
                temp = ((seed ^ inData) & 0x01);
                
                if (temp == 0) {
                        seed >>= 1;
          } else {
                        seed ^= 0x4002;
                        seed >>= 1;
                        seed |= 0x8000;
                }

                inData >>= 1;
        }
        
        return seed;    
}


unsigned char OWI_CheckRomCRC(unsigned char *romValue)
{
        unsigned char i;
        unsigned char crc8 = 0;
        
        for (i = 0; i < 7; i++) {
                crc8 = OWI_ComputeCRC8(*romValue, crc8);
                romValue++;
        }
        
        if (crc8 == (*romValue)) {
                return OWI_CRC_OK;
        }
        
        return OWI_CRC_ERROR;
}

---