changes

Author: endail

include/hx711.h

@@ -32,14 +32,14 @@
 extern "C" {
 #endif
 
-#define HX711_READ_BITS                 24u
-#define HX711_POWER_DOWN_TIMEOUT        60u //microseconds
+#define HX711_READ_BITS                 UINT8_C(24)
+#define HX711_POWER_DOWN_TIMEOUT        UINT8_C(60) //microseconds
 
-#define HX711_MIN_VALUE                 INT32_C(-0x800000)
-#define HX711_MAX_VALUE                 INT32_C(0x7fffff)
+#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              0u
-#define HX711_PIO_MAX_GAIN              2u
+#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];

include/hx711_multi.h

@@ -34,15 +34,15 @@
 extern "C" {
 #endif
 
-#define HX711_MULTI_CONVERSION_DONE_IRQ_NUM     0u
-#define HX711_MULTI_DATA_READY_IRQ_NUM          4u
+#define HX711_MULTI_CONVERSION_DONE_IRQ_NUM     UINT8_C(0)
+#define HX711_MULTI_DATA_READY_IRQ_NUM          UINT8_C(4)
 
-#define HX711_MULTI_ASYNC_REQ_COUNT             NUM_PIOS
-#define HX711_MULTI_ASYNC_PIO_IRQ_IDX           0u
-#define HX711_MULTI_ASYNC_DMA_IRQ_IDX           0u
+#define HX711_MULTI_ASYNC_REQ_COUNT             UINT8_C(NUM_PIOS)
+#define HX711_MULTI_ASYNC_PIO_IRQ_IDX           UINT8_C(0)
+#define HX711_MULTI_ASYNC_DMA_IRQ_IDX           UINT8_C(0)
 
-#define HX711_MULTI_MIN_CHIPS                   1u
-#define HX711_MULTI_MAX_CHIPS                   32u
+#define HX711_MULTI_MIN_CHIPS                   UINT8_C(1)
+#define HX711_MULTI_MAX_CHIPS                   UINT8_C(32)
 
 typedef enum {
     HX711_MULTI_ASYNC_STATE_NONE = 0,
@@ -111,6 +111,21 @@ typedef struct {
 extern hx711_multi_t* hx711_multi__async_request_map[
     HX711_MULTI_ASYNC_REQ_COUNT];
 
+static void hx711_multi__init_asert(
+    hx711_multi_t* const hxm,
+    const hx711_multi_config_t* const config);
+
+static void hx711_multi__init_pio(
+    hx711_multi_t* const hxm,
+    const hx711_multi_config_t* const config);
+
+static void hx711_multi__init_dma(
+    hx711_multi_t* const hxm,
+    const hx711_multi_config_t* const config);
+
+static void hx711_multi__init_irq(
+    hx711_multi_t* const hxm);
+
 /**
  * @brief Whether a given hxm is the cause of the current
  * DMA IRQ.

include/util.h

@@ -25,6 +25,7 @@
 
 #include <stdint.h>
 #include "hardware/pio.h"
+#include "hardware/platform_defs.h"
 #include "hardware/sync.h"
 #include "pico/mutex.h"
 #include "pico/types.h"
@@ -33,44 +34,75 @@
 extern "C" {
 #endif
 
-#define UTIL_DMA_IRQ_INDEX_MIN 0u
-#define UTIL_DMA_IRQ_INDEX_MAX 1u
+// RP2040 sdk doesn't seem to define this
+#define UTIL_NUM_DMA_IRQS UINT8_C(2)
 
-#define UTIL_PIO_IRQ_INDEX_MIN 0u
-#define UTIL_PIO_IRQ_INDEX_MAX 1u
+#define UTIL_DMA_IRQ_INDEX_MIN UINT8_C(0)
+#define UTIL_DMA_IRQ_INDEX_MAX UINT8_C(UTIL_NUM_DMA_IRQS - 1)
 
-#define UTIL_PIO_INTERRUPT_NUM_MIN 0u
-#define UTIL_PIO_INTERRUPT_NUM_MAX 7u
+#define UTIL_PIO_IRQ_INDEX_MIN UINT8_C(0)
+#define UTIL_PIO_IRQ_INDEX_MAX UINT8_C(NUM_PIOS - 1)
 
-#define UTIL_ROUTABLE_PIO_INTERRUPT_NUM_MIN 0u
-#define UTIL_ROUTABLE_PIO_INTERRUPT_NUM_MAX 3u
+#define UTIL_PIO_INTERRUPT_NUM_MIN UINT8_C(0)
+#define UTIL_PIO_INTERRUPT_NUM_MAX UINT8_C(7)
 
+#define UTIL_ROUTABLE_PIO_INTERRUPT_NUM_MIN UINT8_C(0)
+#define UTIL_ROUTABLE_PIO_INTERRUPT_NUM_MAX UINT8_C(3)
+
+/**
+ * @brief Own a mutex for the duration of this block of
+ * code.
+ * @example UTIL_MUTEX_BLOCK(mut, 
+ *  // do something...
+ * );
+ */
 #define UTIL_MUTEX_BLOCK(mut, ...) \
     do { \
         mutex_enter_blocking(&mut); \
         __VA_ARGS__ \
         mutex_exit(&mut); \
     } while(0)
 
+/**
+ * @brief Disable interrupts for the duration of this block of
+ * code.
+ * @example UTIL_INTERRUPTS_OFF_BLOCK(
+ *  // do something atomically...
+ * );
+ * @note the interrupt_status var is uniquely named to avoid
+ * variable conflicts within the block.
+ */
 #define UTIL_INTERRUPTS_OFF_BLOCK(...) \
     do { \
-        const uint32_t _interrupt_status = save_and_disable_interrupts(); \
+        const uint32_t interrupt_status_cb918069_eadf_49bc_9d8c_a8a4defad20c = save_and_disable_interrupts(); \
         __VA_ARGS__ \
-        restore_interrupts(_interrupt_status); \
+        restore_interrupts(interrupt_status_cb918069_eadf_49bc_9d8c_a8a4defad20c); \
     } while(0)
 
-#define DECL_IN_RANGE_FUNC(TYPE) \
+#define UTIL_DECL_IN_RANGE_FUNC(TYPE) \
     bool util_ ## TYPE ##_in_range( \
         const TYPE val, \
         const TYPE min, \
         const TYPE max);
 
-DECL_IN_RANGE_FUNC(int32_t)
-DECL_IN_RANGE_FUNC(uint32_t)
-DECL_IN_RANGE_FUNC(int)
-DECL_IN_RANGE_FUNC(uint)
+UTIL_DECL_IN_RANGE_FUNC(int32_t)
+UTIL_DECL_IN_RANGE_FUNC(uint32_t)
+UTIL_DECL_IN_RANGE_FUNC(int)
+UTIL_DECL_IN_RANGE_FUNC(uint)
+
+/**
+ * @brief Quick lookup for finding an NVIC IRQ number
+ * for a PIO and interrupt index number.
+ * @note Each PIO has two interrupts, hence why this
+ * array is doubled.
+ */
+extern const uint8_t util_pio_to_irq_map[NUM_PIOS * 2];
 
-#undef DECL_IN_RANGE_FUNC
+/**
+ * @brief Quick lookup for finding an NVIC IRQ number
+ * for a DMA interrupt index number.
+ */
+extern const uint8_t util_dma_to_irq_map[UTIL_NUM_DMA_IRQS];
 
 /**
  * @brief Check whether a DMA IRQ index is valid.
@@ -151,17 +183,17 @@ bool util_pio_irq_index_is_valid(const uint idx);
 
 /**
  * @brief Gets the correct NVIC IRQ number for a PIO
- * according to the IRQ number.
+ * according to the IRQ index.
  * 
  * @example util_pion_get_irqn(pio1, 1); //returns PIO1_IRQ_1
  * 
  * @param pio 
- * @param irq_num 0 or 1
+ * @param irq_index 0 or 1
  * @return uint 
  */
 uint util_pion_get_irqn(
     PIO const pio,
-    const uint irq_num);
+    const uint irq_index);
 
 /**
  * @brief Gets the correct PIO interrupt source number according
@@ -220,9 +252,24 @@ bool util_pio_sm_is_enabled(
     PIO const pio,
     const uint sm);
 
+/**
+ * @brief Check whether a PIO interrupt number is valid.
+ * 
+ * @param pio_interrupt_num 
+ * @return true 
+ * @return false 
+ */
 bool util_pio_interrupt_num_is_valid(
     const uint pio_interrupt_num);
 
+/**
+ * @brief Check whether a PIO interrupt number is
+ * a valid routable interrupt number.
+ * 
+ * @param pio_interrupt_num 
+ * @return true 
+ * @return false 
+ */
 bool util_routable_pio_interrupt_num_is_valid(
     const uint pio_interrupt_num);
 
@@ -320,6 +367,8 @@ bool util_pio_sm_try_get(
     uint32_t* const word,
     const uint threshold);
 
+#undef UTIL_DECL_IN_RANGE_FUNC
+
 #ifdef __cplusplus
 }
 #endif

src/hx711.c

@@ -62,6 +62,8 @@ void hx711_init(
         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);
 
         mutex_init(&hx->_mut);
@@ -231,26 +233,31 @@ int32_t hx711_get_twos_comp(const uint32_t raw) {
 }
 
 bool hx711_is_min_saturated(const int32_t val) {
-    return val == HX711_MIN_VALUE; //−8,388,608
+    assert(hx711_is_value_valid(val));
+    return val == HX711_MIN_VALUE;
 }
 
 bool hx711_is_max_saturated(const int32_t val) {
-    return val == HX711_MAX_VALUE; //8,388,607
+    assert(hx711_is_value_valid(val));
+    return val == HX711_MAX_VALUE;
 }
 
 unsigned short hx711_get_settling_time(const hx711_rate_t rate) {
-    assert((uint)rate <= count_of(HX711_SETTLING_TIMES) - 1);
-    return HX711_SETTLING_TIMES[(uint)rate];
+    assert(hx711_is_rate_valid(rate));
+    assert((int)rate <= count_of(HX711_SETTLING_TIMES) - 1);
+    return HX711_SETTLING_TIMES[(int)rate];
 }
 
 unsigned char hx711_get_rate_sps(const hx711_rate_t rate) {
-    assert((uint)rate <= count_of(HX711_SAMPLE_RATES) - 1);
-    return HX711_SAMPLE_RATES[(uint)rate];
+    assert(hx711_is_rate_valid(rate));
+    assert((int)rate <= count_of(HX711_SAMPLE_RATES) - 1);
+    return HX711_SAMPLE_RATES[(int)rate];
 }
 
 unsigned char hx711_get_clock_pulses(const hx711_gain_t gain) {
-    assert((uint)gain <= count_of(HX711_CLOCK_PULSES) - 1);
-    return HX711_CLOCK_PULSES[(uint)gain];
+    assert(hx711_is_gain_valid(gain));
+    assert((int)gain <= count_of(HX711_CLOCK_PULSES) - 1);
+    return HX711_CLOCK_PULSES[(int)gain];
 }
 
 int32_t hx711_get_value(hx711_t* const hx) {
@@ -363,14 +370,14 @@ bool hx711_is_pio_gain_valid(const uint32_t g) {
 
 bool hx711_is_rate_valid(const hx711_rate_t r) {
     return util_int_in_range(
-        r,
+        (int)r,
         hx711_rate_10,
         hx711_rate_80);
 }
 
 bool hx711_is_gain_valid(const hx711_gain_t g) {
     return util_int_in_range(
-        g,
+        (int)g,
         hx711_gain_128,
         hx711_gain_64);
 }
@@ -379,12 +386,12 @@ void hx711_power_up(
     hx711_t* const hx,
     const hx711_gain_t gain) {
 
-        assert(!hx711__is_state_machine_enabled(hx));
+        assert(hx711__is_initd(hx));
+        assert(hx711_is_gain_valid(gain));
 
         //state machines are not running at this point, so don't
         //check for that, only if the hx struct is initd
-        assert(hx711__is_initd(hx));
-        assert(hx711_is_gain_valid(gain));
+        assert(!hx711__is_state_machine_enabled(hx));
 
         const uint32_t gainVal = hx711_gain_to_pio_gain(gain);
 
@@ -443,7 +450,8 @@ void hx711_power_up(
 
 void hx711_power_down(hx711_t* const hx) {
 
-    assert(hx711__is_state_machine_enabled(hx));
+    //don't have to have SMs running; just check for init
+    assert(hx711__is_initd(hx));
 
     UTIL_MUTEX_BLOCK(hx->_mut, 
 
@@ -492,8 +500,12 @@ uint32_t hx711_gain_to_pio_gain(const hx711_gain_t gain) {
 
     assert(hx711_is_gain_valid(gain));
 
-    const uint32_t clockPulses = hx711_get_clock_pulses(gain);
-    return clockPulses - HX711_READ_BITS - 1;
+    const uint32_t clockPulses =
+        hx711_get_clock_pulses(gain) - HX711_READ_BITS - 1;
+
+    assert(hx711_is_pio_gain_valid(clockPulses));
+
+    return clockPulses;
 
 }