|
@@ -0,0 +1,580 @@
|
|
|
+/*
|
|
|
+Copyright (c) 2007, Jim Studt (original old version - many contributors since)
|
|
|
+
|
|
|
+The latest version of this library may be found at:
|
|
|
+ http://www.pjrc.com/teensy/td_libs_OneWire.html
|
|
|
+
|
|
|
+OneWire has been maintained by Paul Stoffregen (paul@pjrc.com) since
|
|
|
+January 2010.
|
|
|
+
|
|
|
+DO NOT EMAIL for technical support, especially not for ESP chips!
|
|
|
+All project support questions must be posted on public forums
|
|
|
+relevant to the board or chips used. If using Arduino, post on
|
|
|
+Arduino's forum. If using ESP, post on the ESP community forums.
|
|
|
+There is ABSOLUTELY NO TECH SUPPORT BY PRIVATE EMAIL!
|
|
|
+
|
|
|
+Github's issue tracker for OneWire should be used only to report
|
|
|
+specific bugs. DO NOT request project support via Github. All
|
|
|
+project and tech support questions must be posted on forums, not
|
|
|
+github issues. If you experience a problem and you are not
|
|
|
+absolutely sure it's an issue with the library, ask on a forum
|
|
|
+first. Only use github to report issues after experts have
|
|
|
+confirmed the issue is with OneWire rather than your project.
|
|
|
+
|
|
|
+Back in 2010, OneWire was in need of many bug fixes, but had
|
|
|
+been abandoned the original author (Jim Studt). None of the known
|
|
|
+contributors were interested in maintaining OneWire. Paul typically
|
|
|
+works on OneWire every 6 to 12 months. Patches usually wait that
|
|
|
+long. If anyone is interested in more actively maintaining OneWire,
|
|
|
+please contact Paul (this is pretty much the only reason to use
|
|
|
+private email about OneWire).
|
|
|
+
|
|
|
+OneWire is now very mature code. No changes other than adding
|
|
|
+definitions for newer hardware support are anticipated.
|
|
|
+
|
|
|
+Version 2.3:
|
|
|
+ Unknown chip fallback mode, Roger Clark
|
|
|
+ Teensy-LC compatibility, Paul Stoffregen
|
|
|
+ Search bug fix, Love Nystrom
|
|
|
+
|
|
|
+Version 2.2:
|
|
|
+ Teensy 3.0 compatibility, Paul Stoffregen, paul@pjrc.com
|
|
|
+ Arduino Due compatibility, http://arduino.cc/forum/index.php?topic=141030
|
|
|
+ Fix DS18B20 example negative temperature
|
|
|
+ Fix DS18B20 example's low res modes, Ken Butcher
|
|
|
+ Improve reset timing, Mark Tillotson
|
|
|
+ Add const qualifiers, Bertrik Sikken
|
|
|
+ Add initial value input to crc16, Bertrik Sikken
|
|
|
+ Add target_search() function, Scott Roberts
|
|
|
+
|
|
|
+Version 2.1:
|
|
|
+ Arduino 1.0 compatibility, Paul Stoffregen
|
|
|
+ Improve temperature example, Paul Stoffregen
|
|
|
+ DS250x_PROM example, Guillermo Lovato
|
|
|
+ PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com
|
|
|
+ Improvements from Glenn Trewitt:
|
|
|
+ - crc16() now works
|
|
|
+ - check_crc16() does all of calculation/checking work.
|
|
|
+ - Added read_bytes() and write_bytes(), to reduce tedious loops.
|
|
|
+ - Added ds2408 example.
|
|
|
+ Delete very old, out-of-date readme file (info is here)
|
|
|
+
|
|
|
+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
|
|
|
+
|
|
|
+Jim Studt's original library was modified by Josh Larios.
|
|
|
+
|
|
|
+Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 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 <Arduino.h>
|
|
|
+#include "OneWire.h"
|
|
|
+#include "util/OneWire_direct_gpio.h"
|
|
|
+
|
|
|
+
|
|
|
+void OneWire::begin(uint8_t pin)
|
|
|
+{
|
|
|
+ pinMode(pin, INPUT);
|
|
|
+ bitmask = PIN_TO_BITMASK(pin);
|
|
|
+ baseReg = PIN_TO_BASEREG(pin);
|
|
|
+#if ONEWIRE_SEARCH
|
|
|
+ reset_search();
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// Perform the onewire reset function. We will wait up to 250uS for
|
|
|
+// the bus to come high, if it doesn't then it is broken or shorted
|
|
|
+// and we return a 0;
|
|
|
+//
|
|
|
+// Returns 1 if a device asserted a presence pulse, 0 otherwise.
|
|
|
+//
|
|
|
+uint8_t OneWire::reset(void)
|
|
|
+{
|
|
|
+ IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
|
|
|
+ volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
|
|
|
+ uint8_t r;
|
|
|
+ uint8_t retries = 125;
|
|
|
+
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_MODE_INPUT(reg, mask);
|
|
|
+ interrupts();
|
|
|
+ // wait until the wire is high... just in case
|
|
|
+ do {
|
|
|
+ if (--retries == 0) return 0;
|
|
|
+ delayMicroseconds(2);
|
|
|
+ } while ( !DIRECT_READ(reg, mask));
|
|
|
+
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_WRITE_LOW(reg, mask);
|
|
|
+ DIRECT_MODE_OUTPUT(reg, mask); // drive output low
|
|
|
+ interrupts();
|
|
|
+ delayMicroseconds(480);
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_MODE_INPUT(reg, mask); // allow it to float
|
|
|
+ delayMicroseconds(70);
|
|
|
+ r = !DIRECT_READ(reg, mask);
|
|
|
+ interrupts();
|
|
|
+ delayMicroseconds(410);
|
|
|
+ return r;
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// Write a bit. Port and bit is used to cut lookup time and provide
|
|
|
+// more certain timing.
|
|
|
+//
|
|
|
+void OneWire::write_bit(uint8_t v)
|
|
|
+{
|
|
|
+ IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
|
|
|
+ volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
|
|
|
+
|
|
|
+ if (v & 1) {
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_WRITE_LOW(reg, mask);
|
|
|
+ DIRECT_MODE_OUTPUT(reg, mask); // drive output low
|
|
|
+ delayMicroseconds(10);
|
|
|
+ DIRECT_WRITE_HIGH(reg, mask); // drive output high
|
|
|
+ interrupts();
|
|
|
+ delayMicroseconds(55);
|
|
|
+ } else {
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_WRITE_LOW(reg, mask);
|
|
|
+ DIRECT_MODE_OUTPUT(reg, mask); // drive output low
|
|
|
+ delayMicroseconds(65);
|
|
|
+ DIRECT_WRITE_HIGH(reg, mask); // drive output high
|
|
|
+ interrupts();
|
|
|
+ delayMicroseconds(5);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// Read a bit. Port and bit is used to cut lookup time and provide
|
|
|
+// more certain timing.
|
|
|
+//
|
|
|
+uint8_t OneWire::read_bit(void)
|
|
|
+{
|
|
|
+ IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
|
|
|
+ volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
|
|
|
+ uint8_t r;
|
|
|
+
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_MODE_OUTPUT(reg, mask);
|
|
|
+ DIRECT_WRITE_LOW(reg, mask);
|
|
|
+ delayMicroseconds(3);
|
|
|
+ DIRECT_MODE_INPUT(reg, mask); // let pin float, pull up will raise
|
|
|
+ delayMicroseconds(10);
|
|
|
+ r = DIRECT_READ(reg, mask);
|
|
|
+ interrupts();
|
|
|
+ delayMicroseconds(53);
|
|
|
+ return r;
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// 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 OneWire::write(uint8_t v, uint8_t power /* = 0 */) {
|
|
|
+ uint8_t bitMask;
|
|
|
+
|
|
|
+ for (bitMask = 0x01; bitMask; bitMask <<= 1) {
|
|
|
+ OneWire::write_bit( (bitMask & v)?1:0);
|
|
|
+ }
|
|
|
+ if ( !power) {
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_MODE_INPUT(baseReg, bitmask);
|
|
|
+ DIRECT_WRITE_LOW(baseReg, bitmask);
|
|
|
+ interrupts();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) {
|
|
|
+ for (uint16_t i = 0 ; i < count ; i++)
|
|
|
+ write(buf[i]);
|
|
|
+ if (!power) {
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_MODE_INPUT(baseReg, bitmask);
|
|
|
+ DIRECT_WRITE_LOW(baseReg, bitmask);
|
|
|
+ interrupts();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// Read a byte
|
|
|
+//
|
|
|
+uint8_t OneWire::read() {
|
|
|
+ uint8_t bitMask;
|
|
|
+ uint8_t r = 0;
|
|
|
+
|
|
|
+ for (bitMask = 0x01; bitMask; bitMask <<= 1) {
|
|
|
+ if ( OneWire::read_bit()) r |= bitMask;
|
|
|
+ }
|
|
|
+ return r;
|
|
|
+}
|
|
|
+
|
|
|
+void OneWire::read_bytes(uint8_t *buf, uint16_t count) {
|
|
|
+ for (uint16_t i = 0 ; i < count ; i++)
|
|
|
+ buf[i] = read();
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// Do a ROM select
|
|
|
+//
|
|
|
+void OneWire::select(const uint8_t rom[8])
|
|
|
+{
|
|
|
+ uint8_t i;
|
|
|
+
|
|
|
+ write(0x55); // Choose ROM
|
|
|
+
|
|
|
+ for (i = 0; i < 8; i++) write(rom[i]);
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// Do a ROM skip
|
|
|
+//
|
|
|
+void OneWire::skip()
|
|
|
+{
|
|
|
+ write(0xCC); // Skip ROM
|
|
|
+}
|
|
|
+
|
|
|
+void OneWire::depower()
|
|
|
+{
|
|
|
+ noInterrupts();
|
|
|
+ DIRECT_MODE_INPUT(baseReg, bitmask);
|
|
|
+ interrupts();
|
|
|
+}
|
|
|
+
|
|
|
+#if ONEWIRE_SEARCH
|
|
|
+
|
|
|
+//
|
|
|
+// 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 OneWire::reset_search()
|
|
|
+{
|
|
|
+ // reset the search state
|
|
|
+ LastDiscrepancy = 0;
|
|
|
+ LastDeviceFlag = false;
|
|
|
+ LastFamilyDiscrepancy = 0;
|
|
|
+ for(int i = 7; ; i--) {
|
|
|
+ ROM_NO[i] = 0;
|
|
|
+ if ( i == 0) break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Setup the search to find the device type 'family_code' on the next call
|
|
|
+// to search(*newAddr) if it is present.
|
|
|
+//
|
|
|
+void OneWire::target_search(uint8_t family_code)
|
|
|
+{
|
|
|
+ // set the search state to find SearchFamily type devices
|
|
|
+ ROM_NO[0] = family_code;
|
|
|
+ for (uint8_t i = 1; i < 8; i++)
|
|
|
+ ROM_NO[i] = 0;
|
|
|
+ LastDiscrepancy = 64;
|
|
|
+ LastFamilyDiscrepancy = 0;
|
|
|
+ LastDeviceFlag = false;
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// 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
|
|
|
+//
|
|
|
+bool OneWire::search(uint8_t *newAddr, bool search_mode /* = true */)
|
|
|
+{
|
|
|
+ uint8_t id_bit_number;
|
|
|
+ uint8_t last_zero, rom_byte_number;
|
|
|
+ bool 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 = false;
|
|
|
+
|
|
|
+ // if the last call was not the last one
|
|
|
+ if (!LastDeviceFlag) {
|
|
|
+ // 1-Wire reset
|
|
|
+ if (!reset()) {
|
|
|
+ // reset the search
|
|
|
+ LastDiscrepancy = 0;
|
|
|
+ LastDeviceFlag = false;
|
|
|
+ LastFamilyDiscrepancy = 0;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // issue the search command
|
|
|
+ if (search_mode == true) {
|
|
|
+ write(0xF0); // NORMAL SEARCH
|
|
|
+ } else {
|
|
|
+ write(0xEC); // CONDITIONAL SEARCH
|
|
|
+ }
|
|
|
+
|
|
|
+ // loop to do the search
|
|
|
+ do
|
|
|
+ {
|
|
|
+ // read a bit and its complement
|
|
|
+ id_bit = read_bit();
|
|
|
+ cmp_id_bit = 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 < 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
|
|
|
+ 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) {
|
|
|
+ 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 = true;
|
|
|
+ }
|
|
|
+ search_result = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // if no device found then reset counters so next 'search' will be like a first
|
|
|
+ if (!search_result || !ROM_NO[0]) {
|
|
|
+ LastDiscrepancy = 0;
|
|
|
+ LastDeviceFlag = false;
|
|
|
+ LastFamilyDiscrepancy = 0;
|
|
|
+ search_result = false;
|
|
|
+ } else {
|
|
|
+ for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i];
|
|
|
+ }
|
|
|
+ return search_result;
|
|
|
+ }
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+#if ONEWIRE_CRC
|
|
|
+// 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
|
|
|
+// Dow-CRC using polynomial X^8 + X^5 + X^4 + X^0
|
|
|
+// Tiny 2x16 entry CRC table created by Arjen Lentz
|
|
|
+// See http://lentz.com.au/blog/calculating-crc-with-a-tiny-32-entry-lookup-table
|
|
|
+static const uint8_t PROGMEM dscrc2x16_table[] = {
|
|
|
+ 0x00, 0x5E, 0xBC, 0xE2, 0x61, 0x3F, 0xDD, 0x83,
|
|
|
+ 0xC2, 0x9C, 0x7E, 0x20, 0xA3, 0xFD, 0x1F, 0x41,
|
|
|
+ 0x00, 0x9D, 0x23, 0xBE, 0x46, 0xDB, 0x65, 0xF8,
|
|
|
+ 0x8C, 0x11, 0xAF, 0x32, 0xCA, 0x57, 0xE9, 0x74
|
|
|
+};
|
|
|
+
|
|
|
+// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
|
|
|
+// and the registers. (Use tiny 2x16 entry CRC table)
|
|
|
+uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
|
|
|
+{
|
|
|
+ uint8_t crc = 0;
|
|
|
+
|
|
|
+ while (len--) {
|
|
|
+ crc = *addr++ ^ crc; // just re-using crc as intermediate
|
|
|
+ crc = pgm_read_byte(dscrc2x16_table + (crc & 0x0f)) ^
|
|
|
+ pgm_read_byte(dscrc2x16_table + 16 + ((crc >> 4) & 0x0f));
|
|
|
+ }
|
|
|
+
|
|
|
+ return crc;
|
|
|
+}
|
|
|
+#else
|
|
|
+//
|
|
|
+// Compute a Dallas Semiconductor 8 bit CRC directly.
|
|
|
+// this is much slower, but a little smaller, than the lookup table.
|
|
|
+//
|
|
|
+uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
|
|
|
+{
|
|
|
+ uint8_t crc = 0;
|
|
|
+
|
|
|
+ while (len--) {
|
|
|
+#if defined(__AVR__)
|
|
|
+ crc = _crc_ibutton_update(crc, *addr++);
|
|
|
+#else
|
|
|
+ uint8_t inbyte = *addr++;
|
|
|
+ for (uint8_t i = 8; i; i--) {
|
|
|
+ uint8_t mix = (crc ^ inbyte) & 0x01;
|
|
|
+ crc >>= 1;
|
|
|
+ if (mix) crc ^= 0x8C;
|
|
|
+ inbyte >>= 1;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ return crc;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+#if ONEWIRE_CRC16
|
|
|
+bool OneWire::check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc)
|
|
|
+{
|
|
|
+ crc = ~crc16(input, len, crc);
|
|
|
+ return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1];
|
|
|
+}
|
|
|
+
|
|
|
+uint16_t OneWire::crc16(const uint8_t* input, uint16_t len, uint16_t crc)
|
|
|
+{
|
|
|
+#if defined(__AVR__)
|
|
|
+ for (uint16_t i = 0 ; i < len ; i++) {
|
|
|
+ crc = _crc16_update(crc, input[i]);
|
|
|
+ }
|
|
|
+#else
|
|
|
+ static const uint8_t oddparity[16] =
|
|
|
+ { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
|
|
|
+
|
|
|
+ for (uint16_t i = 0 ; i < len ; i++) {
|
|
|
+ // Even though we're just copying a byte from the input,
|
|
|
+ // we'll be doing 16-bit computation with it.
|
|
|
+ uint16_t cdata = input[i];
|
|
|
+ cdata = (cdata ^ crc) & 0xff;
|
|
|
+ crc >>= 8;
|
|
|
+
|
|
|
+ if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4])
|
|
|
+ crc ^= 0xC001;
|
|
|
+
|
|
|
+ cdata <<= 6;
|
|
|
+ crc ^= cdata;
|
|
|
+ cdata <<= 1;
|
|
|
+ crc ^= cdata;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ return crc;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+#endif
|