sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

More I2C tool logic

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@3924 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2011-08-29 23:06:54 +00:00
parent 1008ae7196
commit e1c666abbc
9 changed files with 515 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
system/i2c/Makefile
View File

@ -40,7 +40,7 @@ include $(APPDIR)/Make.defs
# I2C tool
ASRCS =
CSRCS = i2c_detect.c i2c_dump.c i2c_get.c i2c_main.c i2c_set.c
CSRCS = i2c_bus.c i2c_common.c i2c_dev.c i2c_dump.c i2c_get.c i2c_main.c i2c_set.c
AOBJS = $(ASRCS:.S=$(OBJEXT))

99
system/i2c/i2c_bus.c Normal file
View File

@ -0,0 +1,99 @@
/****************************************************************************
* apps/system/i2c/i2c_bus.c
*
* Copyright (C) 2011 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/i2c.h>
#include "i2ctool.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: cmd_bus
****************************************************************************/
int cmd_bus(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
FAR struct i2c_dev_s *dev;
int i;
i2ctool_printf(i2ctool, " BUS EXISTS?\n");
for (i = CONFIG_I2CTOOL_MINBUS; i <= CONFIG_I2CTOOL_MAXBUS; i++)
{
dev = up_i2cinitialize(i);
if (dev)
{
i2ctool_printf(i2ctool, "Bus %d: YES\n", i);
(void)up_i2cuninitialize(dev);
}
else
{
i2ctool_printf(i2ctool, "Bus %d: NO\n", i);
}
}
return OK;
}

198
system/i2c/i2c_common.c Normal file
View File

@ -0,0 +1,198 @@
/****************************************************************************
* apps/system/i2c/i2c_common.c
*
* Copyright (C) 2011 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdlib.h>
#include "i2ctool.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: common_args
****************************************************************************/
int common_args(FAR struct i2ctool_s *i2ctool, FAR char **arg)
{
FAR char *ptr = *arg;
long value;
int ret;
if (ptr[0] != '-')
{
goto invalid_argument;
}
switch (ptr[0])
{
case 'a':
ret = arg_hex(arg, &value);
if (value < CONFIG_I2CTOOL_MINADDR || value > CONFIG_I2CTOOL_MAXADDR)
{
goto out_of_range;
}
i2ctool->addr = (uint8_t) value;
return ret;
case 'b':
ret = arg_decimal(arg, &value);
if (value < CONFIG_I2CTOOL_MINBUS || value > CONFIG_I2CTOOL_MAXBUS)
{
goto out_of_range;
}
i2ctool->bus = (uint8_t) value;
return ret;
case 'n':
i2ctool->start = false;
return 1;
case 'r':
ret = arg_hex(arg, &value);
if (value < 0 || value > CONFIG_I2CTOOL_MAXREGADDR)
{
goto out_of_range;
}
i2ctool->regaddr = (uint8_t) value;
return ret;
case 's':
i2ctool->start = true;
return 1;
case 'w':
ret = arg_decimal(arg, &value);
if (value != 8 && value != 16)
{
goto out_of_range;
}
i2ctool->width = (uint8_t) value;
return ret;
default:
goto invalid_argument;
}
invalid_argument:
i2ctool_printf(i2ctool, g_fmtarginvalid, arg);
return ERROR;
out_of_range:
i2ctool_printf(i2ctool, g_fmtargrange, arg);
return ERROR;
}
/****************************************************************************
* Name: arg_string
****************************************************************************/
int arg_string(FAR char **arg, FAR char **value)
{
FAR char *ptr = *arg;
if (ptr[2] == '\0')
{
*value = arg[1];
return 2;
}
else
{
*value = &ptr[2];
return 1;
}
}
/****************************************************************************
* Name: arg_decimal
****************************************************************************/
int arg_decimal(FAR char **arg, FAR long *value)
{
FAR char *string;
int ret;
ret = arg_string(arg, &string);
*value = strtol(string, NULL, 10);
return ret;
}
/****************************************************************************
* Name: arg_hex
****************************************************************************/
int arg_hex(FAR char **arg, FAR long *value)
{
FAR char *string;
int ret;
ret = arg_string(arg, &string);
*value = strtol(string, NULL, 16);
return ret;
}

6
system/i2c/i2c_detect.c → system/i2c/i2c_dev.c
View File

@ -1,5 +1,5 @@
/****************************************************************************
* apps/system/i2c/i2c_detect.c
* apps/system/i2c/i2c_dev.c
*
* Copyright (C) 2011 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
@ -70,10 +70,10 @@
****************************************************************************/
/****************************************************************************
* Name: cmd_detect
* Name: cmd_dev
****************************************************************************/
int cmd_detect(FAR void *handle, int argc, char **argv)
int cmd_dev(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
return OK;
}

2
system/i2c/i2c_dump.c
View File

@ -73,7 +73,7 @@
* Name: cmd_dump
****************************************************************************/
int cmd_dump(FAR void *handle, int argc, char **argv)
int cmd_dump(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
return OK;
}

32
system/i2c/i2c_get.c
View File

@ -39,6 +39,8 @@
#include <nuttx/config.h>
#include <nuttx/i2c.h>
#include "i2ctool.h"
/****************************************************************************
@ -73,7 +75,35 @@
* Name: cmd_get
****************************************************************************/
int cmd_get(FAR void *handle, int argc, char **argv)
int cmd_get(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
FAR struct i2c_dev_s *dev;
int nargs;
int i;
/* Parse any command line arguments */
for (i = 1; i < argc; )
{
nargs = common_args(i2ctool, &argv[i]);
if (nargs < 0)
{
return ERROR;
}
i += nargs;
}
/* Get a handle to the I2C bus */
dev = up_i2cinitialize(i2ctool->bus);
if (!dev)
{
i2ctool_printf(i2ctool, "Failed to get bus %d\n", i2ctool->bus);
return ERROR;
}
#warning "missing logic"
(void)up_i2cuninitialize(dev);
return OK;
}

174
system/i2c/i2c_main.c
View File

