* apps/examples/hx711/hx711_main.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/analog/hx711.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <sys/ioctl.h>
* Private Types
****************************************************************************/
struct hx711_config
{
char dev[32];
char dump;
char channel;
unsigned char gain;
unsigned average;
unsigned loops;
float precision;
int val_per_unit;
int sign;
} g_hx711_config;
* Private Functions
****************************************************************************/
* Name: hx711_print_help
*
* Description:
* Prints help onto stdout.
*
****************************************************************************/
static void hx711_print_help(const char *progname)
{
printf("usage: %s [-d <device>] [options]\n"
"\n"
"\t-h print this help message\n"
"\t-d<path> path to hx711 device, default: /dev/hx711_0\n"
"\t-t<prec> tares the scale with specified precision, might"
"take few seconds to complete.\n"
"\t If you set value per unit, precision is in units, "
"otherwise it's raw values.\n"
"\t If units are used, float can be passed like 0.1\n"
"\t-v<val> value read that coresponds to one unit. This value "
"has to be\n"
"\t calibrated first before it's known\n"
"\t-s reverse sign, if values decreses when mass increases, "
"pass this\n"
"\t-D dumps current device settings (like, average, channel, "
"gain etc.)\n"
"\t-a<avg> set how many samples should be averaged before "
"returning value,\n"
"\t values [1..%d] are valid\n"
"\t-c<chan> set channel to read (either 'a' or 'b' is valid)\n"
"\t-g<gain> set adc gain, for channel 'a' 64 and 128 are valid,\n"
"\t for channel 'b', only 64 is valid\n"
"\t-r<num> read this number of samples before exiting, samples "
"will be printed\n"
"\t on stdout as string, one sample per line\n"
"\n"
"Check documentation for full description\n",
progname, HX711_MAX_AVG_SAMPLES);
}
* Name: hx711_parse_args
*
* Description:
* Parses command line arguments
*
****************************************************************************/
static int hx711_parse_args(int argc, FAR char *argv[])
{
int opt;
memset(&g_hx711_config, 0x00, sizeof(g_hx711_config));
while ((opt = getopt(argc, argv, "hd:Dt:a:c:g:r:v:s")) != -1)
{
switch (opt)
{
case 'h':
hx711_print_help(argv[0]);
return 1;
case 'd':
strcpy(g_hx711_config.dev, optarg);
break;
case 't':
g_hx711_config.precision = atof(optarg);
break;
case 'D':
g_hx711_config.dump = 1;
break;
case 'a':
g_hx711_config.average = atoi(optarg);
break;
case 'c':
g_hx711_config.channel = optarg[0];
break;
case 'g':
g_hx711_config.gain = atoi(optarg);
break;
case 'r':
g_hx711_config.loops = atoi(optarg);
break;
case 's':
g_hx711_config.sign = -1;
break;
case 'v':
g_hx711_config.val_per_unit = atoi(optarg);
break;
default:
fprintf(stderr, "Invalid option, run with -h for help\n");
return 1;
}
}
if (g_hx711_config.dev[0] == '\0')
{
strcpy(g_hx711_config.dev, "/dev/hx711_0");
}
return 0;
}
* Name: hx711_set_options
*
* Description:
* Set hx711 options if they were specified on command line
*
* Input Parameters:
* fd - opened hx711 instance
*
****************************************************************************/
int hx711_set_options(int fd)
{
int ret;
if (g_hx711_config.channel > 0)
{
if ((ret = ioctl(fd, HX711_SET_CHANNEL, g_hx711_config.channel)))
{
fprintf(stderr, "Failed to set channel to %c, error: %s\n",
g_hx711_config.channel, strerror(errno));
return -1;
}
}
if (g_hx711_config.gain > 0)
{
if ((ret = ioctl(fd, HX711_SET_GAIN, g_hx711_config.gain)))
{
fprintf(stderr, "Failed to set gain to %d, error: %s\n",
g_hx711_config.gain, strerror(errno));
return -1;
}
}
if (g_hx711_config.average > 0)
{
if ((ret = ioctl(fd, HX711_SET_AVERAGE, g_hx711_config.average)))
{
fprintf(stderr, "Failed to set average to %d, error: %s\n",
g_hx711_config.average, strerror(errno));
return -1;
}
}
if (g_hx711_config.sign)
{
if ((ret = ioctl(fd, HX711_SET_SIGN, &g_hx711_config.sign)))
{
fprintf(stderr, "Failed to set sign to %d, error: %s\n",
g_hx711_config.sign, strerror(errno));
return -1;
}
}
if (g_hx711_config.val_per_unit > 0)
{
if ((ret = ioctl(fd, HX711_SET_VAL_PER_UNIT,
g_hx711_config.val_per_unit)))
{
fprintf(stderr, "Failed to set val per unit to %d, error: %s\n",
g_hx711_config.val_per_unit, strerror(errno));
return -1;
}
}
return 0;
}
* Name: hx711_dump_options
*
* Description:
* Reads current hx711 settings from kernel driver and dumps them on stdout
*
****************************************************************************/
static void hx711_dump_options(int fd)
{
unsigned average;
unsigned char gain;
char channel;
unsigned val_per_unit;
ioctl(fd, HX711_GET_GAIN, &gain);
ioctl(fd, HX711_GET_CHANNEL, &channel);
ioctl(fd, HX711_GET_AVERAGE, &average);
ioctl(fd, HX711_GET_VAL_PER_UNIT, &val_per_unit);
printf("Current settings for: %s\n", g_hx711_config.dev);
printf("average.............: %u\n", average);
printf("channel.............: %c\n", channel);
printf("gain................: %d\n", gain);
printf("value per unit......: %u\n", val_per_unit);
}
* Name: hx711_read_and_dump
*
* Description:
* Reads configured number of samples, and dumps them to terminal.
*
****************************************************************************/
static int hx711_read_and_dump(int fd)
{
int32_t sample;
while (g_hx711_config.loops--)
{
if (read(fd, &sample, sizeof(sample)) != sizeof(sample))
{
fprintf(stderr, "Error reading from %s, error %s\n",
g_hx711_config.dev, strerror(errno));
return -1;
}
printf("%"PRId32"\n", sample);
}
return 0;
}
* Public Functions
****************************************************************************/
* hx711
****************************************************************************/
int main(int argc, FAR char *argv[])
{
int fd;
if (hx711_parse_args(argc, argv))
{
return 1;
}
fd = open(g_hx711_config.dev, O_RDONLY);
if (fd < 0)
{
fprintf(stderr, "Failed to open %s, error: %s\n", g_hx711_config.dev,
strerror(errno));
return 1;
}
if (hx711_set_options(fd))
{
close(fd);
return 1;
}
if (g_hx711_config.precision)
{
ioctl(fd, HX711_GET_VAL_PER_UNIT, &g_hx711_config.val_per_unit);
if (g_hx711_config.val_per_unit)
{
printf("Taring with %fg precision\n", g_hx711_config.precision);
}
if (ioctl(fd, HX711_TARE, &g_hx711_config.precision))
{
perror("Failed to tare the scale");
close(fd);
return 1;
}
}
if (g_hx711_config.dump)
{
hx711_dump_options(fd);
}
if (g_hx711_config.loops)
{
hx711_read_and_dump(fd);
}
close(fd);
return 0;
}