hx711.h

Go to the documentation of this file.

// MIT License
// 
// Copyright (c) 2023 Daniel Robertson
// 
// 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.
 
#ifndef HX711_H_0ED0E077_8980_484C_BB94_AF52973CDC09
#define HX711_H_0ED0E077_8980_484C_BB94_AF52973CDC09
 
#include <stdbool.h>
#include <stdint.h>
#include "hardware/pio.h"
#include "pico/mutex.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef HX711_NO_MUTEX
    #define HX711_MUTEX_BLOCK(mut, ...) \
        do { \
            mutex_enter_blocking(&mut); \
            __VA_ARGS__ \
            mutex_exit(&mut); \
        } while(0)
#else
    #define HX711_MUTEX_BLOCK(mut, ...) \
    do { \
        __VA_ARGS__ \
    } while(0)
#endif
 
#define HX711_READ_BITS                 UINT8_C(24)
#define HX711_POWER_DOWN_TIMEOUT        UINT8_C(60) //microseconds
 
#define HX711_MIN_VALUE                 INT32_C(-0x800000) //−8,388,608
#define HX711_MAX_VALUE                 INT32_C(0x7fffff) //8,388,607
 
#define HX711_PIO_MIN_GAIN              UINT8_C(0)
#define HX711_PIO_MAX_GAIN              UINT8_C(2)
 
extern const unsigned short HX711_SETTLING_TIMES[3]; //milliseconds
extern const unsigned char HX711_SAMPLE_RATES[2];
extern const unsigned char HX711_CLOCK_PULSES[3];
 
typedef enum {
    hx711_rate_10 = 0,
    hx711_rate_80
} hx711_rate_t;
 
typedef enum {
    hx711_gain_128 = 0,
    hx711_gain_32,
    hx711_gain_64
} hx711_gain_t;
 
typedef struct {
 
    uint _clock_pin;
    uint _data_pin;
 
    PIO _pio;
    const pio_program_t* _reader_prog;
    pio_sm_config _reader_prog_default_config;
    uint _reader_sm;
    uint _reader_offset;
 
#ifndef HX711_NO_MUTEX
    mutex_t _mut;
#endif
 
} hx711_t;
 
typedef void (*hx711_pio_init_t)(hx711_t* const);
typedef void (*hx711_program_init_t)(hx711_t* const);
 
typedef struct {
 
    uint clock_pin;
    uint data_pin;
 
    PIO pio;
    hx711_pio_init_t pio_init;
 
    const pio_program_t* reader_prog;
    hx711_program_init_t reader_prog_init;
 
} hx711_config_t;
 
void hx711_init(
    hx711_t* const hx,
    const hx711_config_t* const config);
 
void hx711_close(hx711_t* const hx);
 
void hx711_set_gain(
    hx711_t* const hx,
    const hx711_gain_t gain);
 
int32_t hx711_get_twos_comp(const uint32_t raw);
 
bool hx711_is_min_saturated(const int32_t val);
 
bool hx711_is_max_saturated(const int32_t val);
 
unsigned short hx711_get_settling_time(const hx711_rate_t rate);
 
unsigned char hx711_get_rate_sps(const hx711_rate_t rate);
 
unsigned char hx711_get_clock_pulses(const hx711_gain_t gain);
 
int32_t hx711_get_value(hx711_t* const hx);
 
bool hx711_get_value_timeout(
    hx711_t* const hx,
    int32_t* const val,
    const uint timeout);
 
bool hx711_get_value_noblock(
    hx711_t* const hx,
    int32_t* const val);
 
static bool hx711__is_initd(hx711_t* const hx);
 
static bool hx711__is_state_machine_enabled(hx711_t* const hx);
 
bool hx711_is_value_valid(const int32_t v);
 
bool hx711_is_pio_gain_valid(const uint32_t g);
 
bool hx711_is_rate_valid(const hx711_rate_t r);
 
bool hx711_is_gain_valid(const hx711_gain_t g);
 
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);
 
void hx711_wait_power_down();
 
uint32_t hx711_gain_to_pio_gain(const hx711_gain_t gain);
 
static bool hx711__try_get_value(
    PIO const pio,
    const uint sm,
    uint32_t* const val);
 
#ifdef __cplusplus
}
#endif
 
#endif