diff --git a/strandstring/OneWireMod.cpp b/strandstring/OneWireMod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d1a2dc6a0cc963601151f160b224beddf3daa17
--- /dev/null
+++ b/strandstring/OneWireMod.cpp
@@ -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 "OneWireMod.h"
+#include "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
diff --git a/strandstring/OneWireMod.h b/strandstring/OneWireMod.h
new file mode 100644
index 0000000000000000000000000000000000000000..e280ffc50082e9244c922c1966739dd10d81744a
--- /dev/null
+++ b/strandstring/OneWireMod.h
@@ -0,0 +1,181 @@
+#ifndef OneWire_h
+#define OneWire_h
+
+#ifdef __cplusplus
+
+#include <stdint.h>
+
+#if defined(__AVR__)
+#include <util/crc16.h>
+#endif
+
+#if ARDUINO >= 100
+#include <Arduino.h> // for delayMicroseconds, digitalPinToBitMask, etc
+#else
+#include "WProgram.h" // for delayMicroseconds
+#include "pins_arduino.h" // for digitalPinToBitMask, etc
+#endif
+
+// You can exclude certain features from OneWire. In theory, this
+// might save some space. In practice, the compiler automatically
+// removes unused code (technically, the linker, using -fdata-sections
+// and -ffunction-sections when compiling, and Wl,--gc-sections
+// when linking), so most of these will not result in any code size
+// reduction. Well, unless you try to use the missing features
+// and redesign your program to not need them! ONEWIRE_CRC8_TABLE
+// is the exception, because it selects a fast but large algorithm
+// or a small but slow algorithm.
+
+// you can exclude onewire_search by defining that to 0
+#ifndef ONEWIRE_SEARCH
+#define ONEWIRE_SEARCH 1
+#endif
+
+// You can exclude CRC checks altogether by defining this to 0
+#ifndef ONEWIRE_CRC
+#define ONEWIRE_CRC 1
+#endif
+
+// Select the table-lookup method of computing the 8-bit CRC
+// by setting this to 1. The lookup table enlarges code size by
+// about 250 bytes. It does NOT consume RAM (but did in very
+// old versions of OneWire). If you disable this, a slower
+// but very compact algorithm is used.
+//#ifndef ONEWIRE_CRC8_TABLE
+//#define ONEWIRE_CRC8_TABLE 1
+//#endif
+
+// You can allow 16-bit CRC checks by defining this to 1
+// (Note that ONEWIRE_CRC must also be 1.)
+#ifndef ONEWIRE_CRC16
+#define ONEWIRE_CRC16 1
+#endif
+
+// Board-specific macros for direct GPIO
+#include "OneWire_direct_regtype.h"
+
+class OneWire
+{
+ private:
+ IO_REG_TYPE bitmask;
+ volatile IO_REG_TYPE *baseReg;
+
+#if ONEWIRE_SEARCH
+ // global search state
+ unsigned char ROM_NO[8];
+ uint8_t LastDiscrepancy;
+ uint8_t LastFamilyDiscrepancy;
+ bool LastDeviceFlag;
+#endif
+
+ public:
+ OneWire(uint8_t pin) { begin(pin); }
+ void begin(uint8_t pin);
+
+ // Perform a 1-Wire reset cycle. Returns 1 if a device responds
+ // with a presence pulse. Returns 0 if there is no device or the
+ // bus is shorted or otherwise held low for more than 250uS
+ uint8_t reset(void);
+
+ // Issue a 1-Wire rom select command, you do the reset first.
+ void select(const uint8_t rom[8]);
+
+ // Issue a 1-Wire rom skip command, to address all on bus.
+ void skip(void);
+
+ // Write a byte. If 'power' is one then the wire is held high at
+ // the end for parasitically powered devices. You are responsible
+ // for eventually depowering it by calling depower() or doing
+ // another read or write.
+ void write(uint8_t v, uint8_t power = 0);
+
+ void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0);
+
+ // Read a byte.
+ uint8_t read(void);
+
+ void read_bytes(uint8_t *buf, uint16_t count);
+
+ // Write a bit. The bus is always left powered at the end, see
+ // note in write() about that.
+ void write_bit(uint8_t v);
+
+ // Read a bit.
+ uint8_t read_bit(void);
+
+ // Stop forcing power onto the bus. You only need to do this if
+ // you used the 'power' flag to write() or used a write_bit() call
+ // and aren't about to do another read or write. You would rather
+ // not leave this powered if you don't have to, just in case
+ // someone shorts your bus.
+ void depower(void);
+
+#if ONEWIRE_SEARCH
+ // Clear the search state so that if will start from the beginning again.
+ void reset_search();
+
+ // Setup the search to find the device type 'family_code' on the next call
+ // to search(*newAddr) if it is present.
+ void target_search(uint8_t family_code);
+
+ // Look for the next device. Returns 1 if a new address has been
+ // returned. A zero might mean that the bus is shorted, there are
+ // no devices, or you have already retrieved all of them. It
+ // might be a good idea to check the CRC to make sure you didn't
+ // get garbage. The order is deterministic. You will always get
+ // the same devices in the same order.
+ bool search(uint8_t *newAddr, bool search_mode = true);
+#endif
+
+#if ONEWIRE_CRC
+ // Compute a Dallas Semiconductor 8 bit CRC, these are used in the
+ // ROM and scratchpad registers.
+ static uint8_t crc8(const uint8_t *addr, uint8_t len);
+
+#if ONEWIRE_CRC16
+ // Compute the 1-Wire CRC16 and compare it against the received CRC.
+ // Example usage (reading a DS2408):
+ // // Put everything in a buffer so we can compute the CRC easily.
+ // uint8_t buf[13];
+ // buf[0] = 0xF0; // Read PIO Registers
+ // buf[1] = 0x88; // LSB address
+ // buf[2] = 0x00; // MSB address
+ // WriteBytes(net, buf, 3); // Write 3 cmd bytes
+ // ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16
+ // if (!CheckCRC16(buf, 11, &buf[11])) {
+ // // Handle error.
+ // }
+ //
+ // @param input - Array of bytes to checksum.
+ // @param len - How many bytes to use.
+ // @param inverted_crc - The two CRC16 bytes in the received data.
+ // This should just point into the received data,
+ // *not* at a 16-bit integer.
+ // @param crc - The crc starting value (optional)
+ // @return True, iff the CRC matches.
+ static bool check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc = 0);
+
+ // Compute a Dallas Semiconductor 16 bit CRC. This is required to check
+ // the integrity of data received from many 1-Wire devices. Note that the
+ // CRC computed here is *not* what you'll get from the 1-Wire network,
+ // for two reasons:
+ // 1) The CRC is transmitted bitwise inverted.
+ // 2) Depending on the endian-ness of your processor, the binary
+ // representation of the two-byte return value may have a different
+ // byte order than the two bytes you get from 1-Wire.
+ // @param input - Array of bytes to checksum.
+ // @param len - How many bytes to use.
+ // @param crc - The crc starting value (optional)
+ // @return The CRC16, as defined by Dallas Semiconductor.
+ static uint16_t crc16(const uint8_t* input, uint16_t len, uint16_t crc = 0);
+#endif
+#endif
+};
+
+// Prevent this name from leaking into Arduino sketches
+#ifdef IO_REG_TYPE
+#undef IO_REG_TYPE
+#endif
+
+#endif // __cplusplus
+#endif // OneWire_h
diff --git a/strandstring/OneWire_direct_gpio.h b/strandstring/OneWire_direct_gpio.h
new file mode 100644
index 0000000000000000000000000000000000000000..07713671c9c869f8001c304a5b01821c02e461de
--- /dev/null
+++ b/strandstring/OneWire_direct_gpio.h
@@ -0,0 +1,420 @@
+#ifndef OneWire_Direct_GPIO_h
+#define OneWire_Direct_GPIO_h
+
+// This header should ONLY be included by OneWire.cpp. These defines are
+// meant to be private, used within OneWire.cpp, but not exposed to Arduino
+// sketches or other libraries which may include OneWire.h.
+
+#include <stdint.h>
+
+// Platform specific I/O definitions
+
+#if defined(__AVR__)
+#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
+#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint8_t
+#define IO_REG_BASE_ATTR asm("r30")
+#define IO_REG_MASK_ATTR
+#if defined(__AVR_ATmega4809__)
+#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask) ((*((base)-8)) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)-8)) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask) ((*((base)-4)) &= ~(mask))
+#define DIRECT_WRITE_HIGH(base, mask) ((*((base)-4)) |= (mask))
+#else
+#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask))
+#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask))
+#endif
+
+#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
+#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
+#define PIN_TO_BITMASK(pin) (1)
+#define IO_REG_TYPE uint8_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR __attribute__ ((unused))
+#define DIRECT_READ(base, mask) (*((base)+512))
+#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0)
+#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1)
+#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1)
+#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1)
+
+#elif defined(__MKL26Z64__)
+#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
+#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint8_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask) ((*((base)+16) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask) (*((base)+20) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+20) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask) (*((base)+8) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask) (*((base)+4) = (mask))
+
+#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
+#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
+#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask) ((*((base)+2) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask) (*((base)+1) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+1) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask) (*((base)+34) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask) (*((base)+33) = (mask))
+
+#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
+// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due.
+// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268
+// If you have trouble with OneWire on Arduino Due, please check the
+// status of delayMicroseconds() before reporting a bug in OneWire!
+#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER))
+#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask))
+#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask))
+#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask))
+#ifndef PROGMEM
+#define PROGMEM
+#endif
+#ifndef pgm_read_byte
+#define pgm_read_byte(addr) (*(const uint8_t *)(addr))
+#endif
+
+#elif defined(__PIC32MX__)
+#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin)))
+#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10
+#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08
+#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04
+#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24
+#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28
+
+#elif defined(ARDUINO_ARCH_ESP8266)
+// Special note: I depend on the ESP community to maintain these definitions and
+// submit good pull requests. I can not answer any ESP questions or help you
+// resolve any problems related to ESP chips. Please do not contact me and please
+// DO NOT CREATE GITHUB ISSUES for ESP support. All ESP questions must be asked
+// on ESP community forums.
+#define PIN_TO_BASEREG(pin) ((volatile uint32_t*) GPO)
+#define PIN_TO_BITMASK(pin) (1 << pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask) ((GPI & (mask)) ? 1 : 0) //GPIO_IN_ADDRESS
+#define DIRECT_MODE_INPUT(base, mask) (GPE &= ~(mask)) //GPIO_ENABLE_W1TC_ADDRESS
+#define DIRECT_MODE_OUTPUT(base, mask) (GPE |= (mask)) //GPIO_ENABLE_W1TS_ADDRESS
+#define DIRECT_WRITE_LOW(base, mask) (GPOC = (mask)) //GPIO_OUT_W1TC_ADDRESS
+#define DIRECT_WRITE_HIGH(base, mask) (GPOS = (mask)) //GPIO_OUT_W1TS_ADDRESS
+
+#elif defined(ARDUINO_ARCH_ESP32)
+#include <driver/rtc_io.h>
+#define PIN_TO_BASEREG(pin) (0)
+#define PIN_TO_BITMASK(pin) (pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+
+static inline __attribute__((always_inline))
+IO_REG_TYPE directRead(IO_REG_TYPE pin)
+{
+ if ( pin < 32 )
+ return (GPIO.in >> pin) & 0x1;
+ else if ( pin < 40 )
+ return (GPIO.in1.val >> (pin - 32)) & 0x1;
+
+ return 0;
+}
+
+static inline __attribute__((always_inline))
+void directWriteLow(IO_REG_TYPE pin)
+{
+ if ( pin < 32 )
+ GPIO.out_w1tc = ((uint32_t)1 << pin);
+ else if ( pin < 34 )
+ GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
+}
+
+static inline __attribute__((always_inline))
+void directWriteHigh(IO_REG_TYPE pin)
+{
+ if ( pin < 32 )
+ GPIO.out_w1ts = ((uint32_t)1 << pin);
+ else if ( pin < 34 )
+ GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32));
+}
+
+static inline __attribute__((always_inline))
+void directModeInput(IO_REG_TYPE pin)
+{
+ if ( digitalPinIsValid(pin) )
+ {
+ uint32_t rtc_reg(rtc_gpio_desc[pin].reg);
+
+ if ( rtc_reg ) // RTC pins PULL settings
+ {
+ ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
+ ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
+ }
+
+ if ( pin < 32 )
+ GPIO.enable_w1tc = ((uint32_t)1 << pin);
+ else
+ GPIO.enable1_w1tc.val = ((uint32_t)1 << (pin - 32));
+
+ uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers?
+ pinFunction |= FUN_IE; // input enable but required for output as well?
+ pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+
+ ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
+
+ GPIO.pin[pin].val = 0;
+ }
+}
+
+static inline __attribute__((always_inline))
+void directModeOutput(IO_REG_TYPE pin)
+{
+ if ( digitalPinIsValid(pin) && pin <= 33 ) // pins above 33 can be only inputs
+ {
+ uint32_t rtc_reg(rtc_gpio_desc[pin].reg);
+
+ if ( rtc_reg ) // RTC pins PULL settings
+ {
+ ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
+ ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
+ }
+
+ if ( pin < 32 )
+ GPIO.enable_w1ts = ((uint32_t)1 << pin);
+ else // already validated to pins <= 33
+ GPIO.enable1_w1ts.val = ((uint32_t)1 << (pin - 32));
+
+ uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers?
+ pinFunction |= FUN_IE; // input enable but required for output as well?
+ pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+
+ ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
+
+ GPIO.pin[pin].val = 0;
+ }
+}
+
+#define DIRECT_READ(base, pin) directRead(pin)
+#define DIRECT_WRITE_LOW(base, pin) directWriteLow(pin)
+#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(pin)
+#define DIRECT_MODE_INPUT(base, pin) directModeInput(pin)
+#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(pin)
+// https://github.com/PaulStoffregen/OneWire/pull/47
+// https://github.com/stickbreaker/OneWire/commit/6eb7fc1c11a15b6ac8c60e5671cf36eb6829f82c
+#ifdef interrupts
+#undef interrupts
+#endif
+#ifdef noInterrupts
+#undef noInterrupts
+#endif
+#define noInterrupts() {portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;portENTER_CRITICAL(&mux)
+#define interrupts() portEXIT_CRITICAL(&mux);}
+//#warning "ESP32 OneWire testing"
+
+#elif defined(ARDUINO_ARCH_STM32)
+#define PIN_TO_BASEREG(pin) (0)
+#define PIN_TO_BITMASK(pin) ((uint32_t)digitalPinToPinName(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, pin) digitalReadFast((PinName)pin)
+#define DIRECT_WRITE_LOW(base, pin) digitalWriteFast((PinName)pin, LOW)
+#define DIRECT_WRITE_HIGH(base, pin) digitalWriteFast((PinName)pin, HIGH)
+#define DIRECT_MODE_INPUT(base, pin) pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0))
+#define DIRECT_MODE_OUTPUT(base, pin) pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_OUTPUT_PP, GPIO_NOPULL, 0))
+
+#elif defined(__SAMD21G18A__)
+#define PIN_TO_BASEREG(pin) portModeRegister(digitalPinToPort(pin))
+#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask) (((*((base)+8)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) = (mask))
+#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+2)) = (mask))
+#define DIRECT_WRITE_LOW(base, mask) ((*((base)+5)) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+6)) = (mask))
+
+#elif defined(RBL_NRF51822)
+#define PIN_TO_BASEREG(pin) (0)
+#define PIN_TO_BITMASK(pin) (pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, pin) nrf_gpio_pin_read(pin)
+#define DIRECT_WRITE_LOW(base, pin) nrf_gpio_pin_clear(pin)
+#define DIRECT_WRITE_HIGH(base, pin) nrf_gpio_pin_set(pin)
+#define DIRECT_MODE_INPUT(base, pin) nrf_gpio_cfg_input(pin, NRF_GPIO_PIN_NOPULL)
+#define DIRECT_MODE_OUTPUT(base, pin) nrf_gpio_cfg_output(pin)
+
+#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
+
+#include "scss_registers.h"
+#include "portable.h"
+#include "avr/pgmspace.h"
+
+#define GPIO_ID(pin) (g_APinDescription[pin].ulGPIOId)
+#define GPIO_TYPE(pin) (g_APinDescription[pin].ulGPIOType)
+#define GPIO_BASE(pin) (g_APinDescription[pin].ulGPIOBase)
+#define DIR_OFFSET_SS 0x01
+#define DIR_OFFSET_SOC 0x04
+#define EXT_PORT_OFFSET_SS 0x0A
+#define EXT_PORT_OFFSET_SOC 0x50
+
+/* GPIO registers base address */
+#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase)
+#define PIN_TO_BITMASK(pin) pin
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+
+static inline __attribute__((always_inline))
+IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+ IO_REG_TYPE ret;
+ if (SS_GPIO == GPIO_TYPE(pin)) {
+ ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS));
+ } else {
+ ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC);
+ }
+ return ((ret >> GPIO_ID(pin)) & 0x01);
+}
+
+static inline __attribute__((always_inline))
+void directModeInput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+ if (SS_GPIO == GPIO_TYPE(pin)) {
+ WRITE_ARC_REG(READ_ARC_REG((((IO_REG_TYPE)base) + DIR_OFFSET_SS)) & ~(0x01 << GPIO_ID(pin)),
+ ((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
+ } else {
+ MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) &= ~(0x01 << GPIO_ID(pin));
+ }
+}
+
+static inline __attribute__((always_inline))
+void directModeOutput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+ if (SS_GPIO == GPIO_TYPE(pin)) {
+ WRITE_ARC_REG(READ_ARC_REG(((IO_REG_TYPE)(base) + DIR_OFFSET_SS)) | (0x01 << GPIO_ID(pin)),
+ ((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
+ } else {
+ MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) |= (0x01 << GPIO_ID(pin));
+ }
+}
+
+static inline __attribute__((always_inline))
+void directWriteLow(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+ if (SS_GPIO == GPIO_TYPE(pin)) {
+ WRITE_ARC_REG(READ_ARC_REG(base) & ~(0x01 << GPIO_ID(pin)), base);
+ } else {
+ MMIO_REG_VAL(base) &= ~(0x01 << GPIO_ID(pin));
+ }
+}
+
+static inline __attribute__((always_inline))
+void directWriteHigh(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+ if (SS_GPIO == GPIO_TYPE(pin)) {
+ WRITE_ARC_REG(READ_ARC_REG(base) | (0x01 << GPIO_ID(pin)), base);
+ } else {
+ MMIO_REG_VAL(base) |= (0x01 << GPIO_ID(pin));
+ }
+}
+
+#define DIRECT_READ(base, pin) directRead(base, pin)
+#define DIRECT_MODE_INPUT(base, pin) directModeInput(base, pin)
+#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(base, pin)
+#define DIRECT_WRITE_LOW(base, pin) directWriteLow(base, pin)
+#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(base, pin)
+
+#elif defined(__riscv)
+
+/*
+ * Tested on highfive1
+ *
+ * Stable results are achieved operating in the
+ * two high speed modes of the highfive1. It
+ * seems to be less reliable in slow mode.
+ */
+#define PIN_TO_BASEREG(pin) (0)
+#define PIN_TO_BITMASK(pin) digitalPinToBitMask(pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+
+static inline __attribute__((always_inline))
+IO_REG_TYPE directRead(IO_REG_TYPE mask)
+{
+ return ((GPIO_REG(GPIO_INPUT_VAL) & mask) != 0) ? 1 : 0;
+}
+
+static inline __attribute__((always_inline))
+void directModeInput(IO_REG_TYPE mask)
+{
+ GPIO_REG(GPIO_OUTPUT_XOR) &= ~mask;
+ GPIO_REG(GPIO_IOF_EN) &= ~mask;
+
+ GPIO_REG(GPIO_INPUT_EN) |= mask;
+ GPIO_REG(GPIO_OUTPUT_EN) &= ~mask;
+}
+
+static inline __attribute__((always_inline))
+void directModeOutput(IO_REG_TYPE mask)
+{
+ GPIO_REG(GPIO_OUTPUT_XOR) &= ~mask;
+ GPIO_REG(GPIO_IOF_EN) &= ~mask;
+
+ GPIO_REG(GPIO_INPUT_EN) &= ~mask;
+ GPIO_REG(GPIO_OUTPUT_EN) |= mask;
+}
+
+static inline __attribute__((always_inline))
+void directWriteLow(IO_REG_TYPE mask)
+{
+ GPIO_REG(GPIO_OUTPUT_VAL) &= ~mask;
+}
+
+static inline __attribute__((always_inline))
+void directWriteHigh(IO_REG_TYPE mask)
+{
+ GPIO_REG(GPIO_OUTPUT_VAL) |= mask;
+}
+
+#define DIRECT_READ(base, mask) directRead(mask)
+#define DIRECT_WRITE_LOW(base, mask) directWriteLow(mask)
+#define DIRECT_WRITE_HIGH(base, mask) directWriteHigh(mask)
+#define DIRECT_MODE_INPUT(base, mask) directModeInput(mask)
+#define DIRECT_MODE_OUTPUT(base, mask) directModeOutput(mask)
+
+#else
+#define PIN_TO_BASEREG(pin) (0)
+#define PIN_TO_BITMASK(pin) (pin)
+#define IO_REG_TYPE unsigned int
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, pin) digitalRead(pin)
+#define DIRECT_WRITE_LOW(base, pin) digitalWrite(pin, LOW)
+#define DIRECT_WRITE_HIGH(base, pin) digitalWrite(pin, HIGH)
+#define DIRECT_MODE_INPUT(base, pin) pinMode(pin,INPUT)
+#define DIRECT_MODE_OUTPUT(base, pin) pinMode(pin,OUTPUT)
+#warning "OneWire. Fallback mode. Using API calls for pinMode,digitalRead and digitalWrite. Operation of this library is not guaranteed on this architecture."
+
+#endif
+
+#endif
diff --git a/strandstring/OneWire_direct_regtype.h b/strandstring/OneWire_direct_regtype.h
new file mode 100644
index 0000000000000000000000000000000000000000..21c4634e3ff1f61b64ebe1303a7e6f61858506fe
--- /dev/null
+++ b/strandstring/OneWire_direct_regtype.h
@@ -0,0 +1,52 @@
+#ifndef OneWire_Direct_RegType_h
+#define OneWire_Direct_RegType_h
+
+#include <stdint.h>
+
+// Platform specific I/O register type
+
+#if defined(__AVR__)
+#define IO_REG_TYPE uint8_t
+
+#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
+#define IO_REG_TYPE uint8_t
+
+#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(__MKL26Z64__)
+#define IO_REG_TYPE uint8_t
+
+#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(__PIC32MX__)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(ARDUINO_ARCH_ESP8266)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(ARDUINO_ARCH_ESP32)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_MASK_ATTR
+
+#elif defined(ARDUINO_ARCH_STM32)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(__SAMD21G18A__)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(RBL_NRF51822)
+#define IO_REG_TYPE uint32_t
+
+#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
+#define IO_REG_TYPE uint32_t
+
+#elif defined(__riscv)
+#define IO_REG_TYPE uint32_t
+
+#else
+#define IO_REG_TYPE unsigned int
+
+#endif
+#endif