hx711.c File Reference

#include <assert.h>
#include <stdint.h>
#include "hardware/gpio.h"
#include "hardware/pio.h"
#include "hardware/timer.h"
#include "pico/platform.h"
#include "pico/mutex.h"
#include "pico/time.h"
#include "../include/hx711.h"
#include "../include/util.h"

Go to the source code of this file.

Functions
void	hx711_init (hx711_t *const hx, const hx711_config_t *const config)
void	hx711_close (hx711_t *const hx)
	Stop communication with the HX711. More...
void	hx711_set_gain (hx711_t *const hx, const hx711_gain_t gain)
	Sets the HX711 gain. More...
int32_t	hx711_get_twos_comp (const uint32_t raw)
	Convert a raw value from the HX711 to a 32-bit signed int. More...
bool	hx711_is_min_saturated (const int32_t val)
	Returns true if the HX711 is saturated at its minimum level. More...
bool	hx711_is_max_saturated (const int32_t val)
	Returns true if the HX711 is saturated at its maximum level. More...
unsigned short	hx711_get_settling_time (const hx711_rate_t rate)
	Returns the number of milliseconds to wait according to the given HX711 sample rate to allow readings to settle. More...
unsigned char	hx711_get_rate_sps (const hx711_rate_t rate)
	Returns the numeric sample rate of the given rate. More...
unsigned char	hx711_get_clock_pulses (const hx711_gain_t gain)
	Returns the clock pulse count for a given gain value. More...
int32_t	hx711_get_value (hx711_t *const hx)
	Obtains a value from the HX711. Blocks until a value is available. More...
bool	hx711_get_value_timeout (hx711_t *const hx, int32_t *const val, const uint timeout)
	Obtains a value from the HX711. Blocks until a value is available or the timeout is reached. More...
bool	hx711_get_value_noblock (hx711_t *const hx, int32_t *const val)
	Obtains a value from the HX711. Returns immediately if no value is available. More...
bool	hx711__is_initd (hx711_t *const hx)
	Check whether the hx struct has been initalised. More...
bool	hx711__is_state_machine_enabled (hx711_t *const hx)
	Check whether the hx struct's state machines are running. More...
bool	hx711_is_value_valid (const int32_t v)
	Check whether the given value is valid for a HX711 implementation. More...
bool	hx711_is_pio_gain_valid (const uint32_t g)
	Check whether a given value is permitted to be transmitted to a PIO State Machine to set a HX711's gain according to the PIO program implementation. More...
bool	hx711_is_rate_valid (const hx711_rate_t r)
	Check whether the given rate is within the range of the predefined rates. More...
bool	hx711_is_gain_valid (const hx711_gain_t g)
	Check whether the given gain is within the range of the predefined gains. More...
void	hx711_power_up (hx711_t *const hx, const hx711_gain_t gain)
void	hx711_power_down (hx711_t *const hx)
void	hx711_wait_settle (const hx711_rate_t rate)
	Convenience function for sleeping for the appropriate amount of time according to the given sample rate to allow readings to settle. More...
void	hx711_wait_power_down ()
	Convenience function for sleeping for the appropriate amount of time to allow the HX711 to power down. More...
uint32_t	hx711_gain_to_pio_gain (const hx711_gain_t gain)
	Convert a hx711_gain_t to a numeric value appropriate for a PIO State Machine. More...
bool	hx711__try_get_value (PIO const pio, const uint sm, uint32_t *const val)
	Attempts to obtain a value from the PIO RX FIFO if one is available. More...

Variables
const unsigned short	HX711_SETTLING_TIMES []
const unsigned char	HX711_SAMPLE_RATES []
const unsigned char	HX711_CLOCK_PULSES []

Function Documentation

hx711__is_initd()

bool hx711__is_initd

(

hx711_t *const

hx

)

Check whether the hx struct has been initalised.

Parameters

hx

Returns

true

false

Definition at line 347 of file hx711.c.

                                        {
    return hx != NULL &&
        hx->_pio != NULL &&
#ifndef HX711_NO_MUTEX
        mutex_is_initialized(&hx->_mut) &&
#endif
        pio_sm_is_claimed(hx->_pio, hx->_reader_sm);
}

References hx711_t::_mut, hx711_t::_pio, and hx711_t::_reader_sm.

Referenced by hx711__is_state_machine_enabled(), hx711_close(), hx711_init(), hx711_power_down(), and hx711_power_up().

