Write bytes to a device on the I2C Bus. More...

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <libgen.h>
#include <unistd.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/opts.h"
#include "rnr/i2c-dev.h"
#include "rnr/i2c.h"
#include "version.h"

Functions
static int	execWrite (i2c_t *pI2C, int addr, byte_t writebuf[], int writelen)
	Execute I²C slave device write. More...

static int	StrToUnsigned (const char s, uint_t pVal)
	Convert string to unsigned integer. More...

static int	StrToByte (const char s, byte_t pByte)
	Convert string to byte. More...

static void	ArgsGet (int argc, char *argv[])
	Get write bytes from command-line arguments. More...

static void	MainInit (int argc, char argv[], i2c_t pI2C)
	Command initialization. More...

int	main (int argc, char *argv[])
	i2cwrite main() More...

Variables
static char *	Argv0
	command name

static int	OptVerbose = 0
	verbose option

static char *	OptDevName = "/dev/i2c/0"
	i2c bus device option

static int	OptDevFd = -1
	opened i2c buse device fd option

static int	OptI2CAddr = -1
	slave i2c device address

static byte_t	ArgWriteBuf [1024]
	write buffer argument

static int	ArgWriteLen = 0
	write byte count arguement

static OptsPgmInfo_T	I2CWritePgmInfo
	Program Information. More...

static OptsInfo_T	I2CWriteOptsInfo []
	Command Line Options Information.

Detailed Description

Write bytes to a device on the I2C Bus.

LastChangedDate: 2011-09-12 16:08:28 -0600 (Mon, 12 Sep 2011)

Rev: 1279

Author: Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright: © 2007-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file i2cwrite.c.

Function Documentation

static void ArgsGet	(	int	argc,
		char *	argv[]
	)

static

Get write bytes from command-line arguments.

Parameters

argc	Command-line argument count.
argv	Command-line arguments.

Returns: Exits on error.

Definition at line 267 of file i2cwrite.c.

References Argv0, ArgWriteBuf, ArgWriteLen, and StrToByte().

Referenced by MainInit().

 {
   int     i;
   size_t  max = sizeof(ArgWriteBuf);  
 
   if( argc == 0 )
   {
     printf("%s Error: At least one byte must be specified\n", Argv0);
     exit(EC_ERROR);
   }
   else if( argc > max )
   {
     fprintf(stderr, 
         "%s: Warning: %d: I2C write. Only %u bytes will be written.\n",
         Argv0, argc, (uint_t)max);
   }
 
   for(i=0; i<argc && i<max; ++i)
   {
     if( StrToByte(argv[i], ArgWriteBuf+i) != OK )
     {
       printf("%s Error: byte %d = '%s': bad byte value\n", Argv0, i, argv[i]);
       exit(EC_ERROR);
     }
   }
 
   ArgWriteLen = i;
 }

static int execWrite	(	i2c_t *	pI2C,
		int	addr,
		byte_t	writebuf[],
		int	writelen
	)

static

Execute I²C slave device write.

Parameters

pI2C	Pointer to I²C handle.
addr	Slave device address.
writebuf	Buffer to write.
writelen	Number of write bytes.

Returns: Returns ≥ 0 on success, -1 on failure.

Definition at line 166 of file i2cwrite.c.

References Argv0, i2c_write(), and OptVerbose.

Referenced by main().

 {
   int   n;
 
   if( OptVerbose )
   {
     printf("%s: i2cdev 0x%02x: writting %u bytes...\n",
         Argv0, (byte_t)addr, writelen);
   }
 
   n = i2c_write(pI2C, (i2c_addr_t)addr, writebuf, (uint_t)writelen); 
 
   if( n < 0 )
   {
     LOGSYSERROR("i2c_write()");
     return RC_ERROR;
   }
 
   if( OptVerbose )
   {
     printf("Wrote %d bytes\n", n);
   }
 
   if( n < writelen )
   {
     LOGERROR("wrote only %d bytes of %d", n, writelen);
   }
 
   return n;
 }

int main	(	int	argc,
		char *	argv[]
	)

i2cwrite main()

Parameters

argc	Count of command-line options and arguments.
argv	Array of command-line options and arguments.

Returns: Exit value.

Definition at line 366 of file i2cwrite.c.

References ArgWriteBuf, ArgWriteLen, execWrite(), MainInit(), and OptI2CAddr.

 {
   i2c_t i2c;
   int   rc;
 
   MainInit(argc, argv, &i2c);
 
   rc = execWrite(&i2c, OptI2CAddr, ArgWriteBuf, ArgWriteLen);
 
   return rc == ArgWriteLen? 0: (rc >= 0? 1: 2);
 }

