shinys000114/wiringPi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WiringPi: Minor changes

Browse Source 
- Fix compile warning
- Remove pwmSetMode function that is not used
- Change the name of changing drive functions
- Aggressively use of WiringPi setupCheck() function
- Move usingGpiomem variable into libodroid structure
- etc...

Signed-off-by: Deokgyu Yang <secugyu@gmail.com>
Change-Id: I355556975cedc686885f3b91d7f1a4ec02f1e232
This commit is contained in:
Deokgyu Yang
2020-03-20 11:16:06 +09:00
parent 90fb4b9435
commit a0bd5eb338
10 changed files with 95 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
gpio/gpio.c
View File

@@ -67,7 +67,6 @@ char *usage = "Usage: gpio -v\n"
" gpio export/edge/unexport ...\n"
" gpio wfi <pin> <mode>\n"
" gpio drive <pin> <value>\n"
" gpio pwm-bal/pwm-ms \n"
" gpio pwmr <range> \n"
" gpio pwmc <divider> \n"
" gpio load spi/i2c\n"
@@ -563,12 +562,12 @@ void doMode (int argc, char *argv [])
/*
* doPadDrive:
* doDrive:
* gpio drive pin value for ODROIDs since it depends on the SoC
*********************************************************************************
*/
static void doPadDrive (int argc, char *argv [])
static void doDrive (int argc, char *argv [])
{
int pin, val;
@@ -580,7 +579,7 @@ static void doPadDrive (int argc, char *argv [])
pin = atoi (argv [2]) ;
val = atoi (argv [3]) ;
setPadDrive (pin, val) ;
setDrive (pin, val) ;
}
/*
@@ -759,16 +758,11 @@ void doPwm (int argc, char *argv [])
/*
* doPwmMode: doPwmRange: doPwmClock:
* doPwmRange: doPwmClock:
* Change the PWM mode, range and clock divider values
*********************************************************************************
*/
static void doPwmMode (int mode)
{
pwmSetMode (mode) ;
}
static void doPwmRange (int argc, char *argv [])
{
unsigned int range ;
@@ -984,11 +978,9 @@ int main (int argc, char *argv [])
else if (strcasecmp (argv [1], "blink" ) == 0) doBlink (argc, argv) ;
// Pi Specifics
else if (strcasecmp (argv [1], "pwm-bal" ) == 0) doPwmMode (PWM_MODE_BAL) ;
else if (strcasecmp (argv [1], "pwm-ms" ) == 0) doPwmMode (PWM_MODE_MS) ;
else if (strcasecmp (argv [1], "pwmr" ) == 0) doPwmRange (argc, argv) ;
else if (strcasecmp (argv [1], "pwmc" ) == 0) doPwmClock (argc, argv) ;
else if (strcasecmp (argv [1], "drive" ) == 0) doPadDrive (argc, argv) ;
else if (strcasecmp (argv [1], "drive" ) == 0) doDrive (argc, argv) ;
else if (strcasecmp (argv [1], "readall" ) == 0) doReadall (argc, argv) ;
else if (strcasecmp (argv [1], "nreadall" ) == 0) doReadall (argc, argv) ;
else if (strcasecmp (argv [1], "i2cdetect") == 0) doI2Cdetect (argc, argv) ;

4
gpio/readall.c
View File

@@ -574,7 +574,7 @@ static void readallPhys(int model, int UNU rev, int physPin, const char *physNam
case MODEL_ODROID_XU3:
case MODEL_ODROID_N2:
case MODEL_ODROID_C4:
printf (" | %2d | %5s", getPadDrive(pin), pupd[getPUPD(pin)]);
printf (" | %2d | %5s", getDrive(pin), pupd[getPUPD(pin)]);
break;
default:
break;
@@ -615,7 +615,7 @@ static void readallPhys(int model, int UNU rev, int physPin, const char *physNam
case MODEL_ODROID_XU3:
case MODEL_ODROID_N2:
case MODEL_ODROID_C4:
printf (" | %-5s | %-2d", pupd[getPUPD(pin)], getPadDrive(pin));
printf (" | %-5s | %-2d", pupd[getPUPD(pin)], getDrive(pin));
break;
default:
break;

3
wiringPi/odroidc1.c
View File

@@ -664,8 +664,7 @@ static void init_gpio_mmap (void)
msg (MSG_ERR,
"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",
strerror (errno));
setUsingGpioMem( TRUE );
setUsingGpiomem(TRUE);
} else
msg (MSG_ERR,
"wiringPiSetup: /dev/gpiomem doesn't exist. Please try again with sudo.\n");

5
wiringPi/odroidc2.c
View File

@@ -701,15 +701,12 @@ static void init_gpio_mmap (void)
msg (MSG_ERR,
"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",
strerror (errno));
setUsingGpioMem( TRUE );
setUsingGpiomem(TRUE);
} else
msg (MSG_ERR,
"wiringPiSetup: /dev/gpiomem doesn't exist. Please try again with sudo.\n");
}
if (fd < 0) {
msg(MSG_ERR, "wiringPiSetup: Cannot open memory area for GPIO use. \n");
} else {

13
wiringPi/odroidc4.c
View File

@@ -112,8 +112,8 @@ static int gpioToMuxReg (int pin);
// wiringPi core function
/*----------------------------------------------------------------------------*/
static int _getModeToGpio (int mode, int pin);
static int _setPadDrive (int pin, int value);
static int _getPadDrive (int pin);
static int _setDrive (int pin, int value);
static int _getDrive (int pin);
static int _pinMode (int pin, int mode);
static int _getAlt (int pin);
static int _getPUPD (int pin);
@@ -303,7 +303,7 @@ static int _getModeToGpio (int mode, int pin)
}
/*----------------------------------------------------------------------------*/
static int _setPadDrive (int pin, int value)
static int _setDrive (int pin, int value)
{
int ds, shift;
@@ -329,7 +329,7 @@ static int _setPadDrive (int pin, int value)
}
/*----------------------------------------------------------------------------*/
static int _getPadDrive (int pin)
static int _getDrive (int pin)
{
int ds, shift;
@@ -633,6 +633,7 @@ static void init_gpio_mmap (void)
msg (MSG_ERR,
"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",
strerror (errno));
setUsingGpiomem(TRUE);
} else
msg (MSG_ERR,
"wiringPiSetup: /dev/gpiomem doesn't exist. Please try again with sudo.\n");
@@ -681,8 +682,8 @@ void init_odroidc4 (struct libodroid *libwiring)
/* wiringPi Core function initialize */
libwiring->getModeToGpio = _getModeToGpio;
libwiring->setPadDrive = _setPadDrive;
libwiring->getPadDrive = _getPadDrive;
libwiring->setDrive = _setDrive;
libwiring->getDrive = _getDrive;
libwiring->pinMode = _pinMode;
libwiring->getAlt = _getAlt;
libwiring->getPUPD = _getPUPD;

3
wiringPi/odroidn1.c
View File

@@ -676,8 +676,7 @@ static void init_gpio_mmap (void)
msg (MSG_ERR,
"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",
strerror (errno));
setUsingGpioMem( TRUE );
setUsingGpiomem(TRUE);
} else
msg (MSG_ERR,
"wiringPiSetup: /dev/gpiomem doesn't exist. Please try again with sudo.\n");

20
wiringPi/odroidn2.c
View File

@@ -193,8 +193,8 @@ static int gpioTophysPin (int pin) UNU;
// wiringPi core function
/*----------------------------------------------------------------------------*/
static int _getModeToGpio (int mode, int pin);
static int _setPadDrive (int pin, int value);
static int _getPadDrive (int pin);
static int _setDrive (int pin, int value);
static int _getDrive (int pin);
static int _pinMode (int pin, int mode);
static int _getAlt (int pin);
static int _getPUPD (int pin);
@@ -383,7 +383,7 @@ static int _getModeToGpio (int mode, int pin)
}
/*----------------------------------------------------------------------------*/
static int _setPadDrive (int pin, int value)
static int _setDrive (int pin, int value)
{
int ds, shift;
@@ -409,7 +409,7 @@ static int _setPadDrive (int pin, int value)
}
/*----------------------------------------------------------------------------*/
static int _getPadDrive (int pin)
static int _getDrive (int pin)
{
int ds, shift;
@@ -472,7 +472,7 @@ static int _pinMode (int pin, int mode)
softToneCreate (origPin);
break;
case PWM_OUTPUT:
usingGpioMemCheck ("pinMode PWM");
usingGpiomemCheck("pinMode PWM");
int pwm_pin, alt;
pwm_pin = gpioToPwmPin(pin);
@@ -495,7 +495,6 @@ static int _pinMode (int pin, int mode)
_pwmSetClock(120);
_pwmSetRange(500);
#endif
break;
default:
msg(MSG_WARN, "%s : Unknown Mode %d\n", __func__, mode);
@@ -646,8 +645,6 @@ static int _pwmWrite (int pin, int value)
* struct wiringPiNodeStruct *node = wiringPiNodes;
*/
setupCheck ("pwmWrite") ;
if (lib->mode == MODE_GPIO_SYS)
return -1;
@@ -806,8 +803,7 @@ static void init_gpio_mmap (void)
msg(MSG_ERR,
"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",
strerror (errno));
setUsingGpioMem( TRUE );
setUsingGpiomem(TRUE);
} else
msg(MSG_ERR,
"wiringPiSetup: /dev/gpiomem doesn't exist. Please try again with sudo.\n");
@@ -865,8 +861,8 @@ void init_odroidn2 (struct libodroid *libwiring)
/* wiringPi Core function initialize */
libwiring->getModeToGpio = _getModeToGpio;
libwiring->setPadDrive = _setPadDrive;
libwiring->getPadDrive = _getPadDrive;
libwiring->setDrive = _setDrive;
libwiring->getDrive = _getDrive;
libwiring->pinMode = _pinMode;
libwiring->getAlt = _getAlt;
libwiring->getPUPD = _getPUPD;