hx711__is_state_machine_enabled()

bool hx711__is_state_machine_enabled

(

hx711_t *const

hx

)

Check whether the hx struct's state machines are running.

Parameters

hx

Returns

true

false

Definition at line 356 of file hx711.c.

                                                        {
    return hx711__is_initd(hx) &&
        util_pio_sm_is_enabled(hx->_pio, hx->_reader_sm);
}

References hx711_t::_pio, hx711_t::_reader_sm, hx711__is_initd(), and util_pio_sm_is_enabled().

Referenced by hx711_get_value(), hx711_get_value_noblock(), hx711_get_value_timeout(), hx711_power_up(), and hx711_set_gain().

hx711__try_get_value()

bool hx711__try_get_value	(	PIO const	pio,
		const uint	sm,
		uint32_t *const	val
	)

Attempts to obtain a value from the PIO RX FIFO if one is available.

Parameters

pio	pointer to PIO
sm	state machine
val	pointer to raw value from HX711 to set

Returns

true if value was obtained

false if value was not obtained

Definition at line 516 of file hx711.c.

                         {
 
        assert(pio != NULL);
        check_sm_param(sm);
        assert(util_pio_sm_is_enabled(pio, sm));
        assert(val != NULL);
 
        static const uint byteThreshold = HX711_READ_BITS / 8;
 
        return util_pio_sm_try_get(
            pio,
            sm,
            val,
            byteThreshold);
 
}

References HX711_READ_BITS, util_pio_sm_is_enabled(), and util_pio_sm_try_get().

Referenced by hx711_get_value_noblock(), and hx711_get_value_timeout().

hx711_close()

void hx711_close

(

hx711_t *const

hx

)

Stop communication with the HX711.

Parameters

hx

Definition at line 123 of file hx711.c.

                                    {
 
    //state machines do not have to be running in order
    //to close
    assert(hx711__is_initd(hx));
 
    HX711_MUTEX_BLOCK(hx->_mut, 
 
        pio_sm_set_enabled(
            hx->_pio,
            hx->_reader_sm,
            false);
 
        pio_sm_unclaim(
            hx->_pio,
            hx->_reader_sm);
 
        pio_remove_program(
            hx->_pio,
            hx->_reader_prog,
            hx->_reader_offset);
 
    );
 
}

References hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_offset, hx711_t::_reader_prog, hx711_t::_reader_sm, hx711__is_initd(), and HX711_MUTEX_BLOCK.

hx711_gain_to_pio_gain()

uint32_t hx711_gain_to_pio_gain

(

const hx711_gain_t

gain

)

Convert a hx711_gain_t to a numeric value appropriate for a PIO State Machine.

Parameters

gain

Returns

uint32_t

gain value is 0-based and calculated by: gain = clock pulses - 24 - 1 ie. gain of 128 is 25 clock pulses, so gain = 25 - 24 - 1 gain = 0

Definition at line 495 of file hx711.c.

                                                         {
 
    assert(hx711_is_gain_valid(gain));
 
    const uint32_t clockPulses =
        hx711_get_clock_pulses(gain) - HX711_READ_BITS - 1;
 
    assert(hx711_is_pio_gain_valid(clockPulses));
 
    return clockPulses;
 
}

References hx711_get_clock_pulses(), hx711_is_gain_valid(), hx711_is_pio_gain_valid(), and HX711_READ_BITS.

Referenced by hx711_multi_power_up(), hx711_multi_set_gain(), hx711_power_up(), and hx711_set_gain().

hx711_get_clock_pulses()

unsigned char hx711_get_clock_pulses

(

const hx711_gain_t

gain

)

Returns the clock pulse count for a given gain value.

Parameters

gain

Returns

unsigned char

Definition at line 259 of file hx711.c.

                                                              {
    assert(hx711_is_gain_valid(gain));
    assert((int)gain <= count_of(HX711_CLOCK_PULSES) - 1);
    return HX711_CLOCK_PULSES[(int)gain];
}

References HX711_CLOCK_PULSES, and hx711_is_gain_valid().

Referenced by hx711_gain_to_pio_gain().

hx711_get_rate_sps()

unsigned char hx711_get_rate_sps

(

const hx711_rate_t

rate

)

Returns the numeric sample rate of the given rate.

Parameters

rate

Returns

