{"id":20989710,"url":"https://github.com/robtillaart/hx711","last_synced_at":"2025-10-05T11:41:19.217Z","repository":{"id":38819779,"uuid":"272734493","full_name":"RobTillaart/HX711","owner":"RobTillaart","description":"Arduino library for HX711 24 bit ADC  used for load cells and scales.","archived":false,"fork":false,"pushed_at":"2024-11-19T11:12:28.000Z","size":93,"stargazers_count":97,"open_issues_count":0,"forks_count":31,"subscribers_count":4,"default_branch":"master","last_synced_at":"2025-03-29T16:07:11.271Z","etag":null,"topics":["arduino","loadcell"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/RobTillaart.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG..md","contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null},"funding":{"github":"RobTillaart","custom":"https://www.paypal.me/robtillaart"}},"created_at":"2020-06-16T14:46:07.000Z","updated_at":"2025-03-21T07:04:11.000Z","dependencies_parsed_at":"2024-03-02T16:33:01.969Z","dependency_job_id":"97dc9c99-ed1c-4ca5-bb5d-8317e7179403","html_url":"https://github.com/RobTillaart/HX711","commit_stats":null,"previous_names":[],"tags_count":18,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RobTillaart%2FHX711","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RobTillaart%2FHX711/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RobTillaart%2FHX711/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/RobTillaart%2FHX711/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/RobTillaart","download_url":"https://codeload.github.com/RobTillaart/HX711/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247369953,"owners_count":20927928,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["arduino","loadcell"],"created_at":"2024-11-19T06:25:53.496Z","updated_at":"2025-10-05T11:41:19.206Z","avatar_url":"https://github.com/RobTillaart.png","language":"C++","funding_links":["https://github.com/sponsors/RobTillaart","https://www.paypal.me/robtillaart"],"categories":[],"sub_categories":[],"readme":"\n[![Arduino CI](https://github.com/RobTillaart/HX711/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)\n[![Arduino-lint](https://github.com/RobTillaart/HX711/actions/workflows/arduino-lint.yml/badge.svg)](https://github.com/RobTillaart/HX711/actions/workflows/arduino-lint.yml)\n[![JSON check](https://github.com/RobTillaart/HX711/actions/workflows/jsoncheck.yml/badge.svg)](https://github.com/RobTillaart/HX711/actions/workflows/jsoncheck.yml)\n[![GitHub issues](https://img.shields.io/github/issues/RobTillaart/HX711.svg)](https://github.com/RobTillaart/HX711/issues)\n\n[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/HX711/blob/master/LICENSE)\n[![GitHub release](https://img.shields.io/github/release/RobTillaart/HX711.svg?maxAge=3600)](https://github.com/RobTillaart/HX711/releases)\n[![PlatformIO Registry](https://badges.registry.platformio.org/packages/robtillaart/library/HX711.svg)](https://registry.platformio.org/libraries/robtillaart/HX711)\n\n\n# HX711\n\nArduino library for HX711 24 bit ADC used for load cells and scales.\n\n\n## Description\n\nThis HX711 library has a public interface (API) which is a superset of the \npublic interface of the HX711 library, version 0.7.3, by [Bogde](https://github.com/bogde/HX711).\nThe API is reused to be compatible on the basic interaction level, so credits \nfor the reused API go to Bogde.\n\nThe implementation of both libraries differ from the beginning. \nThe HX711 by Bogde is in several ways more sophisticated than this HX711 library. \nIn this HX711 library, missing functions, modes and more were added to get more \ninfo from the library.\nSo you can choose the library that fit your needs most.\n\nAnother important difference is that this HX711 library uses floats. \nThe 23 bits mantissa of the IEEE754 float matches the 24 bit ADC very well. \nFurthermore, using floats gave a smaller footprint on the Arduino UNO R3.\n\nNote that the 24 bits of the HX711 contains some noise so depending on setup, \nload etc. only 16 to 20 of the bits are expected significant in practice. \nThis translates roughly to 4 or max 5 significant digits in a single measurement\nThat's why it is advised to average (median) multiple measurements to reduce the noise.\n\n\n### Breaking change 0.4.0\n\nThe **begin()** function has a new parameter **bool fastProcessor** which is default false.\nIt is used to slow down the internal **shiftIn()** to keep clock pulses within the \nspecification. For most processors the internal code is \"slow enough\".\nIf the processor can set an IO pin faster than 0.4 us (spec datasheet == 0.2 us), \nthe parameter **fastProcessor** must be set to true.\n\n\n### Breaking change 0.3.0\n\nIn issue #11 it became clear that the timing of the default **shiftIn()** function to \nread the value of the internal ADC was too fast on some processor boards for the HX711.\nThis resulted in missing the first (= sign) bit or the value read could be a factor two\nhigher than it should. If one calibrated the sensor this would be compensated with the \nfactor that is derived in the calibration process.\n\nIn 0.3.0 a dedicated **shiftIn()** function is added into this library that uses hard\ncoded delayMicroseconds to keep the timing of the clock within HX711 datasheet parameters. \nThis should guarantee that the sign bit is always read correctly on all platforms. \nDrawback is that reading the HX711 takes an extra 50-55 microseconds.\nHow much this affects performance is to be investigated.\n\n\n### HX711_MP\n\n- https://github.com/RobTillaart/HX711_MP\n\nThe library HX711_MP is derived from this HX711 library version 0.3.5.\n\nThe HX711_MP is not compatible, see readme.md of HX711_MP\n\nThe main difference is that the HX711_MP uses a multi-point calibration\nwhich replaces the \"offset + scale\" concept.\nFunctions related to this concept are removed in HX711_MP and replaced by\nits own set of calibration functions.\n\nThis multi-point calibration allows to compensate for non-linear behaviour \nin the sensor readings.\n\n\n### 10 or 80 SPS\n\nThe datasheet mentions that the HX711 can run at 80 samples per second (SPS). \nTo select this mode connect the **RATE** pin(15) of the chip to VCC (HIGH).\nConnecting **RATE** to GND (LOW) gives 10 SPS.\n\nHaving the RATE set to 10 or 80 SPS also changes the time to start up.\nAt 10 SPS it takes 400 milliseconds, at 80 SPS it takes 50 milliseconds.\n\nAll breakout boards I tested have **RATE** connected to GND and offer no\npin to control this from the outside.\nAdafruit however has a breakout board with **RATE** exposed.\nSee https://www.adafruit.com/product/5974\nThere might be more.\n\nIf you have the schema of your board you should be able to expose the **RATE**\npin, e.g. by removing the pull down resistor to GND.\n\nThis library provide experimental means to control the **RATE**, see below.\n\nIf you need more SPS you could consider using the HX71708 device.\nThis is a close \"relative\" of the HX711 that allows to set the SPS to \n10, 20, 80, or 320 Hz. \n- https://github.com/beniseman/HX71708 \n\n\n### Related\n\n- https://github.com/bogde/HX711\n- https://github.com/RobTillaart/weight  (conversions kg \u003c\u003e stone etc.)\n- https://github.com/RobTillaart/HX710AB\n- https://github.com/RobTillaart/HX711\n- https://github.com/RobTillaart/HX711_MP  multipoint calibration version.\n\nDiscussion about resolution of the ADC\n- https://forum.arduino.cc/t/scale-from-50-kg-to-5000kg-what-adc/1139710\n\nSupport for the HX71708 device (close related)\n- https://github.com/beniseman/HX71708 allows to set the SPS to 10, 20, 80, or 320 Hz\n\nLoad cells go to very high weights, this side sells them up to 200 ton.\nNever seen one and cannot tell if it will work with this library.\n- https://stekon.nl/load-cells\n\nBreakout with RATE exposed by ADAfruit\n- https://www.adafruit.com/product/5974\n\n\n### Faulty boards\n\n- https://forum.arduino.cc/t/load-cell-amplifier-hx711-wrong-ground/1046075\n\n\n## Main flow\n\nFirst action is to call **begin(dataPin, clockPin)** to make connection to the **HX711**.\n\nSecond step is to check **isReady()** to wait until the device is ready for measurements.\n\nNext step is calibration for which a number of functions exist.\n- **tare()** measures the offset of the zero point.\n- **set_scale(factor)** set a known conversion factor e.g. from EEPROM.\n- **calibrate_scale(weight, times)** determines the scale factor based upon a known weight e.g. 1 Kg.\nThe weight is typical in grams, however any unit can be used, depending on the \nload cell used.\n\nSteps to take for calibration\n1. clear the scale.\n1. wait until **isReady()** returns true.\n1. call **tare()** to determine and set the zero weight offset.\n1. put a known weight on the scale.\n1. call **calibrate_scale(float weight)**, weight typical in grams, however any unit can be used.\n1. scale factor is calculated.\n1. save the offset and scale for later use e.g. EEPROM.\n\nNote that the units used in **calibrate_scale()** will be returned by **get_units()**.\n\n\n## Interface\n\n```cpp\n#include \"HX711.h\"\n```\n\n### Constructor\n\n- **HX711()** constructor.\n- **~HX711()** destructor.\n- **void begin(uint8_t dataPin, uint8_t clockPin, bool fastProcessor = false, bool doReset = true)** sets a fixed gain 128 for now.\n  - The parameter fastProcessor adds a 1 uS delay for each clock half-cycle to keep the time greater than 200 nS.\n  - The parameter doReset is experimental in 0.6.3.\n  It defaults to true (== backwards compatible) causing a call to reset(), taking extra time \n  before the device is ready to make new measurements. See reset() below. \n  Note that not calling reset() leaves the ADC in the previous or even an undefined state, \n  so use with care. (needs testing)\n- **void reset()** set internal state to the start condition.\nReset() also does a power_down() / power_up() cycle. \nThis cycle adds a delay of 400 (RATE = 10 SPS) or 50 (RATE = 80 SPS) milliseconds.\n\n\n### isReady\n\nThere are different ways to wait for a new measurement.\n\n- **bool is_ready()** checks if load cell is ready to read.\n- **void wait_ready(uint32_t ms = 0)** wait until ready, check every ms.\n- **bool wait_ready_retry(uint8_t retries = 3, uint32_t ms = 0)** wait max retries.\n- **bool wait_ready_timeout(uint32_t timeout = 1000, uint32_t ms = 0)** wait max timeout milliseconds.\n\n\n### Read\n\nWarning: the read calls are blocking calls, which can take up to 400 ms in the first read() call.\nBest practice is to check with isReady() before calling read().\n\n- **float read()** get a raw read.\n- **float read_average(uint8_t times = 10)** get average of times raw reads. times = 1 or more.\n- **float read_median(uint8_t times = 7)** get median of multiple raw reads. \ntimes = 3..15 - odd numbers preferred.\n- **float read_medavg(uint8_t times = 7)** get average of \"middle half\" of multiple raw reads.\ntimes = 3..15 - odd numbers preferred.\n- **float read_runavg(uint8_t times = 7, float alpha = 0.5)** get running average over times measurements.\nThe weight alpha can be set to any value between 0 and 1, times \u003e= 1.\n- **uint32_t last_read()** returns timestamp in milliseconds of last read.\n\n\n### Gain + channel\n\nUse with care as it is not 100% reliable - see issue #27. (solutions welcome).\n\nRead datasheet before use.\n\nConstants (see .h file)\n\n- **HX711_CHANNEL_A_GAIN_128 = 128**  This is the default in the constructor.\n- **HX711_CHANNEL_A_GAIN_64 = 64**\n- **HX711_CHANNEL_B_GAIN_32 = 32**  Note fixed gain for channel B.\n\nThe selection of channels + gain is in theory straightforward. \n\n- **bool set_gain(uint8_t gain = 128, bool forced = false)** values: 128 (default), 64 or 32.\nIf one uses an invalid value for the parameter gain, the channel and gain are not changed.\nIf forced == false it will not set the new gain if the library \"thinks\" it\nalready has the right value.\nIf forced == true, it will explicitly try to set the gain/channel again.\nThis includes a dummy **read()** so the next \"user\" **read()** will give the right info.\n- **uint8_t get_gain()** returns set gain (128, 64 or 32).\n\nBy setting the gain to one of the three constants the gain and the channel is selected.\nThe **set_gain()** does a dummy read if gain has changed (or forced == true) so the \nnext call to **read()** will return info from the selected channel/gain.\n\nAccording to the datasheet the gain/channel change may take up to 400ms (table page 3).\n\nWarning 1: if you use **set_gain()** in your program the HX711 can be in different states.\nIf there is an expected or unexpected reboot of the MCU, this could lead \nto an unknown state at the reboot of the code. \nSo in such case it is strongly advised to call **set_gain()** explicitly in **setup()** \nso the device is in a known state.\n\nWarning 2: In practice it seems harder to get the channel and gain selection as reliable\nas the datasheet states it should be. So use with care. (feedback welcome)\nSee discussion #27 HX711. \n\n\n### Read mode\n\nGet and set the operational mode for **get_value()** and indirect **get_units()**.\n\nConstants (see .h file)\n\n- **HX711_RAW_MODE**\n- **HX711_AVERAGE_MODE**\n- **HX711_MEDIAN_MODE**\n- **HX711_MEDAVG_MODE**\n- **HX711_RUNAVG_MODE**\n\n\nIn **HX711_MEDIAN_MODE** and **HX711_MEDAVG_MODE** mode only 3..15 samples are allowed\nto keep memory footprint relative low.\n\n- **void set_raw_mode()** will cause **read()** to be called only once!\n- **void set_average_mode()** take the average of n measurements.\n- **void set_median_mode()** take the median of n measurements.\n- **void set_medavg_mode()** take the average of n/2 median measurements.\n- **void set_runavg_mode()** default alpha = 0.5.\n- **uint8_t get_mode()** returns current set mode. Default is **HX711_AVERAGE_MODE**.\n\n\n### Get values\n\nGet values from the HX711 corrected for offset and scale.\nNote that in **HX711_RAW_MODE** the times parameter will be ignored =\u003e just call **read()** once.\n\n- **float get_value(uint8_t times = 1)** read value, corrected for offset.\n- **float get_units(uint8_t times = 1)** read value, converted to proper units.\n- **bool set_scale(float scale = 1.0)** set scale factor which is normally a positive \nnumber larger than 50. Depends on load-cell used.\nReturns false if scale == 0.\nNote that for some specific applications, scale might be negative. \n- **float get_scale()** returns set scale factor.\n- **void set_offset(int32_t offset = 0)** idem.\n- **int32_t get_offset()** idem.\n\n\n### Tare \u0026 calibration I\n\nSteps to take for calibration\n1. clear the scale.\n1. call **tare()** to determine and set the zero weight offset.\n1. put a known weight on the scale.\n1. call **calibrate_scale(float weight)**, weight typical in grams, however any unit can be used.\n1. scale factor is calculated.\n1. save the offset and scale for later use e.g. EEPROM.\n\nNote that the units used in **calibrate_scale()** will be returned by **get_units()**.\n\n- **void tare(uint8_t times = 10)** call tare to determine the offset\nto calibrate the zero (reference) level. See below.\n- **float get_tare()** returns the offset \\* scale.\nNote this differs after calls to **calibrate_scale()**.\nUse **get_offset()** to get only the offset.\n- **bool tare_set()** checks if a tare has been set.\nAssumes offset is not zero, which is true for all load cells tested.\n- **void calibrate_scale(float weight, uint8_t times = 10)** \nThe calibration weight averages times measurements to improve accuracy.\nWeight is typical in grams, however any unit can be used.\nBe aware this unit will also be returned by **get_units()**.\n\nSince 0.6.0 the weight is defined as float which allows easier calibration in\nother units e.g. define the weight as 2.5 kg instead of 2500 gram.\nThe function **GetUnits()** will then return its value in kg too.\n\nAlso by using a float the range of calibration weights is substantially increased.\nOne can now define 250 gram as 250000 milligram, where before the value was max \n65535 units (theoretical increase of precision from 4.8 to 6.9 digits).\nThis allows the calibration of superheavy load cells, e.g 500 kg and use a \ndefined weight of 100000 gram. \nFinally the use of floats allow the use of decimals e.g. a calibration weight \nof 125.014 kg or 306.4 gram.\n\nNote: calibrate_scale() uses averaging and does not use the mode set.\n\nNote: calibrate_scale() can have a negative value as weight e.g. force of a balloon.\n\n\n### Tare \u0026 calibration II\n\nA load cell + HX711 module without weight gives a raw value, mostly not equal to zero.\nThe function **get_tare()** is used to measure this raw value and allows the user\nto define this value as a zero weight (force) point.\nThis zero point is normally without any load, however it is possible to define \na zero point with a \"fixed\" load e.g. a cup, a dish, even a spring or whatever.\nThis allows the system to automatically subtract the weight / force of the cup etc.\n\n**Warning**: The user must be aware that the \"fixed\" load together with the \n\"variable\" load does not exceed the specifications of the load cell.\n\nE.g. a load cell which can handle 1000 grams with a cup of 300 grams should not \nbe calibrated with a weight of more than 700 grams.\nIn fact it is better to calibrate with a weight in the order of 80 to 90% of \nthe maximum load so in this example a weight of 500 to 600 grams.\nThat would make the total 800-900 grams == 80/90% of the max load.\n\nAnother point to consider when calibrating is to use a weight that is \nin the range you want to make your measurements.\nE.g. if you want to measure coffee beans in portions of 250 grams, use \na weight in the range 200-300 grams. Could just save an extra bit.\n\nFurthermore it is also important to do the calibration at the temperature you \nexpect to do the weight measurements. See temperature section below.\n\n\n### Inner formula\n\nWeight = **get_scale()** x raw + **get_tare()**.\n\nWith the two parameters one can interpolate the inner formula.\nThis can be used e.g to make an ideal graph of the conversion.\nThis can be compared with actual values to get an indication\nof the accuracy of the load cell.\n\n\n### Power management\n\n- **void power_down()** idem. Explicitly blocks for 64 microseconds. \n(See Page 5 datasheet). \n- **void power_up()** wakes up the HX711. \nIt should reset the HX711 to defaults but this is not always seen. \nSee discussion issue #27 GitHub. Needs more testing.\n\nNote: Having the RATE set to 10 or 80 SPS changes the time to start up.\nAt 10 SPS it takes 400 milliseconds, at 80 SPS it takes 50 milliseconds.\n(See datasheet, Output settling time on page 3)\n\n\n### Rate\n\n**Experimental**\n\nSee section \"10 or 80 SPS\" above.\n\nNote this only works if the **RATE** pin is exposed and connected to\nthe IO pin configured in set_rate_pin().\nIf not configured the other functions won't work.\n\n- **void set_rate_pin(uint8_t pin)** sets the IO pin for SPS selection.\n- **void set_rate_10SPS()** sets rate to 10 SPS.\n- **void set_rate_80SPS()** sets rate to 80 SPS.\n- **uint8_t get_rate()** returns 10 d(default) or 80.\n\n\n### Pricing\n\nSome price functions were added to make it easy to use this library\nfor pricing goods or for educational purposes. \nThese functions are under discussion if they will stay in the library.\nFor weight conversion functions see https://github.com/RobTillaart/weight\n\n- **float get_price(uint8_t times = 1)** idem.\n- **void  set_unit_price(float price = 1.0)** idem.\n- **float get_unit_price()** idem.\n\n\n### Millivolts\n\n**Experimental**\n\nTo be verified in a test setup.\n\nIn issue #53, a question was asked to convert the input of the HX711 to millivolts.\nThinking about this question resulted in a simple and elegant idea:\n\n- Apply 0.000 mV to the system.\n- Call **tare(times)** to calibrate the zero point. \n- Then apply 20.000 mV to the system.\n- Call **calibrate_scale(20000)** to map the raw reading to 20000 µV = 20 mV.\n\nAssuming the scale is linear, the HX711 now works like a millivolt meter.\nAnd the **float get_units(uint8_t times = 1)** will return microvolts.\n\nIn fact, one could map any linear unit this way, e.g. if the voltage applied \nis linear with temperature, humidity or wind speed one can map this directly.\n\n\n## Notes\n\n\n### Scale values for load cells\n\nThese scale values worked pretty well with a set of load cells I have, \nUse calibrate to find your favourite values.\n\n- 5 KG load cell   scale.set_scale(420.52);\n- 20 KG load cell  scale.set_scale(127.15);\n\n\n### Connections HX711\n\n- A+/A-  uses gain of 128 or 64\n- B+/B-  uses gain of 32\n\nColour scheme wires of two devices.\n\n|  HX711 Pin  |  Colour dev 1   |  Colour dev 2   |\n|:-----------:|:---------------:|:---------------:|\n|      E+     |  red            |  red            |\n|      E-     |  black          |  black          |\n|      A-     |  white          |  blue           |\n|      A+     |  green          |  white          |\n|      B-     |  not connected  |  not connected  |\n|      B+     |  not connected  |  not connected  |\n\n\n### Temperature\n\nLoad cells do have a temperature related error. (see datasheet load cell)\nThis can be reduced by doing the calibration and take the tare\nat the operational temperature one uses for the measurements.\n\nAnother way to handle this is to add a good temperature sensor\n(e.g. DS18B20, SHT85) and compensate for the temperature\ndifferences in your code.\n\n\n## Multiple HX711\n\n\n### Separate lines\n\nSimplest way to control multiple HX711's is to have a separate **DOUT** and **CLK** \nline for every HX711 connected.\n\n\n### Multiplexer\n\nAlternative one could use a multiplexer like the https://github.com/RobTillaart/HC4052\nor possibly an https://github.com/RobTillaart/TCA9548.\nAlthough to control the multiplexer one need some extra lines and code.\n\n\n### Share CLOCK line\n\nSee **HX_loadcell_array.ino**\n\nAnother way to control multiple HX711's is to share the **CLK** line. \nThis has a few side effects which might be acceptable or not.\n\nKnown side effects - page 4 and 5 datasheet.\n\n- The **CLK** is used to select channel and to select gain for the NEXT sample.\n- The **CLK** is used for power down.\n- After wake up after power down all HX711's will reset to channel A and gain 128.\n**WARNING:** if one of the objects does a **powerDown()** or **reset()** it resets its internal states.\nThe other objects however won't reset their internal state, so a mismatch can occur.\n\nSo in short, sharing the **CLK** line causes all HX711 modules share the same state.\nThis can introduce extra complexity if one uses mixed gains or channels.\nIf all HX711's use the same settings it should work, however extra care is needed for\n**powerDown()** and **reset()**.\n\n**WARNING: Sharing the data lines is NOT possible as it could cause short circuit.**\n\nSee https://github.com/RobTillaart/HX711/issues/40\n\n\n## Future\n\n\n#### Must\n\n- update documentation\n- keep in sync with HX711_MP, HX710AB library.\n\n#### Should\n\n- test\n  - different load cells.\n  - B channel explicitly.\n  - test reset and reboot behaviours.\n  - test and verify the proper working of the rate functions.\n- investigate read()\n  - investigate the need of yield after interrupts\n  - investigate blocking loop at begin =\u003e less yield() calls ?\n- add performance figures\n\n#### Could\n\n- add error handling?\n- optimize fastProcessor code (possible better performance)\n  - injecting 2 micro delays is not always needed.\n  - int flag instead of bool.\n- make enum of the MODE's\n- add examples\n  - example the adding scale\n  - void weight_clr(), void weight_add(), float weight_get() - adding scale\n  - example for using rate functions.\n- investigate temperature compensation.\n- decide pricing keep/not =\u003e move to .cpp\n\n#### Wont\n\n- why store the gain as \\_gain while the iterations m = 1..3 is used most\n  - read() less code\n  - **changes from explanatory code to vague**\n  - very small performance gain.\n  - code moves to both get/set_gain() so footprint might rise.\n\n\n## Support\n\nIf you appreciate my libraries, you can support the development and maintenance.\nImprove the quality of the libraries by providing issues and Pull Requests, or\ndonate through PayPal or GitHub sponsors.\n\nThank you,\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frobtillaart%2Fhx711","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frobtillaart%2Fhx711","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frobtillaart%2Fhx711/lists"}