void digitalWrite(int pin, int value) {
if(platform != NULL) {
if(platform->digitalWrite) {
if(platform->digitalWrite(pin, value) == -1) {
wiringXLog(LOG_ERR, "%s: error while calling digitalWrite", platform->name);
wiringXGC();
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support digitalWrite", platform->name);
wiringXGC();
}
}
}
void pinMode(int pin, int mode) {
if(device) {
if(device->pinMode) {
if(device->pinMode(pin, mode) == -1) {
fprintf(stderr, "%s: error while calling pinMode\n", device->name);
wiringXGC();
}
} else {
fprintf(stderr, "%s: device doesn't support pinMode\n", device->name);
wiringXGC();
}
}
}
void pinMode(int pin, int mode) {
if(platform != NULL) {
if(platform->pinMode) {
if(platform->pinMode(pin, mode) == -1) {
wiringXLog(LOG_ERR, "%s: error while calling pinMode", platform->name);
wiringXGC();
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support pinMode", platform->name);
wiringXGC();
}
}
}
void digitalWrite(int pin, int value) {
if(device) {
if(device->digitalWrite) {
if(device->digitalWrite(pin, value) == -1) {
fprintf(stderr, "%s: error while calling digitalWrite\n", device->name);
wiringXGC();
}
} else {
fprintf(stderr, "%s: device doesn't support digitalWrite\n", device->name);
wiringXGC();
}
}
}
int wiringXSetup(void) {
if(setup == -2) {
hummingboardInit();
raspberrypiInit();
bananapiInit();
radxaInit();
int match = 0;
struct devices_t *tmp = devices;
while(tmp) {
if(tmp->identify() >= 0) {
device = tmp;
match = 1;
break;
}
tmp = tmp->next;
}
if(match == 0) {
fprintf(stderr, "wiringX: hardware not supported\n");
wiringXGC();
return -1;
}
printf("running on a %s\n", device->name);
setup = device->setup();
return setup;
} else {
return setup;
}
}
int wiringXSPISetup(int channel, int speed) {
if(platform != NULL) {
if(platform->SPISetup) {
int x = platform->SPISetup(channel, speed);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling SPISetup", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support SPISetup", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXI2CSetup(int devId) {
if(platform != NULL) {
if(platform->I2CSetup) {
int x = platform->I2CSetup(devId);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling I2CSetup", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support I2CSetup", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXSPIDataRW(int channel, unsigned char *data, int len) {
if(platform != NULL) {
if(platform->SPIDataRW) {
int x = platform->SPIDataRW(channel, data, len);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling SPIDataRW", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support SPIDataRW", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXI2CWriteReg16(int fd, int reg, int data) {
if(platform != NULL) {
if(platform->I2CWriteReg16) {
int x = platform->I2CWriteReg16(fd, reg, data);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling I2CWriteReg16", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support I2CWriteReg16", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXI2CReadReg8(int fd, int reg) {
if(platform != NULL) {
if(platform->I2CReadReg8) {
int x = platform->I2CReadReg8(fd, reg);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling I2CReadReg8", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support I2CReadReg8", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXISR(int pin, int mode) {
if(platform != NULL) {
if(platform->isr) {
int x = platform->isr(pin, mode);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling isr", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support isr", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXAnalogRead(int channel){
if(platform != NULL) {
if(platform->analogRead) {
int x = platform->analogRead(channel);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling analogRead", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support analogRead", platform->name);
wiringXGC();
}
}
return -1;
}
int digitalRead(int pin) {
if(device) {
if(device->digitalRead) {
int x = device->digitalRead(pin);
if(x == -1) {
fprintf(stderr, "%s: error while calling digitalRead\n", device->name);
wiringXGC();
} else {
return x;
}
} else {
fprintf(stderr, "%s: device doesn't support digitalRead\n", device->name);
wiringXGC();
}
}
return -1;
}
int digitalRead(int pin) {
if(platform != NULL) {
if(platform->digitalRead) {
int x = platform->digitalRead(pin);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling digitalRead", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support digitalRead", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXI2CWriteReg16(int fd, int reg, int data) {
if(device) {
if(device->I2CWriteReg16) {
int x = device->I2CWriteReg16(fd, reg, data);
if(x == -1) {
fprintf(stderr, "%s: error while calling I2CWriteReg16\n", device->name);
wiringXGC();
} else {
return x;
}
} else {
fprintf(stderr, "%s: device doesn't support I2CWriteReg16\n", device->name);
wiringXGC();
}
}
return -1;
}
int wiringXI2CSetup(int devId) {
if(device) {
if(device->I2CSetup) {
int x = device->I2CSetup(devId);
if(x == -1) {
fprintf(stderr, "%s: error while calling I2CSetup\n", device->name);
wiringXGC();
} else {
return x;
}
} else {
fprintf(stderr, "%s: device doesn't support I2CSetup\n", device->name);
wiringXGC();
}
}
return -1;
}
int wiringXI2CReadReg8(int fd, int reg) {
if(device) {
if(device->I2CReadReg8) {
int x = device->I2CReadReg8(fd, reg);
if(x == -1) {
fprintf(stderr, "%s: error while calling I2CReadReg8\n", device->name);
wiringXGC();
} else {
return x;
}
} else {
fprintf(stderr, "%s: device doesn't support I2CReadReg8\n", device->name);
wiringXGC();
}
}
return -1;
}
int wiringXISR(int pin, int mode) {
if(device) {
if(device->isr) {
int x = device->isr(pin, mode);
if(x == -1) {
fprintf(stderr, "%s: error while calling isr\n", device->name);
wiringXGC();
} else {
return x;
}
} else {
fprintf(stderr, "%s: device doesn't support isr\n", device->name);
wiringXGC();
}
}
return -1;
}
int waitForInterrupt(int pin, int ms) {
if(device) {
if(device->waitForInterrupt) {
int x = device->waitForInterrupt(pin, ms);
if(x == -1) {
fprintf(stderr, "%s: error while calling waitForInterrupt\n", device->name);
wiringXGC();
} else {
return x;
}
} else {
fprintf(stderr, "%s: device doesn't support waitForInterrupt\n", device->name);
wiringXGC();
}
}
return -1;
}
int waitForInterrupt(int pin, int ms) {
if(platform != NULL) {
if(platform->waitForInterrupt) {
int x = platform->waitForInterrupt(pin, ms);
if(x == -1) {
wiringXLog(LOG_ERR, "%s: error while calling waitForInterrupt", platform->name);
wiringXGC();
} else {
return x;
}
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support waitForInterrupt", platform->name);
wiringXGC();
}
}
return -1;
}
void Java_eu_jm0_wiringX_wiringX_GC(JNIEnv *env, jclass c) {
// call original function
wiringXGC();
// free handle on logger
deregisterLogConsumer();
// clear object cache
cache_clear(env);
}
int wiringXValidGPIO(int gpio) {
if(platform != NULL) {
if(platform->validGPIO) {
return platform->validGPIO(gpio);
} else {
wiringXLog(LOG_ERR, "%s: platform doesn't support gpio number validation", platform->name);
wiringXGC();
}
}
return -1;
}
int wiringXValidGPIO(int gpio) {
if(device) {
if(device->validGPIO) {
return device->validGPIO(gpio);
} else {
fprintf(stderr, "%s: device doesn't support gpio number validation\n", device->name);
wiringXGC();
}
}
return -1;
}
int main(void) {
int data = 0;
if(wiringXSetup("pcduino1", NULL) == -1) {
wiringXGC();
return -1;
}
while(1) {
data = wiringXAnalogRead(0);
printf("result:%d\n", data);
data = wiringXAnalogRead(1);
printf("result:%d\n", data);
data = wiringXAnalogRead(2);
printf("result:%d\n", data);
sleep(2);
}
}
int wiringXSetup(void) {
#ifndef _WIN32
if(wiringXLog == NULL) {
wiringXLog = _fprintf;
}
if(wiringXSupported() == 0) {
if(setup == -2) {
hummingboardInit();
raspberrypiInit();
bananapiInit();
ci20Init();
radxaInit();
odroidInit();
int match = 0;
struct platform_t *tmp = platforms;
while(tmp) {
if(tmp->identify() >= 0) {
platform = tmp;
match = 1;
break;
}
tmp = tmp->next;
}
if(match == 0) {
wiringXLog(LOG_ERR, "hardware not supported");
wiringXGC();
return -1;
} else {
wiringXLog(LOG_DEBUG, "running on a %s", platform->name);
}
setup = platform->setup();
return setup;
} else {
return setup;
}
}
#endif
return -1;
}
int main(int argc, char *argv[]) {
pthread_t pth;
char *str = NULL, *platform = NULL;
char usagestr[190];
int gpio_out = 0, gpio_in = 0;
int i = 0, err = 0, invalid = 0;
memset(usagestr, '\0', 190);
// expect 2 arguments => argc must be 3
if(argc != 4) {
snprintf(usagestr, 189, usage, argv[0], argv[0]);
puts(usagestr);
return -1;
}
// check for valid, numeric arguments
for(i=2; i<argc; i++) {
str = argv[i];
while(*str != '\0') {
if(!isdigit(*str)) {
invalid = 1;
}
str++;
}
if(invalid == 1) {
printf("%s: Invalid GPIO %s\n", argv[0], argv[i]);
return -1;
}
}
platform = argv[1];
gpio_out = atoi(argv[2]);
gpio_in = atoi(argv[3]);
if(gpio_out == gpio_in) {
printf("%s: GPIO for output and input (interrupt) should not be the same\n", argv[0]);
return -1;
}
if(wiringXSetup(platform, NULL) == -1) {
wiringXGC();
return -1;
}
if(wiringXValidGPIO(gpio_out) != 0) {
printf("%s: Invalid GPIO %d for output\n", argv[0], gpio_out);
wiringXGC();
return -1;
}
if(wiringXValidGPIO(gpio_in) != 0) {
printf("%s: Invalid GPIO %d for input (interrupt)\n", argv[0], gpio_in);
wiringXGC();
return -1;
}
pinMode(gpio_out, PINMODE_OUTPUT);
if((wiringXISR(gpio_in, ISR_MODE_BOTH)) != 0) {
printf("%s: Cannot set GPIO %d to interrupt BOTH\n", argv[0], gpio_in);
wiringXGC();
return -1;
}
err = pthread_create(&pth, NULL, interrupt, &gpio_in);
if(err != 0) {
printf("Can't create thread: [%s]\n", strerror(err));
wiringXGC();
return -1;
} else {
printf("Thread created succesfully\n");
}
for(i=0; i<5; i++) {
printf(" Writing to GPIO %d: High\n", gpio_out);
digitalWrite(gpio_out, HIGH);
sleep(1);
printf(" Writing to GPIO %d: Low\n", gpio_out);
digitalWrite(gpio_out, LOW);
sleep(2);
}
printf("Main finished, waiting for thread ...\n");
pthread_join(pth, NULL);
wiringXGC();
return 0;
}
static int createCode(JsonNode *code) {
int free_def = 0;
int gpio = -1;
int state = -1;
double itmp = -1;
char *def = NULL;
int have_error = 0;
relay->rawlen = 0;
if(json_find_string(code, "default-state", &def) != 0) {
if((def = MALLOC(4)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(def, "off");
free_def = 1;
}
if(json_find_number(code, "gpio", &itmp) == 0)
gpio = (int)round(itmp);
if(json_find_number(code, "off", &itmp) == 0)
state=0;
else if(json_find_number(code, "on", &itmp) == 0)
state=1;
if(gpio == -1 || state == -1) {
logprintf(LOG_ERR, "relay: insufficient number of arguments");
have_error = 1;
goto clear;
} else if(wiringXSupported() == 0) {
if(wiringXSetup() < 0) {
logprintf(LOG_ERR, "unable to setup wiringX") ;
return EXIT_FAILURE;
} else {
if(wiringXValidGPIO(gpio) != 0) {
logprintf(LOG_ERR, "relay: invalid gpio range");
have_error = 1;
goto clear;
} else {
if(strstr(progname, "daemon") != NULL) {
pinMode(gpio, OUTPUT);
if(strcmp(def, "off") == 0) {
if(state == 1) {
digitalWrite(gpio, LOW);
} else if(state == 0) {
digitalWrite(gpio, HIGH);
}
} else {
if(state == 0) {
digitalWrite(gpio, LOW);
} else if(state == 1) {
digitalWrite(gpio, HIGH);
}
}
} else {
wiringXGC();
}
createMessage(gpio, state);
goto clear;
}
}
}
clear:
if(free_def == 1) {
FREE(def);
}
if(have_error) {
return EXIT_FAILURE;
} else {
return EXIT_SUCCESS;
}
}
