liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-3179] 1-Wire Overdrive Mode (#2522)

Browse Source 
* Separate ibutton to its own module, add one_wire to f18
* Move onewire cli to a separate app
* Add definitions for normal and overdrive timings
* Update api definitions
* Add rough overdrive timings definition for onewire emulation
* Remove one_wire_host_timing.h
* Add rough overdrive timings for onewire host
* Improve overdrive mode
* Working overdrive mode from flipper to flipper
* Update thermometer example app
* Turn on otg power when running thermometer example app
* Implement reset overdrive switching
* Always exit out of overdrive mode
* Improve overdrive timings
* Fix typos
* Fix reset behaviour
* Use overdrive mode everywhere in DS1996
* Improve comments
* Bump API version

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
Georgii Surkov
2023-03-22 17:54:06 +03:00
committed by GitHub
parent 1f236ede0e
commit 8b224ecb15
16 changed files with 397 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/one_wire/SConscript
View File

@@ -8,7 +8,6 @@ env.Append(
"#/lib/one_wire",
],
SDK_HEADERS=[
File("one_wire_host_timing.h"),
File("one_wire_host.h"),
File("one_wire_slave.h"),
File("maxim_crc.h"),

85
lib/one_wire/one_wire_host.c
View File

@@ -1,10 +1,54 @@
#include <furi.h>
/**
* Timings based on Application Note 126:
* https://www.analog.com/media/en/technical-documentation/tech-articles/1wire-communication-through-software--maxim-integrated.pdf
*/
#include "one_wire_host.h"
#include "one_wire_host_timing.h"
typedef struct {
uint16_t a;
uint16_t b;
uint16_t c;
uint16_t d;
uint16_t e;
uint16_t f;
uint16_t g;
uint16_t h;
uint16_t i;
uint16_t j;
} OneWireHostTimings;
static const OneWireHostTimings onewire_host_timings_normal = {
.a = 9,
.b = 64,
.c = 64,
.d = 14,
.e = 9,
.f = 55,
.g = 0,
.h = 480,
.i = 70,
.j = 410,
};
static const OneWireHostTimings onewire_host_timings_overdrive = {
.a = 1,
.b = 8,
.c = 8,
.d = 3,
.e = 1,
.f = 7,
.g = 3,
.h = 70,
.i = 9,
.j = 40,
};
struct OneWireHost {
const GpioPin* gpio_pin;
const OneWireHostTimings* timings;
unsigned char saved_rom[8]; /** < global search state */
uint8_t last_discrepancy;
uint8_t last_family_discrepancy;
@@ -15,6 +59,7 @@ OneWireHost* onewire_host_alloc(const GpioPin* gpio_pin) {
OneWireHost* host = malloc(sizeof(OneWireHost));
host->gpio_pin = gpio_pin;
onewire_host_reset_search(host);
onewire_host_set_overdrive(host, false);
return host;
}
@@ -27,6 +72,8 @@ bool onewire_host_reset(OneWireHost* host) {
uint8_t r;
uint8_t retries = 125;
const OneWireHostTimings* timings = host->timings;
// wait until the gpio is high
furi_hal_gpio_write(host->gpio_pin, true);
do {
@@ -35,19 +82,19 @@ bool onewire_host_reset(OneWireHost* host) {
} while(!furi_hal_gpio_read(host->gpio_pin));
// pre delay
furi_delay_us(OWH_RESET_DELAY_PRE);
furi_delay_us(timings->g);
// drive low
furi_hal_gpio_write(host->gpio_pin, false);
furi_delay_us(OWH_RESET_DRIVE);
furi_delay_us(timings->h);
// release
furi_hal_gpio_write(host->gpio_pin, true);
furi_delay_us(OWH_RESET_RELEASE);
furi_delay_us(timings->i);
// read and post delay
r = !furi_hal_gpio_read(host->gpio_pin);
furi_delay_us(OWH_RESET_DELAY_POST);
furi_delay_us(timings->j);
return r;
}
@@ -55,17 +102,19 @@ bool onewire_host_reset(OneWireHost* host) {
bool onewire_host_read_bit(OneWireHost* host) {
bool result;
const OneWireHostTimings* timings = host->timings;
// drive low
furi_hal_gpio_write(host->gpio_pin, false);
furi_delay_us(OWH_READ_DRIVE);
furi_delay_us(timings->a);
// release
furi_hal_gpio_write(host->gpio_pin, true);
furi_delay_us(OWH_READ_RELEASE);
furi_delay_us(timings->e);
// read and post delay
result = furi_hal_gpio_read(host->gpio_pin);
furi_delay_us(OWH_READ_DELAY_POST);
furi_delay_us(timings->f);
return result;
}
@@ -89,22 +138,24 @@ void onewire_host_read_bytes(OneWireHost* host, uint8_t* buffer, uint16_t count)
}
void onewire_host_write_bit(OneWireHost* host, bool value) {
const OneWireHostTimings* timings = host->timings;
if(value) {
// drive low
furi_hal_gpio_write(host->gpio_pin, false);
furi_delay_us(OWH_WRITE_1_DRIVE);
furi_delay_us(timings->a);
// release
furi_hal_gpio_write(host->gpio_pin, true);
furi_delay_us(OWH_WRITE_1_RELEASE);
furi_delay_us(timings->b);
} else {
// drive low
furi_hal_gpio_write(host->gpio_pin, false);
furi_delay_us(OWH_WRITE_0_DRIVE);
furi_delay_us(timings->c);
// release
furi_hal_gpio_write(host->gpio_pin, true);
furi_delay_us(OWH_WRITE_0_RELEASE);
furi_delay_us(timings->d);
}
}
@@ -122,10 +173,6 @@ void onewire_host_write_bytes(OneWireHost* host, const uint8_t* buffer, uint16_t
}
}
void onewire_host_skip(OneWireHost* host) {
onewire_host_write(host, 0xCC);
}
void onewire_host_start(OneWireHost* host) {
furi_hal_gpio_write(host->gpio_pin, true);
furi_hal_gpio_init(host->gpio_pin, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
@@ -154,7 +201,7 @@ void onewire_host_target_search(OneWireHost* host, uint8_t family_code) {
host->last_device_flag = false;
}
uint8_t onewire_host_search(OneWireHost* host, uint8_t* new_addr, OneWireHostSearchMode mode) {
bool onewire_host_search(OneWireHost* host, uint8_t* new_addr, OneWireHostSearchMode mode) {
uint8_t id_bit_number;
uint8_t last_zero, rom_byte_number, search_result;
uint8_t id_bit, cmp_id_bit;
@@ -268,3 +315,7 @@ uint8_t onewire_host_search(OneWireHost* host, uint8_t* new_addr, OneWireHostSea
return search_result;
}
void onewire_host_set_overdrive(OneWireHost* host, bool set) {
host->timings = set ? &onewire_host_timings_overdrive : &onewire_host_timings_normal;
}

89
lib/one_wire/one_wire_host.h
View File

@@ -15,114 +15,115 @@ extern "C" {
typedef enum {
OneWireHostSearchModeConditional = 0, /**< Search for alarmed device */
OneWireHostSearchModeNormal = 1, /**< Search all devices */
OneWireHostSearchModeNormal = 1, /**< Search for all devices */
} OneWireHostSearchMode;
typedef struct OneWireHost OneWireHost;
/**
* Allocate onewire host bus
* @param pin
* @return OneWireHost*
* Allocate OneWireHost instance
* @param [in] gpio_pin connection pin
* @return pointer to OneWireHost instance
*/
OneWireHost* onewire_host_alloc(const GpioPin* gpio_pin);
/**
* Deallocate onewire host bus
* @param host
* Destroy OneWireHost instance, free resources
* @param [in] host pointer to OneWireHost instance
*/
void onewire_host_free(OneWireHost* host);
/**
* Reset bus
* @param host
* @return bool
* Reset the 1-Wire bus
* @param [in] host pointer to OneWireHost instance
* @return true if presence was detected, false otherwise
*/
bool onewire_host_reset(OneWireHost* host);
/**
* Read one bit
* @param host
* @return bool
* @param [in] host pointer to OneWireHost instance
* @return received bit value
*/
bool onewire_host_read_bit(OneWireHost* host);
/**
* Read one byte
* @param host
* @return uint8_t
* @param [in] host pointer to OneWireHost instance
* @return received byte value
*/
uint8_t onewire_host_read(OneWireHost* host);
/**
* Read many bytes
* @param host
* @param buffer
* @param count
* Read one or more bytes
* @param [in] host pointer to OneWireHost instance
* @param [out] buffer received data buffer
* @param [in] count number of bytes to read
*/
void onewire_host_read_bytes(OneWireHost* host, uint8_t* buffer, uint16_t count);
/**
* Write one bit
* @param host
* @param value
* @param [in] host pointer to OneWireHost instance
* @param value bit value to write
*/
void onewire_host_write_bit(OneWireHost* host, bool value);
/**
* Write one byte
* @param host
* @param value
* @param [in] host pointer to OneWireHost instance
* @param value byte value to write
*/
void onewire_host_write(OneWireHost* host, uint8_t value);
/**
* Write many bytes
* @param host
* @param buffer
* @param count
* Write one or more bytes
* @param [in] host pointer to OneWireHost instance
* @param [in] buffer pointer to the data to write
* @param [in] count size of the data to write
*/
void onewire_host_write_bytes(OneWireHost* host, const uint8_t* buffer, uint16_t count);
/**
* Skip ROM command
* @param host
*/
void onewire_host_skip(OneWireHost* host);
/**
* Start working with the bus
* @param host
* @param [in] host pointer to OneWireHost instance
*/
void onewire_host_start(OneWireHost* host);
/**
* Stop working with the bus
* @param host
* @param [in] host pointer to OneWireHost instance
*/
void onewire_host_stop(OneWireHost* host);
/**
*
* @param host
* Reset previous search results
* @param [in] host pointer to OneWireHost instance
*/
void onewire_host_reset_search(OneWireHost* host);
/**
*
* @param host
* @param family_code
* Set the family code to search for
* @param [in] host pointer to OneWireHost instance
* @param [in] family_code device family code
*/
void onewire_host_target_search(OneWireHost* host, uint8_t family_code);
/**
*
* @param host
* @param newAddr
* @param mode
* @return uint8_t
* Search for devices on the 1-Wire bus
* @param [in] host pointer to OneWireHost instance
* @param [out] new_addr pointer to the buffer to contain the unique ROM of the found device
* @param [in] mode search mode
* @return true on success, false otherwise
*/
uint8_t onewire_host_search(OneWireHost* host, uint8_t* new_addr, OneWireHostSearchMode mode);
bool onewire_host_search(OneWireHost* host, uint8_t* new_addr, OneWireHostSearchMode mode);
/**
* Enable overdrive mode
* @param [in] host pointer to OneWireHost instance
* @param [in] set true to turn overdrive on, false to turn it off
*/
void onewire_host_set_overdrive(OneWireHost* host, bool set);
#ifdef __cplusplus
}

30
lib/one_wire/one_wire_host_timing.h
View File

@@ -1,30 +0,0 @@
/**
* @file one_wire_host_timing.h
*
* 1-Wire library, timing list
*/
#pragma once
#define OWH_TIMING_A 9
#define OWH_TIMING_B 64
#define OWH_TIMING_C 64
#define OWH_TIMING_D 14
#define OWH_TIMING_E 9
#define OWH_TIMING_F 55
#define OWH_TIMING_G 0
#define OWH_TIMING_H 480
#define OWH_TIMING_I 70
#define OWH_TIMING_J 410
#define OWH_WRITE_1_DRIVE OWH_TIMING_A
#define OWH_WRITE_1_RELEASE OWH_TIMING_B
#define OWH_WRITE_0_DRIVE OWH_TIMING_C
#define OWH_WRITE_0_RELEASE OWH_TIMING_D
#define OWH_READ_DRIVE 3
#define OWH_READ_RELEASE OWH_TIMING_E
#define OWH_READ_DELAY_POST OWH_TIMING_F
#define OWH_RESET_DELAY_PRE OWH_TIMING_G
#define OWH_RESET_DRIVE OWH_TIMING_H
#define OWH_RESET_RELEASE OWH_TIMING_I
#define OWH_RESET_DELAY_POST OWH_TIMING_J

188
lib/one_wire/one_wire_slave.c
View File

@@ -3,20 +3,7 @@
#include <furi.h>
#include <furi_hal.h>
#define ONEWIRE_TRSTL_MIN 270 /* Minimum Reset Low time */
#define ONEWIRE_TRSTL_MAX 1200 /* Maximum Reset Low time */
#define ONEWIRE_TPDH_TYP 20 /* Typical Presence Detect High time */
#define ONEWIRE_TPDL_MIN 100 /* Minimum Presence Detect Low time */
#define ONEWIRE_TPDL_MAX 480 /* Maximum Presence Detect Low time */
#define ONEWIRE_TSLOT_MIN 60 /* Minimum Read/Write Slot time */
#define ONEWIRE_TSLOT_MAX 135 /* Maximum Read/Write Slot time */
#define ONEWIRE_TW1L_MAX 20 /* Maximum Master Write 1 time */
#define ONEWIRE_TRL_TMSR_MAX 30 /* Maximum Master Read Low + Read Sample time */
#define ONEWIRE_TH_TIMEOUT 15000 /* Maximum time before general timeout */
#define TH_TIMEOUT_MAX 15000 /* Maximum time before general timeout */
typedef enum {
OneWireSlaveErrorNone = 0,
@@ -26,10 +13,29 @@ typedef enum {
OneWireSlaveErrorTimeout,
} OneWireSlaveError;
typedef struct {
uint16_t trstl_min; /* Minimum Reset Low time */
uint16_t trstl_max; /* Maximum Reset Low time */
uint16_t tpdh_typ; /* Typical Presence Detect High time */
uint16_t tpdl_min; /* Minimum Presence Detect Low time */
uint16_t tpdl_max; /* Maximum Presence Detect Low time */
uint16_t tslot_min; /* Minimum Read/Write Slot time */
uint16_t tslot_max; /* Maximum Read/Write Slot time */
uint16_t tw1l_max; /* Maximum Master Write 1 time */
uint16_t trl_tmsr_max; /* Maximum Master Read Low + Read Sample time */
} OneWireSlaveTimings;
struct OneWireSlave {
const GpioPin* gpio_pin;
const OneWireSlaveTimings* timings;
OneWireSlaveError error;
bool is_first_reset;
bool is_short_reset;
OneWireSlaveResetCallback reset_callback;
OneWireSlaveCommandCallback command_callback;
OneWireSlaveResultCallback result_callback;
@@ -39,42 +45,72 @@ struct OneWireSlave {
void* command_callback_context;
};
static const OneWireSlaveTimings onewire_slave_timings_normal = {
.trstl_min = 270,
.trstl_max = 1200,
.tpdh_typ = 20,
.tpdl_min = 100,
.tpdl_max = 480,
.tslot_min = 60,
.tslot_max = 135,
.tw1l_max = 20,
.trl_tmsr_max = 30,
};
static const OneWireSlaveTimings onewire_slave_timings_overdrive = {
.trstl_min = 48,
.trstl_max = 80,
.tpdh_typ = 0,
.tpdl_min = 8,
.tpdl_max = 24,
.tslot_min = 6,
.tslot_max = 16,
.tw1l_max = 2,
.trl_tmsr_max = 3,
};
/*********************** PRIVATE ***********************/
static uint32_t
onewire_slave_wait_while_gpio_is(OneWireSlave* bus, uint32_t time, const bool pin_value) {
uint32_t start = DWT->CYCCNT;
uint32_t time_ticks = time * furi_hal_cortex_instructions_per_microsecond();
uint32_t time_captured;
static bool
onewire_slave_wait_while_gpio_is(OneWireSlave* bus, uint32_t time_us, const bool pin_value) {
const uint32_t time_start = DWT->CYCCNT;
const uint32_t time_ticks = time_us * furi_hal_cortex_instructions_per_microsecond();
uint32_t time_elapsed;
do { //-V1044
time_captured = DWT->CYCCNT;
time_elapsed = DWT->CYCCNT - time_start;
if(furi_hal_gpio_read(bus->gpio_pin) != pin_value) {
uint32_t remaining_time = time_ticks - (time_captured - start);
remaining_time /= furi_hal_cortex_instructions_per_microsecond();
return remaining_time;
return time_ticks >= time_elapsed;
}
} while((time_captured - start) < time_ticks);
} while(time_elapsed < time_ticks);
return 0;
return false;
}
static bool onewire_slave_show_presence(OneWireSlave* bus) {
static inline bool onewire_slave_show_presence(OneWireSlave* bus) {
const OneWireSlaveTimings* timings = bus->timings;
// wait until the bus is high (might return immediately)
onewire_slave_wait_while_gpio_is(bus, ONEWIRE_TRSTL_MAX, false);
onewire_slave_wait_while_gpio_is(bus, timings->trstl_max, false);
// wait while master delay presence check
furi_delay_us(ONEWIRE_TPDH_TYP);
furi_delay_us(timings->tpdh_typ);
// show presence
furi_hal_gpio_write(bus->gpio_pin, false);
furi_delay_us(ONEWIRE_TPDL_MIN);
furi_delay_us(timings->tpdl_min);
furi_hal_gpio_write(bus->gpio_pin, true);
// somebody also can show presence
const uint32_t wait_low_time = ONEWIRE_TPDL_MAX - ONEWIRE_TPDL_MIN;
const uint32_t wait_low_time = timings->tpdl_max - timings->tpdl_min;
// so we will wait
if(onewire_slave_wait_while_gpio_is(bus, wait_low_time, false) == 0) {
if(!onewire_slave_wait_while_gpio_is(bus, wait_low_time, false)) {
bus->error = OneWireSlaveErrorPresenceConflict;
return false;
}
@@ -85,27 +121,36 @@ static bool onewire_slave_show_presence(OneWireSlave* bus) {
static inline bool onewire_slave_receive_and_process_command(OneWireSlave* bus) {
/* Reset condition detected, send a presence pulse and reset protocol state */
if(bus->error == OneWireSlaveErrorResetInProgress) {
if(onewire_slave_show_presence(bus)) {
bus->error = OneWireSlaveErrorNone;
if(!bus->is_first_reset) {
/* Guess the reset type */
bus->is_short_reset = onewire_slave_wait_while_gpio_is(
bus,
onewire_slave_timings_overdrive.trstl_max -
onewire_slave_timings_overdrive.tslot_max,
false);
} else {
bus->is_first_reset = false;
}
if(bus->reset_callback != NULL) {
bus->reset_callback(bus->reset_callback_context);
furi_assert(bus->reset_callback);
if(bus->reset_callback(bus->is_short_reset, bus->reset_callback_context)) {
if(onewire_slave_show_presence(bus)) {
bus->error = OneWireSlaveErrorNone;
return true;
}
return true;
}
} else if(bus->error == OneWireSlaveErrorNone) {
uint8_t command;
if(!onewire_slave_receive(bus, &command, 1)) {
/* Upon failure, request an additional iteration to
choose the appropriate action by checking bus->error */
return true;
} else if(bus->command_callback) {
return bus->command_callback(command, bus->command_callback_context);
} else {
bus->error = OneWireSlaveErrorInvalidCommand;
if(onewire_slave_receive(bus, &command, sizeof(command))) {
furi_assert(bus->command_callback);
if(bus->command_callback(command, bus->command_callback_context)) {
return true;
}
}
return (bus->error == OneWireSlaveErrorResetInProgress);
}
return false;
@@ -115,9 +160,6 @@ static inline bool onewire_slave_bus_start(OneWireSlave* bus) {
FURI_CRITICAL_ENTER();
furi_hal_gpio_init(bus->gpio_pin, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
/* Start in Reset state in order to send a presence pulse immediately */
bus->error = OneWireSlaveErrorResetInProgress;
while(onewire_slave_receive_and_process_command(bus))
;
@@ -139,7 +181,15 @@ static void onewire_slave_exti_callback(void* context) {
const uint32_t pulse_length =
(DWT->CYCCNT - pulse_start) / furi_hal_cortex_instructions_per_microsecond();
if((pulse_length >= ONEWIRE_TRSTL_MIN) && pulse_length <= (ONEWIRE_TRSTL_MAX)) {
if((pulse_length >= onewire_slave_timings_overdrive.trstl_min) &&
(pulse_length <= onewire_slave_timings_normal.trstl_max)) {
/* Start in reset state in order to send a presence pulse immediately */
bus->error = OneWireSlaveErrorResetInProgress;
/* Determine reset type (chooses speed mode if supported by the emulated device) */
bus->is_short_reset = pulse_length <= onewire_slave_timings_overdrive.trstl_max;
/* Initial reset allows going directly into overdrive mode */
bus->is_first_reset = true;
const bool result = onewire_slave_bus_start(bus);
if(result && bus->result_callback != NULL) {
@@ -158,6 +208,7 @@ OneWireSlave* onewire_slave_alloc(const GpioPin* gpio_pin) {
OneWireSlave* bus = malloc(sizeof(OneWireSlave));
bus->gpio_pin = gpio_pin;
bus->timings = &onewire_slave_timings_normal;
bus->error = OneWireSlaveErrorNone;
return bus;
@@ -205,52 +256,45 @@ void onewire_slave_set_result_callback(
}
bool onewire_slave_receive_bit(OneWireSlave* bus) {
const OneWireSlaveTimings* timings = bus->timings;
// wait while bus is low
uint32_t time = ONEWIRE_TSLOT_MAX;
time = onewire_slave_wait_while_gpio_is(bus, time, false);
if(time == 0) {
if(!onewire_slave_wait_while_gpio_is(bus, timings->tslot_max, false)) {
bus->error = OneWireSlaveErrorResetInProgress;
return false;
}
// wait while bus is high
time = ONEWIRE_TH_TIMEOUT;
time = onewire_slave_wait_while_gpio_is(bus, time, true);
if(time == 0) {
if(!onewire_slave_wait_while_gpio_is(bus, TH_TIMEOUT_MAX, true)) {
bus->error = OneWireSlaveErrorTimeout;
return false;
}
// wait a time of zero
time = ONEWIRE_TW1L_MAX;
time = onewire_slave_wait_while_gpio_is(bus, time, false);
return (time > 0);
return onewire_slave_wait_while_gpio_is(bus, timings->tw1l_max, false);
}
bool onewire_slave_send_bit(OneWireSlave* bus, bool value) {
const OneWireSlaveTimings* timings = bus->timings;
// wait while bus is low
uint32_t time = ONEWIRE_TSLOT_MAX;
time = onewire_slave_wait_while_gpio_is(bus, time, false);
if(time == 0) {
if(!onewire_slave_wait_while_gpio_is(bus, timings->tslot_max, false)) {
bus->error = OneWireSlaveErrorResetInProgress;
return false;
}
// wait while bus is high
time = ONEWIRE_TH_TIMEOUT;
time = onewire_slave_wait_while_gpio_is(bus, time, true);
if(time == 0) {
if(!onewire_slave_wait_while_gpio_is(bus, TH_TIMEOUT_MAX, true)) {
bus->error = OneWireSlaveErrorTimeout;
return false;
}
// choose write time
uint32_t time;
if(!value) {
furi_hal_gpio_write(bus->gpio_pin, false);
time = ONEWIRE_TRL_TMSR_MAX;
time = timings->trl_tmsr_max;
} else {
time = ONEWIRE_TSLOT_MIN;
time = timings->tslot_min;
}
// hold line for ZERO or ONE time
@@ -301,3 +345,13 @@ bool onewire_slave_receive(OneWireSlave* bus, uint8_t* data, size_t data_size) {
}
return true;
}
void onewire_slave_set_overdrive(OneWireSlave* bus, bool set) {
const OneWireSlaveTimings* new_timings = set ? &onewire_slave_timings_overdrive :
&onewire_slave_timings_normal;
if(bus->timings != new_timings) {
/* Prevent erroneous reset by waiting for the previous time slot to finish */
onewire_slave_wait_while_gpio_is(bus, bus->timings->tslot_max, false);
bus->timings = new_timings;
}
}

84
lib/one_wire/one_wire_slave.h
View File

@@ -18,68 +18,85 @@ extern "C" {
typedef struct OneWireDevice OneWireDevice;
typedef struct OneWireSlave OneWireSlave;
typedef void (*OneWireSlaveResetCallback)(void* context);
typedef void (*OneWireSlaveResultCallback)(void* context);
typedef bool (*OneWireSlaveResetCallback)(bool is_short, void* context);
typedef bool (*OneWireSlaveCommandCallback)(uint8_t command, void* context);
typedef void (*OneWireSlaveResultCallback)(void* context);
/**
* Allocate onewire slave
* @param gpio_pin
* @return OneWireSlave*
* Allocate OneWireSlave instance
* @param [in] gpio_pin connection pin
* @return pointer to OneWireSlave instance
*/
OneWireSlave* onewire_slave_alloc(const GpioPin* gpio_pin);
/**
* Free onewire slave
* @param bus
* Destroy OneWireSlave instance, free resources
* @param [in] bus pointer to OneWireSlave instance
*/
void onewire_slave_free(OneWireSlave* bus);
/**
* Start working with the bus
* @param bus
* @param [in] bus pointer to OneWireSlave instance
*/
void onewire_slave_start(OneWireSlave* bus);
/**
* Stop working with the bus
* @param bus
* @param [in] bus pointer to OneWireSlave instance
*/
void onewire_slave_stop(OneWireSlave* bus);
/**
* TODO: description comment
* Receive one bit
* @param [in] bus pointer to OneWireSlave instance
* @return received bit value
*/
bool onewire_slave_receive_bit(OneWireSlave* bus);
/**
* TODO: description comment
* Send one bit
* @param [in] bus pointer to OneWireSlave instance
* @param [in] value bit value to send
* @return true on success, false on failure
*/
bool onewire_slave_send_bit(OneWireSlave* bus, bool value);
/**
* Send data
* @param bus
* @param data
* @param data_size
* @return bool
* Send one or more bytes of data
* @param [in] bus pointer to OneWireSlave instance
* @param [in] data pointer to the data to send
* @param [in] data_size size of the data to send
* @return true on success, false on failure
*/
bool onewire_slave_send(OneWireSlave* bus, const uint8_t* data, size_t data_size);
/**
* Receive data
* @param bus
* @param data
* @param data_size
* @return bool
* Receive one or more bytes of data
* @param [in] bus pointer to OneWireSlave instance
* @param [out] data pointer to the receive buffer
* @param [in] data_size number of bytes to receive
* @return true on success, false on failure
*/
bool onewire_slave_receive(OneWireSlave* bus, uint8_t* data, size_t data_size);
/**
* Set a callback to be called on each reset
* @param bus
* @param callback
* @param context
* Enable overdrive mode
* @param [in] bus pointer to OneWireSlave instance
* @param [in] set true to turn overdrive on, false to turn it off
*/
void onewire_slave_set_overdrive(OneWireSlave* bus, bool set);
/**
* Set a callback function to be called on each reset.
* The return value of the callback determines whether the emulated device
* supports the short reset (passed as the is_short parameter).
* In most applications, it should also call onewire_slave_set_overdrive()
* to set the appropriate speed mode.
*
* @param [in] bus pointer to OneWireSlave instance
* @param [in] callback pointer to a callback function
* @param [in] context additional parameter to be passed to the callback
*/
void onewire_slave_set_reset_callback(
OneWireSlave* bus,
@@ -87,10 +104,13 @@ void onewire_slave_set_reset_callback(
void* context);
/**
* Set a callback to be called on each command
* @param bus
* @param callback
* @param context
* Set a callback function to be called on each command.
* The return value of the callback determines whether further operation
* is possible. As a rule of thumb, return true unless a critical error happened.
*
* @param [in] bus pointer to OneWireSlave instance
* @param [in] callback pointer to a callback function
* @param [in] context additional parameter to be passed to the callback
*/
void onewire_slave_set_command_callback(
OneWireSlave* bus,
@@ -99,9 +119,9 @@ void onewire_slave_set_command_callback(
/**
* Set a callback to report emulation success
* @param bus
* @param result_cb
* @param context
* @param [in] bus pointer to OneWireSlave instance
* @param [in] result_cb pointer to a callback function
* @param [in] context additional parameter to be passed to the callback
*/
void onewire_slave_set_result_callback(
OneWireSlave* bus,