15
wiringPi/odroidxu3.c
View File

@@ -109,8 +109,8 @@ static int gpioToDSReg (int pin);
// wiringPi core function
/*----------------------------------------------------------------------------*/
static int _getModeToGpio (int mode, int pin);
static int _setPadDrive (int pin, int value);
static int _getPadDrive (int pin);
static int _setDrive (int pin, int value);
static int _getDrive (int pin);
static int _pinMode (int pin, int mode);
static int _getAlt (int pin);
static int _getPUPD (int pin);
@@ -284,7 +284,7 @@ static int _getModeToGpio (int mode, int pin)
}
/*----------------------------------------------------------------------------*/
static int _setPadDrive (int pin, int value)
static int _setDrive (int pin, int value)
{
int ds, shift;
@@ -314,7 +314,7 @@ static int _setPadDrive (int pin, int value)
}
/*----------------------------------------------------------------------------*/
static int _getPadDrive (int pin)
static int _getDrive (int pin)
{
int ds, shift;
@@ -682,8 +682,7 @@ static void init_gpio_mmap (void)
msg (MSG_ERR,
"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",
strerror (errno));
setUsingGpioMem( TRUE );
setUsingGpiomem(TRUE);
} else
msg (MSG_ERR,
"wiringPiSetup: /dev/gpiomem doesn't exist. Please try again with sudo.\n");
@@ -737,8 +736,8 @@ void init_odroidxu3 (struct libodroid *libwiring)
/* wiringPi Core function initialize */
libwiring->getModeToGpio = _getModeToGpio;
libwiring->setPadDrive = _setPadDrive;
libwiring->getPadDrive = _getPadDrive;
libwiring->setDrive = _setDrive;
libwiring->getDrive = _getDrive;
libwiring->pinMode = _pinMode;
libwiring->getAlt = _getAlt;
libwiring->getPUPD = _getPUPD;

103
wiringPi/wiringPi.c
View File