static void MainInit	(	int	argc,
		char *	argv[],
		i2c_t *	pI2C
	)

static

Command initialization.

Parameters

argc	Command-line argument count.
argv	Command-line arguments.
pI2C	Pointer to I²C handle.

Definition at line 303 of file i2cwrite.c.

References i2c_struct::addr, ArgsGet(), Argv0, i2c_struct::fd, I2C_ADDR_DEV_HIGH, I2C_ADDR_DEV_LOW, i2c_open(), I2CWriteOptsInfo, I2CWritePgmInfo, OptDevFd, OptDevName, OptI2CAddr, OptVerbose, and PkgInfo.

Referenced by main().

 {
   // Name of this process
   Argv0 = basename(argv[0]);
 
   // Get the environment
   //EnvGet();
 
   // Parse input arguments
   argv = OptsGet(Argv0, &PkgInfo, &I2CWritePgmInfo, I2CWriteOptsInfo, true,
                  &argc, argv);
 
   // Final option checks
   if( OptI2CAddr < 0x00 )
   {
     fprintf(stderr, "%s: Address option required\n", Argv0);
     exit(EC_BAD_OPT);
   }
   else if( (OptI2CAddr < I2C_ADDR_DEV_LOW) || (OptI2CAddr > I2C_ADDR_DEV_HIGH) )
   {
     fprintf(stderr, "%s: Address out of range: 0x%x\n", Argv0, OptI2CAddr);
     exit(EC_BAD_OPT);
   }
 
   // Convert command-line arguments
   ArgsGet(argc, argv);
 
   // Opened device specified
   if( OptDevFd >= 0 )
   {
     pI2C->fd    = OptDevFd;
     pI2C->addr  = (ushort_t)(-1);
   }
 
   // I2C Bus device specified
   else
   {
     if( OptDevName == NULL || OptDevName[0] == 0 )
     {
       OptDevName = "/dev/i2c/0";
     }
 
     if( OptVerbose )
     {
       printf("I2C device: %s\n\n", OptDevName);
     }
   
     if( i2c_open(pI2C, OptDevName) < 0 )
     {
      LOGSYSERROR("%s: Failed to open.", OptDevName);
      exit(EC_ERROR);
     }
   }
 }

static int StrToByte	(	const char *	s,
		byte_t *	pByte
	)

static

Convert string to byte.

Parameters

	s	String.
[out]	pByte	Pointer to converted value.

Returns: Returns OK on success, RC_ERROR on error.

Definition at line 240 of file i2cwrite.c.

References StrToUnsigned().

Referenced by ArgsGet().

 {
   uint_t  uVal;
 
   if( StrToUnsigned(s, &uVal) != OK )
   {
     return RC_ERROR;
   }
   else if( uVal > 0xff )
   {
     return RC_ERROR;
   }
   else
   {
     *pByte = (byte_t)uVal;
     return OK;
   }
 }

static int StrToUnsigned	(	const char *	s,
		uint_t *	pVal
	)

static

Convert string to unsigned integer.

Parameters

	s	String.
[out]	pVal	Pointer to converted value.

Returns: Returns OK on success, RC_ERROR on error.

Definition at line 205 of file i2cwrite.c.

Referenced by StrToByte().

 {
   long    lVal;
   char   *sEnd;
 
   if( (s == NULL) || (*s == 0) )
   {
     return RC_ERROR;
   }
   
   lVal = strtol(s, &sEnd, 0);
 
   if( *sEnd != 0 )
   {
     return RC_ERROR;
   }
   else if( lVal < 0 )
   {
     return RC_ERROR;
   }
   else
   {
     *pVal = (uint_t)lVal;
     return OK;
   }
 }

Variable Documentation

OptsPgmInfo_T I2CWritePgmInfo

static

Initial value:

=
{
  .usage_args = "byte1 [byte2 ...]",
  .synopsis = "Write bytes to a device on an I2C Bus.",
  .long_desc = 
    "The %P command write the bytes arguments to an I2C Bus for a device "
    "with the specified address.",
  .diagnostics = 
    "Exit status is 0 if the bytes are successfully written. "
    "Exist status is >= 2 if error(s) are encountered.",
}

Program Information.

Definition at line 85 of file i2cwrite.c.

Referenced by MainInit().

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation