nicolas
/
esp32-ds18b20-ledc
mirror of https://github.com/nmasse-itix/esp32-ds18b20-ledc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add support for multiple devices on single 1-Wire bus.

main
David Antliff 8 years ago
parent
5f89347bc8
commit
33a03fd31f
6 changed files with 591 additions and 381 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 232
      main/ds18b20.c
  2. 91
      main/ds18b20_main.c
  3. 8
      main/ds18b20_static.h
  4. 610
      main/owb.c
  5. 23
      main/owb.h
  6. 8
      main/owb_static.h

232
main/ds18b20.c
View File

@ -29,143 +29,145 @@
struct _DS18B20_Info
{
bool init;
bool use_crc;
OneWireBus * bus;
uint64_t rom_code;
bool init;
bool use_crc;
OneWireBus * bus;
uint64_t rom_code;
};
static bool _is_init(const DS18B20_Info * ds18b20_info)
{
bool ok = false;
if (ds18b20_info != NULL)
{
if (ds18b20_info->init)
{
// OK
ok = true;
}
else
{
ESP_LOGE(TAG, "ds18b20_info is not initialised");
}
}
else
{
ESP_LOGE(TAG, "ds18b20_info is NULL");
}
return ok;
bool ok = false;
if (ds18b20_info != NULL)
{
if (ds18b20_info->init)
{
// OK
ok = true;
}
else
{
ESP_LOGE(TAG, "ds18b20_info is not initialised");
}
}
else
{
ESP_LOGE(TAG, "ds18b20_info is NULL");
}
return ok;
}
DS18B20_Info * ds18b20_malloc(void)
{
DS18B20_Info * ds18b20_info = malloc(sizeof(*ds18b20_info));
if (ds18b20_info != NULL)
{
memset(ds18b20_info, 0, sizeof(*ds18b20_info));
ESP_LOGD(TAG, "malloc %p", ds18b20_info);
}
else
{
ESP_LOGE(TAG, "malloc failed");
}
return ds18b20_info;
DS18B20_Info * ds18b20_info = malloc(sizeof(*ds18b20_info));
if (ds18b20_info != NULL)
{
memset(ds18b20_info, 0, sizeof(*ds18b20_info));
ESP_LOGD(TAG, "malloc %p", ds18b20_info);
}
else
{
ESP_LOGE(TAG, "malloc failed");
}
return ds18b20_info;
}
void ds18b20_free(DS18B20_Info ** ds18b20_info)
{
if (ds18b20_info != NULL && (*ds18b20_info != NULL))
{
ESP_LOGD(TAG, "free %p", *ds18b20_info);
free(*ds18b20_info);
*ds18b20_info = NULL;
}
if (ds18b20_info != NULL && (*ds18b20_info != NULL))
{
ESP_LOGD(TAG, "free %p", *ds18b20_info);
free(*ds18b20_info);
*ds18b20_info = NULL;
}
}
void ds18b20_init(DS18B20_Info * ds18b20_info, OneWireBus * bus, uint64_t rom_code)
{
if (ds18b20_info != NULL)
{
ds18b20_info->bus = bus;
ds18b20_info->rom_code = rom_code;
ds18b20_info->use_crc = false;
ds18b20_info->init = true;
}
else
{
ESP_LOGE(TAG, "ds18b20_info is NULL");
}
if (ds18b20_info != NULL)
{
ds18b20_info->bus = bus;
ds18b20_info->rom_code = rom_code;
ds18b20_info->use_crc = false;
ds18b20_info->init = true;
}
else
{
ESP_LOGE(TAG, "ds18b20_info is NULL");
}
}
void ds18b20_use_crc(DS18B20_Info * ds18b20_info, bool use_crc)
{
if (_is_init(ds18b20_info))
{
ds18b20_info->use_crc = use_crc;
ESP_LOGD(TAG, "use_crc %d", ds18b20_info->use_crc);
}
if (_is_init(ds18b20_info))
{
ds18b20_info->use_crc = use_crc;
ESP_LOGD(TAG, "use_crc %d", ds18b20_info->use_crc);
}
}
float ds18b20_get_temp(DS18B20_Info * ds18b20_info)
{
float temp = 0.0f;
if (_is_init(ds18b20_info))
{
OneWireBus * bus = ds18b20_info->bus;
if (owb_reset(bus))
{
//owb_write_byte(bus, OWB_ROM_SKIP);
owb_write_byte(bus, OWB_ROM_MATCH);
owb_write_rom_code(bus, ds18b20_info->rom_code);
owb_write_byte(bus, DS18B20_FUNCTION_TEMP_CONVERT);
vTaskDelay(750 / portTICK_PERIOD_MS);
// reset
owb_reset(bus);
owb_write_byte(bus, OWB_ROM_SKIP);
owb_write_byte(bus, DS18B20_FUNCTION_SCRATCHPAD_READ);
uint8_t temp_LSB = 0;
uint8_t temp_MSB = 0;
if (ds18b20_info->use_crc)
{
// Without CRC:
temp_LSB = owb_read_byte(bus);
temp_MSB = owb_read_byte(bus);
owb_reset(bus); // terminate early
}
else
{
// with CRC:
uint8_t buffer[9];
owb_read_bytes(bus, buffer, 9);
temp_LSB = buffer[0];
temp_MSB = buffer[1];
uint8_t crc = 0;
for (int i = 0; i < 9; ++i)
{
crc = owb_crc8(crc, buffer[i]);
}
ESP_LOGD(TAG, "crc 0x%02x", crc);
if (crc != 0)
{
ESP_LOGE(TAG, "CRC failed");
temp_LSB = temp_MSB = 0;
}
}
ESP_LOGD(TAG, "temp_LSB 0x%02x, temp_MSB 0x%02x", temp_LSB, temp_MSB);
temp = (float)(((temp_MSB << 8) + temp_LSB) >> 4);
}
else
{
ESP_LOGE(TAG, "ds18b20 device not responding");
}
}
return temp;
float temp = 0.0f;
if (_is_init(ds18b20_info))
{
OneWireBus * bus = ds18b20_info->bus;
if (owb_reset(bus))
{
//owb_write_byte(bus, OWB_ROM_SKIP);
owb_write_byte(bus, OWB_ROM_MATCH);
owb_write_rom_code(bus, ds18b20_info->rom_code);
owb_write_byte(bus, DS18B20_FUNCTION_TEMP_CONVERT);
vTaskDelay(750 / portTICK_PERIOD_MS);
// reset
owb_reset(bus);
//owb_write_byte(bus, OWB_ROM_SKIP);
owb_write_byte(bus, OWB_ROM_MATCH);
owb_write_rom_code(bus, ds18b20_info->rom_code);
owb_write_byte(bus, DS18B20_FUNCTION_SCRATCHPAD_READ);
uint8_t temp_LSB = 0;
uint8_t temp_MSB = 0;
if (ds18b20_info->use_crc)
{
// Without CRC:
temp_LSB = owb_read_byte(bus);
temp_MSB = owb_read_byte(bus);
owb_reset(bus); // terminate early
}
else
{
// with CRC:
uint8_t buffer[9];
owb_read_bytes(bus, buffer, 9);
temp_LSB = buffer[0];
temp_MSB = buffer[1];
uint8_t crc = 0;
for (int i = 0; i < 9; ++i)
{
crc = owb_crc8(crc, buffer[i]);
}
ESP_LOGD(TAG, "crc 0x%02x", crc);
if (crc != 0)
{
ESP_LOGE(TAG, "CRC failed");
temp_LSB = temp_MSB = 0;
}
}
ESP_LOGD(TAG, "temp_LSB 0x%02x, temp_MSB 0x%02x", temp_LSB, temp_MSB);
temp = (float)(((temp_MSB << 8) + temp_LSB) >> 4);
}
else
{
ESP_LOGE(TAG, "ds18b20 device not responding");
}
}
return temp;
}

91
main/ds18b20_main.c
View File

@ -4,6 +4,7 @@
#include "freertos/task.h"
#include "esp_system.h"
// Uncomment to enable static (stack-based) allocation of instances and avoid malloc/free.
//#define USE_STATIC 1
#ifdef USE_STATIC
@ -16,44 +17,90 @@
#define GPIO_DS18B20_0 (GPIO_NUM_4)
#define MAX_DEVICES (8)
void app_main()
{
// Create a 1-Wire bus
// Create a 1-Wire bus
#ifdef USE_STATIC
OneWireBus_Static owb_static; // static allocation
OneWireBus * owb = &owb_static;
OneWireBus_Static owb_static; // static allocation
OneWireBus * owb = &owb_static;
#else
OneWireBus * owb = owb_malloc(); // heap allocation
OneWireBus * owb = owb_malloc(); // heap allocation
#endif
owb_init(owb, GPIO_DS18B20_0);
owb_init(owb, GPIO_DS18B20_0);
owb_use_crc(owb, true); // enable CRC check for ROM code
//owb_search(); // find all connected devices
//OneWireBusROMCode rom_code = 0x1162e87ccee28;
uint64_t rom_code = owb_read_rom(owb);
printf("1-Wire ROM code 0x%08" PRIx64 "\n", rom_code);
// find all connected devices
uint8_t device_rom_codes[8][MAX_DEVICES] = {0};
int num_devices = 0;
OneWireBus_SearchState search_state = {0};
bool found = owb_search_first(owb, &search_state);
while (found)
{
printf("Device %d found: ", num_devices);
for (int i = 7; i >= 0; i--)
{
device_rom_codes[num_devices][i] = search_state.rom_code[i];
printf("%02x", search_state.rom_code[i]);
}
printf("\n");
++num_devices;
found = owb_search_next(owb, &search_state);
}
//uint64_t rom_code = 0x0001162e87ccee28; // pink
//uint64_t rom_code = 0xf402162c6149ee28; // green
//uint64_t rom_code = 0x1502162ca5b2ee28; // orange
//uint64_t rom_code = owb_read_rom(owb);
//printf("1-Wire ROM code 0x%08" PRIx64 "\n", rom_code);
// Create a DS18B20 device on the 1-Wire bus
// Create a DS18B20 device on the 1-Wire bus
#ifdef USE_STATIC
DS18B20_Info_Static ds18b20_info_static; // static allocation
DS18B20_Info * ds18b20_info = &ds18b20_info_static;
DS18B20_Info_Static ds18b20_info_static; // static allocation
DS18B20_Info * ds18b20_info = &ds18b20_info_static;
DS18B20_Info devices_static[MAX_DEVICES] = {0};
DS18B20_Info * devices[MAX_DEVICES] = {0};
for (int i = 0; i < MAX_DEVICES; ++i)
{
devices[i] = &(devices_static[i]);
}
#else
DS18B20_Info * ds18b20_info = ds18b20_malloc(); // heap allocation
DS18B20_Info * ds18b20_info = ds18b20_malloc(); // heap allocation
DS18B20_Info * devices[MAX_DEVICES] = {0};
#endif
ds18b20_init(ds18b20_info, owb, rom_code); // associate with bus and device
//ds18b20_init_solo(ds18b20_info, owb); // only one device on bus
ds18b20_use_crc(ds18b20_info, true); // enable CRC check for temperature readings
for (int i = 0; i < num_devices; ++i)
{
#ifdef USE_STATIC
DS18B20_Info * ds18b20_info = devices[i];
#else
DS18B20_Info * ds18b20_info = ds18b20_malloc(); // heap allocation
devices[i] = ds18b20_info;
#endif
uint64_t rom_code = 0;
for (int j = 7; j >= 0; --j)
{
rom_code |= ((uint64_t)device_rom_codes[i][j] << (8 * j));
}
printf("1-Wire ROM code 0x%08" PRIx64 "\n", rom_code);
ds18b20_init(ds18b20_info, owb, rom_code); // associate with bus and device
//ds18b20_init_solo(ds18b20_info, owb); // only one device on bus
ds18b20_use_crc(ds18b20_info, true); // enable CRC check for temperature readings
}
while (1)
{
float temp = ds18b20_get_temp(ds18b20_info);
printf("Temp %.1f degrees C\n", temp);
while (1)
{
for (int i = 0; i < num_devices; ++i)
{
float temp = ds18b20_get_temp(devices[i]);
printf("Temp %d: %.1f degrees C\n", i, temp);
}
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}
for (int i = 10; i >= 0; i--) {
printf("Restarting in %d seconds...\n", i);
@ -61,7 +108,7 @@ void app_main()
}
ds18b20_free(&ds18b20_info);
owb_free(&owb);
owb_free(&owb);
printf("Restarting now.\n");
fflush(stdout);

8
main/ds18b20_static.h
View File

@ -14,10 +14,10 @@ extern "C" {
struct _DS18B20_Info
{
bool init;
bool use_crc;
OneWireBus * bus;
uint64_t rom_code;
bool init;
bool use_crc;
OneWireBus * bus;
uint64_t rom_code;
};
typedef struct _DS18B20_Info DS18B20_Info_Static;

610
main/owb.c
View File

@ -12,64 +12,54 @@
#define TAG "owb"
struct _OneWireBus_Timing
{
int A, B, C, D, E, F, G, H, I, J;
int A, B, C, D, E, F, G, H, I, J;
};
// 1-Wire timing delays (standard) in ticks (quarter-microseconds).
static const struct _OneWireBus_Timing _StandardTiming = {
6 * 4,
64 * 4,
60 * 4,
10 * 4,
9 * 4,
55 * 4,
0, // G
480 * 4, // H
70 * 4, // I
410 * 4, // J
6 * 4,
64 * 4,
60 * 4,
10 * 4,
9 * 4,
55 * 4,
0, // G
480 * 4, // H
70 * 4, // I
410 * 4, // J
};
//struct _OneWireBus
//{
// bool init;
// int gpio;
// const struct _OneWireBus_Timing * timing;
// bool use_crc;
//};
static void _tick_delay(int ticks)
{
// Each tick is 0.25 microseconds.
float time_us = ticks / 4.0;
ets_delay_us(time_us);
// Each tick is 0.25 microseconds.
float time_us = ticks / 4.0;
ets_delay_us(time_us);
}
static bool _is_init(const OneWireBus * bus)
bool _is_init(const OneWireBus * bus)
{
bool ok = false;
if (bus != NULL)
{
if (bus->init)
{
// OK
ok = true;
}
else
{
ESP_LOGE(TAG, "bus is not initialised");
}
}
else
{
ESP_LOGE(TAG, "bus is NULL");
}
return ok;
bool ok = false;
if (bus != NULL)
{
if (bus->init)
{
// OK
ok = true;
}
else
{
ESP_LOGE(TAG, "bus is not initialised");
}
}
else
{
ESP_LOGE(TAG, "bus is NULL");
}
return ok;
}
/**
* @brief Generate a 1-Wire reset.
* @param[in] bus Initialised bus instance.
@ -77,26 +67,26 @@ static bool _is_init(const OneWireBus * bus)
*/
static bool _reset(const OneWireBus * bus)
{
bool present = false;
if (_is_init(bus))
{
gpio_set_direction(bus->gpio, GPIO_MODE_OUTPUT);
_tick_delay(bus->timing->G);
gpio_set_level(bus->gpio, 0); // Drive DQ low
_tick_delay(bus->timing->H);
gpio_set_level(bus->gpio, 1); // Release the bus
_tick_delay(bus->timing->I);
gpio_set_direction(bus->gpio, GPIO_MODE_INPUT);
int level1 = gpio_get_level(bus->gpio);
_tick_delay(bus->timing->J); // Complete the reset sequence recovery
int level2 = gpio_get_level(bus->gpio);
present = (level1 == 0) && (level2 == 1); // Sample for presence pulse from slave
ESP_LOGD(TAG, "reset: level1 0x%x, level2 0x%x, present %d", level1, level2, present);
}
return present;
bool present = false;
if (_is_init(bus))
{
gpio_set_direction(bus->gpio, GPIO_MODE_OUTPUT);
_tick_delay(bus->timing->G);
gpio_set_level(bus->gpio, 0); // Drive DQ low
_tick_delay(bus->timing->H);
gpio_set_level(bus->gpio, 1); // Release the bus
_tick_delay(bus->timing->I);
gpio_set_direction(bus->gpio, GPIO_MODE_INPUT);
int level1 = gpio_get_level(bus->gpio);
_tick_delay(bus->timing->J); // Complete the reset sequence recovery
int level2 = gpio_get_level(bus->gpio);
present = (level1 == 0) && (level2 == 1); // Sample for presence pulse from slave
ESP_LOGD(TAG, "reset: level1 0x%x, level2 0x%x, present %d", level1, level2, present);
}
return present;
}
/**
@ -106,16 +96,16 @@ static bool _reset(const OneWireBus * bus)
*/
static void _write_bit(const OneWireBus * bus, int bit)
{
if (_is_init(bus))
{
int delay1 = bit ? bus->timing->A : bus->timing->C;
int delay2 = bit ? bus->timing->B : bus->timing->D;
gpio_set_direction(bus->gpio, GPIO_MODE_OUTPUT);
gpio_set_level(bus->gpio, 0); // Drive DQ low
_tick_delay(delay1);
gpio_set_level(bus->gpio, 1); // Release the bus
_tick_delay(delay2);
}
if (_is_init(bus))
{
int delay1 = bit ? bus->timing->A : bus->timing->C;
int delay2 = bit ? bus->timing->B : bus->timing->D;
gpio_set_direction(bus->gpio, GPIO_MODE_OUTPUT);
gpio_set_level(bus->gpio, 0); // Drive DQ low
_tick_delay(delay1);
gpio_set_level(bus->gpio, 1); // Release the bus
_tick_delay(delay2);
}
}
/**
@ -124,21 +114,21 @@ static void _write_bit(const OneWireBus * bus, int bit)
*/
static int _read_bit(const OneWireBus * bus)
{
int result = 0;
if (_is_init(bus))
{
gpio_set_direction(bus->gpio, GPIO_MODE_OUTPUT);
gpio_set_level(bus->gpio, 0); // Drive DQ low
_tick_delay(bus->timing->A);
gpio_set_level(bus->gpio, 1); // Release the bus
_tick_delay(bus->timing->E);
gpio_set_direction(bus->gpio, GPIO_MODE_INPUT);
int level = gpio_get_level(bus->gpio);
_tick_delay(bus->timing->F); // Complete the timeslot and 10us recovery
result = level & 0x01;
}
return result;
int result = 0;
if (_is_init(bus))
{
gpio_set_direction(bus->gpio, GPIO_MODE_OUTPUT);
gpio_set_level(bus->gpio, 0); // Drive DQ low
_tick_delay(bus->timing->A);
gpio_set_level(bus->gpio, 1); // Release the bus
_tick_delay(bus->timing->E);
gpio_set_direction(bus->gpio, GPIO_MODE_INPUT);
int level = gpio_get_level(bus->gpio);
_tick_delay(bus->timing->F); // Complete the timeslot and 10us recovery
result = level & 0x01;
}
return result;
}
/**
@ -148,15 +138,15 @@ static int _read_bit(const OneWireBus * bus)
*/
static void _write_byte(const OneWireBus * bus, uint8_t data)
{
if (_is_init(bus))
{
ESP_LOGD(TAG, "write 0x%02x", data);
for (int i = 0; i < 8; ++i)
{
_write_bit(bus, data & 0x01);
data >>= 1;
}
}
if (_is_init(bus))
{
ESP_LOGD(TAG, "write 0x%02x", data);
for (int i = 0; i < 8; ++i)
{
_write_bit(bus, data & 0x01);
data >>= 1;
}
}
}
/**
@ -166,20 +156,20 @@ static void _write_byte(const OneWireBus * bus, uint8_t data)
*/
static uint8_t _read_byte(const OneWireBus * bus)
{
uint8_t result = 0;
if (_is_init(bus))
{
for (int i = 0; i < 8; ++i)
{
result >>= 1;
if (_read_bit(bus))
{
result |= 0x80;
}
}
ESP_LOGD(TAG, "read 0x%02x", result);
}
return result;
uint8_t result = 0;
if (_is_init(bus))
{
for (int i = 0; i < 8; ++i)
{
result >>= 1;
if (_read_bit(bus))
{
result |= 0x80;
}
}
ESP_LOGD(TAG, "read 0x%02x", result);
}
return result;
}
/**
@ -191,11 +181,11 @@ static uint8_t _read_byte(const OneWireBus * bus)
*/
static uint8_t * _read_block(const OneWireBus * bus, uint8_t * buffer, unsigned int len)
{
for (int i = 0; i < len; ++i)
{
*buffer++ = _read_byte(bus);
}
return buffer;
for (int i = 0; i < len; ++i)
{
*buffer++ = _read_byte(bus);
}
return buffer;
}
/**
@ -207,11 +197,11 @@ static uint8_t * _read_block(const OneWireBus * bus, uint8_t * buffer, unsigned
*/
static const uint8_t * _write_block(const OneWireBus * bus, const uint8_t * buffer, unsigned int len)
{
for (int i = 0; i < len; ++i)
{
_write_byte(bus, buffer[i]);
}
return buffer;
for (int i = 0; i < len; ++i)
{
_write_byte(bus, buffer[i]);
}
return buffer;
}
/**
@ -222,27 +212,148 @@ static const uint8_t * _write_block(const OneWireBus * bus, const uint8_t * buff
*/
static uint8_t _calc_crc(uint8_t crc, uint8_t data)
{
// https://www.maximintegrated.com/en/app-notes/index.mvp/id/27
static const uint8_t table[256] = {
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
};
return table[crc ^ data];
// https://www.maximintegrated.com/en/app-notes/index.mvp/id/27
static const uint8_t table[256] = {
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
};
return table[crc ^ data];
}
static bool _search(const OneWireBus * bus, OneWireBus_SearchState * state)
{
// Based on https://www.maximintegrated.com/en/app-notes/index.mvp/id/187
// initialize for search
int id_bit_number = 1;
int last_zero = 0;
int rom_byte_number = 0;
int id_bit = 0;
int cmp_id_bit = 0;
uint8_t rom_byte_mask = 1;
uint8_t search_direction = 0;
bool search_result = false;
uint8_t crc8 = 0;
if (_is_init(bus))
{
// if the last call was not the last one
if (!state->last_device_flag)
{
// 1-Wire reset
if (!_reset(bus))
{
// reset the search
state->last_discrepancy = 0;
state->last_device_flag = false;
state->last_family_discrepancy = 0;
return false;
}
// issue the search command
_write_byte(bus, OWB_ROM_SEARCH);
// loop to do the search
do
{
// read a bit and its complement
id_bit = _read_bit(bus);
cmp_id_bit = _read_bit(bus);
// 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 < state->last_discrepancy)
search_direction = ((state->rom_code[rom_byte_number] & rom_byte_mask) > 0);
else
// if equal to last pick 1, if not then pick 0
search_direction = (id_bit_number == state->last_discrepancy);
// 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)
state->last_family_discrepancy = last_zero;
}
}
// set or clear the bit in the ROM byte rom_byte_number
// with mask rom_byte_mask
if (search_direction == 1)
state->rom_code[rom_byte_number] |= rom_byte_mask;
else
state->rom_code[rom_byte_number] &= ~rom_byte_mask;
// serial number search direction write bit
_write_bit(bus, 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)
{
crc8 = _calc_crc(crc8, state->rom_code[rom_byte_number]); // accumulate the CRC
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) || (crc8 != 0)))
{
// search successful so set LastDiscrepancy,LastDeviceFlag,search_result
state->last_discrepancy = last_zero;
// check for last device
if (state->last_discrepancy == 0)
state->last_device_flag = true;
search_result = true;
}
}
// if no device found then reset counters so next 'search' will be like a first
if (!search_result || !state->rom_code[0])
{
state->last_discrepancy = 0;
state->last_device_flag = false;
state->last_family_discrepancy = 0;
search_result = false;
}
}
return search_result;
}
@ -250,145 +361,176 @@ static uint8_t _calc_crc(uint8_t crc, uint8_t data)
OneWireBus * owb_malloc()
{
OneWireBus * bus = malloc(sizeof(*bus));
if (bus != NULL)
{
memset(bus, 0, sizeof(*bus));
ESP_LOGD(TAG, "malloc %p", bus);
}
else
{
ESP_LOGE(TAG, "malloc failed");
}
return bus;
OneWireBus * bus = malloc(sizeof(*bus));
if (bus != NULL)
{
memset(bus, 0, sizeof(*bus));
ESP_LOGD(TAG, "malloc %p", bus);
}
else
{
ESP_LOGE(TAG, "malloc failed");
}
return bus;
}
void owb_free(OneWireBus ** bus)
{
if (bus != NULL && (*bus != NULL))
{
ESP_LOGD(TAG, "free %p", *bus);
free(*bus);
*bus = NULL;
}
if (bus != NULL && (*bus != NULL))
{
ESP_LOGD(TAG, "free %p", *bus);
free(*bus);
*bus = NULL;
}
}
void owb_init(OneWireBus * bus, int gpio)
{
if (bus != NULL)
{
bus->gpio = gpio;
bus->timing = &_StandardTiming;
bus->init = true;
// platform specific:
gpio_pad_select_gpio(bus->gpio);
}
else
{
ESP_LOGE(TAG, "bus is NULL");
}
if (bus != NULL)
{
bus->gpio = gpio;
bus->timing = &_StandardTiming;
bus->init = true;
// platform specific:
gpio_pad_select_gpio(bus->gpio);
}
else
{
ESP_LOGE(TAG, "bus is NULL");
}
}
void owb_use_crc(OneWireBus * bus, bool use_crc)
{
if (_is_init(bus))
{
bus->use_crc = use_crc;
ESP_LOGD(TAG, "use_crc %d", bus->use_crc);
}
if (_is_init(bus))
{
bus->use_crc = use_crc;
ESP_LOGD(TAG, "use_crc %d", bus->use_crc);
}
}
int owb_rom_search(OneWireBus * bus)
{
// TODO
return 0;
// TODO
return 0;
}
uint64_t owb_read_rom(const OneWireBus * bus)
{
uint64_t rom_code = 0;
if (_is_init(bus))
{
if (_reset(bus))
{
uint8_t buffer[8] = { 0 };
_write_byte(bus, OWB_ROM_READ);
_read_block(bus, buffer, 8);
// device provides LSB first
for (int i = 7; i >= 0; --i)
{
// watch out for integer promotion
rom_code |= ((uint64_t)buffer[i] << (8 * i));
}
if (bus->use_crc)
{
// check CRC
uint8_t crc = 0;
for (int i = 0; i < 8; ++i)
{
crc = _calc_crc(crc, buffer[i]);
}
ESP_LOGD(TAG, "crc 0x%02x", crc);
if (crc != 0)
{
ESP_LOGE(TAG, "CRC failed");
rom_code = 0;
}
ESP_LOGD(TAG, "rom_code 0x%08" PRIx64, rom_code);
}
}
else
{
ESP_LOGE(TAG, "ds18b20 device not responding");
}
}
return rom_code;
uint64_t rom_code = 0;
if (_is_init(bus))
{
if (_reset(bus))
{
uint8_t buffer[8] = { 0 };
_write_byte(bus, OWB_ROM_READ);
_read_block(bus, buffer, 8);
// device provides LSB first
for (int i = 7; i >= 0; --i)
{
// watch out for integer promotion
rom_code |= ((uint64_t)buffer[i] << (8 * i));
}
if (bus->use_crc)
{
// check CRC
uint8_t crc = 0;
for (int i = 0; i < 8; ++i)
{
crc = _calc_crc(crc, buffer[i]);
}
ESP_LOGD(TAG, "crc 0x%02x", crc);
if (crc != 0)
{
ESP_LOGE(TAG, "CRC failed");
rom_code = 0;
}
ESP_LOGD(TAG, "rom_code 0x%08" PRIx64, rom_code);
}
}
else
{
ESP_LOGE(TAG, "ds18b20 device not responding");
}
}
return rom_code;
}
bool owb_reset(const OneWireBus * bus)
{
return _reset(bus);
return _reset(bus);
}
void owb_write_byte(const OneWireBus * bus, uint8_t data)
{
_write_byte(bus, data);
_write_byte(bus, data);
}
uint8_t owb_read_byte(const OneWireBus * bus)
{
return _read_byte(bus);
return _read_byte(bus);
}
uint8_t * owb_read_bytes(const OneWireBus * bus, uint8_t * buffer, unsigned int len)
{
return _read_block(bus, buffer, len);
return _read_block(bus, buffer, len);
}
const uint8_t * owb_write_bytes(const OneWireBus * bus, const uint8_t * buffer, unsigned int len)
{
return _write_block(bus, buffer, len);
return _write_block(bus, buffer, len);
}
void owb_write_rom_code(const OneWireBus * bus, uint64_t rom_code)
{
uint8_t buffer[sizeof(uint64_t)] = {0};
for (int i = 0; i < sizeof(buffer); ++i)
{
// LSB first
buffer[i] = rom_code & 0xFF;
rom_code >>= 8;
}
_write_block(bus, buffer, sizeof(buffer));
uint8_t buffer[sizeof(uint64_t)] = {0};
for (int i = 0; i < sizeof(buffer); ++i)
{
// LSB first
buffer[i] = rom_code & 0xFF;
rom_code >>= 8;
}
_write_block(bus, buffer, sizeof(buffer));
}
uint8_t owb_crc8(uint8_t crc, uint8_t data)
{
return _calc_crc(crc, data);
return _calc_crc(crc, data);
}
bool owb_search_first(const OneWireBus * bus, OneWireBus_SearchState * state)
{
bool result = false;
if (state != NULL)
{
memset(state->rom_code, 0, sizeof(state->rom_code));
state->last_discrepancy = 0;
state->last_family_discrepancy = 0;
state->last_device_flag = false;
result = _search(bus, state);
}
else
{
ESP_LOGE(TAG, "state is NULL");
}
return result;
}
bool owb_search_next(const OneWireBus * bus, OneWireBus_SearchState * state)
{
bool result = false;
if (state != NULL)
{
result = _search(bus, state);
}
else
{
ESP_LOGE(TAG, "state is NULL");
}
return result;
}

