int main(int argc, char **argv)
{
int usepin;
if (!bcm2835_init())
return 1;
// check board revision and set the pin to be an output
if (get_rpi_revision()==1)
{
usepin = PIN;
} else {
usepin = PIN_V2;
}
bcm2835_gpio_fsel(usepin, BCM2835_GPIO_FSEL_INPT);
while (1)
{
if (bcm2835_gpio_lev(usepin)==LOW)
{
printf("Button state: NOT PRESSED\n");
} else {
printf("Button state: PRESSED\n");
}
// wait a bit
delay(500);
}
return 0;
}
PyMODINIT_FUNC initGPIO(void)
#endif
{
int i;
PyObject *module = NULL;
#if PY_MAJOR_VERSION > 2
if ((module = PyModule_Create(&rpigpiomodule)) == NULL)
return NULL;
#else
if ((module = Py_InitModule3("RPi.GPIO", rpi_gpio_methods, moduledocstring)) == NULL)
return;
#endif
define_constants(module);
for (i=0; i<54; i++)
gpio_direction[i] = -1;
// detect board revision and set up accordingly
revision = get_rpi_revision();
if (revision == -1)
{
PyErr_SetString(PyExc_RuntimeError, "This module can only be run on a Raspberry Pi!");
setup_error = 1;
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
} else if (revision == 1) {
pin_to_gpio = &pin_to_gpio_rev1;
} else if (revision == 2) {
pin_to_gpio = &pin_to_gpio_rev2;
} else { // assume model B+
pin_to_gpio = &pin_to_gpio_rev3;
}
rpi_revision = Py_BuildValue("i", revision);
PyModule_AddObject(module, "RPI_REVISION", rpi_revision);
// Add PWM class
if (PWM_init_PWMType() == NULL)
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
Py_INCREF(&PWMType);
PyModule_AddObject(module, "PWM", (PyObject*)&PWMType);
if (!PyEval_ThreadsInitialized())
PyEval_InitThreads();
// register exit functions - last declared is called first
if (Py_AtExit(cleanup) != 0)
{
setup_error = 1;
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
if (Py_AtExit(event_cleanup_all) != 0)
{
setup_error = 1;
cleanup();
#if PY_MAJOR_VERSION > 2
return NULL;
#else
return;
#endif
}
#if PY_MAJOR_VERSION > 2
return module;
#else
return;
#endif
}
int main(int argc, char *argv[]) {
uint8_t ctr = 0;
GPAD_ST gpads[GPADSNUM];
BTN_DEV_ST button;
int16_t clockpin;
int16_t strobepin;
int16_t data1pin;
int16_t data2pin;
int16_t clockpin_v2;
int16_t strobepin_v2;
int16_t data1pin_v2;
int16_t data2pin_v2;
if (!bcm2835_init())
return 1;
if (readConfigurationfile() != 0 ) {
return 1;
}
if (strcmp(confres.adapter_version,"1x")==0) {
clockpin = RPI_GPIO_P1_19;
strobepin = RPI_GPIO_P1_23;
data1pin = RPI_GPIO_P1_05;
data2pin = RPI_GPIO_P1_07;
clockpin_v2 = RPI_V2_GPIO_P1_19;
strobepin_v2 = RPI_V2_GPIO_P1_23;
data1pin_v2 = RPI_V2_GPIO_P1_05;
data2pin_v2 = RPI_V2_GPIO_P1_07;
printf("[SNESDev-Rpi] Using pin setup for RetroPie GPIO-Adapter Version 1.X\n");
} else if (strcmp(confres.adapter_version,"2x")==0) {
clockpin = RPI_GPIO_P1_16;
strobepin = RPI_GPIO_P1_18;
data1pin = RPI_GPIO_P1_15;
data2pin = RPI_GPIO_P1_13;
clockpin_v2 = RPI_V2_GPIO_P1_16;
strobepin_v2 = RPI_V2_GPIO_P1_18;
data1pin_v2 = RPI_V2_GPIO_P1_15;
data2pin_v2 = RPI_V2_GPIO_P1_13;
printf("[SNESDev-Rpi] Using pin setup for RetroPie GPIO-Adapter Version 2.X\n");
} else {
clockpin = RPI_GPIO_P1_16;
strobepin = RPI_GPIO_P1_18;
data1pin = RPI_GPIO_P1_15;
data2pin = RPI_GPIO_P1_13;
clockpin_v2 = RPI_V2_GPIO_P1_16;
strobepin_v2 = RPI_V2_GPIO_P1_18;
data1pin_v2 = RPI_V2_GPIO_P1_15;
data2pin_v2 = RPI_V2_GPIO_P1_13;
printf("[SNESDev-Rpi] Using pin setup for RetroPie GPIO-Adapter Version 2.X\n");
}
if (confres.gamepad1_enabled || confres.gamepad2_enabled) {
gpads[0].port = 1;
gpads[1].port = 1;
// check board revision and set pins to be used
// these are acutally also used by the gamecon driver
if (get_rpi_revision()==1)
{
gpads[0].pin_clock = clockpin;
gpads[0].pin_strobe = strobepin;
gpads[0].pin_data = data1pin;
gpads[1].pin_clock = clockpin;
gpads[1].pin_strobe = strobepin;
gpads[1].pin_data = data2pin;
} else {
gpads[0].pin_clock = clockpin_v2;
gpads[0].pin_strobe = strobepin_v2;
gpads[0].pin_data = data1pin_v2;
gpads[1].pin_clock = clockpin_v2;
gpads[1].pin_strobe = strobepin_v2;
gpads[1].pin_data = data2pin_v2;
}
if (strcmp(confres.gamepad1_type,"nes")==0) {
gpads[0].type = GPAD_TYPE_NES;
} else {
gpads[0].type = GPAD_TYPE_SNES;
}
if (strcmp(confres.gamepad2_type,"nes")==0) {
gpads[1].type = GPAD_TYPE_NES;
} else {
gpads[1].type = GPAD_TYPE_SNES;
}
if (confres.gamepad1_enabled) {
printf("[SNESDev-Rpi] Enabling game pad 1 with type '%s'.\n", confres.gamepad1_type);
gpad_open(&gpads[0]);
switch (gpads->type) {
case GPAD_TYPE_SNES:
uinput_gpad_open(&uinp_gpads[0], UINPUT_GPAD_TYPE_SNES);
break;
case GPAD_TYPE_NES:
uinput_gpad_open(&uinp_gpads[0], UINPUT_GPAD_TYPE_NES);
break;
default:
break;
}
}
if (confres.gamepad2_enabled) {
printf("[SNESDev-Rpi] Enabling game pad 2 with type '%s'.\n", confres.gamepad2_type);
gpad_open(&gpads[1]);
switch (gpads->type) {
case GPAD_TYPE_SNES:
uinput_gpad_open(&uinp_gpads[1], UINPUT_GPAD_TYPE_SNES);
break;
case GPAD_TYPE_NES:
uinput_gpad_open(&uinp_gpads[1], UINPUT_GPAD_TYPE_NES);
break;
default:
break;
}
}
}
if (confres.button_enabled) {
printf("[SNESDev-Rpi] Enabling button.\n");
button.port = 1;
if (get_rpi_revision()==1) {
button.pin = BUTTONPIN;
} else {
button.pin = BUTTONPIN_V2;
}
btn_open(&button);
uinput_kbd_open(&uinp_kbd);
}
register_signalhandlers();
///* enter the main loop */
doRun = 1;
while (doRun) {
if (confres.gamepad1_enabled || confres.gamepad2_enabled) {
/* read states of the buttons */
for (ctr = 0; ctr < GPADSNUM; ctr++) {
gpad_read(&gpads[ctr]);
}
///* send an event (pressed or released) for each button */
for (ctr = 0; ctr < GPADSNUM; ctr++) {
if ((ctr==0 && !(confres.gamepad1_enabled)) ||
(ctr==1 && !(confres.gamepad2_enabled))) {
continue;
}
gpad_read(&gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_A, BTN_A,
&uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_B, BTN_B,
&uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_X, BTN_X,
&uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_Y, BTN_Y,
&uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_L, BTN_TL,
&uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_R, BTN_TR,
&uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_SELECT,
BTN_SELECT, &uinp_gpads[ctr]);
processPadBtn(gpads[ctr].state, EV_KEY, GPAD_SNES_START,
BTN_START, &uinp_gpads[ctr]);
if ((gpads[ctr].state & GPAD_SNES_LEFT) == GPAD_SNES_LEFT) {
uinput_gpad_write(&uinp_gpads[ctr], ABS_X, 0, EV_ABS);
} else if ((gpads[ctr].state & GPAD_SNES_RIGHT) == GPAD_SNES_RIGHT) {
uinput_gpad_write(&uinp_gpads[ctr], ABS_X, 4, EV_ABS);
} else {
uinput_gpad_write(&uinp_gpads[ctr], ABS_X, 2, EV_ABS);
}
if ((gpads[ctr].state & GPAD_SNES_UP) == GPAD_SNES_UP) {
uinput_gpad_write(&uinp_gpads[ctr], ABS_Y, 0, EV_ABS);
} else if ((gpads[ctr].state & GPAD_SNES_DOWN) == GPAD_SNES_DOWN) {
uinput_gpad_write(&uinp_gpads[ctr], ABS_Y, 4, EV_ABS);
} else {
uinput_gpad_write(&uinp_gpads[ctr], ABS_Y, 2, EV_ABS);
}
}
}
if (confres.button_enabled) {
btn_read(&button);
switch (button.state) {
case BTN_STATE_IDLE:
break;
case BTN_STATE_PRESSED:
if (button.pressedCtr == 1 && button.duration >= 1) {
uinput_kbd_write(&uinp_kbd, KEY_R, 1, EV_KEY);
}
break;
case BTN_STATE_RELEASED:
if (button.pressedCtr == 1 && button.duration >= 1) {
uinput_kbd_write(&uinp_kbd, KEY_R, 0, EV_KEY);
} else if (button.pressedCtr == 3 && button.duration >= 1) {
// Sending ESC
uinput_kbd_write(&uinp_kbd, KEY_ESC, 1, EV_KEY);
usleep(50000);
uinput_kbd_write(&uinp_kbd, KEY_ESC, 0, EV_KEY);
} else if (button.pressedCtr == 5 && button.duration >= 1) {
uinput_kbd_write(&uinp_kbd, KEY_F4, 1, EV_KEY);
usleep(50000);
uinput_kbd_write(&uinp_kbd, KEY_F4, 0, EV_KEY);
// shutting down
system("shutdown -t 3 -h now");
}
break;
}
}
/* wait for some time to keep the CPU load low */
if (confres.button_enabled && !(confres.gamepad1_enabled || confres.gamepad2_enabled)) {
bcm2835_delay(FRAMEWAITLONG);
} else {
bcm2835_delay(FRAMEWAIT);
}
}
return 0;
}
int rtapi_app_main(void)
{
int n, retval = 0;
int rev, ncores, pinno;
char *endptr;
if ((rev = get_rpi_revision()) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"unrecognized Raspberry revision, see /proc/cpuinfo\n");
return -EINVAL;
}
ncores = number_of_cores();
rtapi_print_msg(RTAPI_MSG_INFO, "%d cores rev %d", ncores, rev);
switch (rev) {
case 3:
rtapi_print_msg(RTAPI_MSG_INFO, "Raspberry2\n");
pins = rpi2_pins;
gpios = rpi2_gpios;
npins = sizeof(rpi2_pins);
break;
case 1:
rtapi_print_msg(RTAPI_MSG_INFO, "Raspberry1 rev 1.0\n");
pins = rev1_pins;
gpios = rev1_gpios;
npins = sizeof(rev1_pins);
break;
case 2:
rtapi_print_msg(RTAPI_MSG_INFO, "Raspberry1 Rev 2.0\n");
pins = rev2_pins;
gpios = rev2_gpios;
npins = sizeof(rev2_pins);
break;
default:
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: ERROR: board revision %d not supported\n", rev);
return -EINVAL;
}
port_data = hal_malloc(npins * sizeof(void *));
if (port_data == 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: ERROR: hal_malloc() failed\n");
hal_exit(comp_id);
return -1;
}
if (dir == 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "HAL_GPIO: ERROR: no config string\n");
return -1;
}
dir_map = strtoul(dir, &endptr,0);
if (*endptr) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: dir=%s - trailing garbage: '%s'\n",
dir, endptr);
return -1;
}
if (exclude == 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "HAL_GPIO: ERROR: no exclude string\n");
return -1;
}
exclude_map = strtoul(exclude, &endptr,0);
if (*endptr) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: exclude=%s - trailing garbage: '%s'\n",
exclude, endptr);
return -1;
}
if (setup_gpio_access(rev, ncores))
return -1;
comp_id = hal_init("hal_gpio");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: ERROR: hal_init() failed\n");
return -1;
}
for (n = 0; n < npins; n++) {
if (exclude_map & RTAPI_BIT(n))
continue;
pinno = pins[n];
if (dir_map & RTAPI_BIT(n)) {
bcm2835_gpio_fsel(gpios[n], BCM2835_GPIO_FSEL_OUTP);
if ((retval = hal_pin_bit_newf(HAL_IN, &port_data[n],
comp_id, "hal_gpio.pin-%02d-out", pinno)) < 0)
break;
} else {
bcm2835_gpio_fsel(gpios[n], BCM2835_GPIO_FSEL_INPT);
if ((retval = hal_pin_bit_newf(HAL_OUT, &port_data[n],
comp_id, "hal_gpio.pin-%02d-in", pinno)) < 0)
break;
}
}
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: ERROR: pin %d export failed with err=%i\n",
n,retval);
hal_exit(comp_id);
return -1;
}
retval = hal_export_funct("hal_gpio.write", write_port, 0,
0, 0, comp_id);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: ERROR: write funct export failed\n");
hal_exit(comp_id);
return -1;
}
retval = hal_export_funct("hal_gpio.read", read_port, 0,
0, 0, comp_id);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"HAL_GPIO: ERROR: read funct export failed\n");
hal_exit(comp_id);
return -1;
}
rtapi_print_msg(RTAPI_MSG_INFO,
"HAL_GPIO: installed driver\n");
hal_ready(comp_id);
return 0;
}