@@ -125,13 +125,11 @@ int pthread_cancel(pthread_t h) {
// Debugging & Return codes
int wiringPiDebug = FALSE ;
int wiringPiReturnCodes = FALSE ;
int wiringPiSetuped = FALSE ;
// ODROID Wiring Library
struct libodroid libwiring;
unsigned int usingGpioMem = FALSE;
int wiringPiSetuped = FALSE;
/*----------------------------------------------------------------------------*/
//
// Return true/false if the supplied module is loaded
@@ -221,7 +219,7 @@ int wiringPiFailure (int fatal, const char *message, ...)
* function. Mosty because they need feeding C drip by drip )-:
*/
/*----------------------------------------------------------------------------*/
void setupCheck (const char *fName)
void setupCheck(const char *fName)
{
if (!wiringPiSetuped) {
fprintf (stderr, "%s: You have not called one of the wiringPiSetup\n"
@@ -232,23 +230,22 @@ void setupCheck (const char *fName)
/*----------------------------------------------------------------------------*/
/*
* gpioMemCheck:
* usingGpiomemCheck: setUsingGpiomem:
* See if we're using the /dev/gpiomem interface, if-so then some operations
* can't be done and will crash the Pi.
*/
/*----------------------------------------------------------------------------*/
void usingGpioMemCheck (const char *what)
void usingGpiomemCheck(const char *what)
{
if (usingGpioMem) {
fprintf (stderr, "%s: Unable to do this when using /dev/gpiomem. Try sudo?\n", what) ;
exit (EXIT_FAILURE) ;
if (libwiring.usingGpiomem) {
fprintf (stderr, "%s: Unable to do this when using /dev/gpiomem. Try sudo?\n", what) ;
exit (EXIT_FAILURE) ;
}
}
/*----------------------------------------------------------------------------*/
void setUsingGpioMem( const unsigned int value )
void setUsingGpiomem(const unsigned int value)
{
usingGpioMem = value;
libwiring.usingGpiomem = value;
}
/*----------------------------------------------------------------------------*/
@@ -436,6 +433,8 @@ void piBoardId (int *model, int *rev, int *mem, int *maker, int *warranty)
/*----------------------------------------------------------------------------*/
int wpiPinToGpio (int wpiPin)
{
setupCheck(__func__);
if (libwiring.getModeToGpio)
return libwiring.getModeToGpio(MODE_PINS, wpiPin);
@@ -451,6 +450,8 @@ int wpiPinToGpio (int wpiPin)
/*----------------------------------------------------------------------------*/
int physPinToGpio (int physPin)
{
setupCheck(__func__);
if (libwiring.getModeToGpio)
return libwiring.getModeToGpio(MODE_PHYS, physPin);
@@ -459,27 +460,31 @@ int physPinToGpio (int physPin)
/*----------------------------------------------------------------------------*/
/*
* setPadDrive:
* Set the PAD driver value
* setDrive:
* Set the pin driver value
*/
/*----------------------------------------------------------------------------*/
void setPadDrive (int pin, int value)
void setDrive (int pin, int value)
{
if (libwiring.setPadDrive)
if (libwiring.setPadDrive(pin, value) < 0)
setupCheck(__func__);
if (libwiring.setDrive)
if (libwiring.setDrive(pin, value) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin);
}
/*----------------------------------------------------------------------------*/
/*
* getPadDrive:
* Get the PAD driver value
* getDrive:
* Get the pin driver value
*/
/*----------------------------------------------------------------------------*/
int getPadDrive (int pin)
int getDrive (int pin)
{
if (libwiring.getPadDrive)
return libwiring.getPadDrive(pin);
setupCheck(__func__);
if (libwiring.getDrive)
return libwiring.getDrive(pin);
return -1;
}
@@ -493,28 +498,14 @@ int getPadDrive (int pin)
/*----------------------------------------------------------------------------*/
int getAlt (int pin)
{
setupCheck(__func__);
if (libwiring.getAlt)
return libwiring.getAlt(pin);
return -1;
}
/*----------------------------------------------------------------------------*/
/*
* pwmSetMode:
* Select the native "balanced" mode, or standard mark:space mode
*/
/*----------------------------------------------------------------------------*/
void pwmSetMode (int mode)
{
if (libwiring.pwmSetMode) {
libwiring.pwmSetMode(mode);
} else {
warn_msg(__func__);
}
}
/*----------------------------------------------------------------------------*/
/*
* pwmSetRange:
@@ -522,9 +513,10 @@ void pwmSetMode (int mode)
* value. If you want different in your own code, then write your own.
*/
/*----------------------------------------------------------------------------*/
void pwmSetRange (unsigned int range)
{
setupCheck(__func__);
if (libwiring.pwmSetRange) {
libwiring.pwmSetRange(range);
} else {
@@ -540,9 +532,10 @@ void pwmSetRange (unsigned int range)
* after further study of the manual and testing with a 'scope
*/
/*----------------------------------------------------------------------------*/
void pwmSetClock (int divisor)
{
setupCheck(__func__);
if (libwiring.pwmSetClock) {
libwiring.pwmSetClock(divisor);
} else {
@@ -559,6 +552,8 @@ void pwmSetClock (int divisor)
/*----------------------------------------------------------------------------*/
int getPUPD (int pin)
{
setupCheck(__func__);
if (libwiring.getPUPD)
return libwiring.getPUPD(pin);
@@ -572,6 +567,8 @@ int getPUPD (int pin)
/*----------------------------------------------------------------------------*/
void pinMode (int pin, int mode)
{
setupCheck(__func__);
if (libwiring.pinMode)
if (libwiring.pinMode(pin, mode) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin);
@@ -581,6 +578,8 @@ void pinMode (int pin, int mode)
/*----------------------------------------------------------------------------*/
void pullUpDnControl (int pin, int pud)
{
setupCheck(__func__);
if (libwiring.pullUpDnControl)
if (libwiring.pullUpDnControl(pin, pud) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin);
@@ -589,6 +588,8 @@ void pullUpDnControl (int pin, int pud)
/*----------------------------------------------------------------------------*/
int digitalRead (int pin)
{
setupCheck(__func__);
if (libwiring.digitalRead)
return libwiring.digitalRead(pin);
@@ -598,6 +599,8 @@ int digitalRead (int pin)
/*----------------------------------------------------------------------------*/
void digitalWrite (int pin, int value)
{
setupCheck(__func__);
if (libwiring.digitalWrite)
if (libwiring.digitalWrite(pin, value) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin);
@@ -606,6 +609,8 @@ void digitalWrite (int pin, int value)
/*----------------------------------------------------------------------------*/
void pwmWrite(int pin, int value)
{
setupCheck(__func__);
if (libwiring.pwmWrite) {
if (libwiring.pwmWrite(pin, value) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin);
@@ -617,6 +622,8 @@ void pwmWrite(int pin, int value)
/*----------------------------------------------------------------------------*/
int analogRead (int pin)
{
setupCheck(__func__);
if (libwiring.analogRead)
return libwiring.analogRead(pin);
@@ -626,6 +633,8 @@ int analogRead (int pin)
/*----------------------------------------------------------------------------*/
void digitalWriteByte (const int value)
{
setupCheck(__func__);
if (libwiring.digitalWriteByte)
if (libwiring.digitalWriteByte(value) < 0)
msg(MSG_WARN, "%s: Not available. \n", __func__);
@@ -634,6 +643,8 @@ void digitalWriteByte (const int value)
/*----------------------------------------------------------------------------*/
unsigned int digitalReadByte (void)
{
setupCheck(__func__);
if (libwiring.digitalReadByte)
return libwiring.digitalReadByte();
@@ -696,10 +707,8 @@ static void *interruptHandler (void *arg)
int wiringPiISR (int pin, int mode, void (*function)(void))
{
pthread_t threadId;
const char *modeS;
char fName [64];
char pinS [8];
pid_t pid;
int count, i;
char c;
int GpioPin;
@@ -724,13 +733,6 @@ int wiringPiISR (int pin, int mode, void (*function)(void))
// is a way that will work when we're running in "Sys" mode, as
// a non-root user. (without sudo)
if (mode != INT_EDGE_SETUP) {
if (mode == INT_EDGE_FALLING)
modeS = "falling" ;
else if (mode == INT_EDGE_RISING)
modeS = "rising" ;
else
modeS = "both" ;
sprintf (pinS, "%d", GpioPin) ;
FILE *export, *direct, *edge;
@@ -968,9 +970,9 @@ void wiringPiVersion (int *major, char **minor)
int wiringPiSetup (void)
{
int i;
if (wiringPiSetuped)
return 0;
wiringPiSetuped = TRUE;
// libwiring init
@@ -980,6 +982,7 @@ int wiringPiSetup (void)
libwiring.sysFds[i] = -1;
// init wiringPi mode
libwiring.mode = MODE_UNINITIALISED;
libwiring.usingGpiomem = FALSE;
if (getenv (ENV_DEBUG) != NULL)
wiringPiDebug = TRUE;

24
wiringPi/wiringPi.h
View File

@@ -36,10 +36,9 @@
#define FALSE (!TRUE)
#endif
#define UNU __attribute__((unused))
#define PIN_NUM_CALC_SYSFD(X) (X > 255 ? X - libwiring.pinBase : X)
#define UNU __attribute__((unused))
#define ENV_DEBUG "WIRINGPI_DEBUG"
#define ENV_CODES "WIRINGPI_CODES"
#define ENV_GPIOMEM "WIRINGPI_GPIOMEM"
@@ -83,10 +82,6 @@
#define PUD_DOWN 1
#define PUD_UP 2
// PWM
#define PWM_MODE_MS 0
#define PWM_MODE_BAL 1
// Interrupt levels
#define INT_EDGE_SETUP 0
#define INT_EDGE_FALLING 1
@@ -131,8 +126,8 @@ struct libodroid
/* wiringPi core func */
int (*getModeToGpio) (int mode, int pin);
int (*setPadDrive) (int pin, int value);
int (*getPadDrive) (int pin);
int (*setDrive) (int pin, int value);
int (*getDrive) (int pin);
int (*pinMode) (int pin, int mode);
int (*getAlt) (int pin);
int (*getPUPD) (int pin);
@@ -143,7 +138,6 @@ struct libodroid
int (*analogRead) (int pin);
int (*digitalWriteByte) (const unsigned int value);
unsigned int (*digitalReadByte) (void);
void (*pwmSetMode) (int mode);
void (*pwmSetRange) (unsigned int range);
void (*pwmSetClock) (int divisor);
@@ -157,6 +151,9 @@ struct libodroid
/* GPIO pin base number */
int pinBase;
/* Running with gpiomem */
char usingGpiomem;
// Time for easy calculations
uint64_t epochMilli, epochMicro ;
};
@@ -213,8 +210,8 @@ extern int wiringPiFailure (int fatal, const char *message, ...);
extern int msg (int type, const char *message, ...);
extern int moduleLoaded (char *);
extern void setupCheck (const char *fName);
extern void usingGpioMemCheck (const char *what);
extern void setUsingGpioMem (const unsigned int value);
extern void usingGpiomemCheck (const char *what);
extern void setUsingGpiomem (const unsigned int value);
// Core WiringPi functions
extern void wiringPiVersion (int *major, char **minor);
@@ -223,8 +220,8 @@ extern int wiringPiSetupSys (void);
extern int wiringPiSetupGpio (void);
extern int wiringPiSetupPhys (void);
extern void setPadDrive (int pin, int value);
extern int getPadDrive (int pin);
extern void setDrive (int pin, int value);
extern int getDrive (int pin);
extern int getAlt (int pin);
extern int getPUPD (int pin);
extern void pinMode (int pin, int mode);
@@ -242,7 +239,6 @@ extern void piBoardId (int *model, int *rev, int *mem, int *maker, int *warran
extern int wpiPinToGpio (int wpiPin);
extern int physPinToGpio (int physPin);
extern void pwmSetMode (int mode);
extern void pwmSetRange (unsigned int range);
extern void pwmSetClock (int divisor);