23
main/owb.h
View File

@ -2,6 +2,7 @@
#define ONE_WIRE_BUS_H
#include <stdint.h>
#include <stdbool.h>
#ifdef __cplusplus
extern "C" {
@ -54,6 +55,9 @@ void owb_use_crc(OneWireBus * bus, bool use_crc);
*/
uint64_t owb_read_rom(const OneWireBus * bus);
// TODO
bool owb_verify_rom(const OneWireBus * bus, uint64_t rom_code);
/**
* @brief Reset the 1-Wire bus.
* @param[in] bus Pointer to initialised bus instance.
@ -100,13 +104,28 @@ const uint8_t * owb_write_bytes(const OneWireBus * bus, const uint8_t * buffer,
*/
void owb_write_rom_code(const OneWireBus * bus, uint64_t rom_code);
/**
/**
* @brief 1-Wire 8-bit CRC lookup.
* @param[in] crc Starting CRC value. Pass in prior CRC to accumulate.
* @param[in] data Byte to feed into CRC.
* @return Resultant CRC value.
*/
uint8_t owb_crc8(uint8_t crc, uint8_t data);
uint8_t owb_crc8(uint8_t crc, uint8_t data);
// Search API
struct OneWireBus_SearchState
{
uint8_t rom_code[8];
int last_discrepancy;
int last_family_discrepancy;
int last_device_flag;
};
typedef struct OneWireBus_SearchState OneWireBus_SearchState;
bool owb_search_first(const OneWireBus * bus, OneWireBus_SearchState * state);
bool owb_search_next(const OneWireBus * bus, OneWireBus_SearchState * state);
#ifdef __cplusplus

8
main/owb_static.h
View File

@ -13,10 +13,10 @@ extern "C" {
struct _OneWireBus
{
bool init;
int gpio;
const struct _OneWireBus_Timing * timing;
bool use_crc;
bool init;
int gpio;
const struct _OneWireBus_Timing * timing;
bool use_crc;
};
typedef struct _OneWireBus OneWireBus_Static;

Write Preview
Loading…
Cancel
Save