Retrode

digitaLumberjack · 29 Jun 2015, 18:03

Non j'ai compilé a l'arrache...

digitaLumberjack · 29 Jun 2015, 20:45

Si tu me modifie le fichier acris je te le compile comme tu le veux

acris · 30 Jun 2015, 09:42

@Violene merci pour le test. @retroboy merci beaucoup si j'ai bien compris il faut déclarer la touche dans retrogame.c puis lancer le make. J'ai ajouté ceci : GPIO 11

 {  11,      KEY_ESC       },   // escape, out of emulator
 
/*
ADAFRUIT RETROGAME UTILITY: remaps buttons on Raspberry Pi GPIO header
to virtual USB keyboard presses.  Great for classic game emulators!
Retrogame is interrupt-driven and efficient (usually under 0.3% CPU use)
and debounces inputs for glitch-free gaming.
Connect one side of button(s) to GND pin (there are several on the GPIO
header, but see later notes) and the other side to GPIO pin of interest.
Internal pullups are used; no resistors required.  Avoid pins 8 and 10;
these are configured as a serial port by default on most systems (this
can be disabled but takes some doing).  Pin configuration is currently
set in global table; no config file yet.  See later comments.
Must be run as root, i.e. 'sudo ./retrogame &' or configure init scripts
to launch automatically at system startup.
Requires uinput kernel module.  This is typically present on popular
Raspberry Pi Linux distributions but not enabled on some older varieties.
To enable, either type:
    sudo modprobe uinput
Or, to make this persistent between reboots, add a line to /etc/modules:
    uinput
Prior versions of this code, when being compiled for use with the Cupcade
or PiGRRL projects, required CUPCADE to be #defined.  This is no longer
the case; instead a test is performed to see if a PiTFT is connected, and
one of two I/O tables is automatically selected.
Written by Phil Burgess for Adafruit Industries, distributed under BSD
License.  Adafruit invests time and resources providing this open source
code, please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Copyright (c) 2013 Adafruit Industries.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
  this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <sys/mman.h>
#include <linux/input.h>
#include <linux/uinput.h>
 
// START HERE ------------------------------------------------------------
// This table remaps GPIO inputs to keyboard values.  In this initial
// implementation there's a 1:1 relationship (can't attach multiple keys
// to a button) and the list is fixed in code; there is no configuration
// file.  Buttons physically connect between GPIO pins and ground.  There
// are only a few GND pins on the GPIO header, so a breakout board is
// often needed.  If you require just a couple extra ground connections
// and have unused GPIO pins, set the corresponding key value to GND to
// create a spare ground point.
 
#define GND -1
struct {
	int pin;
	int key;
} *io, // In main() this pointer is set to one of the two tables below.
   ioTFT[] = {
	// This pin/key table is used if an Adafruit PiTFT display
	// is detected (e.g. Cupcade or PiGRRL).
	// Input   Output (from /usr/include/linux/input.h)
	{   2,     KEY_LEFT     },   // Joystick (4 pins)
	{   3,     KEY_RIGHT    },
	{   4,     KEY_DOWN     },
	{  17,     KEY_UP       },
	{  27,     KEY_Z        },   // A/Fire/jump/primary
	{  22,     KEY_X        },   // B/Bomb/secondary
	{  23,     KEY_R        },   // Credit
	{  18,     KEY_Q        },   // Start 1P
        {  11,     KEY_ESC       },   // escape, out of emulator
	{  -1,     -1           } }, // END OF LIST, DO NOT CHANGE
	// MAME must be configured with 'z' & 'x' as buttons 1 & 2 -
	// this was required for the accompanying 'menu' utility to
	// work (catching crtl/alt w/ncurses gets totally NASTY).
	// Credit/start are likewise moved to 'r' & 'q,' reason being
	// to play nicer with certain emulators not liking numbers.
	// GPIO options are 'maxed out' with PiTFT + above table.
	// If additional buttons are desired, will need to disable
	// serial console and/or use P5 header.  Or use keyboard.
   ioStandard[] = {
	// This pin/key table is used when the PiTFT isn't found
	// (using HDMI or composite instead), as with our original
	// retro gaming guide.
	// Input   Output (from /usr/include/linux/input.h)
	{  25,     KEY_LEFT     },   // Joystick (4 pins)
	{   9,     KEY_RIGHT    },
	{  10,     KEY_UP       },
	{  17,     KEY_DOWN     },
	{  23,     KEY_LEFTCTRL },   // A/Fire/jump/primary
	{   7,     KEY_LEFTALT  },   // B/Bomb/secondary
	// For credit/start/etc., use USB keyboard or add more buttons.
	{  -1,     -1           } }; // END OF LIST, DO NOT CHANGE
 
// A "Vulcan nerve pinch" (holding down a specific button combination
// for a few seconds) issues an 'esc' keypress to MAME (which brings up
// an exit menu or quits the current game).  The button combo is
// configured with a bitmask corresponding to elements in the above io[]
// array.  The default value here uses elements 6 and 7 (credit and start
// in the Cupcade pinout).  If you change this, make certain it's a combo
// that's not likely to occur during actual gameplay (i.e. avoid using
// joystick directions or hold-for-rapid-fire buttons).
// Also key auto-repeat times are set here.  This is for navigating the
// game menu using the 'gamera' utility; MAME disregards key repeat
// events (as it should).
const unsigned long vulcanMask = (1L << 6) | (1L << 7);
const int           vulcanKey  = KEY_ESC, // Keycode to send
                    vulcanTime = 1500,    // Pinch time in milliseconds
                    repTime1   = 500,     // Key hold time to begin repeat
                    repTime2   = 100;     // Time between key repetitions
 
// A few globals ---------------------------------------------------------
 
char
  *progName,                         // Program name (for error reporting)
   sysfs_root[] = "/sys/class/gpio", // Location of Sysfs GPIO files
   running      = 1;                 // Signal handler will set to 0 (exit)
volatile unsigned int
  *gpio;                             // GPIO register table
const int
   debounceTime = 20;                // 20 ms for button debouncing
 
// Some utility functions ------------------------------------------------
 
// Set one GPIO pin attribute through the Sysfs interface.
int pinConfig(int pin, char *attr, char *value) {
	char filename[50];
	int  fd, w, len = strlen(value);
	sprintf(filename, "%s/gpio%d/%s", sysfs_root, pin, attr);
	if((fd = open(filename, O_WRONLY)) < 0) return -1;
	w = write(fd, value, len);
	close(fd);
	return (w != len); // 0 = success
}
 
// Un-export any Sysfs pins used; don't leave filesystem cruft.  Also
// restores any GND pins to inputs.  Write errors are ignored as pins
// may be in a partially-initialized state.
void cleanup() {
	char buf[50];
	int  fd, i;
	sprintf(buf, "%s/unexport", sysfs_root);
	if((fd = open(buf, O_WRONLY)) >= 0) {
		for(i=0; io[i].pin >= 0; i++) {
			// Restore GND items to inputs
			if(io[i].key == GND)
				pinConfig(io[i].pin, "direction", "in");
			// And un-export all items regardless
			sprintf(buf, "%d", io[i].pin);
			write(fd, buf, strlen(buf));
		}
		close(fd);
	}
}
 
// Quick-n-dirty error reporter; print message, clean up and exit.
void err(char *msg) {
	printf("%s: %s.  Try 'sudo %s'.\n", progName, msg, progName);
	cleanup();
	exit(1);
}
 
// Interrupt handler -- set global flag to abort main loop.
void signalHandler(int n) {
	running = 0;
}
 
// Detect Pi board type.  Doesn't return super-granular details,
// just the most basic distinction needed for GPIO compatibility:
// 0: Pi 1 Model B revision 1
// 1: Pi 1 Model B revision 2, Model A, Model B+, Model A+
// 2: Pi 2 Model B
 
static int boardType(void) {
	FILE *fp;
	char  buf[1024], *ptr;
	int   n, board = 1; // Assume Pi1 Rev2 by default
 
	// Relies on info in /proc/cmdline.  If this becomes unreliable
	// in the future, alt code below uses /proc/cpuinfo if any better.
#if 1
	if((fp = fopen("/proc/cmdline", "r"))) {
		while(fgets(buf, sizeof(buf), fp)) {
			if((ptr = strstr(buf, "mem_size=")) &&
			   (sscanf(&ptr[9], "%x", &n) == 1) &&
			   (n == 0x3F000000)) {
				board = 2; // Appears to be a Pi 2
				break;
			} else if((ptr = strstr(buf, "boardrev=")) &&
			          (sscanf(&ptr[9], "%x", &n) == 1) &&
			          ((n == 0x02) || (n == 0x03))) {
				board = 0; // Appears to be an early Pi
				break;
			}
		}
		fclose(fp);
	}
#else
	char s[8];
	if((fp = fopen("/proc/cpuinfo", "r"))) {
		while(fgets(buf, sizeof(buf), fp)) {
			if((ptr = strstr(buf, "Hardware")) &&
			   (sscanf(&ptr[8], " : %7s", s) == 1) &&
			   (!strcmp(s, "BCM2709"))) {
				board = 2; // Appears to be a Pi 2
				break;
			} else if((ptr = strstr(buf, "Revision")) &&
			          (sscanf(&ptr[8], " : %x", &n) == 1) &&
			          ((n == 0x02) || (n == 0x03))) {
				board = 0; // Appears to be an early Pi
				break;
			}
		}
		fclose(fp);
	}
#endif
 
	return board;
}
 
// Main stuff ------------------------------------------------------------
 
#define PI1_BCM2708_PERI_BASE 0x20000000
#define PI1_GPIO_BASE         (PI1_BCM2708_PERI_BASE + 0x200000)
#define PI2_BCM2708_PERI_BASE 0x3F000000
#define PI2_GPIO_BASE         (PI2_BCM2708_PERI_BASE + 0x200000)
#define BLOCK_SIZE            (4*1024)
#define GPPUD                 (0x94 / 4)
#define GPPUDCLK0             (0x98 / 4)
 
int main(int argc, char *argv[]) {
 
	// A few arrays here are declared with 32 elements, even though
	// values aren't needed for io[] members where the 'key' value is
	// GND.  This simplifies the code a bit -- no need for mallocs and
	// tests to create these arrays -- but may waste a handful of
	// bytes for any declared GNDs.
	char                   buf[50],      // For sundry filenames
	                       c,            // Pin input value ('0'/'1')
	                       board;        // 0=Pi1Rev1, 1=Pi1Rev2, 2=Pi2
	int                    fd,           // For mmap, sysfs, uinput
	                       i, j,         // Asst. counter
	                       bitmask,      // Pullup enable bitmask
	                       timeout = -1, // poll() timeout
	                       intstate[32], // Last-read state
	                       extstate[32], // Debounced state
	                       lastKey = -1; // Last key down (for repeat)
	unsigned long          bitMask, bit; // For Vulcan pinch detect
	volatile unsigned char shortWait;    // Delay counter
	struct input_event     keyEv, synEv; // uinput events
	struct pollfd          p[32];        // GPIO file descriptors
 
	progName = argv[0];             // For error reporting
	signal(SIGINT , signalHandler); // Trap basic signals (exit cleanly)
	signal(SIGKILL, signalHandler);
 
	// Select io[] table for Cupcade (TFT) or 'normal' project.
	io = (access("/etc/modprobe.d/adafruit.conf", F_OK) ||
	      access("/dev/fb1", F_OK)) ? ioStandard : ioTFT;
 
	// If this is a "Revision 1" Pi board (no mounting holes),
	// remap certain pin numbers in the io[] array for compatibility.
	// This way the code doesn't need modification for old boards.
	board = boardType();
	if(board == 0) {
		for(i=0; io[i].pin >= 0; i++) {
			if(     io[i].pin ==  2) io[i].pin = 0;
			else if(io[i].pin ==  3) io[i].pin = 1;
			else if(io[i].pin == 27) io[i].pin = 21;
		}
	}
 
	// ----------------------------------------------------------------
	// Although Sysfs provides solid GPIO interrupt handling, there's
	// no interface to the internal pull-up resistors (this is by
	// design, being a hardware-dependent feature).  It's necessary to
	// grapple with the GPIO configuration registers directly to enable
	// the pull-ups.  Based on GPIO example code by Dom and Gert van
	// Loo on elinux.org
 
	if((fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0)
		err("Can't open /dev/mem");
	gpio = mmap(            // Memory-mapped I/O
	  NULL,                 // Any adddress will do
	  BLOCK_SIZE,           // Mapped block length
	  PROT_READ|PROT_WRITE, // Enable read+write
	  MAP_SHARED,           // Shared with other processes
	  fd,                   // File to map
	  (board == 2) ?
	   PI2_GPIO_BASE :      // -> GPIO registers
	   PI1_GPIO_BASE);
 
	close(fd);              // Not needed after mmap()
	if(gpio == MAP_FAILED) err("Can't mmap()");
	// Make combined bitmap of pullup-enabled pins:
	for(bitmask=i=0; io[i].pin >= 0; i++)
		if(io[i].key != GND) bitmask |= (1 << io[i].pin);
	gpio[GPPUD]     = 2;                    // Enable pullup
	for(shortWait=150;--shortWait;);        // Min 150 cycle wait
	gpio[GPPUDCLK0] = bitmask;              // Set pullup mask
	for(shortWait=150;--shortWait;);        // Wait again
	gpio[GPPUD]     = 0;                    // Reset pullup registers
	gpio[GPPUDCLK0] = 0;
	(void)munmap((void *)gpio, BLOCK_SIZE); // Done with GPIO mmap()
 
	// ----------------------------------------------------------------
	// All other GPIO config is handled through the sysfs interface.
 
	sprintf(buf, "%s/export", sysfs_root);
	if((fd = open(buf, O_WRONLY)) < 0) // Open Sysfs export file
		err("Can't open GPIO export file");
	for(i=j=0; io[i].pin >= 0; i++) { // For each pin of interest...
		sprintf(buf, "%d", io[i].pin);
		write(fd, buf, strlen(buf));             // Export pin
		pinConfig(io[i].pin, "active_low", "0"); // Don't invert
		if(io[i].key == GND) {
			// Set pin to output, value 0 (ground)
			if(pinConfig(io[i].pin, "direction", "out") ||
			   pinConfig(io[i].pin, "value"    , "0"))
				err("Pin config failed (GND)");
		} else {
			// Set pin to input, detect rise+fall events
			if(pinConfig(io[i].pin, "direction", "in") ||
			   pinConfig(io[i].pin, "edge"     , "both"))
				err("Pin config failed");
			// Get initial pin value
			sprintf(buf, "%s/gpio%d/value",
			  sysfs_root, io[i].pin);
			// The p[] file descriptor array isn't necessarily
			// aligned with the io[] array.  GND keys in the
			// latter are skipped, but p[] requires contiguous
			// entries for poll().  So the pins to monitor are
			// at the head of p[], and there may be unused
			// elements at the end for each GND.  Same applies
			// to the intstate[] and extstate[] arrays.
			if((p[j].fd = open(buf, O_RDONLY)) < 0)
				err("Can't access pin value");
			intstate[j] = 0;
			if((read(p[j].fd, &c, 1) == 1) && (c == '0'))
				intstate[j] = 1;
			extstate[j] = intstate[j];
			p[j].events  = POLLPRI; // Set up poll() events
			p[j].revents = 0;
			j++;
		}
	} // 'j' is now count of non-GND items in io[] table
	close(fd); // Done exporting
 
	// ----------------------------------------------------------------
	// Set up uinput
 
#if 1
	// Retrogame normally uses /dev/uinput for generating key events.
	// Cupcade requires this and it's the default.  SDL2 (used by
	// some newer emulators) doesn't like it, wants /dev/input/event0
	// instead.  Enable that code by changing to "#if 0" above.
	if((fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK)) < 0)
		err("Can't open /dev/uinput");
	if(ioctl(fd, UI_SET_EVBIT, EV_KEY) < 0)
		err("Can't SET_EVBIT");
	for(i=0; io[i].pin >= 0; i++) {
		if(io[i].key != GND) {
			if(ioctl(fd, UI_SET_KEYBIT, io[i].key) < 0)
				err("Can't SET_KEYBIT");
		}
	}
	if(ioctl(fd, UI_SET_KEYBIT, vulcanKey) < 0) err("Can't SET_KEYBIT");
	struct uinput_user_dev uidev;
	memset(&uidev, 0, sizeof(uidev));
	snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "retrogame");
	uidev.id.bustype = BUS_USB;
	uidev.id.vendor  = 0x1;
	uidev.id.product = 0x1;
	uidev.id.version = 1;
	if(write(fd, &uidev, sizeof(uidev)) < 0)
		err("write failed");
	if(ioctl(fd, UI_DEV_CREATE) < 0)
		err("DEV_CREATE failed");
#else // SDL2 prefers this event methodology
	if((fd = open("/dev/input/event0", O_WRONLY | O_NONBLOCK)) < 0)
		err("Can't open /dev/input/event0");
#endif
 
	// Initialize input event structures
	memset(&keyEv, 0, sizeof(keyEv));
	keyEv.type  = EV_KEY;
	memset(&synEv, 0, sizeof(synEv));
	synEv.type  = EV_SYN;
	synEv.code  = SYN_REPORT;
	synEv.value = 0;
 
	// 'fd' is now open file descriptor for issuing uinput events
 
	// ----------------------------------------------------------------
	// Monitor GPIO file descriptors for button events.  The poll()
	// function watches for GPIO IRQs in this case; it is NOT
	// continually polling the pins!  Processor load is near zero.
 
	while(running) { // Signal handler can set this to 0 to exit
		// Wait for IRQ on pin (or timeout for button debounce)
		if(poll(p, j, timeout) > 0) { // If IRQ...
			for(i=0; i<j; i++) {       // Scan non-GND pins...
				if(p[i].revents) { // Event received?
					// Read current pin state, store
					// in internal state flag, but
					// don't issue to uinput yet --
					// must wait for debounce!
					lseek(p[i].fd, 0, SEEK_SET);
					read(p[i].fd, &c, 1);
					if(c == '0')      intstate[i] = 1;
					else if(c == '1') intstate[i] = 0;
					p[i].revents = 0; // Clear flag
				}
			}
			timeout = debounceTime; // Set timeout for debounce
			c       = 0;            // Don't issue SYN event
			// Else timeout occurred
		} else if(timeout == debounceTime) { // Button debounce timeout
			// 'j' (number of non-GNDs) is re-counted as
			// it's easier than maintaining an additional
			// remapping table or a duplicate key[] list.
			bitMask = 0L; // Mask of buttons currently pressed
			bit     = 1L;
			for(c=i=j=0; io[i].pin >= 0; i++, bit<<=1) {
				if(io[i].key != GND) {
					// Compare internal state against
					// previously-issued value.  Send
					// keystrokes only for changed states.
					if(intstate[j] != extstate[j]) {
						extstate[j] = intstate[j];
						keyEv.code  = io[i].key;
						keyEv.value = intstate[j];
						write(fd, &keyEv,
						  sizeof(keyEv));
						c = 1; // Follow w/SYN event
						if(intstate[j]) { // Press?
							// Note pressed key
							// and set initial
							// repeat interval.
							lastKey = i;
							timeout = repTime1;
						} else { // Release?
							// Stop repeat and
							// return to normal
							// IRQ monitoring
							// (no timeout).
							lastKey = timeout = -1;
						}
					}
					j++;
					if(intstate[i]) bitMask |= bit;
				}
			}
 
			// If the "Vulcan nerve pinch" buttons are pressed,
			// set long timeout -- if this time elapses without
			// a button state change, esc keypress will be sent.
			if((bitMask & vulcanMask) == vulcanMask)
				timeout = vulcanTime;
		} else if(timeout == vulcanTime) { // Vulcan timeout occurred
			// Send keycode (MAME exits or displays exit menu)
			keyEv.code = vulcanKey;
			for(i=1; i>= 0; i--) { // Press, release
				keyEv.value = i;
				write(fd, &keyEv, sizeof(keyEv));
				usleep(10000); // Be slow, else MAME flakes
				write(fd, &synEv, sizeof(synEv));
				usleep(10000);
			}
			timeout = -1; // Return to normal processing
			c       = 0;  // No add'l SYN required
		} else if(lastKey >= 0) { // Else key repeat timeout
			if(timeout == repTime1) timeout = repTime2;
			else if(timeout > 30)   timeout -= 5; // Accelerate
			c           = 1; // Follow w/SYN event
			keyEv.code  = io[lastKey].key;
			keyEv.value = 2; // Key repeat event
			write(fd, &keyEv, sizeof(keyEv));
		}
		if(c) write(fd, &synEv, sizeof(synEv));
	}
 
	// ----------------------------------------------------------------
	// Clean up
 
	ioctl(fd, UI_DEV_DESTROY); // Destroy and
	close(fd);                 // close uinput
	cleanup();                 // Un-export pins
 
	puts("Done.");
 
	return 0;
}

julien-tomulic · 6 Jul 2015, 11:44

je penche sur une réalisation du même genre (le reset sur gpio avec un retour sous emulationstation) mon niveau de programmation étant proche de 0 je suis attentif a votre poste si vous arrivez a quelque choses ça m’intéresse je suis tomber sur un principe quelque peu différent peut être que vous y comprendrait plus que moi au lieu de passé par ADAFRUIT c'est un script python qui simule l’appuie sur echap http://carrefour-numerique.cite-sciences.fr/fablab/wiki/doku.php?id=projets:retropie_gpio_additions

acris · 6 Jul 2015, 12:53

Bonjour l'idée est intéressante du moment ou tu veux ajouter des boutons. dès que j'ai un moment je testerai. Cependant adafruit va plus loin car il permet de simuler les touches clavier sur les gpio, donc si certains jeux requièrent le clavier il serait donc possible d utiliser un kit joystick placé sur le gpio pour jouer en théorie

une-fille-etoilee · 6 Jul 2015, 18:28

d'ailleurs, mon projet prends doucement forme.... j'attends encore du matériel pour fixer tout ca proprement...parce que simplement collé, ca me convient pas du tout...

julien-tomulic · 7 Jul 2015, 20:43

Oui je suis bien d'accord Acris Adfruit et plus complet, mais moi qui dans mon cas ne cherche qu'a faire un "retour bureau" c'est peut etre un peu complexe a metre en oeuvre ? Si tu teste je suis preneur de tes conclusion

une-fille-etoilee · 16 Jul 2015, 12:50

Bonjour a ceux et celles qui suivent ce topic... je viens aux nouvelles, histoire de savoir ou en est l'intégration d'adafruit, tu as pu tester tout ca acris ?

acris · 17 Jul 2015, 05:50

Nop car il me faut un bouton pour tester je dois en récupérer un au travail et avec cette canicule pas trop sur le pc.

une-fille-etoilee · 17 Jul 2015, 07:11

j'te comprends, la chaleur n'incite pas a bosser.....chez moi aussi c'est l'enfer....

une-fille-etoilee · 17 Jul 2015, 20:00

mon petit bricolage avance doucement...au fil du matos que la poste me livre... J'ai pu intégrée dans la snes le pi, le retrode, le port manettes d'origine que j'ai bricolé et j'ai meme remis le levier d'ejection des cartouches. il faudra que je le renforce a long terme parce que je l'ai bien aminci pour qu'il prenne sa place. il me reste a recevoir le LM2596 que j'ai commandé sur amazon afin de pouvoir me servir de l'alim d'origine de la snes... j'aimerais pouvoir utiliser la trappe sous la snes pour déporter le dernier port usb (qui me servirais eventuellement a synchroniser mes manettes ps3 les jours ou j'ai pas envie de trimballer celles de snes. il faut aussi que je branche le bouton power d'origine (sur le LS2596) et le bouton reset sur le GPIO. J'aimerais aussi trouver un moyen de faire briller la led d'origine de la console...je me demande si je fais une simple led power ou si je déporte la led d'activité du pi.... et enfin, trouver un adaptateur usb/snes pour la 2eme manette...puisqu'il semble impossible de déclarer les 2 manettes du retrode ca fait beaucoup de choses, et peu de place...

omg · 18 Jul 2015, 07:09

Pas mal du tout ce pztit projet. J'aime beaucoup!!

acris · 18 Jul 2015, 09:34

Salut je ne suis pas familière avec ce type de bricolage si j ai bien compris le LM2596 est un convertisseur et régulateur qui va te permettre de modifier le voltage et l'ampérage de l'alimentation de la snes pour obtenir du 5V 2A ? Je pense que tu dois brancher des fils sur les GPIO genre +5V ET GND parce que je vois pas comment cette "chose" sera relié Je regarde dès que possible faut juste que je retrouve mon cable bouton (en ce moment je monte des meubles lol)

une-fille-etoilee · 19 Jul 2015, 13:19

Le LM2596 me servira a convertir en effet les 9v de transfo d'origine snes en 5v avec une intensité j'espère suffisante....(le transfo snes sors 1.3A, ce qui est peu) si ca marche pas, je prendrais un transfo 9v plus puissant, mais je voulais tenter de garder au maximum la connectique arrière d'origine. pour les branchements du GPIO, nottement du bouton reset, ce sera indépendant. le circuit d'alimentation n'interviendra pas, surtout que le GPIO possède ses propres alimentations bon montage de meubles...

une-fille-etoilee · 4 Aug 2015, 13:22

tu as pu tester le bouton reset grace a adafruit acris ? j'arrive a la fin de mon bricolage, il me reste la led a cabler, j'attends de recevoir une résistance de 160 ohm pour la brancher au 5v l'alim a finaliser, j'ai pas pu utiliser le module lm2596, ca rebootait le pi sans arret, je pense que l'intensité dispo en sortie etait trop faible. du coup j'ai commandé une alim 5v avec le connecteur rond de la snes directement. et ce fameux bouton reset, qui, ca me plairais bien quand meme, provoque un retour menu lorsqu'on appui dessus... je ferais un petit récapitulatif photo lorsque tout sera fini

acris · 4 Aug 2015, 16:36

Nop pas testé j etais en vacances la semaine dernière et j ai pas retrouvé mon cable mais j ai pas oublié. on avait pas un problème aussi de gamepad identitiques qui ne fonctionnaient pas via le retrode ? si tu mets les 2 manettes snes il y en a qu'une seule qui fonctionnent ? j ai pas relu les 8 pages

une-fille-etoilee · 4 Aug 2015, 21:18

oui, on avais un soucis de manette, meme si le retrode permet les 2 manettes, lorsque je branche les 2, il ne m'en reconnais qu'une seule. si j'appuis sur A sur la manette 2, ca a le meme effet que si j'appuis sur A sur la manette 1. et a part utiliser les codes hexa d'affectation fournie par le fabricant, je ne vois pas comment faire. [kbL] 06 1b 28 2c 52 51 50 4f 09 07 04 16 [kbR] 10 11 05 19 33 37 36 38 0e 0d 0a 0b SNES controllers, the order is B Y SELECT START UP DOWN LEFT RIGHT A X L R mais voila, mis a part trifouiller dans les fichiers de retroarch, je ne vois pas comment intégrer cet adressage. j'ai contourné le probleme en achetant un adaptateur snes-usb que j'ai vampirisé et intégré a mon boitier. c'est moins joli et ca me bouffe un port usb, mais bon...c'est mieux que rien, et j'ai mes 2 ports manettes qui fonctionnent pour l'instant. résoudre ce problème devient maintenant du fignolage. j'ai pour l'instant gardé mon lm2596, mais j'ai commandé une alim plus puissante que celle de la snes. elle débite 1.2A, ce qui doit etre trop peu pour le pi, surtout que la conversion en 5v doit générer des pertes. je devais avoir moins de 1A en sortie. j'en ai commandé une de 5A, a voir si la sortie 5v sera assez stable pour tout ca....sinon, je prendrais une alim 5v directement. c'est dangereux a mon sens, puisque peu de choses distinguera ma snes modifiée d'une vraie, et il y a le risque que quelqu'un y mette le transfo d'origine si j'opte pour cette solution.

acris · 5 Aug 2015, 10:22

Salut je me demande si le problème ne serait pas comme avec les adapteurs mayflash...... on est entrain d'essayer de résoudre le problème. Dans emulationstation tu as pu configurer tes deux manettes à tour de rôle et ensuite mettre joueur 1 et joueur 2 ? ou pas du tout. Si oui, le problème se situe t il lorsque tu lances les emulateurs une seule manette est reconnue ? peux tu brancher les deux manettes snes sur ton retrode puis réaliser ses quelques tests joysticks : https://github.com/digitalLumberjack/recalbox-os/wiki/Tester-votre-joystick-avec-jstest-(FR) et poste les rapports demandés puis exécuter ces deux commandes :

jstest /dev/input/js0
jstest /dev/input/js1
udevadm info -p $(udevadm info -q path -n /dev/input/js0)
udevadm info -p $(udevadm info -q path -n /dev/input/js1)

une-fille-etoilee · 11 Aug 2015, 13:20

merci de ne pas lacher l'affaire acris.... dans emulationstation, lorsque je vais dans la configuration des manettes, je n'ai qu'une seule reconnue : #0 MATTHIAS HULLIN RETRODE lorsque je veux adresser les boutons, ca me dit toujours une manette reconnue si je configure les boutons de la manette qui est branchée sur le port 1 du retrode, la manette 1 marche parfaitement bien, la manette 2 quand a elle n'a plus que son pavé directionnel qui fonctionne. si je configure la manette 2, c'est l'inverse, la manette 1 n'a plus que sa croix directionnelle qui marche. comme si les pavé directionnels n'etaient qu'une seule et meme entrée ensuite, la liste des commande que tu m'a demandé

cat /proc/bus/input/devices I: Bus=0003 Vendor=0403 Product=97c1 Version=0111 N: Name="Matthias Hullin Retrode " P: Phys=usb-bcm2708_usb-1.5/input1 S: Sysfs=/devices/platform/bcm2708_usb/usb1/1-1/1-1.5/1-1.5:1.1/0003:0403:97C1.0001/input/input0 U: Uniq= H: Handlers=js0 event0 B: PROP=0 B: EV=1b B: KEY=ffffffff 0 0 0 0 0 0 0 0 0 B: ABS=3 B: MSC=10 I: Bus=0003 Vendor=0403 Product=97c1 Version=0111 N: Name="Matthias Hullin Retrode " P: Phys=usb-bcm2708_usb-1.5/input2 S: Sysfs=/devices/platform/bcm2708_usb/usb1/1-1/1-1.5/1-1.5:1.2/0003:0403:97C1.0002/input/input1 U: Uniq= H: Handlers=mouse0 event1 B: PROP=0 B: EV=17 B: KEY=70000 0 0 0 0 0 0 0 0 B: REL=3 B: MSC=10

ls /dev/input/js*

/dev/input/js0

jstest /dev/input/js0

Driver version is 2.1.0. Joystick (Matthias Hullin Retrode ) has 2 axes (X, Y) and 32 buttons (Trigger, ThumbBtn, ThumbBtn2, TopBtn, TopBtn2, PinkieBtn, BaseBtn, BaseBtn2, BaseBtn3, BaseBtn4, BaseBtn5, BaseBtn6, BtnDead, BtnA, BtnB, BtnC, BtnX, BtnY, BtnZ, BtnTL, BtnTR, BtnTL2, BtnTR2, BtnSelect, BtnStart, BtnMode, BtnThumbL, BtnThumbR, ?, ?, ?, ?). Testing ... (interrupt to exit) Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29Axes: 0: 0 1: 0 Buttons: 0:off 1:off 2:off 3:off 4:off 5:off 6:off 7:off 8:off 9:off 10:off 11:off 12:off 13:off 14:off 15:off 16:off 17:off 18:off 19:off 20:off 21:off 22:off 23:off 24:off 25:off 26:off 27:off 28:off 29:off 30:off 31:off

jstest /dev/input/js1

jstest: No such file or directory

udevadm info -p $(udevadm info -q path -n /dev/input/js0)

P: /devices/platform/bcm2708_usb/usb1/1-1/1-1.5/1-1.5:1.1/0003:0403:97C1.0001/input/input0/js0 N: input/js0 S: input/by-id/usb-Matthias_Hullin_Retrode-if01-joystick S: input/by-path/platform-bcm2708_usb-usb-0:1.5:1.1-joystick E: DEVLINKS=/dev/input/by-id/usb-Matthias_Hullin_Retrode-if01-joystick /dev/input/by-path/platform-bcm2708_usb-usb-0:1.5:1.1-joystick E: DEVNAME=/dev/input/js0 E: DEVPATH=/devices/platform/bcm2708_usb/usb1/1-1/1-1.5/1-1.5:1.1/0003:0403:97C1.0001/input/input0/js0 E: ID_BUS=usb E: ID_INPUT=1 E: ID_INPUT_JOYSTICK=1 E: ID_MODEL=Retrode E: ID_MODEL_ENC=Retrode\x20\x20\x20\x20\x20\x20\x20 E: ID_MODEL_ID=97c1 E: ID_PATH=platform-bcm2708_usb-usb-0:1.5:1.1 E: ID_PATH_TAG=platform-bcm2708_usb-usb-0_1_5_1_1 E: ID_REVISION=1707 E: ID_SERIAL=Matthias_Hullin_Retrode E: ID_TYPE=hid E: ID_USB_DRIVER=usbhid E: ID_USB_INTERFACES=:080650:030000:030102: E: ID_USB_INTERFACE_NUM=01 E: ID_VENDOR=Matthias_Hullin E: ID_VENDOR_ENC=Matthias\x20Hullin E: ID_VENDOR_ID=0403 E: MAJOR=13 E: MINOR=0 E: SUBSYSTEM=input E: USEC_INITIALIZED=4881823

udevadm info -p $(udevadm info -q path -n /dev/input/js1)

device node not found info: option requires an argument -- 'p'

voila pour les retour sur ces commandes lorsque j'ai fais jstest sur js0, j'ai essayée en effet les divers boutons manette sur les axes 0 et 1, j'ai bien les croix directionnelles des 2 manettes par contre, pour le bouton Y, il est bien detecté en 9 pour la manette 1 et en 1 pour la manette 2. j'ai bien une affectation différente pour chaque bouton, mais pas pour la croix. C'est bigrement de chez bigrement etrange je pense que c'est du au fait que recalbox n'autorise pas plus de 2 axes par manette

19 Aug 2015, 14:50

This post is deleted!

Solved Retrode

Want to support us ?

71
Online

98.2k
Users

28.0k
Topics

186.9k
Posts

	{ 11, KEY_ESC }, // escape, out of emulator

	/*
	ADAFRUIT RETROGAME UTILITY: remaps buttons on Raspberry Pi GPIO header
	to virtual USB keyboard presses. Great for classic game emulators!
	Retrogame is interrupt-driven and efficient (usually under 0.3% CPU use)
	and debounces inputs for glitch-free gaming.
	Connect one side of button(s) to GND pin (there are several on the GPIO
	header, but see later notes) and the other side to GPIO pin of interest.
	Internal pullups are used; no resistors required. Avoid pins 8 and 10;
	these are configured as a serial port by default on most systems (this
	can be disabled but takes some doing). Pin configuration is currently
	set in global table; no config file yet. See later comments.
	Must be run as root, i.e. 'sudo ./retrogame &' or configure init scripts
	to launch automatically at system startup.
	Requires uinput kernel module. This is typically present on popular
	Raspberry Pi Linux distributions but not enabled on some older varieties.
	To enable, either type:
	sudo modprobe uinput
	Or, to make this persistent between reboots, add a line to /etc/modules:
	uinput
	Prior versions of this code, when being compiled for use with the Cupcade
	or PiGRRL projects, required CUPCADE to be #defined. This is no longer
	the case; instead a test is performed to see if a PiTFT is connected, and
	one of two I/O tables is automatically selected.
	Written by Phil Burgess for Adafruit Industries, distributed under BSD
	License. Adafruit invests time and resources providing this open source
	code, please support Adafruit and open-source hardware by purchasing
	products from Adafruit!
	Copyright (c) 2013 Adafruit Industries.
	All rights reserved.
	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions are met:
	- Redistributions of source code must retain the above copyright notice,
	this list of conditions and the following disclaimer.
	- Redistributions in binary form must reproduce the above copyright notice,
	this list of conditions and the following disclaimer in the documentation
	and/or other materials provided with the distribution.
	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <poll.h>
	#include <signal.h>
	#include <sys/mman.h>
	#include <linux/input.h>
	#include <linux/uinput.h>

	// START HERE ------------------------------------------------------------
	// This table remaps GPIO inputs to keyboard values. In this initial
	// implementation there's a 1:1 relationship (can't attach multiple keys
	// to a button) and the list is fixed in code; there is no configuration
	// file. Buttons physically connect between GPIO pins and ground. There
	// are only a few GND pins on the GPIO header, so a breakout board is
	// often needed. If you require just a couple extra ground connections
	// and have unused GPIO pins, set the corresponding key value to GND to
	// create a spare ground point.

	#define GND -1
	struct {
	int pin;
	int key;
	} *io, // In main() this pointer is set to one of the two tables below.
	ioTFT[] = {
	// This pin/key table is used if an Adafruit PiTFT display
	// is detected (e.g. Cupcade or PiGRRL).
	// Input Output (from /usr/include/linux/input.h)
	{ 2, KEY_LEFT }, // Joystick (4 pins)
	{ 3, KEY_RIGHT },
	{ 4, KEY_DOWN },
	{ 17, KEY_UP },
	{ 27, KEY_Z }, // A/Fire/jump/primary
	{ 22, KEY_X }, // B/Bomb/secondary
	{ 23, KEY_R }, // Credit
	{ 18, KEY_Q }, // Start 1P
	{ 11, KEY_ESC }, // escape, out of emulator
	{ -1, -1 } }, // END OF LIST, DO NOT CHANGE
	// MAME must be configured with 'z' & 'x' as buttons 1 & 2 -
	// this was required for the accompanying 'menu' utility to
	// work (catching crtl/alt w/ncurses gets totally NASTY).
	// Credit/start are likewise moved to 'r' & 'q,' reason being
	// to play nicer with certain emulators not liking numbers.
	// GPIO options are 'maxed out' with PiTFT + above table.
	// If additional buttons are desired, will need to disable
	// serial console and/or use P5 header. Or use keyboard.
	ioStandard[] = {
	// This pin/key table is used when the PiTFT isn't found
	// (using HDMI or composite instead), as with our original
	// retro gaming guide.
	// Input Output (from /usr/include/linux/input.h)
	{ 25, KEY_LEFT }, // Joystick (4 pins)
	{ 9, KEY_RIGHT },
	{ 10, KEY_UP },
	{ 17, KEY_DOWN },
	{ 23, KEY_LEFTCTRL }, // A/Fire/jump/primary
	{ 7, KEY_LEFTALT }, // B/Bomb/secondary
	// For credit/start/etc., use USB keyboard or add more buttons.
	{ -1, -1 } }; // END OF LIST, DO NOT CHANGE

	// A "Vulcan nerve pinch" (holding down a specific button combination
	// for a few seconds) issues an 'esc' keypress to MAME (which brings up
	// an exit menu or quits the current game). The button combo is
	// configured with a bitmask corresponding to elements in the above io[]
	// array. The default value here uses elements 6 and 7 (credit and start
	// in the Cupcade pinout). If you change this, make certain it's a combo
	// that's not likely to occur during actual gameplay (i.e. avoid using
	// joystick directions or hold-for-rapid-fire buttons).
	// Also key auto-repeat times are set here. This is for navigating the
	// game menu using the 'gamera' utility; MAME disregards key repeat
	// events (as it should).
	const unsigned long vulcanMask = (1L << 6) \| (1L << 7);
	const int vulcanKey = KEY_ESC, // Keycode to send
	vulcanTime = 1500, // Pinch time in milliseconds
	repTime1 = 500, // Key hold time to begin repeat
	repTime2 = 100; // Time between key repetitions

	// A few globals ---------------------------------------------------------

	char
	*progName, // Program name (for error reporting)
	sysfs_root[] = "/sys/class/gpio", // Location of Sysfs GPIO files
	running = 1; // Signal handler will set to 0 (exit)
	volatile unsigned int
	*gpio; // GPIO register table
	const int
	debounceTime = 20; // 20 ms for button debouncing

	// Some utility functions ------------------------------------------------

	// Set one GPIO pin attribute through the Sysfs interface.
	int pinConfig(int pin, char attr, char value) {
	char filename[50];
	int fd, w, len = strlen(value);
	sprintf(filename, "%s/gpio%d/%s", sysfs_root, pin, attr);
	if((fd = open(filename, O_WRONLY)) < 0) return -1;
	w = write(fd, value, len);
	close(fd);
	return (w != len); // 0 = success
	}

	// Un-export any Sysfs pins used; don't leave filesystem cruft. Also
	// restores any GND pins to inputs. Write errors are ignored as pins
	// may be in a partially-initialized state.
	void cleanup() {
	char buf[50];
	int fd, i;
	sprintf(buf, "%s/unexport", sysfs_root);
	if((fd = open(buf, O_WRONLY)) >= 0) {
	for(i=0; io[i].pin >= 0; i++) {
	// Restore GND items to inputs
	if(io[i].key == GND)
	pinConfig(io[i].pin, "direction", "in");
	// And un-export all items regardless
	sprintf(buf, "%d", io[i].pin);
	write(fd, buf, strlen(buf));
	}
	close(fd);
	}
	}

	// Quick-n-dirty error reporter; print message, clean up and exit.
	void err(char *msg) {
	printf("%s: %s. Try 'sudo %s'.\n", progName, msg, progName);
	cleanup();
	exit(1);
	}

	// Interrupt handler -- set global flag to abort main loop.
	void signalHandler(int n) {
	running = 0;
	}

	// Detect Pi board type. Doesn't return super-granular details,
	// just the most basic distinction needed for GPIO compatibility:
	// 0: Pi 1 Model B revision 1
	// 1: Pi 1 Model B revision 2, Model A, Model B+, Model A+
	// 2: Pi 2 Model B

	static int boardType(void) {
	FILE *fp;
	char buf[1024], *ptr;
	int n, board = 1; // Assume Pi1 Rev2 by default

	// Relies on info in /proc/cmdline. If this becomes unreliable
	// in the future, alt code below uses /proc/cpuinfo if any better.
	#if 1
	if((fp = fopen("/proc/cmdline", "r"))) {
	while(fgets(buf, sizeof(buf), fp)) {
	if((ptr = strstr(buf, "mem_size=")) &&
	(sscanf(&ptr[9], "%x", &n) == 1) &&
	(n == 0x3F000000)) {
	board = 2; // Appears to be a Pi 2
	break;
	} else if((ptr = strstr(buf, "boardrev=")) &&
	(sscanf(&ptr[9], "%x", &n) == 1) &&
	((n == 0x02) \|\| (n == 0x03))) {
	board = 0; // Appears to be an early Pi
	break;
	}
	}
	fclose(fp);
	}
	#else
	char s[8];
	if((fp = fopen("/proc/cpuinfo", "r"))) {
	while(fgets(buf, sizeof(buf), fp)) {
	if((ptr = strstr(buf, "Hardware")) &&
	(sscanf(&ptr[8], " : %7s", s) == 1) &&
	(!strcmp(s, "BCM2709"))) {
	board = 2; // Appears to be a Pi 2
	break;
	} else if((ptr = strstr(buf, "Revision")) &&
	(sscanf(&ptr[8], " : %x", &n) == 1) &&
	((n == 0x02) \|\| (n == 0x03))) {
	board = 0; // Appears to be an early Pi
	break;
	}
	}
	fclose(fp);
	}
	#endif

	return board;
	}

	// Main stuff ------------------------------------------------------------

	#define PI1_BCM2708_PERI_BASE 0x20000000
	#define PI1_GPIO_BASE (PI1_BCM2708_PERI_BASE + 0x200000)
	#define PI2_BCM2708_PERI_BASE 0x3F000000
	#define PI2_GPIO_BASE (PI2_BCM2708_PERI_BASE + 0x200000)
	#define BLOCK_SIZE (4*1024)
	#define GPPUD (0x94 / 4)
	#define GPPUDCLK0 (0x98 / 4)

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

	// A few arrays here are declared with 32 elements, even though
	// values aren't needed for io[] members where the 'key' value is
	// GND. This simplifies the code a bit -- no need for mallocs and
	// tests to create these arrays -- but may waste a handful of
	// bytes for any declared GNDs.
	char buf[50], // For sundry filenames
	c, // Pin input value ('0'/'1')
	board; // 0=Pi1Rev1, 1=Pi1Rev2, 2=Pi2
	int fd, // For mmap, sysfs, uinput
	i, j, // Asst. counter
	bitmask, // Pullup enable bitmask
	timeout = -1, // poll() timeout
	intstate[32], // Last-read state
	extstate[32], // Debounced state
	lastKey = -1; // Last key down (for repeat)
	unsigned long bitMask, bit; // For Vulcan pinch detect
	volatile unsigned char shortWait; // Delay counter
	struct input_event keyEv, synEv; // uinput events
	struct pollfd p[32]; // GPIO file descriptors

	progName = argv[0]; // For error reporting
	signal(SIGINT , signalHandler); // Trap basic signals (exit cleanly)
	signal(SIGKILL, signalHandler);

	// Select io[] table for Cupcade (TFT) or 'normal' project.
	io = (access("/etc/modprobe.d/adafruit.conf", F_OK) \|\|
	access("/dev/fb1", F_OK)) ? ioStandard : ioTFT;

	// If this is a "Revision 1" Pi board (no mounting holes),
	// remap certain pin numbers in the io[] array for compatibility.
	// This way the code doesn't need modification for old boards.
	board = boardType();
	if(board == 0) {
	for(i=0; io[i].pin >= 0; i++) {
	if( io[i].pin == 2) io[i].pin = 0;
	else if(io[i].pin == 3) io[i].pin = 1;
	else if(io[i].pin == 27) io[i].pin = 21;
	}
	}

	// ----------------------------------------------------------------
	// Although Sysfs provides solid GPIO interrupt handling, there's
	// no interface to the internal pull-up resistors (this is by
	// design, being a hardware-dependent feature). It's necessary to
	// grapple with the GPIO configuration registers directly to enable
	// the pull-ups. Based on GPIO example code by Dom and Gert van
	// Loo on elinux.org

	if((fd = open("/dev/mem", O_RDWR \| O_SYNC)) < 0)
	err("Can't open /dev/mem");
	gpio = mmap( // Memory-mapped I/O
	NULL, // Any adddress will do
	BLOCK_SIZE, // Mapped block length
	PROT_READ\|PROT_WRITE, // Enable read+write
	MAP_SHARED, // Shared with other processes
	fd, // File to map
	(board == 2) ?
	PI2_GPIO_BASE : // -> GPIO registers
	PI1_GPIO_BASE);

	close(fd); // Not needed after mmap()
	if(gpio == MAP_FAILED) err("Can't mmap()");
	// Make combined bitmap of pullup-enabled pins:
	for(bitmask=i=0; io[i].pin >= 0; i++)
	if(io[i].key != GND) bitmask \|= (1 << io[i].pin);
	gpio[GPPUD] = 2; // Enable pullup
	for(shortWait=150;--shortWait;); // Min 150 cycle wait
	gpio[GPPUDCLK0] = bitmask; // Set pullup mask
	for(shortWait=150;--shortWait;); // Wait again
	gpio[GPPUD] = 0; // Reset pullup registers
	gpio[GPPUDCLK0] = 0;
	(void)munmap((void *)gpio, BLOCK_SIZE); // Done with GPIO mmap()

	// ----------------------------------------------------------------
	// All other GPIO config is handled through the sysfs interface.

	sprintf(buf, "%s/export", sysfs_root);
	if((fd = open(buf, O_WRONLY)) < 0) // Open Sysfs export file
	err("Can't open GPIO export file");
	for(i=j=0; io[i].pin >= 0; i++) { // For each pin of interest...
	sprintf(buf, "%d", io[i].pin);
	write(fd, buf, strlen(buf)); // Export pin
	pinConfig(io[i].pin, "active_low", "0"); // Don't invert
	if(io[i].key == GND) {
	// Set pin to output, value 0 (ground)
	if(pinConfig(io[i].pin, "direction", "out") \|\|
	pinConfig(io[i].pin, "value" , "0"))
	err("Pin config failed (GND)");
	} else {
	// Set pin to input, detect rise+fall events
	if(pinConfig(io[i].pin, "direction", "in") \|\|
	pinConfig(io[i].pin, "edge" , "both"))
	err("Pin config failed");
	// Get initial pin value
	sprintf(buf, "%s/gpio%d/value",
	sysfs_root, io[i].pin);
	// The p[] file descriptor array isn't necessarily
	// aligned with the io[] array. GND keys in the
	// latter are skipped, but p[] requires contiguous
	// entries for poll(). So the pins to monitor are
	// at the head of p[], and there may be unused
	// elements at the end for each GND. Same applies
	// to the intstate[] and extstate[] arrays.
	if((p[j].fd = open(buf, O_RDONLY)) < 0)
	err("Can't access pin value");
	intstate[j] = 0;
	if((read(p[j].fd, &c, 1) == 1) && (c == '0'))
	intstate[j] = 1;
	extstate[j] = intstate[j];
	p[j].events = POLLPRI; // Set up poll() events
	p[j].revents = 0;
	j++;
	}
	} // 'j' is now count of non-GND items in io[] table
	close(fd); // Done exporting

	// ----------------------------------------------------------------
	// Set up uinput

	#if 1
	// Retrogame normally uses /dev/uinput for generating key events.
	// Cupcade requires this and it's the default. SDL2 (used by
	// some newer emulators) doesn't like it, wants /dev/input/event0
	// instead. Enable that code by changing to "#if 0" above.
	if((fd = open("/dev/uinput", O_WRONLY \| O_NONBLOCK)) < 0)
	err("Can't open /dev/uinput");
	if(ioctl(fd, UI_SET_EVBIT, EV_KEY) < 0)
	err("Can't SET_EVBIT");
	for(i=0; io[i].pin >= 0; i++) {
	if(io[i].key != GND) {
	if(ioctl(fd, UI_SET_KEYBIT, io[i].key) < 0)
	err("Can't SET_KEYBIT");
	}
	}
	if(ioctl(fd, UI_SET_KEYBIT, vulcanKey) < 0) err("Can't SET_KEYBIT");
	struct uinput_user_dev uidev;
	memset(&uidev, 0, sizeof(uidev));
	snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "retrogame");
	uidev.id.bustype = BUS_USB;
	uidev.id.vendor = 0x1;
	uidev.id.product = 0x1;
	uidev.id.version = 1;
	if(write(fd, &uidev, sizeof(uidev)) < 0)
	err("write failed");
	if(ioctl(fd, UI_DEV_CREATE) < 0)
	err("DEV_CREATE failed");
	#else // SDL2 prefers this event methodology
	if((fd = open("/dev/input/event0", O_WRONLY \| O_NONBLOCK)) < 0)
	err("Can't open /dev/input/event0");
	#endif

	// Initialize input event structures
	memset(&keyEv, 0, sizeof(keyEv));
	keyEv.type = EV_KEY;
	memset(&synEv, 0, sizeof(synEv));
	synEv.type = EV_SYN;
	synEv.code = SYN_REPORT;
	synEv.value = 0;

	// 'fd' is now open file descriptor for issuing uinput events

	// ----------------------------------------------------------------
	// Monitor GPIO file descriptors for button events. The poll()
	// function watches for GPIO IRQs in this case; it is NOT
	// continually polling the pins! Processor load is near zero.

	while(running) { // Signal handler can set this to 0 to exit
	// Wait for IRQ on pin (or timeout for button debounce)
	if(poll(p, j, timeout) > 0) { // If IRQ...
	for(i=0; i<j; i++) { // Scan non-GND pins...
	if(p[i].revents) { // Event received?
	// Read current pin state, store
	// in internal state flag, but
	// don't issue to uinput yet --
	// must wait for debounce!
	lseek(p[i].fd, 0, SEEK_SET);
	read(p[i].fd, &c, 1);
	if(c == '0') intstate[i] = 1;
	else if(c == '1') intstate[i] = 0;
	p[i].revents = 0; // Clear flag
	}
	}
	timeout = debounceTime; // Set timeout for debounce
	c = 0; // Don't issue SYN event
	// Else timeout occurred
	} else if(timeout == debounceTime) { // Button debounce timeout
	// 'j' (number of non-GNDs) is re-counted as
	// it's easier than maintaining an additional
	// remapping table or a duplicate key[] list.
	bitMask = 0L; // Mask of buttons currently pressed
	bit = 1L;
	for(c=i=j=0; io[i].pin >= 0; i++, bit<<=1) {
	if(io[i].key != GND) {
	// Compare internal state against
	// previously-issued value. Send
	// keystrokes only for changed states.
	if(intstate[j] != extstate[j]) {
	extstate[j] = intstate[j];
	keyEv.code = io[i].key;
	keyEv.value = intstate[j];
	write(fd, &keyEv,
	sizeof(keyEv));
	c = 1; // Follow w/SYN event
	if(intstate[j]) { // Press?
	// Note pressed key
	// and set initial
	// repeat interval.
	lastKey = i;
	timeout = repTime1;
	} else { // Release?
	// Stop repeat and
	// return to normal
	// IRQ monitoring
	// (no timeout).
	lastKey = timeout = -1;
	}
	}
	j++;
	if(intstate[i]) bitMask \|= bit;
	}
	}

	// If the "Vulcan nerve pinch" buttons are pressed,
	// set long timeout -- if this time elapses without
	// a button state change, esc keypress will be sent.
	if((bitMask & vulcanMask) == vulcanMask)
	timeout = vulcanTime;
	} else if(timeout == vulcanTime) { // Vulcan timeout occurred
	// Send keycode (MAME exits or displays exit menu)
	keyEv.code = vulcanKey;
	for(i=1; i>= 0; i--) { // Press, release
	keyEv.value = i;
	write(fd, &keyEv, sizeof(keyEv));
	usleep(10000); // Be slow, else MAME flakes
	write(fd, &synEv, sizeof(synEv));
	usleep(10000);
	}
	timeout = -1; // Return to normal processing
	c = 0; // No add'l SYN required
	} else if(lastKey >= 0) { // Else key repeat timeout
	if(timeout == repTime1) timeout = repTime2;
	else if(timeout > 30) timeout -= 5; // Accelerate
	c = 1; // Follow w/SYN event
	keyEv.code = io[lastKey].key;
	keyEv.value = 2; // Key repeat event
	write(fd, &keyEv, sizeof(keyEv));
	}
	if(c) write(fd, &synEv, sizeof(synEv));
	}

	// ----------------------------------------------------------------
	// Clean up

	ioctl(fd, UI_DEV_DESTROY); // Destroy and
	close(fd); // close uinput
	cleanup(); // Un-export pins

	puts("Done.");

	return 0;
	}

Solved Retrode

Want to support us ?

71Online

98.2kUsers

28.0kTopics

186.9kPosts

71
Online

98.2k
Users

28.0k
Topics

186.9k
Posts