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 export/edge/unexport ...\n"
" gpio wfi <pin> <mode>\n" " gpio wfi <pin> <mode>\n"
" gpio drive <pin> <value>\n" " gpio drive <pin> <value>\n"
" gpio pwm-bal/pwm-ms \n"
" gpio pwmr <range> \n" " gpio pwmr <range> \n"
" gpio pwmc <divider> \n" " gpio pwmc <divider> \n"
" gpio load spi/i2c\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 * 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; int pin, val;
@@ -580,7 +579,7 @@ static void doPadDrive (int argc, char *argv [])
pin = atoi (argv [2]) ; pin = atoi (argv [2]) ;
val = atoi (argv [3]) ; 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 * Change the PWM mode, range and clock divider values
********************************************************************************* *********************************************************************************
*/ */
static void doPwmMode (int mode)
{
pwmSetMode (mode) ;
}
static void doPwmRange (int argc, char *argv []) static void doPwmRange (int argc, char *argv [])
{ {
unsigned int range ; unsigned int range ;
@@ -984,11 +978,9 @@ int main (int argc, char *argv [])
else if (strcasecmp (argv [1], "blink" ) == 0) doBlink (argc, argv) ; else if (strcasecmp (argv [1], "blink" ) == 0) doBlink (argc, argv) ;
// Pi Specifics // 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], "pwmr" ) == 0) doPwmRange (argc, argv) ;
else if (strcasecmp (argv [1], "pwmc" ) == 0) doPwmClock (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], "readall" ) == 0) doReadall (argc, argv) ;
else if (strcasecmp (argv [1], "nreadall" ) == 0) doReadall (argc, argv) ; else if (strcasecmp (argv [1], "nreadall" ) == 0) doReadall (argc, argv) ;
else if (strcasecmp (argv [1], "i2cdetect") == 0) doI2Cdetect (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_XU3:
case MODEL_ODROID_N2: case MODEL_ODROID_N2:
case MODEL_ODROID_C4: case MODEL_ODROID_C4:
printf (" | %2d | %5s", getPadDrive(pin), pupd[getPUPD(pin)]); printf (" | %2d | %5s", getDrive(pin), pupd[getPUPD(pin)]);
break; break;
default: default:
break; 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_XU3:
case MODEL_ODROID_N2: case MODEL_ODROID_N2:
case MODEL_ODROID_C4: case MODEL_ODROID_C4:
printf (" | %-5s | %-2d", pupd[getPUPD(pin)], getPadDrive(pin)); printf (" | %-5s | %-2d", pupd[getPUPD(pin)], getDrive(pin));
break; break;
default: default:
break; break;

3
wiringPi/odroidc1.c
View File

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

13
wiringPi/odroidc4.c
View File

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

3
wiringPi/odroidn1.c
View File

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

15
wiringPi/odroidxu3.c
View File

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

97
wiringPi/wiringPi.c
View File

@@ -125,13 +125,11 @@ int pthread_cancel(pthread_t h) {
// Debugging & Return codes // Debugging & Return codes
int wiringPiDebug = FALSE ; int wiringPiDebug = FALSE ;
int wiringPiReturnCodes = FALSE ; int wiringPiReturnCodes = FALSE ;
int wiringPiSetuped = FALSE ;
// ODROID Wiring Library // ODROID Wiring Library
struct libodroid libwiring; struct libodroid libwiring;
unsigned int usingGpioMem = FALSE;
int wiringPiSetuped = FALSE;
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
// //
// Return true/false if the supplied module is loaded // Return true/false if the supplied module is loaded
@@ -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 * See if we're using the /dev/gpiomem interface, if-so then some operations
* can't be done and will crash the Pi. * can't be done and will crash the Pi.
*/ */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void usingGpioMemCheck (const char *what) void usingGpiomemCheck(const char *what)
{ {
if (usingGpioMem) { if (libwiring.usingGpiomem) {
fprintf (stderr, "%s: Unable to do this when using /dev/gpiomem. Try sudo?\n", what) ; fprintf (stderr, "%s: Unable to do this when using /dev/gpiomem. Try sudo?\n", what) ;
exit (EXIT_FAILURE) ; 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) int wpiPinToGpio (int wpiPin)
{ {
setupCheck(__func__);
if (libwiring.getModeToGpio) if (libwiring.getModeToGpio)
return libwiring.getModeToGpio(MODE_PINS, wpiPin); return libwiring.getModeToGpio(MODE_PINS, wpiPin);
@@ -451,6 +450,8 @@ int wpiPinToGpio (int wpiPin)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
int physPinToGpio (int physPin) int physPinToGpio (int physPin)
{ {
setupCheck(__func__);
if (libwiring.getModeToGpio) if (libwiring.getModeToGpio)
return libwiring.getModeToGpio(MODE_PHYS, physPin); return libwiring.getModeToGpio(MODE_PHYS, physPin);
@@ -459,27 +460,31 @@ int physPinToGpio (int physPin)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* /*
* setPadDrive: * setDrive:
* Set the PAD driver value * Set the pin driver value
*/ */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void setPadDrive (int pin, int value) void setDrive (int pin, int value)
{ {
if (libwiring.setPadDrive) setupCheck(__func__);
if (libwiring.setPadDrive(pin, value) < 0)
if (libwiring.setDrive)
if (libwiring.setDrive(pin, value) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin); msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* /*
* getPadDrive: * getDrive:
* Get the PAD driver value * Get the pin driver value
*/ */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
int getPadDrive (int pin) int getDrive (int pin)
{ {
if (libwiring.getPadDrive) setupCheck(__func__);
return libwiring.getPadDrive(pin);
if (libwiring.getDrive)
return libwiring.getDrive(pin);
return -1; return -1;
} }
@@ -493,28 +498,14 @@ int getPadDrive (int pin)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
int getAlt (int pin) int getAlt (int pin)
{ {
setupCheck(__func__);
if (libwiring.getAlt) if (libwiring.getAlt)
return libwiring.getAlt(pin); return libwiring.getAlt(pin);
return -1; 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: * pwmSetRange:
@@ -522,9 +513,10 @@ void pwmSetMode (int mode)
* value. If you want different in your own code, then write your own. * value. If you want different in your own code, then write your own.
*/ */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void pwmSetRange (unsigned int range) void pwmSetRange (unsigned int range)
{ {
setupCheck(__func__);
if (libwiring.pwmSetRange) { if (libwiring.pwmSetRange) {
libwiring.pwmSetRange(range); libwiring.pwmSetRange(range);
} else { } else {
@@ -540,9 +532,10 @@ void pwmSetRange (unsigned int range)
* after further study of the manual and testing with a 'scope * after further study of the manual and testing with a 'scope
*/ */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void pwmSetClock (int divisor) void pwmSetClock (int divisor)
{ {
setupCheck(__func__);
if (libwiring.pwmSetClock) { if (libwiring.pwmSetClock) {
libwiring.pwmSetClock(divisor); libwiring.pwmSetClock(divisor);
} else { } else {
@@ -559,6 +552,8 @@ void pwmSetClock (int divisor)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
int getPUPD (int pin) int getPUPD (int pin)
{ {
setupCheck(__func__);
if (libwiring.getPUPD) if (libwiring.getPUPD)
return libwiring.getPUPD(pin); return libwiring.getPUPD(pin);
@@ -572,6 +567,8 @@ int getPUPD (int pin)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void pinMode (int pin, int mode) void pinMode (int pin, int mode)
{ {
setupCheck(__func__);
if (libwiring.pinMode) if (libwiring.pinMode)
if (libwiring.pinMode(pin, mode) < 0) if (libwiring.pinMode(pin, mode) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin); 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) void pullUpDnControl (int pin, int pud)
{ {
setupCheck(__func__);
if (libwiring.pullUpDnControl) if (libwiring.pullUpDnControl)
if (libwiring.pullUpDnControl(pin, pud) < 0) if (libwiring.pullUpDnControl(pin, pud) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin); 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) int digitalRead (int pin)
{ {
setupCheck(__func__);
if (libwiring.digitalRead) if (libwiring.digitalRead)
return libwiring.digitalRead(pin); return libwiring.digitalRead(pin);
@@ -598,6 +599,8 @@ int digitalRead (int pin)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void digitalWrite (int pin, int value) void digitalWrite (int pin, int value)
{ {
setupCheck(__func__);
if (libwiring.digitalWrite) if (libwiring.digitalWrite)
if (libwiring.digitalWrite(pin, value) < 0) if (libwiring.digitalWrite(pin, value) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin); 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) void pwmWrite(int pin, int value)
{ {
setupCheck(__func__);
if (libwiring.pwmWrite) { if (libwiring.pwmWrite) {
if (libwiring.pwmWrite(pin, value) < 0) if (libwiring.pwmWrite(pin, value) < 0)
msg(MSG_WARN, "%s: Not available for pin %d. \n", __func__, pin); 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) int analogRead (int pin)
{ {
setupCheck(__func__);
if (libwiring.analogRead) if (libwiring.analogRead)
return libwiring.analogRead(pin); return libwiring.analogRead(pin);
@@ -626,6 +633,8 @@ int analogRead (int pin)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
void digitalWriteByte (const int value) void digitalWriteByte (const int value)
{ {
setupCheck(__func__);
if (libwiring.digitalWriteByte) if (libwiring.digitalWriteByte)
if (libwiring.digitalWriteByte(value) < 0) if (libwiring.digitalWriteByte(value) < 0)
msg(MSG_WARN, "%s: Not available. \n", __func__); msg(MSG_WARN, "%s: Not available. \n", __func__);
@@ -634,6 +643,8 @@ void digitalWriteByte (const int value)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
unsigned int digitalReadByte (void) unsigned int digitalReadByte (void)
{ {
setupCheck(__func__);
if (libwiring.digitalReadByte) if (libwiring.digitalReadByte)
return libwiring.digitalReadByte(); return libwiring.digitalReadByte();
@@ -696,10 +707,8 @@ static void *interruptHandler (void *arg)
int wiringPiISR (int pin, int mode, void (*function)(void)) int wiringPiISR (int pin, int mode, void (*function)(void))
{ {
pthread_t threadId; pthread_t threadId;
const char *modeS;
char fName [64]; char fName [64];
char pinS [8]; char pinS [8];
pid_t pid;
int count, i; int count, i;
char c; char c;
int GpioPin; 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 // is a way that will work when we're running in "Sys" mode, as
// a non-root user. (without sudo) // a non-root user. (without sudo)
if (mode != INT_EDGE_SETUP) { 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) ; sprintf (pinS, "%d", GpioPin) ;
FILE *export, *direct, *edge; FILE *export, *direct, *edge;
@@ -968,9 +970,9 @@ void wiringPiVersion (int *major, char **minor)
int wiringPiSetup (void) int wiringPiSetup (void)
{ {
int i; int i;
if (wiringPiSetuped) if (wiringPiSetuped)
return 0; return 0;
wiringPiSetuped = TRUE; wiringPiSetuped = TRUE;
// libwiring init // libwiring init
@@ -980,6 +982,7 @@ int wiringPiSetup (void)
libwiring.sysFds[i] = -1; libwiring.sysFds[i] = -1;
// init wiringPi mode // init wiringPi mode
libwiring.mode = MODE_UNINITIALISED; libwiring.mode = MODE_UNINITIALISED;
libwiring.usingGpiomem = FALSE;
if (getenv (ENV_DEBUG) != NULL) if (getenv (ENV_DEBUG) != NULL)
wiringPiDebug = TRUE; wiringPiDebug = TRUE;

24
wiringPi/wiringPi.h
View File

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