unsigned char

Definition at line 253 of file hx711.c.

                                                          {
    assert(hx711_is_rate_valid(rate));
    assert((int)rate <= count_of(HX711_SAMPLE_RATES) - 1);
    return HX711_SAMPLE_RATES[(int)rate];
}

References hx711_is_rate_valid(), and HX711_SAMPLE_RATES.

hx711_get_settling_time()

unsigned short hx711_get_settling_time

(

const hx711_rate_t

rate

)

Returns the number of milliseconds to wait according to the given HX711 sample rate to allow readings to settle.

Parameters

rate

Returns

unsigned short

Definition at line 247 of file hx711.c.

                                                                {
    assert(hx711_is_rate_valid(rate));
    assert((int)rate <= count_of(HX711_SETTLING_TIMES) - 1);
    return HX711_SETTLING_TIMES[(int)rate];
}

References hx711_is_rate_valid(), and HX711_SETTLING_TIMES.

Referenced by hx711_wait_settle().

hx711_get_twos_comp()

int32_t hx711_get_twos_comp

(

const uint32_t

raw

)

Convert a raw value from the HX711 to a 32-bit signed int.

Parameters

raw

Returns

int32_t

Definition at line 231 of file hx711.c.

                                                {
    return
        (int32_t)(-(raw & +HX711_MIN_VALUE)) + 
        (int32_t)(raw & HX711_MAX_VALUE);
}

References HX711_MAX_VALUE, and HX711_MIN_VALUE.

Referenced by hx711_get_value(), hx711_get_value_noblock(), hx711_get_value_timeout(), and hx711_multi_pinvals_to_values().

hx711_get_value()

int32_t hx711_get_value

(

hx711_t *const

hx

)

Obtains a value from the HX711. Blocks until a value is available.

Parameters

hx

Returns

int32_t

Block until a value is available

NOTE: remember that reading from the RX FIFO simultaneously clears it. That's why we can keep calling this function hx711_get_value and be assured we'll be getting a new value each time, even if the RX FIFO is currently empty.

Definition at line 265 of file hx711.c.

                                           {
 
    assert(hx711__is_state_machine_enabled(hx));
 
    uint32_t rawVal;
 
    HX711_MUTEX_BLOCK(hx->_mut, 
 
        rawVal = pio_sm_get_blocking(
            hx->_pio,
            hx->_reader_sm);
 
    );
 
    return hx711_get_twos_comp(rawVal);
 
}

References hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_sm, hx711__is_state_machine_enabled(), hx711_get_twos_comp(), and HX711_MUTEX_BLOCK.

hx711_get_value_noblock()

bool hx711_get_value_noblock	(	hx711_t *const	hx,
		int32_t *const	val
	)

Obtains a value from the HX711. Returns immediately if no value is available.

Parameters

hx
val	pointer to the value

Returns

true if a value was available and val is set

false if a value was not available

Definition at line 322 of file hx711.c.

                        {
 
        assert(hx711__is_state_machine_enabled(hx));
        assert(val != NULL);
 
        bool success;
        uint32_t tempVal;
 
        HX711_MUTEX_BLOCK(hx->_mut, 
            success = hx711__try_get_value(
                hx->_pio,
                hx->_reader_sm,
                &tempVal);
        );
 
        if(success) {
            *val = hx711_get_twos_comp(tempVal);
        }
 
        return success;
 
}

References hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_sm, hx711__is_state_machine_enabled(), hx711__try_get_value(), hx711_get_twos_comp(), and HX711_MUTEX_BLOCK.

hx711_get_value_timeout()

bool hx711_get_value_timeout	(	hx711_t *const	hx,
		int32_t *const	val,
		const uint	timeout
	)

Obtains a value from the HX711. Blocks until a value is available or the timeout is reached.

Parameters

hx
val	pointer to the value
timeout	maximum time to wait for a value in microseconds

Returns

true if a value was obtained within the timeout

false if a timeout was reached

Definition at line 292 of file hx711.c.

                        {
 
        assert(hx711__is_state_machine_enabled(hx));
        assert(val != NULL);
 
        bool success = false;
        const absolute_time_t endTime = make_timeout_time_us(timeout);
        uint32_t tempVal;
 
        assert(!is_nil_time(endTime));
 
        HX711_MUTEX_BLOCK(hx->_mut, 
            while(!time_reached(endTime)) {
                if((success = hx711__try_get_value(hx->_pio, hx->_reader_sm, &tempVal))) {
                    break;
                }
            }
        );
 
        if(success) {
            *val = hx711_get_twos_comp(tempVal);
        }
 
        return success;
 
}

References hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_sm, hx711__is_state_machine_enabled(), hx711__try_get_value(), hx711_get_twos_comp(), and HX711_MUTEX_BLOCK.

hx711_init()

void hx711_init	(	hx711_t *const	hx,
		const hx711_config_t *const	config
	)

There was originally a call here to gpio_put on the clock pin to power up the HX711. I have decided to remove this and also remove enabling the state machine from the pio init function. This does leave the HX711's power state undefined from the perspective of the code, but does give a much clearer separation of duties. This function merely init's the hardware and state machine, and the hx711_set_power function sets the power and enables/disables the state machine.

There was originally a call here to gpio_pull_up on the data pin to prevent erroneous data ready states. This was incorrect. Page 4 of the datasheet states: "The 25th pulse at PD_SCK input will pull DOUT pin back to high (Fig.2)."

Definition at line 50 of file hx711.c.

                                        {
 
        assert(!hx711__is_initd(hx));
 
        assert(hx != NULL);
        assert(config != NULL);
 
        assert(config->pio != NULL);
        assert(config->pio_init != NULL);
 
        assert(config->reader_prog != NULL);
        assert(config->reader_prog_init != NULL);
 
        check_gpio_param(config->clock_pin);
        check_gpio_param(config->data_pin);
        assert(config->clock_pin != config->data_pin);
 
#ifndef HX711_NO_MUTEX
        mutex_init(&hx->_mut);
#endif
 
        HX711_MUTEX_BLOCK(hx->_mut, 
 
            hx->_clock_pin = config->clock_pin;
            hx->_data_pin = config->data_pin;
            hx->_pio = config->pio;
            hx->_reader_prog = config->reader_prog;
 
            util_gpio_set_output(hx->_clock_pin);
 
            gpio_set_input_enabled(
                hx->_data_pin,
                true);
 
            //either statement below will panic if it fails
            hx->_reader_offset = pio_add_program(
                hx->_pio,
                hx->_reader_prog);
 
            hx->_reader_sm = (uint)pio_claim_unused_sm(
                hx->_pio,
                true);
 
            config->pio_init(hx);
            config->reader_prog_init(hx);
 
        );
 
}

References hx711_t::_clock_pin, hx711_t::_data_pin, hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_offset, hx711_t::_reader_prog, hx711_t::_reader_sm, hx711_config_t::clock_pin, hx711_config_t::data_pin, hx711__is_initd(), HX711_MUTEX_BLOCK, hx711_config_t::pio, hx711_config_t::pio_init, hx711_config_t::reader_prog, hx711_config_t::reader_prog_init, and util_gpio_set_output().

hx711_is_gain_valid()

bool hx711_is_gain_valid

(

const hx711_gain_t

g

)

Check whether the given gain is within the range of the predefined gains.

Parameters

g

Returns

true

false

Definition at line 382 of file hx711.c.

                                               {
    return util_int_in_range(
        (int)g,
        hx711_gain_128,
        hx711_gain_64);
}

References hx711_gain_128, and hx711_gain_64.

Referenced by hx711_gain_to_pio_gain(), hx711_get_clock_pulses(), hx711_power_up(), and hx711_set_gain().

hx711_is_max_saturated()

bool hx711_is_max_saturated

(

const int32_t

val

)

Returns true if the HX711 is saturated at its maximum level.

Parameters

val

Returns

true

false

Definition at line 242 of file hx711.c.

                                               {
    assert(hx711_is_value_valid(val));
    return val == HX711_MAX_VALUE;
}

References hx711_is_value_valid(), and HX711_MAX_VALUE.

hx711_is_min_saturated()

bool hx711_is_min_saturated

(

const int32_t

val

)

Returns true if the HX711 is saturated at its minimum level.

Parameters

val

Returns

true

false

Definition at line 237 of file hx711.c.

                                               {
    assert(hx711_is_value_valid(val));
    return val == HX711_MIN_VALUE;
}

References hx711_is_value_valid(), and HX711_MIN_VALUE.

hx711_is_pio_gain_valid()

bool hx711_is_pio_gain_valid

(

const uint32_t

g

)

