784 lines
26 KiB
C
Executable File
784 lines
26 KiB
C
Executable File
|
|
|
|
// === 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 <string.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#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 <stdbool.h>
|
|
#include <stdint.h>
|
|
#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 ===
|