Diff: OneWireCRC.cpp
- Revision:
- 1:7218c076189b
- Child:
- 2:193926923cb0
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/OneWireCRC.cpp Sun Apr 17 17:26:52 2011 +0000
@@ -0,0 +1,549 @@
+/*
+* OneWireCRC. This is a port to mbed of Jim Studt's Adruino One Wire
+* library. Please see additional copyrights below this one, including
+* references to other copyrights.
+*
+* Copyright (C) <2011> Version 1.2 Wim De Roeve
+* <2009> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireCRC.
+*
+* OneWireCRC is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* OneWireCRC is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireCRC. If not, see <http://www.gnu.org/licenses/>.
+*/
+/*
+Copyright (c) 2007, Jim Studt
+
+Version 2.0: Modifications by Paul Stoffregen, January 2010:
+http://www.pjrc.com/teensy/td_libs_OneWire.html
+ Search fix from Robin James
+ http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
+ Use direct optimized I/O in all cases
+ Disable interrupts during timing critical sections
+ (this solves many random communication errors)
+ Disable interrupts during read-modify-write I/O
+ Reduce RAM consumption by eliminating unnecessary
+ variables and trimming many to 8 bits
+ Optimize both crc8 - table version moved to flash
+
+Modified to work with larger numbers of devices - avoids loop.
+Tested in Arduino 11 alpha with 12 sensors.
+26 Sept 2008 -- Robin James
+http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
+
+
+Updated to work with arduino-0008 and to include skip() as of
+2007/07/06. --RJL20
+
+Modified to calculate the 8-bit CRC directly, avoiding the need for
+the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010
+-- Tom Pollard, Jan 23, 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Much of the code was inspired by Derek Yerger's code, though I don't
+think much of that remains. In any event that was..
+ (copyleft) 2006 by Derek Yerger - Free to distribute freely.
+
+The CRC code was excerpted and inspired by the Dallas Semiconductor
+sample code bearing this copyright.
+*/
+//---------------------------------------------------------------------------
+// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// Except as contained in this notice, the name of Dallas Semiconductor
+// shall not be used except as stated in the Dallas Semiconductor
+// Branding Policy.
+//--------------------------------------------------------------------------
+
+#include "OneWireCRC.h"
+#include "OneWireDefs.h"
+
+// recommended data sheet timings in micro seconds
+const int standardT[] = {6, 64, 60, 10, 9, 55, 0, 480, 70, 410};
+const int overdriveT[] = {1.5, 7.5, 7.5, 2.5, 0.75, 7, 2.5, 70, 8.5, 40};
+
+OneWireCRC::OneWireCRC(PinName oneWire, eSpeed speed) : oneWirePort(oneWire)
+{
+ if (STANDARD == speed) timing = standardT;
+ else timing = overdriveT; // overdrive
+
+ resetSearch(); // reset address search state
+}
+
+// Generate a 1-wire reset, return 1 if no presence detect was found,
+// return 0 otherwise.
+// (NOTE: does not handle alarm presence from DS2404/DS1994)
+int OneWireCRC::reset()
+{
+
+ BYTE result = 0; // sample presence pulse result
+
+ wait_us(timing[6]);
+ oneWirePort.output();
+ oneWirePort = 0;
+ wait_us(timing[7]);
+ oneWirePort.input();
+ wait_us(timing[8]);
+ result = !(oneWirePort & 0x01);
+ wait_us(timing[9]);
+
+ return result;
+}
+
+//
+// Write a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+void OneWireCRC::writeBit(int bit)
+{
+ bit = bit & 0x01;
+
+ if (bit)
+ {
+ // Write '1' bit
+ oneWirePort.output();
+ oneWirePort = 0;
+ wait_us(timing[0]);
+ oneWirePort.input();
+ wait_us(timing[1]);
+ }
+ else
+ {
+ // Write '0' bit
+ oneWirePort.output();
+ oneWirePort = 0;
+ wait_us(timing[2]);
+ oneWirePort.input();
+ wait_us(timing[3]);
+ }
+}
+
+//
+// Read a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+int OneWireCRC::readBit()
+{
+ BYTE result;
+
+ oneWirePort.output();
+ oneWirePort = 0;
+ wait_us(timing[0]);
+ oneWirePort.input();
+ wait_us(timing[4]);
+ result = oneWirePort & 0x01;
+ wait_us(timing[5]);
+
+ return result;
+}
+
+//
+// Write a byte. The writing code uses the active drivers to raise the
+// pin high, if you need power after the write (e.g. DS18S20 in
+// parasite power mode) then set 'power' to 1, otherwise the pin will
+// go tri-state at the end of the write to avoid heating in a short or
+// other mishap.
+//
+void OneWireCRC::writeByte(int data)
+{
+ // Loop to write each bit in the byte, LS-bit first
+ for (int loop = 0; loop < 8; loop++)
+ {
+ writeBit(data & 0x01);
+
+ // shift the data byte for the next bit
+ data >>= 1;
+ }
+}
+
+//
+// Read a byte
+//
+int OneWireCRC::readByte()
+{
+ int result = 0;
+
+ for (int loop = 0; loop < 8; loop++)
+ {
+ // shift the result to get it ready for the next bit
+ result >>= 1;
+
+ // if result is one, then set MS bit
+ if (readBit()) result |= 0x80;
+ }
+
+ return result;
+}
+
+int OneWireCRC::touchByte(int data)
+{
+ int result = 0;
+
+ for (int loop = 0; loop < 8; loop++)
+ {
+ // shift the result to get it ready for the next bit
+ result >>= 1;
+
+ // If sending a '1' then read a bit else write a '0'
+ if (data & 0x01)
+ {
+ if (readBit()) result |= 0x80;
+ }
+ else writeBit(0);
+
+ // shift the data byte for the next bit
+ data >>= 1;
+ }
+
+ return result;
+}
+
+void OneWireCRC::block(BYTE* data, int data_len)
+{
+ for (int loop = 0; loop < data_len; loop++)
+ {
+ data[loop] = touchByte(data[loop]);
+ }
+}
+
+int OneWireCRC::overdriveSkip(BYTE* data, int data_len)
+{
+ // set the speed to 'standard'
+ timing = standardT;
+
+ // reset all devices
+ if (reset()) return 0; // if no devices found
+
+ // overdrive skip command
+ writeByte(OVERDRIVE_SKIP);
+
+ // set the speed to 'overdrive'
+ timing = overdriveT;
+
+ // do a 1-Wire reset in 'overdrive' and return presence result
+ return reset();
+}
+
+//
+// Do a ROM select
+//
+void OneWireCRC::matchROM(BYTE rom[8])
+{
+ writeByte(MATCH_ROM); // Choose ROM
+
+ for(int i = 0; i < 8; i++) writeByte(rom[i]);
+}
+
+//
+// Do a ROM skip
+//
+void OneWireCRC::skipROM()
+{
+ writeByte(SKIP_ROM); // Skip ROM
+}
+
+//
+// You need to use this function to start a search again from the beginning.
+// You do not need to do it for the first search, though you could.
+//
+void OneWireCRC::resetSearch()
+{
+ /* searchJunction = -1;
+ searchExhausted = false;
+ for (int i = 0; i < 8; i++)
+ {
+ _address[i] = 0;
+ }*/
+
+ // reset the search state
+ LastDiscrepancy = 0;
+ LastDeviceFlag = 0;
+ LastFamilyDiscrepancy = 0;
+ for(int i = 7; ; i--)
+ {
+ ROM_NO[i] = 0;
+ if ( i == 0) break;
+ }
+}
+// Changed in version 1.1
+//
+// Perform a search. If this function returns a '1' then it has
+// enumerated the next device and you may retrieve the ROM from the
+// OneWire::address variable. If there are no devices, no further
+// devices, or something horrible happens in the middle of the
+// enumeration then a 0 is returned. If a new device is found then
+// its address is copied to newAddr. Use OneWire::reset_search() to
+// start over.
+//
+// --- Replaced by the one from the Dallas Semiconductor web site ---
+//--------------------------------------------------------------------------
+// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing
+// search state.
+// Return TRUE : device found, ROM number in ROM_NO buffer
+// FALSE : device not found, end of search
+//
+uint8_t OneWireCRC::search(uint8_t *newAddr)
+{
+ uint8_t id_bit_number;
+ uint8_t last_zero, rom_byte_number, search_result;
+ uint8_t 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;
+
+ // if the last call was not the last one
+ if (!LastDeviceFlag)
+ {
+ // 1-Wire reset
+ if (!reset())
+ {
+ // reset the search
+ LastDiscrepancy = 0;
+ LastDeviceFlag = 0;
+ LastFamilyDiscrepancy = 0;
+ return 0;
+ }
+
+ // issue the search command
+ writeByte(0xF0);
+
+ // loop to do the search
+ do
+ {
+ // read a bit and its complement
+ id_bit = readBit();
+ cmp_id_bit = readBit();
+
+ // 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 < LastDiscrepancy)
+ search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0);
+ else
+ // if equal to last pick 1, if not then pick 0
+ search_direction = (id_bit_number == LastDiscrepancy);
+
+ // 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)
+ 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_NO[rom_byte_number] |= rom_byte_mask;
+ else
+ ROM_NO[rom_byte_number] &= ~rom_byte_mask;
+
+ // serial number search direction write bit
+ writeBit(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)
+ {
+ 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 successful so set LastDiscrepancy,LastDeviceFlag,search_result
+ LastDiscrepancy = last_zero;
+
+ // check for last device
+ if (LastDiscrepancy == 0)
+ LastDeviceFlag = 1;
+
+ search_result = 1;
+ }
+ }
+
+ // if no device found then reset counters so next 'search' will be like a first
+ if (!search_result || !ROM_NO[0])
+ {
+ LastDiscrepancy = 0;
+ LastDeviceFlag = 0;
+ LastFamilyDiscrepancy = 0;
+ search_result = 0;
+ }
+ else
+ for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i];
+
+ return search_result;
+ }
+
+// The 1-Wire CRC scheme is described in Maxim Application Note 27:
+// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
+//
+
+#if ONEWIRE_CRC8_TABLE
+// This table comes from Dallas sample code where it is freely reusable,
+// though Copyright (C) 2000 Dallas Semiconductor Corporation
+static BYTE dscrc_table[] =
+{
+ 0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
+ 157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
+ 35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
+ 190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
+ 70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
+ 219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
+ 101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
+ 248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
+ 140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
+ 17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
+ 175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
+ 50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
+ 202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
+ 87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
+ 233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
+ 116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
+
+//
+// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
+// and the registers. (note: this might better be done without the
+// table, it would probably be smaller and certainly fast enough
+// compared to all those delayMicrosecond() calls. But I got
+// confused, so I use this table from the examples.)
+//
+BYTE OneWireCRC::crc8(BYTE* addr, BYTE len)
+{
+ BYTE i;
+ BYTE crc = 0;
+
+ for (i = 0; i < len; i++)
+ {
+ crc = dscrc_table[crc ^ addr[i] ];
+ }
+
+ return crc;
+}
+#else
+//
+// Compute a Dallas Semiconductor 8 bit CRC directly.
+//
+BYTE OneWireCRC::crc8(BYTE* addr, BYTE len)
+{
+ BYTE i, j;
+ BYTE crc = 0;
+
+ for (i = 0; i < len; i++)
+ {
+ BYTE inbyte = addr[i];
+ for (j = 0; j < 8; j++)
+ {
+ BYTE mix = (crc ^ inbyte) & 0x01;
+ crc >>= 1;
+ if (mix) crc ^= 0x8C;
+ inbyte >>= 1;
+ }
+ }
+
+ return crc;
+}
+#endif
+
+static short oddparity[16] = { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
+
+//
+// Compute a Dallas Semiconductor 16 bit CRC. I have never seen one of
+// these, but here it is.
+//
+unsigned short OneWireCRC::crc16(unsigned short* data, unsigned short len)
+{
+ unsigned short i;
+ unsigned short crc = 0;
+
+ for ( i = 0; i < len; i++)
+ {
+ unsigned short cdata = data[len];
+
+ cdata = (cdata ^ (crc & 0xff)) & 0xff;
+ crc >>= 8;
+
+ if (oddparity[cdata & 0xf] ^ oddparity[cdata >> 4]) crc ^= 0xc001;
+
+ cdata <<= 6;
+ crc ^= cdata;
+ cdata <<= 1;
+ crc ^= cdata;
+ }
+
+ return crc;
+}
+
Wim De Roeve