Check whether a given value is permitted to be transmitted to a PIO State Machine to set a HX711's gain according to the PIO program implementation.

Parameters

g

Returns

true

false

Definition at line 368 of file hx711.c.

                                               {
    return util_uint32_t_in_range(
        g,
        HX711_PIO_MIN_GAIN,
        HX711_PIO_MAX_GAIN);
}

References HX711_PIO_MAX_GAIN, and HX711_PIO_MIN_GAIN.

Referenced by hx711_gain_to_pio_gain(), hx711_multi_power_up(), hx711_multi_set_gain(), hx711_power_up(), and hx711_set_gain().

hx711_is_rate_valid()

bool hx711_is_rate_valid

(

const hx711_rate_t

r

)

Check whether the given rate is within the range of the predefined rates.

Parameters

r

Returns

true

false

Definition at line 375 of file hx711.c.

                                               {
    return util_int_in_range(
        (int)r,
        hx711_rate_10,
        hx711_rate_80);
}

References hx711_rate_10, and hx711_rate_80.

Referenced by hx711_get_rate_sps(), and hx711_get_settling_time().

hx711_is_value_valid()

bool hx711_is_value_valid

(

const int32_t

v

)

Check whether the given value is valid for a HX711 implementation.

Parameters

v

Returns

true

false

Definition at line 361 of file hx711.c.

                                           {
    return util_int32_t_in_range(
        v,
        HX711_MIN_VALUE,
        HX711_MAX_VALUE);
}

References HX711_MAX_VALUE, and HX711_MIN_VALUE.

Referenced by hx711_is_max_saturated(), hx711_is_min_saturated(), and hx711_multi_pinvals_to_values().

hx711_power_down()

void hx711_power_down

(

hx711_t *const

hx

)

1. set clock pin high to start the power down process

NOTE: the HX711 chip requires the clock pin to be held high for 60+ us calling functions should therefore do:

hx711_power_down(&hx); hx711_wait_power_down();

Definition at line 455 of file hx711.c.

                                         {
 
    //don't have to have SMs running; just check for init
    assert(hx711__is_initd(hx));
 
    HX711_MUTEX_BLOCK(hx->_mut, 
 
        //1. stop the state machine
        pio_sm_set_enabled(
            hx->_pio,
            hx->_reader_sm,
            false);
 
        gpio_put(
            hx->_clock_pin,
            true);
 
    );
 
}

References hx711_t::_clock_pin, hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_sm, hx711__is_initd(), and HX711_MUTEX_BLOCK.

hx711_power_up()

void hx711_power_up	(	hx711_t *const	hx,
		const hx711_gain_t	gain
	)

NOTE: pio_sm_restart should not be used here. That function clears the clock divider which is currently set in the dedicated pio init function.

1. set the clock pin low to power up the chip

There does not appear to be any delay after powering up. Any actual delay would presumably be dealt with by the HX711 prior to the data pin going low. Which, in turn, is handled by the state machine in waiting for the low signal.

Definition at line 389 of file hx711.c.

                             {
 
        //the struct should be init'd, but the state machines
        //should not be running
        assert(hx711__is_initd(hx));
        assert(!hx711__is_state_machine_enabled(hx));
 
        assert(hx711_is_gain_valid(gain));
 
        const uint32_t gainVal = hx711_gain_to_pio_gain(gain);
 
        assert(hx711_is_pio_gain_valid(gainVal));
 
        HX711_MUTEX_BLOCK(hx->_mut, 
 
            gpio_put(
                hx->_clock_pin,
                false);
 
            //2. reset the state machine using the default config
            //obtained when init'ing.
            pio_sm_init(
                hx->_pio,
                hx->_reader_sm,
                hx->_reader_offset,
                &hx->_reader_prog_default_config);
 
            //make sure TX FIFO is empty before putting the 
            //gain in.
            pio_sm_drain_tx_fifo(
                hx->_pio,
                hx->_reader_sm);
 
            //3. Push the initial gain into the TX FIFO
            pio_sm_put(
                hx->_pio,
                hx->_reader_sm,
                gainVal);
 
            //4. start the state machine
            pio_sm_set_enabled(
                hx->_pio,
                hx->_reader_sm,
                true);
 
        );
 
}

