// === Início de: components/peripherals/src/onewire.c === /* * The MIT License (MIT) * * Copyright (c) 2014 zeroday nodemcu.com * * 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. * ------------------------------------------------------------------------------- * Portions copyright (C) 2000 Dallas Semiconductor Corporation, under the * following additional terms: * * 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 #include #include #include "rom/ets_sys.h" #include "onewire.h" #define ONEWIRE_SELECT_ROM 0x55 #define ONEWIRE_SKIP_ROM 0xcc #define ONEWIRE_SEARCH 0xf0 #define ONEWIRE_CRC8_TABLE static portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED; // Waits up to `max_wait` microseconds for the specified pin to go high. // Returns true if successful, false if the bus never comes high (likely // shorted). static inline bool _onewire_wait_for_bus(gpio_num_t pin, int max_wait) { bool state; for (int i = 0; i < ((max_wait + 4) / 5); i++) { if (gpio_get_level(pin)) break; ets_delay_us(5); } state = gpio_get_level(pin); // Wait an extra 1us to make sure the devices have an adequate recovery // time before we drive things low again. ets_delay_us(1); return state; } static void setup_pin(gpio_num_t pin, bool open_drain) { gpio_set_direction(pin, open_drain ? GPIO_MODE_INPUT_OUTPUT_OD : GPIO_MODE_OUTPUT); // gpio_set_pull_mode(pin, GPIO_PULLUP_ONLY); } // 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 false; // // Returns true if a device asserted a presence pulse, false otherwise. // bool onewire_reset(gpio_num_t pin) { setup_pin(pin, true); gpio_set_level(pin, 1); // wait until the wire is high... just in case if (!_onewire_wait_for_bus(pin, 250)) return false; gpio_set_level(pin, 0); ets_delay_us(480); portENTER_CRITICAL(&mux); gpio_set_level(pin, 1); // allow it to float ets_delay_us(70); bool r = !gpio_get_level(pin); portEXIT_CRITICAL(&mux); // Wait for all devices to finish pulling the bus low before returning if (!_onewire_wait_for_bus(pin, 410)) return false; return r; } static bool _onewire_write_bit(gpio_num_t pin, bool v) { if (!_onewire_wait_for_bus(pin, 10)) return false; portENTER_CRITICAL(&mux); if (v) { gpio_set_level(pin, 0); // drive output low ets_delay_us(10); gpio_set_level(pin, 1); // allow output high ets_delay_us(55); } else { gpio_set_level(pin, 0); // drive output low ets_delay_us(65); gpio_set_level(pin, 1); // allow output high } ets_delay_us(1); portEXIT_CRITICAL(&mux); return true; } static int _onewire_read_bit(gpio_num_t pin) { if (!_onewire_wait_for_bus(pin, 10)) return -1; portENTER_CRITICAL(&mux); gpio_set_level(pin, 0); ets_delay_us(2); gpio_set_level(pin, 1); // let pin float, pull up will raise ets_delay_us(11); int r = gpio_get_level(pin); // Must sample within 15us of start ets_delay_us(48); portEXIT_CRITICAL(&mux); return r; } // Write a byte. The writing code uses open-drain mode and expects the pullup // resistor to pull the line high when not driven low. If you need strong // power after the write (e.g. DS18B20 in parasite power mode) then call // onewire_power() after this is complete to actively drive the line high. // bool onewire_write(gpio_num_t pin, uint8_t v) { for (uint8_t bitMask = 0x01; bitMask; bitMask <<= 1) if (!_onewire_write_bit(pin, (bitMask & v))) return false; return true; } bool onewire_write_bytes(gpio_num_t pin, const uint8_t* buf, size_t count) { for (size_t i = 0; i < count; i++) if (!onewire_write(pin, buf[i])) return false; return true; } // Read a byte // int onewire_read(gpio_num_t pin) { int r = 0; for (uint8_t bitMask = 0x01; bitMask; bitMask <<= 1) { int bit = _onewire_read_bit(pin); if (bit < 0) return -1; else if (bit) r |= bitMask; } return r; } bool onewire_read_bytes(gpio_num_t pin, uint8_t* buf, size_t count) { size_t i; int b; for (i = 0; i < count; i++) { b = onewire_read(pin); if (b < 0) return false; buf[i] = b; } return true; } bool onewire_select(gpio_num_t pin, onewire_addr_t addr) { uint8_t i; if (!onewire_write(pin, ONEWIRE_SELECT_ROM)) return false; for (i = 0; i < 8; i++) { if (!onewire_write(pin, addr & 0xff)) return false; addr >>= 8; } return true; } bool onewire_skip_rom(gpio_num_t pin) { return onewire_write(pin, ONEWIRE_SKIP_ROM); } bool onewire_power(gpio_num_t pin) { // Make sure the bus is not being held low before driving it high, or we // may end up shorting ourselves out. if (!_onewire_wait_for_bus(pin, 10)) return false; setup_pin(pin, false); gpio_set_level(pin, 1); return true; } void onewire_depower(gpio_num_t pin) { setup_pin(pin, true); } void onewire_search_start(onewire_search_t* search) { // reset the search state memset(search, 0, sizeof(*search)); } void onewire_search_prefix(onewire_search_t* search, uint8_t family_code) { uint8_t i; search->rom_no[0] = family_code; for (i = 1; i < 8; i++) { search->rom_no[i] = 0; } search->last_discrepancy = 64; search->last_device_found = false; } // Perform a search. If the next device has been successfully enumerated, its // ROM address will be returned. If there are no devices, no further // devices, or something horrible happens in the middle of the // enumeration then ONEWIRE_NONE is returned. 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 1 : device found, ROM number in ROM_NO buffer // 0 : device not found, end of search // onewire_addr_t onewire_search_next(onewire_search_t* search, gpio_num_t pin) { //TODO: add more checking for read/write errors uint8_t id_bit_number; uint8_t last_zero, search_result; int rom_byte_number; int8_t id_bit, cmp_id_bit; onewire_addr_t addr; unsigned char rom_byte_mask; bool 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 (!search->last_device_found) { // 1-Wire reset if (!onewire_reset(pin)) { // reset the search search->last_discrepancy = 0; search->last_device_found = false; return ONEWIRE_NONE; } // issue the search command onewire_write(pin, ONEWIRE_SEARCH); // loop to do the search do { // read a bit and its complement id_bit = _onewire_read_bit(pin); cmp_id_bit = _onewire_read_bit(pin); 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 < search->last_discrepancy) search_direction = ((search->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 == search->last_discrepancy); // if 0 was picked then record its position in LastZero if (!search_direction) last_zero = id_bit_number; } // set or clear the bit in the ROM byte rom_byte_number // with mask rom_byte_mask if (search_direction) search->rom_no[rom_byte_number] |= rom_byte_mask; else search->rom_no[rom_byte_number] &= ~rom_byte_mask; // serial number search direction write bit _onewire_write_bit(pin, 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 last_discrepancy,last_device_found,search_result search->last_discrepancy = last_zero; // check for last device if (search->last_discrepancy == 0) search->last_device_found = true; search_result = 1; } } // if no device found then reset counters so next 'search' will be like a first if (!search_result || !search->rom_no[0]) { search->last_discrepancy = 0; search->last_device_found = false; return ONEWIRE_NONE; } else { addr = 0; for (rom_byte_number = 7; rom_byte_number >= 0; rom_byte_number--) { addr = (addr << 8) | search->rom_no[rom_byte_number]; } //printf("Ok I found something at %08x%08x...\n", (uint32_t)(addr >> 32), (uint32_t)addr); } return addr; } // The 1-Wire CRC scheme is described in Maxim Application Note 27: // "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products" // #ifdef ONEWIRE_CRC8_TABLE // This table comes from Dallas sample code where it is freely reusable, // though Copyright (c) 2000 Dallas Semiconductor Corporation static const uint8_t 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 to // 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.) // uint8_t onewire_crc8(const uint8_t* data, uint8_t len) { uint8_t crc = 0; while (len--) crc = dscrc_table[crc ^ *data++]; return crc; } #else // // Compute a Dallas Semiconductor 8 bit CRC directly. // this is much slower, but much smaller, than the lookup table. // uint8_t onewire_crc8(const uint8_t* data, uint8_t len) { uint8_t crc = 0; while (len--) { uint8_t inbyte = *data++; for (int i = 8; i; i--) { uint8_t mix = (crc ^ inbyte) & 0x01; crc >>= 1; if (mix) crc ^= 0x8C; inbyte >>= 1; } } return crc; } #endif /* ONEWIRE_CRC8_TABLE */ // 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 1, iff the CRC matches. bool onewire_check_crc16(const uint8_t* input, size_t len, const uint8_t* inverted_crc, uint16_t crc_iv) { uint16_t crc = ~onewire_crc16(input, len, crc_iv); return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1]; } // 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. uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv) { uint16_t crc = crc_iv; static const uint8_t oddparity[16] = { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }; uint16_t i; for (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; } return crc; } // === Fim de: components/peripherals/src/onewire.c === // === Início de: components/peripherals/src/onewire.h === /* * The MIT License (MIT) * * Copyright (c) 2014 zeroday nodemcu.com * * 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. * ------------------------------------------------------------------------------- * Portions copyright (C) 2000 Dallas Semiconductor Corporation, under the * following additional terms: * * Except as contained in this notice, the name of Dallas Semiconductor * shall not be used except as stated in the Dallas Semiconductor * Branding Policy. */ #ifndef ONEWIRE_H_ #define ONEWIRE_H_ #include #include #include "driver/gpio.h" /** * Type used to hold all 1-Wire device ROM addresses (64-bit) */ typedef uint64_t onewire_addr_t; /** * Structure to contain the current state for onewire_search_next(), etc */ typedef struct { uint8_t rom_no[8]; uint8_t last_discrepancy; bool last_device_found; } onewire_search_t; /** * ::ONEWIRE_NONE is an invalid ROM address that will never occur in a device * (CRC mismatch), and so can be useful as an indicator for "no-such-device", * etc. */ #define ONEWIRE_NONE ((onewire_addr_t)(0xffffffffffffffffLL)) /** * @brief Perform a 1-Wire reset cycle. * * @param pin The GPIO pin connected to the 1-Wire bus. * * @return `true` if at least one device responds with a presence pulse, * `false` if no devices were detected (or the bus is shorted, etc) */ bool onewire_reset(gpio_num_t pin); /** * @brief Issue a 1-Wire "ROM select" command to select a particular device. * * It is necessary to call ::onewire_reset() before calling this function. * * @param pin The GPIO pin connected to the 1-Wire bus. * @param addr The ROM address of the device to select * * @return `true` if the "ROM select" command could be successfully issued, * `false` if there was an error. */ bool onewire_select(gpio_num_t pin, const onewire_addr_t addr); /** * @brief Issue a 1-Wire "skip ROM" command to select *all* devices on the bus. * * It is necessary to call ::onewire_reset() before calling this function. * * @param pin The GPIO pin connected to the 1-Wire bus. * * @return `true` if the "skip ROM" command could be successfully issued, * `false` if there was an error. */ bool onewire_skip_rom(gpio_num_t pin); /** * @brief Write a byte on the onewire bus. * * The writing code uses open-drain mode and expects the pullup resistor to * pull the line high when not driven low. If you need strong power after the * write (e.g. DS18B20 in parasite power mode) then call ::onewire_power() * after this is complete to actively drive the line high. * * @param pin The GPIO pin connected to the 1-Wire bus. * @param v The byte value to write * * @return `true` if successful, `false` on error. */ bool onewire_write(gpio_num_t pin, uint8_t v); /** * @brief Write multiple bytes on the 1-Wire bus. * * See ::onewire_write() for more info. * * @param pin The GPIO pin connected to the 1-Wire bus. * @param buf A pointer to the buffer of bytes to be written * @param count Number of bytes to write * * @return `true` if all bytes written successfully, `false` on error. */ bool onewire_write_bytes(gpio_num_t pin, const uint8_t *buf, size_t count); /** * @brief Read a byte from a 1-Wire device. * * @param pin The GPIO pin connected to the 1-Wire bus. * * @return the read byte on success, negative value on error. */ int onewire_read(gpio_num_t pin); /** * @brief Read multiple bytes from a 1-Wire device. * * @param pin The GPIO pin connected to the 1-Wire bus. * @param[out] buf A pointer to the buffer to contain the read bytes * @param count Number of bytes to read * * @return `true` on success, `false` on error. */ bool onewire_read_bytes(gpio_num_t pin, uint8_t *buf, size_t count); /** * @brief Actively drive the bus high to provide extra power for certain * operations of parasitically-powered devices. * * For parasitically-powered devices which need more power than can be * provided via the normal pull-up resistor, it may be necessary for some * operations to drive the bus actively high. This function can be used to * perform that operation. * * The bus can be depowered once it is no longer needed by calling * ::onewire_depower(), or it will be depowered automatically the next time * ::onewire_reset() is called to start another command. * * @note Make sure the device(s) you are powering will not pull more current * than the ESP32/ESP8266 is able to supply via its GPIO pins (this is * especially important when multiple devices are on the same bus and * they are all performing a power-intensive operation at the same time * (i.e. multiple DS18B20 sensors, which have all been given a * "convert T" operation by using ::onewire_skip_rom())). * * @note This routine will check to make sure that the bus is already high * before driving it, to make sure it doesn't attempt to drive it high * while something else is pulling it low (which could cause a reset or * damage the ESP32/ESP8266). * * @param pin The GPIO pin connected to the 1-Wire bus. * * @return `true` on success, `false` on error. */ bool onewire_power(gpio_num_t pin); /** * @brief Stop forcing power onto the bus. * * You only need to do this if you previously called ::onewire_power() to drive * the bus high and now want to allow it to float instead. Note that * onewire_reset() will also automatically depower the bus first, so you do * not need to call this first if you just want to start a new operation. * * @param pin The GPIO pin connected to the 1-Wire bus. */ void onewire_depower(gpio_num_t pin); /** * @brief Clear the search state so that it will start from the beginning on * the next call to ::onewire_search_next(). * * @param[out] search The onewire_search_t structure to reset. */ void onewire_search_start(onewire_search_t *search); /** * @brief Setup the search to search for devices with the specified * "family code". * * @param[out] search The onewire_search_t structure to update. * @param family_code The "family code" to search for. */ void onewire_search_prefix(onewire_search_t *search, uint8_t family_code); /** * @brief Search for the next device on the bus. * * The order of returned device addresses is deterministic. You will always * get the same devices in the same order. * * @note It might be a good idea to check the CRC to make sure you didn't get * garbage. * * @return the address of the next device on the bus, or ::ONEWIRE_NONE if * there is no next address. ::ONEWIRE_NONE might also mean that * the bus is shorted, there are no devices, or you have already * retrieved all of them. */ onewire_addr_t onewire_search_next(onewire_search_t *search, gpio_num_t pin); /** * @brief Compute a Dallas Semiconductor 8 bit CRC. * * These are used in the ROM address and scratchpad registers to verify the * transmitted data is correct. */ uint8_t onewire_crc8(const uint8_t *data, uint8_t len); /** * @brief Compute the 1-Wire CRC16 and compare it against the received CRC. * * Example usage (reading a DS2408): * @code{.c} * // 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 * onewire_write_bytes(pin, buf, 3); // Write 3 cmd bytes * onewire_read_bytes(pin, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16 * if (!onewire_check_crc16(buf, 11, &buf[11])) { * // TODO: Handle error. * } * @endcode * * @param input Array of bytes to checksum. * @param len Number of bytes in `input` * @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_iv The crc starting value (optional) * * @return `true` if the CRC matches, `false` otherwise. */ bool onewire_check_crc16(const uint8_t* input, size_t len, const uint8_t* inverted_crc, uint16_t crc_iv); /** * @brief 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 are in `input`. * @param crc_iv The crc starting value (optional) * * @return the CRC16, as defined by Dallas Semiconductor. */ uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv); #endif /* ONEWIRE_H_ */ // === Fim de: components/peripherals/src/onewire.h ===