@ -56,44 +56,16 @@
* Pre-processor Definitions
****************************************************************************/
/* Are we using the NuttX console for I/O? Or some other character device? */
#ifdef CONFIG_I2CTOOL_INDEV
# define INFD(p) ((p)->ss_infd)
# define INSTREAM(p) ((p)->ss_instream)
#else
# define INFD(p) 0
# define INSTREAM(p) stdin
#endif
#ifdef CONFIG_I2CTOOL_OUTDEV
# define OUTFD(p) ((p)->ss_outfd)
# define OUTSTREAM(p) ((p)->ss_outstream)
#else
# define OUTFD(p) 1
# define OUTSTREAM(p) stdout
#endif
/****************************************************************************
* Private Types
****************************************************************************/
struct i2ctool_s
{
/* Output streams */
#ifdef CONFIG_I2CTOOL_OUTDEV
int ss_outfd; /* Output file descriptor */
FILE *ss_outstream; /* Output stream */
#endif
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int cmd_help(FAR void *handle, int argc, char **argv);
static int cmd_unrecognized(FAR void *handle, int argc, char **argv);
static int cmd_help(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
static int cmd_unrecognized(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
/****************************************************************************
* Private Data
@ -103,12 +75,13 @@ struct i2ctool_s g_i2ctool;
static const struct cmdmap_s g_i2ccmds[] =
{
{ "?", cmd_help, 1, 1, NULL },
{ "detect", cmd_detect, 1, 1, NULL },
{ "dump", cmd_dump, 1, 1, NULL },
{ "get", cmd_get, 1, 1, NULL },
{ "help", cmd_help, 1, 1, NULL },
{ "set", cmd_set, 1, 1, NULL },
{ "?", cmd_help, "Show help", NULL },
{ "bus", cmd_bus, "List busses" "[OPTIONS]" },
{ "dev", cmd_dev, "List devices", "[OPTIONS]" },
{ "dump", cmd_dump, "Dump registers", "[OPTIONS]" },
{ "get", cmd_get, "Read registers", "[OPTIONS]" },
{ "help", cmd_help, "Show help", NULL },
{ "set", cmd_set, "Write registers", "[OPTIONS]]" },
};
/****************************************************************************
@ -138,33 +111,41 @@ const char g_fmtinternalerror[] = "i2ctool: %s: Internal error\n";
* Name: cmd_help
****************************************************************************/
static int cmd_help(FAR void *handle, int argc, char **argv)
static int cmd_help(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
const struct cmdmap_s *ptr;
i2ctool_printf(handle, "Usage: i2ctool <cmd> [arguments]\n");
i2ctool_printf(handle, "Where <cmd> is one of:\n");
i2ctool_printf(i2ctool, "Usage: i2ctool <cmd> [arguments]\n");
i2ctool_printf(i2ctool, "Where <cmd> is one of:\n");
for (ptr = g_i2ccmds; ptr->cmd; ptr++)
{
if (ptr->usage)
{
i2ctool_printf(handle, " %s %s\n", ptr->cmd, ptr->usage);
i2ctool_printf(i2ctool, "%s: %s %s\n", ptr->desc, ptr->cmd, ptr->usage);
}
else
{
i2ctool_printf(handle, " %s\n", ptr->cmd);
i2ctool_printf(i2ctool, "%s: %s\n", ptr->desc, ptr->cmd);
}
}
i2ctool_printf(handle, "NOTES:\n");
i2ctool_printf(i2ctool, "Where common OPTIONS include:\n");
i2ctool_printf(i2ctool, "[-a addr] is the I2C device address (hex). Default: %02x\n",
CONFIG_I2CTOOL_MINADDR);
i2ctool_printf(i2ctool, "[-b bus] is the I2C bus number (decimal). Default: %d\n",
CONFIG_I2CTOOL_MINBUS);
i2ctool_printf(i2ctool, "[-r regaddr] is the I2C device register address (hex). Default: 0\n");
i2ctool_printf(i2ctool, "[-w width] is the data width (8 or 16 decimal). Default: 8 \n");
i2ctool_printf(i2ctool, "[-s|n], send/don't send start between command and data. Default: -n\n");
i2ctool_printf(i2ctool, "\nNOTES:\n");
#ifndef CONFIG_DISABLE_ENVIRON
i2ctool_printf(handle, "- An environment variable like $PATH may be used for any argument.\n");
i2ctool_printf(i2ctool, "o An environment variable like $PATH may be used for any argument.\n");
#endif
i2ctool_printf(handle, "- Arguments are persistent. For example, once the I2C address is\n");
i2ctool_printf(handle, " specified, that address will be re-used until it changes.\n");
i2ctool_printf(handle, "WARNING:\n");
i2ctool_printf(handle, "- The I2C detect command may have bad side effects on your I2C devices.\n");
i2ctool_printf(handle, " Use only at your own risk.\n");
i2ctool_printf(i2ctool, "o Arguments are \"sticky\". For example, once the I2C address is\n");
i2ctool_printf(i2ctool, " specified, that address will be re-used until it changes.\n");
i2ctool_printf(i2ctool, "\nWARNING:\n");
i2ctool_printf(i2ctool, "o The I2C dev command may have bad side effects on your I2C devices.\n");
i2ctool_printf(i2ctool, " Use only at your own risk.\n");
return OK;
}
@ -172,9 +153,9 @@ static int cmd_help(FAR void *handle, int argc, char **argv)
* Name: cmd_unrecognized
****************************************************************************/
static int cmd_unrecognized(FAR void *handle, int argc, char **argv)
static int cmd_unrecognized(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
i2ctool_printf(handle, g_fmtcmdnotfound, argv[0]);
i2ctool_printf(i2ctool, g_fmtcmdnotfound, argv[0]);
return ERROR;
}
@ -182,11 +163,11 @@ static int cmd_unrecognized(FAR void *handle, int argc, char **argv)
* Name: i2c_execute
****************************************************************************/
static int i2c_execute(FAR void *handle, int argc, char *argv[])
static int i2c_execute(FAR struct i2ctool_s *i2ctool, int argc, char *argv[])
{
const struct cmdmap_s *cmdmap;
const char *cmd;
cmd_t handler = cmd_unrecognized;
cmd_t handler;
int ret;
/* The form of argv is:
@ -197,46 +178,21 @@ static int i2c_execute(FAR void *handle, int argc, char *argv[])
* argv[argc]: NULL terminating pointer
*/
cmd = argv[0];
/* See if the command is one that we understand */
cmd = argv[0];
handler = cmd_unrecognized;
for (cmdmap = g_i2ccmds; cmdmap->cmd; cmdmap++)
{
if (strcmp(cmdmap->cmd, cmd) == 0)
{
/* Check if a valid number of arguments was provided. We
* do this simple, imperfect checking here so that it does
* not have to be performed in each command.
*/
if (argc < cmdmap->minargs)
{
/* Fewer than the minimum number were provided */
i2ctool_printf(handle, g_fmtargrequired, cmd);
return ERROR;
}
else if (argc > cmdmap->maxargs)
{
/* More than the maximum number were provided */
i2ctool_printf(handle, g_fmttoomanyargs, cmd);
return ERROR;
}
else
{
/* A valid number of arguments were provided (this does
* not mean they are right).
*/
handler = cmdmap->handler;
break;
}
handler = cmdmap->handler;
break;
}
}
ret = handler(handle, argc, argv);
ret = handler(i2ctool, argc, argv);
return ret;
}
@ -244,7 +200,7 @@ static int i2c_execute(FAR void *handle, int argc, char *argv[])
* Name: i2c_argument
****************************************************************************/
FAR char *i2c_argument(FAR void *handle, int argc, char *argv[], int *pindex)
FAR char *i2c_argument(FAR struct i2ctool_s *i2ctool, int argc, char *argv[], int *pindex)
{
FAR char *arg;
int index = *pindex;
@ -289,7 +245,7 @@ FAR char *i2c_argument(FAR void *handle, int argc, char *argv[], int *pindex)
* Name: i2c_parse
****************************************************************************/
int i2c_parse(FAR void *handle, int argc, char *argv[])
int i2c_parse(FAR struct i2ctool_s *i2ctool, int argc, char *argv[])
{
FAR char *newargs[MAX_ARGUMENTS+1];
FAR char *cmd;
@ -303,7 +259,7 @@ int i2c_parse(FAR void *handle, int argc, char *argv[])
/* Parse out the command, skipping the first argument (the program name)*/
index = 1;
cmd = i2c_argument(handle, argc, argv, &index);
cmd = i2c_argument(i2ctool, argc, argv, &index);
/* Check if any command was provided */
@ -314,7 +270,7 @@ int i2c_parse(FAR void *handle, int argc, char *argv[])
* command status.
*/
return cmd_help(handle, 0, NULL);
return cmd_help(i2ctool, 0, NULL);
}
/* Parse all of the arguments following the command name. */
@ -322,7 +278,7 @@ int i2c_parse(FAR void *handle, int argc, char *argv[])
newargs[0] = cmd;
for (nargs = 1; nargs < MAX_ARGUMENTS; nargs++)
{
newargs[nargs] = i2c_argument(handle, argc, argv, &index);
newargs[nargs] = i2c_argument(i2ctool, argc, argv, &index);
if (!newargs[nargs])
{
break;
@ -332,7 +288,7 @@ int i2c_parse(FAR void *handle, int argc, char *argv[])
/* Then execute the command */
return i2c_execute(handle, nargs, newargs);
return i2c_execute(i2ctool, nargs, newargs);
}
/****************************************************************************
@ -399,10 +355,32 @@ static void i2c_teardown(void)
int MAIN_NAME(int argc, char *argv[])
{
/* Verify settings */
if (g_i2ctool.bus < CONFIG_I2CTOOL_MINBUS || g_i2ctool.bus > CONFIG_I2CTOOL_MAXBUS)
{
g_i2ctool.bus = CONFIG_I2CTOOL_MINBUS;
}
if (g_i2ctool.addr < CONFIG_I2CTOOL_MINADDR || g_i2ctool.addr > CONFIG_I2CTOOL_MAXADDR)
{
g_i2ctool.addr = CONFIG_I2CTOOL_MINADDR;
}
if (g_i2ctool.regaddr < CONFIG_I2CTOOL_MAXREGADDR)
{
g_i2ctool.regaddr = 0;
}
if (g_i2ctool.width != 8 && g_i2ctool.width != 16)
{
g_i2ctool.width = 8;
}
/* Parse process the command line */
i2c_setup();
(void)i2c_parse((FAR void *)&g_i2ctool, argc, argv);
(void)i2c_parse(&g_i2ctool, argc, argv);
i2c_teardown();
return OK;
@ -416,16 +394,13 @@ int MAIN_NAME(int argc, char *argv[])
*
****************************************************************************/
int i2ctool_printf(FAR void *handle, const char *fmt, ...)
int i2ctool_printf(FAR struct i2ctool_s *i2ctool, const char *fmt, ...)
{
#ifdef CONFIG_I2CTOOL_OUTDEV
FAR struct i2ctool_s *pstate = (FAR struct i2ctool_s *)handle;
#endif
va_list ap;
int ret;
va_start(ap, fmt);
ret = vfprintf(OUTSTREAM(pstate), fmt, ap);
ret = vfprintf(OUTSTREAM(i2ctool), fmt, ap);
va_end(ap);
return ret;
@ -439,19 +414,16 @@ int i2ctool_printf(FAR void *handle, const char *fmt, ...)
*
****************************************************************************/
ssize_t i2ctool_write(FAR void *handle, FAR const void *buffer, size_t nbytes)
ssize_t i2ctool_write(FAR struct i2ctool_s *i2ctool, FAR const void *buffer, size_t nbytes)
{
#ifdef CONFIG_I2CTOOL_OUTDEV
FAR struct i2ctool_s *pstate = (FAR struct i2ctool_s *)handle;
#endif
ssize_t ret;
/* Write the data to the output stream */
ret = fwrite(buffer, 1, nbytes, OUTSTREAM(pstate));
ret = fwrite(buffer, 1, nbytes, OUTSTREAM(i2ctool));
if (ret < 0)
{
dbg("[%d] Failed to send buffer: %d\n", OUTFD(pstate), errno);
dbg("[%d] Failed to send buffer: %d\n", OUTFD(i2ctool), errno);
}
return ret;
}

32
system/i2c/i2c_set.c
View File

@ -39,6 +39,8 @@
#include <nuttx/config.h>
#include <nuttx/i2c.h>
#include "i2ctool.h"
/****************************************************************************
@ -73,7 +75,35 @@
* Name: cmd_set
****************************************************************************/
int cmd_set(FAR void *handle, int argc, char **argv)
int cmd_set(FAR struct i2ctool_s *i2ctool, int argc, char **argv)
{
FAR struct i2c_dev_s *dev;
int nargs;
int i;
/* Parse any command line arguments */
for (i = 1; i < argc; )
{
nargs = common_args(i2ctool, &argv[i]);
if (nargs < 0)
{
return ERROR;
}
i += nargs;
}
/* Get a handle to the I2C bus */
dev = up_i2cinitialize(i2ctool->bus);
if (!dev)
{
i2ctool_printf(i2ctool, "Failed to get bus %d\n", i2ctool->bus);
return ERROR;
}
#warning "missing logic"
(void)up_i2cuninitialize(dev);
return OK;
}

91
system/i2c/i2ctool.h
View File

@ -52,8 +52,30 @@
/****************************************************************************
* Definitions
****************************************************************************/
/* Configuration ************************************************************/
#ifndef CONFIG_I2CTOOL_MINBUS
# define CONFIG_I2CTOOL_MINBUS 0
#endif
/* This is the maximum number of arguments that will be accepted for a command */
#ifndef CONFIG_I2CTOOL_MAXBUS
# define CONFIG_I2CTOOL_MAXBUS 3
#endif
#ifndef CONFIG_I2CTOOL_MINADDR
# define CONFIG_I2CTOOL_MINADDR 0x03
#endif
#ifndef CONFIG_I2CTOOL_MAXADDR
# define CONFIG_I2CTOOL_MAXADDR 0x77
#endif
#ifndef CONFIG_I2CTOOL_MAXREGADDR
# define CONFIG_I2CTOOL_MAXREGADDR 0xff
#endif
/* This is the maximum number of arguments that will be accepted for a
* command
*/
#define MAX_ARGUMENTS 6
@ -61,6 +83,24 @@
#define MAX_LINELEN 80
/* Are we using the NuttX console for I/O? Or some other character device? */
#ifdef CONFIG_I2CTOOL_INDEV
# define INFD(p) ((p)->ss_infd)
# define INSTREAM(p) ((p)->ss_instream)
#else
# define INFD(p) 0
# define INSTREAM(p) stdin
#endif
#ifdef CONFIG_I2CTOOL_OUTDEV
# define OUTFD(p) ((p)->ss_outfd)
# define OUTSTREAM(p) ((p)->ss_outstream)
#else
# define OUTFD(p) 1
# define OUTSTREAM(p) stdout
#endif
/* Output is via printf but can be changed using this macro */
#ifdef CONFIG_CPP_HAVE_VARARGS
@ -73,15 +113,32 @@
* Public Types
****************************************************************************/
typedef int (*cmd_t)(FAR void *handle, int argc, char **argv);
struct i2ctool_s
{
/* Sticky options */
uint8_t addr; /* [-a addr] is the I2C device address */
uint8_t bus; /* [-b bus] is the I2C bus number */
uint8_t regaddr; /* [-r regaddr] is the I2C device register address */
uint8_t width; /* [-w width] is the data width (8 or 16) */
bool start; /* [-s|n], send/don't send start between command and data */
/* Output streams */
#ifdef CONFIG_I2CTOOL_OUTDEV
int ss_outfd; /* Output file descriptor */
FILE *ss_outstream; /* Output stream */
#endif
};
typedef int (*cmd_t)(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
struct cmdmap_s
{
const char *cmd; /* Name of the command */
cmd_t handler; /* Function that handles the command */
uint8_t minargs; /* Minimum number of arguments (including command) */
uint8_t maxargs; /* Maximum number of arguments (including command) */
const char *usage; /* Usage instructions for 'help' command */
FAR const char *cmd; /* Name of the command */
cmd_t handler; /* Function that handles the command */
FAR const char *desc; /* Short description */
FAR const char *usage; /* Usage instructions for 'help' command */
};
/****************************************************************************
@ -105,14 +162,22 @@ extern const char g_fmtinternalerror[];
/* Message handler */
ssize_t i2ctool_write(FAR void *handle, FAR const void *buffer, size_t nbytes);
int i2ctool_printf(FAR void *handle, const char *fmt, ...);
ssize_t i2ctool_write(FAR struct i2ctool_s *i2ctool, FAR const void *buffer, size_t nbytes);
int i2ctool_printf(FAR struct i2ctool_s *i2ctool, const char *fmt, ...);
/* Command handlers */
extern int cmd_detect(FAR void *handle, int argc, char **argv);
extern int cmd_dump(FAR void *handle, int argc, char **argv);
extern int cmd_get(FAR void *handle, int argc, char **argv);
extern int cmd_set(FAR void *handle, int argc, char **argv);
int cmd_bus(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
int cmd_dev(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
int cmd_dump(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
int cmd_get(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
int cmd_set(FAR struct i2ctool_s *i2ctool, int argc, char **argv);
/* Common logic */
int common_args(FAR struct i2ctool_s *i2ctool, FAR char **arg);
int arg_string(FAR char **arg, FAR char **value);
int arg_decimal(FAR char **arg, FAR long *value);
int arg_hex(FAR char **arg, FAR long *value);
#endif /* __APPS_SYSTEM_I2C_I2CTOOLS_H */