References hx711_t::_clock_pin, hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_offset, hx711_t::_reader_prog_default_config, hx711_t::_reader_sm, hx711__is_initd(), hx711__is_state_machine_enabled(), hx711_gain_to_pio_gain(), hx711_is_gain_valid(), hx711_is_pio_gain_valid(), and HX711_MUTEX_BLOCK.

hx711_set_gain()

void hx711_set_gain	(	hx711_t *const	hx,
		const hx711_gain_t	gain
	)

Sets the HX711 gain.

Parameters

hx
gain

Before putting anything in the TX FIFO buffer, assume the worst-case scenario which is that there's something already in there. There ought not to be, but clearing it ensures the following pio_sm_put* call does not need to block as this function to change the gain should take precedence.

At this point the current value in the RX FIFO will have been calculated based on whatever the previous set gain was. So, the RX FIFO needs to be cleared.

NOTE: checking for whether the RX FIFO is not empty won't work. A conversion may have already begun before any bits have been moved into the ISR.

UPDATE: the worst-case scenario here is that the pio_sm_put call has occurred after the pio "pull", because we then need to wait until the following "pull" in the state machine. If this happens:

1. there may already be a value in the RX FIFO; and
2. another value will need to be read and discarded following which the new gain will be set.

To handle 1.: Clear the RX FIFO with a non-blocking read. If the RX FIFO is empty, no harm done because the call won't block.

To handle 2.: Read the "next" value with a blocking read to ensure the "next, next" value will be set to the desired gain.

Immediately following the above blocking call, the state machine will pull in the data in the pio_sm_put call above and pulse the HX711 the correct number of times to set the desired gain.

No further communication with the state machine from this function is required. Any other function(s) wishing to obtain a value from the HX711 need only block until one is there (or check the RX FIFO level).

Definition at line 149 of file hx711.c.

                                                                {
 
    assert(hx711__is_state_machine_enabled(hx));
    assert(hx711_is_gain_valid(gain));
 
    const uint32_t pioGain = hx711_gain_to_pio_gain(gain);
 
    assert(hx711_is_pio_gain_valid(pioGain));
 
    HX711_MUTEX_BLOCK(hx->_mut, 
 
        pio_sm_drain_tx_fifo(
            hx->_pio,
            hx->_reader_sm);
 
        pio_sm_put(
            hx->_pio,
            hx->_reader_sm,
            pioGain);
 
        //1. clear the RX FIFO with the non-blocking read
        pio_sm_get(
            hx->_pio,
            hx->_reader_sm);
 
        //2. wait until the value from the currently-set gain
        //can be safely read and discarded
        pio_sm_get_blocking(
            hx->_pio,
            hx->_reader_sm);
 
    );
 
}

References hx711_t::_mut, hx711_t::_pio, hx711_t::_reader_sm, hx711__is_state_machine_enabled(), hx711_gain_to_pio_gain(), hx711_is_gain_valid(), hx711_is_pio_gain_valid(), and HX711_MUTEX_BLOCK.

hx711_wait_power_down()

void hx711_wait_power_down

(

)

Convenience function for sleeping for the appropriate amount of time to allow the HX711 to power down.

Definition at line 491 of file hx711.c.

                             {
    sleep_us(HX711_POWER_DOWN_TIMEOUT);
}

References HX711_POWER_DOWN_TIMEOUT.

Referenced by hx711_multi_sync().

hx711_wait_settle()

void hx711_wait_settle

(

const hx711_rate_t

rate

)

Convenience function for sleeping for the appropriate amount of time according to the given sample rate to allow readings to settle.

Parameters

rate

Definition at line 487 of file hx711.c.

                                                {
    sleep_ms(hx711_get_settling_time(rate));
}

References hx711_get_settling_time().

Variable Documentation

HX711_CLOCK_PULSES

const unsigned char HX711_CLOCK_PULSES[]

Initial value:

= {
    25,
    26,
    27
}

Definition at line 44 of file hx711.c.

Referenced by hx711_get_clock_pulses().

HX711_SAMPLE_RATES

const unsigned char HX711_SAMPLE_RATES[]

Initial value:

= {
    10,
    80
}

Definition at line 39 of file hx711.c.

Referenced by hx711_get_rate_sps().

HX711_SETTLING_TIMES

const unsigned short HX711_SETTLING_TIMES[]

Initial value:

= {
    400,
    50
}

Definition at line 34 of file hx711.c.

Referenced by hx711_get_settling_time().