sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
94e34d0020
nuttx/drivers/analog/hx711.c
Michał Łyszczek 768e533123 drivers/analog/hx711.c: fix tare calculation 
Taring was done with user defined sign, which later resulted in tare
being "resigned" twice. Because of that taring was workign correctly
for one sign, and not the other.

Fix it to disable user sign when tarring, and tare always without
changing sign.

Signed-off-by: Michał Łyszczek <michal.lyszczek@bofc.pl>
2024-03-03 01:56:40 +08:00

971 lines
25 KiB
C
Raw Blame History

/****************************************************************************
* drivers/analog/hx711.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <nuttx/kmalloc.h>
#include <nuttx/irq.h>
#include <sys/param.h>
#include <ctype.h>
#include <stdio.h>
#include <nuttx/analog/hx711.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define DEVNAME_FMT "/dev/hx711_%d"
#define DEVNAME_FMTLEN (11 + 3 + 1)
/* hx711 is a 24 bit ADC, but in case they decide to do like a
* hx771s(uperb) with 32 bit resolution, here is easy to change def
*/
#define HX711_BITS_PER_READ 24
#define HX711_TARE_MAX_LOOP 64
#define HX711_TARE_NSAMPLES 5
/****************************************************************************
* Private Types
****************************************************************************/
struct hx711_dev_s
{
FAR struct hx711_lower_s *lower;
mutex_t excl;
sem_t hx711_ready;
int crefs;
int unlinked;
unsigned char minor;
int val_per_unit;
long tare;
unsigned char average;
unsigned char gain;
char channel;
signed char sign;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int hx711_open(FAR struct file *filep);
static int hx711_close(FAR struct file *filep);
static int hx711_unlink(FAR struct inode *inode);
static int hx711_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
static ssize_t hx711_read(FAR struct file *filep,
FAR char *buf, size_t buflen);
static int32_t hx711_single_read(FAR struct hx711_dev_s *dev);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct file_operations g_hx711_fops =
{
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
.unlink = hx711_unlink,
#endif /* CONFIG_DISABLE_PSEUDOFS_OPERATIONS */
.open = hx711_open,
.close = hx711_close,
.read = hx711_read,
.ioctl = hx711_ioctl
};
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: hx711_tare
*
* Description:
* Tares the scale. Function will read some number of samples and will
* check if these readings are stable (more or less the same within
* specified precision). If operation is a success, next call to read()
* will return value close to 0 (if no force is applied to tensometer).
*
* Input Parameters:
* dev - hx711 instance to tare
* precision - precision with which to tare the scale. If set to 100
* function will set new tare if min-max values read are
* less than 100
*
* Returned Value:
* OK - on success
* -EIO - no communication with the hx711
* -ETIME - scale was not stable for HX711_TARE_NSAMPLES loops
*
****************************************************************************/
static int hx711_tare(FAR struct hx711_dev_s *dev, float precision)
{
int32_t samples[HX711_TARE_NSAMPLES];
int i;
int j;
int min;
int max;
long tare;
int prec;
long taresave;
signed char signsave;
/* If value per unit is defined, we assume precision is specified
* in units, calculate raw value for precision
*/
prec = dev->val_per_unit > 0 ? precision * dev->val_per_unit : precision;
/* Save old tare value and sign, which we will restore when we
* have an error
*/
taresave = dev->tare;
signsave = dev->sign;
/* Reset tare value and sign during taring */
dev->tare = 0;
dev->sign = 1;
for (i = 0; i != HX711_TARE_NSAMPLES; i++)
{
samples[i] = hx711_single_read(dev);
if (samples[i] == INT32_MIN)
{
dev->tare = taresave;
dev->sign = signsave;
return -EIO;
}
}
for (i = 0; i != HX711_TARE_MAX_LOOP; i++)
{
/* Check if scale reading is stable */
min = INT_MAX;
max = INT_MIN;
for (j = 0; j != HX711_TARE_NSAMPLES; j++)
{
min = samples[j] < min ? samples[j] : min;
max = samples[j] > max ? samples[j] : max;
}
if (max - min <= prec)
{
/* Scale readings are stable within specified precision.
* Use average of these readings to set new tare value.
*/
for (tare = j = 0; j != HX711_TARE_NSAMPLES; j++)
{
tare += samples[j];
}
tare /= HX711_TARE_NSAMPLES;
dev->tare = tare;
dev->sign = signsave;
return OK;
}
/* Reading is not yet stable, perform next read and check
* stability again
*/
samples[i % HX711_TARE_NSAMPLES] = hx711_single_read(dev);
if (samples[i % HX711_TARE_NSAMPLES] == INT32_MIN)
{
dev->tare = taresave;
dev->sign = signsave;
return -EIO;
}
}
/* If we get here, we couldn't get stable readings within specified
* limit
*/
dev->tare = taresave;
dev->sign = signsave;
return -ETIME;
}
/****************************************************************************
* Name: hx711_ioctl
*
* Description:
* Perform device specific operations.
*
* Input Parameters:
* filep - file on vfs associated with the driver.
* cmd - command to perform
* arg - argument for the cmd
*
* Returned Value:
* Returns OK on success or negated errno on failure.
*
****************************************************************************/
static int hx711_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct hx711_dev_s *dev;
int ret;
dev = filep->f_inode->i_private;
/* Get exclusive access to the hx711 driver state */
ret = nxmutex_lock(&dev->excl);
if (ret < 0)
{
return ret;
}
ret = OK;
switch (cmd)
{
case HX711_SET_AVERAGE:
if (arg < 1 || arg > HX711_MAX_AVG_SAMPLES)
{
/* Averaging more than HX711_MAX_AVG_SAMPLES samples could
* overflow averaging variable leading to invalid reading.
*/
ret = -EINVAL;
break;
}
dev->average = arg;
break;
case HX711_SET_CHANNEL:
if (arg != 'a' || arg != 'b')
{
/* Only channel a or b are available */
ret = -EINVAL;
break;
}
dev->channel = arg;
if (dev->channel == 'b')
{
/* Only valid gain for channel b is 32, adjust */
dev->gain = 32;
}
if (dev->channel == 'a')
{
/* If we are switching from channel 'b', gain will be 32,
* which is invalid value for channel 'a'. If current gain
* is not valid for channel 'a', set default value of 128
*/
if (dev->gain != 128 && dev->gain != 64)
{
dev->gain = 128;
}
}
/* Channel setting will be applied after next read from hx711,
* we have to do one dummy read, so that user can immediately
* read from new channel
*/
if (hx711_single_read(dev) == INT32_MIN)
{
ret = -EIO;
}
break;
case HX711_SET_GAIN:
if (dev->channel == 'a' && (arg != 128 || arg != 64))
{
/* For channel 'a' only gain of value 128 and 64 are valid */
ret = -EINVAL;
break;
}
else if (dev->channel == 'b' && arg != 32)
{
/* For channel 'b' only gain of 32 is valid */
ret = -EINVAL;
break;
}
dev->gain = arg;
break;
case HX711_SET_VAL_PER_UNIT:
dev->val_per_unit = arg;
break;
case HX711_GET_AVERAGE:
{
unsigned *ptr = (unsigned *)((uintptr_t)arg);
if (ptr == NULL)
{
ret = -EINVAL;
break;
}
*ptr = dev->average;
break;
}
case HX711_GET_CHANNEL:
{
char *ptr = (char *)((uintptr_t)arg);
if (ptr == NULL)
{
ret = -EINVAL;
break;
}
*ptr = dev->channel;
break;
}
case HX711_GET_GAIN:
{
unsigned char *ptr = (unsigned char *)((uintptr_t)arg);
if (ptr == NULL)
{
ret = -EINVAL;
break;
}
*ptr = dev->gain;
break;
}
case HX711_GET_VAL_PER_UNIT:
{
unsigned *ptr = (unsigned *)((uintptr_t)arg);
if (ptr == NULL)
{
ret = -EINVAL;
break;
}
*ptr = dev->val_per_unit;
break;
}
case HX711_TARE:
{
float *precision = (float *)((uintptr_t)arg);
if (precision == NULL)
{
ret = -EINVAL;
break;
}
ret = hx711_tare(dev, *precision);
break;
}
case HX711_SET_SIGN:
{
int *sign = (int *)((uintptr_t)arg);
if (sign == NULL || (*sign != 1 && *sign != -1))
{
ret = EINVAL;
break;
}
dev->sign = *sign;
break;
}
default:
ret = EINVAL;
}
nxmutex_unlock(&dev->excl);
return ret;
}
/****************************************************************************
* Name: hx711_data_interrupt
*
* Description:
* Function is called when we are waiting for hx711 to be ready and once
* data line goes from HIGH to LOW state.
*
* Input Parameters:
* arg - hx711 device instance
*
****************************************************************************/
static int hx711_data_interrupt(int irq, FAR void *context, FAR void *arg)
{
UNUSED(irq);
UNUSED(context);
FAR struct hx711_dev_s *dev = arg;
nxsem_post(&dev->hx711_ready);
return 0;
}
/****************************************************************************
* Name: hx711_wait_ready
*
* Description:
* Waits for conversion to be ready to read.
*
* Input Parameters:
* dev - hx711 device instance
*
* Returned Value:
* Function returns OK when chip is ready for reading, or -EIO, which
* means there is problem communicating with the device.
*
****************************************************************************/
static int hx711_wait_ready(FAR struct hx711_dev_s *dev)
{
int ret;
struct timespec tp;
/* It is possible that there was no read() call for long enough
* that hx711 is already ready, if that is the case just quickly return
*/
if (dev->lower->data_read(dev->minor) == 0)
{
return OK;
}
/* Install data line interrupt, so we know when hx711 is ready.
* This can even be 100ms between sampling, and up to 500ms when
* hx711 goes out of low power mode
*/
if ((ret = dev->lower->data_irq(dev->minor, hx711_data_interrupt, dev)))
{
return ret;
}
/* During waiting for ready signal, clock should be low */
dev->lower->clock_set(dev->minor, 0);
clock_gettime(CLOCK_MONOTONIC, &tp);
tp.tv_sec += 1;
if ((ret = nxsem_timedwait(&dev->hx711_ready, &tp)))
{
/* Chip not ready for long time. This probably mean that the
* hx711 chip is not properly (if at all) connected.
*/
dev->lower->data_irq(dev->minor, NULL, NULL);
return -EIO;
}
/* hx711 is ready */
dev->lower->data_irq(dev->minor, NULL, NULL);
return OK;
}
/****************************************************************************
* Name: hx711_delay
*
* Description:
* hx711 datasheet specifies that time between clock changes should be
* between 0.2us and 50us, with typical value of 1us. On slow MCUs this
* is not a problem, as all operations between clocking take longer than
* that time, but on fast CHIP, clocking without delay will cause data
* lose.
*
****************************************************************************/
static void hx711_delay(void)
{
#ifdef CONFIG_ADC_HX711_ADD_DELAY
up_delay(1);
#endif
}
/****************************************************************************
* Name: hx711_single_read
*
* Description:
* Reads single, 24bit adc data from hx711. Function will perform
* conversion form 24bit 2's complement to 32bit 2's complement.
*
* Input Parameters:
* dev - hx711 instance to perform read from.
*
* Returned Value:
* Read value from hx711. Returned value is stored on 24 bits of
* int32_t type. If there was error during read, function will
* return INT32_MIN.
*
****************************************************************************/
static int32_t hx711_single_read(FAR struct hx711_dev_s *dev)
{
int32_t value;
int i;
int pulses;
int flags;
int ret;
/* Wait for conversion to be finished */
if ((ret = hx711_wait_ready(dev)))
{
/* Timeout while waiting for chip, assuming chip is not connected */
nxmutex_unlock(&dev->excl);
return INT32_MIN;
}
/* Even though we are clocking the hx711, we must perform whole readout
* without interruption. This is because, if we set clock pin to HIGH,
* hx711 will go into low power mode in 60us unless we set clock to LOW
* within that time.
*/
flags = enter_critical_section();
for (value = i = 0; i != HX711_BITS_PER_READ; i++)
{
dev->lower->clock_set(dev->minor, 1);
hx711_delay();
/* Data is sent MSB first */
value |= dev->lower->data_read(dev->minor);
value <<= 1;
dev->lower->clock_set(dev->minor, 0);
hx711_delay();
}
/* Next few clock pulses will determine type of next conversion
* hx711 will perform. We gotta do this in the same critical
* section block as read.
*
* 1 pulse - Channel A, Gain 128
* 2 pulses - Channel B, Gain 32
* 3 pulses - Channel A, Gain 64
*/
if (dev->channel == 'b')
{
/* Channel B has static gain of 32 */
pulses = 2;
}
else
{
/* channel A has 2 possible gains, either 128 or 64. */
pulses = dev->gain == 128 ? 1 : 3;
}
for (i = 0; i != pulses; i++)
{
dev->lower->clock_set(dev->minor, 1);
hx711_delay();
dev->lower->clock_set(dev->minor, 0);
hx711_delay();
}
leave_critical_section(flags);
/* Data is sent in standard 2's complement, but we just stored
* 24bit integer in a 32bit integer. For positives reading this
* makes no difference, but if we have just returned 24bit negative
* number in 32bit integer, we would end up with positive (and false)
* reading.
*
* If number is negative, convert it to 32bit negative.
*/
if (value & 0x800000)
{
value |= 0xff000000;
}
/* Apply tare value and sign at the end */
return dev->sign * (value - dev->tare);
}
/****************************************************************************
* Name: hx711_read
*
* Description:
* Performs read from the hx711 device. Only a single value can be read
* with single call, but when averaging is enabled, driver will read
* configured number of points and will return single, average value
* of them all.
*
* Input Parameters:
* filep - file on vfs associated with the driver.
* buf - pointer to 32bit integer where value will be stored.
* buflen - size of buf, must be equal to 4 (sizeof(int32_t))
*
* Returned Value:
* On success 4 is returned (sizeof(int32_t)), as in number of bytes
* copied to userspace. On failure, negated errno is returned.
*
****************************************************************************/
static ssize_t hx711_read(FAR struct file *filep,
FAR char *buf, size_t buflen)
{
FAR struct hx711_dev_s *dev;
int ret;
int32_t value; /* 24bit value from hx711 will be stored here */
int32_t average;
int i;
value = 0;
dev = filep->f_inode->i_private;
if (buflen == 0)
{
return 0;
}
if (buflen < sizeof(int32_t))
{
return -EINVAL;
}
/* Get exclusive access to the hx711 driver state */
ret = nxmutex_lock(&dev->excl);
if (ret < 0)
{
return ret;
}
for (i = 1; i <= (int)dev->average; i++)
{
value = hx711_single_read(dev);
if (value == INT32_MIN)
{
/* There was error while reading sample. */
nxmutex_unlock(&dev->excl);
return -EIO;
}
average = (average * (i - 1) + value) / i;
}
/* We are done with the device, so free mutex for next possible client */
nxmutex_unlock(&dev->excl);
/* If user specified value per unit, we convert raw data into units */
if (dev->val_per_unit > 0)
{
average /= dev->val_per_unit;
}
/* Copy data back to userspace and exit */
if (buflen == sizeof(int32_t))
{
/* int32 was passed, assuming binary operation from C code */
memcpy(buf, &average, sizeof(average));
return sizeof(int32_t);
}
else
{
/* Something else passed, assuming it's shell operation. If it's
* called from C, it's assumed user wants c-string.
*/
ret = snprintf(buf, buflen, "%"PRIi32"\n", average);
/* snprintf returns number of bytes written (or that would have
* been written) without null byte, but we return number of bytes
* written including that byte, hence +1.
*/
ret += 1;
/* If buflen is not big enough, snprintf() will return number
* of bytes that would have been written to buf if enough space
* had been available and not number of bytes actually written.
* We must return number of bytes actually written, so we take
* smaller value.
*/
return MIN(ret, (int)buflen);
}
}
/****************************************************************************
* Name: hx711_cleanup
*
* Description:
* Called when last user closed hx711 dsevice and that device is (or was)
* unlinked.
*
* Input Parameters:
* dev - hx711 device instance.
*
****************************************************************************/
static void hx711_cleanup(FAR struct hx711_dev_s *dev)
{
/* Put chip into sleep state by setting clock to HIGH */
dev->lower->clock_set(dev->minor, 1);
if (dev->lower->cleanup)
{
dev->lower->cleanup(dev->minor);
}
nxmutex_destroy(&dev->excl);
nxsem_destroy(&dev->hx711_ready);
kmm_free(dev);
}
/****************************************************************************
* Name: hx711_open
*
* Description:
* Open driver for use by userspace application.
*
* Input Parameters:
* filep - pointer to a file structure to open
*
* Returned Value:
* OK on success, or negated errno on failure
*
****************************************************************************/
static int hx711_open(FAR struct file *filep)
{
FAR struct hx711_dev_s *dev;
int ret;
dev = filep->f_inode->i_private;
/* Get exclusive access to the hx711 driver state */
ret = nxmutex_lock(&dev->excl);
if (ret < 0)
{
return ret;
}
/* Increment the count of open references on the driver */
dev->crefs++;
DEBUGASSERT(dev->crefs > 0);
nxmutex_unlock(&dev->excl);
return OK;
}
/****************************************************************************
* Name: hx711_close
*
* Description:
* Closes the driver device. If this is last reference and file has been
* unlinked, we will also free resources allocated by ipcc_register()
*
* Input Parameters:
* filep - pointer to a file structure to close.
*
* Returned Value:
* OK on success, or negated errno on failure.
*
****************************************************************************/
static int hx711_close(FAR struct file *filep)
{
FAR struct hx711_dev_s *dev;
int ret;
dev = filep->f_inode->i_private;
/* Get exclusive access to the hx711 driver state */
ret = nxmutex_lock(&dev->excl);
if (ret < 0)
{
return ret;
}
/* Decrement the count of open references on the driver */
DEBUGASSERT(dev->crefs > 0);
dev->crefs--;
if (dev->crefs <= 0 && dev->unlinked)
{
/* If count ref is zero and file has been unlinked, it
* means nobody uses the driver and seems like nobody
* wants to use it anymore, so free up resources. This
* also means we are last holders of excl mutex, which
* will be destroyed in cleanup function, so we don't
* have to unlock it here.
*/
hx711_cleanup(dev);
return OK;
}
nxmutex_unlock(&dev->excl);
return OK;
}
/****************************************************************************
* Name: hx711_unlink
*
* Description:
* Action to take upon file unlinking. Function will free resources if
* noone is using the driver when unlinking occured. If driver is still
* in use, it will be marked as unlinked and resource freeing will take
* place in hx711_close() function instead, once last reference is closed.
*
* Input Parameters:
* inode - driver inode that is being unlinked.
*
* Returned Value:
* OK on successfull close, or negated errno on failure.
*
****************************************************************************/
static int hx711_unlink(FAR struct inode *inode)
{
FAR struct hx711_dev_s *dev;
int ret;
dev = inode->i_private;
/* Get exclusive access to the hx711 driver state */
ret = nxmutex_lock(&dev->excl);
if (ret < 0)
{
return ret;
}
/* Is anyone still using the driver? */
if (dev->crefs <= 0)
{
/* No, we are free to free resources */
hx711_cleanup(dev);
return OK;
}
/* Yes, someone is still using the driver, just mark file
* as unlinked and free resources in hx711_close() once last
* reference is closed.
*/
dev->unlinked = true;
nxmutex_unlock(&dev->excl);
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: hx711_register
*
* Description:
* Register new hx711 device in /dev/hx711_%d. Multiple hx711 can be
* supported by providing different minor number. When driver calls
* platform specific function, minor number is passed back, so platform
* can know which hx711 is manipulated.
*
* Input Parameters:
* minor - unique number identifying hx711 chip.
* lower - provided by platform code to manipulate hx711 with platform
* dependant functions>
*
* Returned Value:
* OK on success, or negated errno on failure
*
****************************************************************************/
int hx711_register(unsigned char minor, FAR struct hx711_lower_s *lower)
{
FAR struct hx711_dev_s *dev;
char devname[DEVNAME_FMTLEN];
int ret;
dev = kmm_zalloc(sizeof(*dev));
if (dev == NULL)
{
return -ENOMEM;
}
snprintf(devname, DEVNAME_FMTLEN, DEVNAME_FMT, minor);
ret = register_driver(devname, &g_hx711_fops, 0666, dev);
if (ret)
{
kmm_free(dev);
return ret;
}
dev->channel = 'a';
dev->gain = 128;
dev->lower = lower;
dev->average = 1;
dev->sign = 1;
nxmutex_init(&dev->excl);
nxsem_init(&dev->hx711_ready, 0, 0);
/* Put chip into working state by setting clock to LOW */
dev->lower->clock_set(dev->minor, 0);
return OK;
}
Reference in New Issue View Git Blame Copy Permalink