MickGyver
9 months ago
13 changed files with 568 additions and 51 deletions
Split View
Diff Options
-
+2 -0.gitignore
-
+27 -1NESControllersUSB/NESControllersUSB.ino
-
BINNESControllersUSB/images/snes-usb-adapter-wiring.png
-
+1 -1NeoGeoControllerUSB/NeoGeoControllerUSB.ino
-
+2 -2SNESControllersUSB/Gamepad.cpp
-
+1 -1SNESControllersUSB/Gamepad.h
-
+63 -46SNESControllersUSB/SNESControllersUSB.ino
-
BINSNESControllersUSB/images/snes-usb-adapter-wiring.png
-
+152 -0SNESNTTControllersUSB/Gamepad.cpp
-
+60 -0SNESNTTControllersUSB/Gamepad.h
-
+17 -0SNESNTTControllersUSB/README.md
-
+243 -0SNESNTTControllersUSB/SNESNTTControllersUSB.ino
-
BINSNESNTTControllersUSB/images/snes-usb-adapter-wiring.png
+ 2
- 0
.gitignore
View File
| @ -1,3 +1,5 @@ | |||
| # Ignore VS Code folders | |||
| .vscode | |||
| .build | |||
| # Ignore HEX files | |||
| *.hex | |||
+ 27
- 1
NESControllersUSB/NESControllersUSB.ino
View File
BIN
NESControllersUSB/images/snes-usb-adapter-wiring.png
View File
| Before | After |
|---|---|
|
|
| Width: 700 | Height: 544 | Size: 267 KiB | Width: 700 | Height: 544 | Size: 275 KiB |
+ 1
- 1
NeoGeoControllerUSB/NeoGeoControllerUSB.ino
View File
+ 2
- 2
SNESControllersUSB/Gamepad.cpp
View File
+ 1
- 1
SNESControllersUSB/Gamepad.h
View File
+ 63
- 46
SNESControllersUSB/SNESControllersUSB.ino
View File
BIN
SNESControllersUSB/images/snes-usb-adapter-wiring.png
View File
| Before | After |
|---|---|
|
|
| Width: 700 | Height: 544 | Size: 267 KiB | Width: 700 | Height: 544 | Size: 275 KiB |
+ 152
- 0
SNESNTTControllersUSB/Gamepad.cpp
View File
| @ -0,0 +1,152 @@ | |||
| /* Gamepad.cpp | |||
| * | |||
| * Based on the advanced HID library for Arduino: | |||
| * https://github.com/NicoHood/HID | |||
| * Copyright (c) 2014-2015 NicoHood | |||
| * | |||
| * Copyright (c) 2020 Mikael Norrgård <http://daemonbite.com> | |||
| * | |||
| * GNU GENERAL PUBLIC LICENSE | |||
| * Version 3, 29 June 2007 | |||
| * | |||
| * This program is free software: you can redistribute it and/or modify | |||
| * it under the terms of the GNU General Public License as published by | |||
| * the Free Software Foundation, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * This program is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
| * GNU General Public License for more details. | |||
| * | |||
| * You should have received a copy of the GNU General Public License | |||
| * along with this program. If not, see <https://www.gnu.org/licenses/>. | |||
| * | |||
| */ | |||
| #include "Gamepad.h" | |||
| static const uint8_t _hidReportDescriptor[] PROGMEM = { | |||
| 0x05, 0x01, // USAGE_PAGE (Generic Desktop) | |||
| 0x09, 0x04, // USAGE (Joystick) (Maybe change to gamepad? I don't think so but...) | |||
| 0xa1, 0x01, // COLLECTION (Application) | |||
| 0xa1, 0x00, // COLLECTION (Physical) | |||
| 0x05, 0x09, // USAGE_PAGE (Button) | |||
| 0x19, 0x01, // USAGE_MINIMUM (Button 1) | |||
| 0x29, 0x18, // USAGE_MAXIMUM (Button 24) | |||
| 0x15, 0x00, // LOGICAL_MINIMUM (0) | |||
| 0x25, 0x01, // LOGICAL_MAXIMUM (1) | |||
| 0x95, 0x18, // REPORT_COUNT (24) | |||
| 0x75, 0x01, // REPORT_SIZE (1) | |||
| 0x81, 0x02, // INPUT (Data,Var,Abs) | |||
| 0x05, 0x01, // USAGE_PAGE (Generic Desktop) | |||
| 0x09, 0x01, // USAGE (pointer) | |||
| 0xa1, 0x00, // COLLECTION (Physical) | |||
| 0x09, 0x30, // USAGE (X) | |||
| 0x09, 0x31, // USAGE (Y) | |||
| 0x15, 0xff, // LOGICAL_MINIMUM (-1) | |||
| 0x25, 0x01, // LOGICAL_MAXIMUM (1) | |||
| 0x95, 0x02, // REPORT_COUNT (2) | |||
| 0x75, 0x08, // REPORT_SIZE (8) | |||
| 0x81, 0x02, // INPUT (Data,Var,Abs) | |||
| 0xc0, // END_COLLECTION | |||
| 0xc0, // END_COLLECTION | |||
| 0xc0, // END_COLLECTION | |||
| }; | |||
| Gamepad_::Gamepad_(void) : PluggableUSBModule(1, 1, epType), protocol(HID_REPORT_PROTOCOL), idle(1) | |||
| { | |||
| epType[0] = EP_TYPE_INTERRUPT_IN; | |||
| PluggableUSB().plug(this); | |||
| } | |||
| int Gamepad_::getInterface(uint8_t* interfaceCount) | |||
| { | |||
| *interfaceCount += 1; // uses 1 | |||
| HIDDescriptor hidInterface = { | |||
| D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE), | |||
| D_HIDREPORT(sizeof(_hidReportDescriptor)), | |||
| D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01) | |||
| }; | |||
| return USB_SendControl(0, &hidInterface, sizeof(hidInterface)); | |||
| } | |||
| int Gamepad_::getDescriptor(USBSetup& setup) | |||
| { | |||
| // Check if this is a HID Class Descriptor request | |||
| if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) { return 0; } | |||
| if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) { return 0; } | |||
| // In a HID Class Descriptor wIndex cointains the interface number | |||
| if (setup.wIndex != pluggedInterface) { return 0; } | |||
| // Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol | |||
| // due to the USB specs, but Windows and Linux just assumes its in report mode. | |||
| protocol = HID_REPORT_PROTOCOL; | |||
| return USB_SendControl(TRANSFER_PGM, _hidReportDescriptor, sizeof(_hidReportDescriptor)); | |||
| } | |||
| bool Gamepad_::setup(USBSetup& setup) | |||
| { | |||
| if (pluggedInterface != setup.wIndex) { | |||
| return false; | |||
| } | |||
| uint8_t request = setup.bRequest; | |||
| uint8_t requestType = setup.bmRequestType; | |||
| if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) | |||
| { | |||
| if (request == HID_GET_REPORT) { | |||
| // TODO: HID_GetReport(); | |||
| return true; | |||
| } | |||
| if (request == HID_GET_PROTOCOL) { | |||
| // TODO: Send8(protocol); | |||
| return true; | |||
| } | |||
| } | |||
| if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) | |||
| { | |||
| if (request == HID_SET_PROTOCOL) { | |||
| protocol = setup.wValueL; | |||
| return true; | |||
| } | |||
| if (request == HID_SET_IDLE) { | |||
| idle = setup.wValueL; | |||
| return true; | |||
| } | |||
| if (request == HID_SET_REPORT) | |||
| { | |||
| } | |||
| } | |||
| return false; | |||
| } | |||
| void Gamepad_::reset() | |||
| { | |||
| _GamepadReport.X = 0; | |||
| _GamepadReport.Y = 0; | |||
| _GamepadReport.buttons = 0; | |||
| this->send(); | |||
| } | |||
| void Gamepad_::send() | |||
| { | |||
| USB_Send(pluggedEndpoint | TRANSFER_RELEASE, &_GamepadReport, sizeof(GamepadReport)); | |||
| } | |||
| uint8_t Gamepad_::getShortName(char *name) | |||
| { | |||
| if(!next) | |||
| { | |||
| strcpy(name, gp_serial); | |||
| return strlen(name); | |||
| } | |||
| return 0; | |||
| } | |||
+ 60
- 0
SNESNTTControllersUSB/Gamepad.h
View File
| @ -0,0 +1,60 @@ | |||
| /* Gamepad.h | |||
| * | |||
| * Based on the advanced HID library for Arduino: | |||
| * https://github.com/NicoHood/HID | |||
| * Copyright (c) 2014-2015 NicoHood | |||
| * | |||
| * Copyright (c) 2020 Mikael Norrgård <http://daemonbite.com> | |||
| * | |||
| * GNU GENERAL PUBLIC LICENSE | |||
| * Version 3, 29 June 2007 | |||
| * | |||
| * This program is free software: you can redistribute it and/or modify | |||
| * it under the terms of the GNU General Public License as published by | |||
| * the Free Software Foundation, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * This program is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
| * GNU General Public License for more details. | |||
| * | |||
| * You should have received a copy of the GNU General Public License | |||
| * along with this program. If not, see <https://www.gnu.org/licenses/>. | |||
| * | |||
| */ | |||
| #pragma once | |||
| #include "HID.h" | |||
| extern const char* gp_serial; | |||
| typedef struct { | |||
| uint32_t buttons : 24; | |||
| int8_t X; | |||
| int8_t Y; | |||
| } GamepadReport; | |||
| class Gamepad_ : public PluggableUSBModule | |||
| { | |||
| private: | |||
| uint8_t reportId; | |||
| protected: | |||
| int getInterface(uint8_t* interfaceCount); | |||
| int getDescriptor(USBSetup& setup); | |||
| uint8_t getShortName(char *name); | |||
| bool setup(USBSetup& setup); | |||
| uint8_t epType[1]; | |||
| uint8_t protocol; | |||
| uint8_t idle; | |||
| public: | |||
| GamepadReport _GamepadReport; | |||
| Gamepad_(void); | |||
| void reset(void); | |||
| void send(); | |||
| }; | |||
+ 17
- 0
SNESNTTControllersUSB/README.md
View File
| @ -0,0 +1,17 @@ | |||
| # DaemonBite SNES/NES USB Controller adapter with NTT Datapad support | |||
| ## Introduction | |||
| With this simple to build adapter you can connect SNES and NES gamepads to a PC, Raspberry PI, MiSTer FPGA etc. The Arduino Pro Micro has very low lag when configured as a USB gamepad and it is plug n' play once it has been programmed. The controller type is auto-detected. | |||
| The NTT Data Keypad controller for SNES is also supported in this version. For a faster version, use the project in the SNESControllersUSB folder. | |||
| ## Parts you need | |||
| - Arduino Pro Micro (ATMega32U4) | |||
| - Male end of SNES or NES controller extension cable | |||
| - Heat shrink tube (Ø ~20mm) | |||
| - Micro USB cable | |||
| ## Wiring | |||
|  | |||
| ## License | |||
| This project is licensed under the GNU General Public License v3.0. | |||
+ 243
- 0
SNESNTTControllersUSB/SNESNTTControllersUSB.ino
View File
| @ -0,0 +1,243 @@ | |||
| /* DaemonBite (S)NES Controllers to USB Adapter with NTT Datapad support | |||
| * Author: Mikael Norrgård <mick@daemonbite.com> | |||
| * | |||
| * Copyright (c) 2020 Mikael Norrgård <http://daemonbite.com> | |||
| * | |||
| * GNU GENERAL PUBLIC LICENSE | |||
| * Version 3, 29 June 2007 | |||
| * | |||
| * This program is free software: you can redistribute it and/or modify | |||
| * it under the terms of the GNU General Public License as published by | |||
| * the Free Software Foundation, either version 3 of the License, or | |||
| * (at your option) any later version. | |||
| * | |||
| * This program is distributed in the hope that it will be useful, | |||
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
| * GNU General Public License for more details. | |||
| * | |||
| * You should have received a copy of the GNU General Public License | |||
| * along with this program. If not, see <https://www.gnu.org/licenses/>. | |||
| * | |||
| */ | |||
| #include "Gamepad.h" | |||
| // ATT: 20 chars max (including NULL at the end) according to Arduino source code. | |||
| // Additionally serial number is used to differentiate arduino projects to have different button maps! | |||
| const char *gp_serial = "NES/SNES to USB"; | |||
| #define DEBUG | |||
| #define GAMEPAD_COUNT 1 // NOTE: To have more than 2 two gamepads you need to disable the CDC of the Arduino. | |||
| #define GAMEPAD_COUNT_MAX 4 | |||
| #define BUTTON_READ_DELAY 20 // Delay between button reads in µs | |||
| #define CYCLES_LATCH 128 // 12µs according to specs (8 seems to work fine) (1 cycle @ 16MHz takes 62.5ns so 62.5ns * 128 = 8000ns = 8µs) | |||
| #define CYCLES_CLOCK 64 // 6µs according to specs (4 seems to work fine) | |||
| #define CYCLES_PAUSE 64 // 6µs according to specs (4 seems to work fine) | |||
| #define UP 0x01 | |||
| #define DOWN 0x02 | |||
| #define LEFT 0x04 | |||
| #define RIGHT 0x08 | |||
| #define NTT_CONTROL_BIT 0x20000000 | |||
| #define DELAY_CYCLES(n) __builtin_avr_delay_cycles(n) | |||
| // Wire it all up according to the following table: | |||
| // | |||
| // NES SNES Arduino Pro Micro | |||
| // -------------------------------------- | |||
| // VCC VCC (All gamepads) | |||
| // GND GND (All gamepads) | |||
| // OUT0 (LATCH) 2 (PD1, All gamepads) | |||
| // CUP (CLOCK) 3 (PD0, All gamepads) | |||
| // D1 (GP1: DATA) A0 (PF7, Gamepad 1) | |||
| // D1 (GP2: DATA) A1 (PF6, Gamepad 2) | |||
| // D1 (GP3: DATA) A2 (PF5, Gamepad 3, not currently used) | |||
| // D1 (GP4: DATA) A3 (PF4, Gamepad 4, not currently used) | |||
| enum ControllerType { | |||
| NONE, | |||
| NES, | |||
| SNES, | |||
| NTT | |||
| }; | |||
| // Set up USB HID gamepads | |||
| Gamepad_ Gamepad[GAMEPAD_COUNT]; | |||
| // Controllers | |||
| uint32_t buttons[GAMEPAD_COUNT_MAX] = {0,0,0,0}; | |||
| uint32_t buttonsPrev[GAMEPAD_COUNT_MAX] = {0,0,0,0}; | |||
| uint8_t gpBit[GAMEPAD_COUNT_MAX] = {B10000000,B01000000,B00100000,B00010000}; | |||
| ControllerType controllerType[GAMEPAD_COUNT_MAX] = {NONE,NONE,NONE,NONE}; | |||
| uint32_t btnBits[32] = {0x10,0x40,0x400,0x800,UP,DOWN,LEFT,RIGHT,0x20,0x80,0x100,0x200, // Standard SNES controller | |||
| 0x10000000,0x20000000,0x40000000,0x80000000,0x1000,0x2000,0x4000,0x8000, // NTT Data Keypad (NDK10) | |||
| 0x10000,0x20000,0x40000,0x80000,0x100000,0x200000,0x400000,0x800000, | |||
| 0x1000000,0x2000000,0x4000000,0x8000000}; | |||
| uint8_t gp = 0; | |||
| uint8_t buttonCount = 32; | |||
| // Timing | |||
| uint32_t microsButtons = 0; | |||
| #ifdef DEBUG | |||
| uint32_t microsStart = 0; | |||
| uint32_t microsEnd = 0; | |||
| uint8_t counter = 0; | |||
| #endif | |||
| void setup() | |||
| { | |||
| // Setup latch and clock pins (2,3 or PD1, PD0) | |||
| DDRD |= B00000011; // output | |||
| PORTD &= ~B00000011; // low | |||
| // Setup data pins A0-A3 (PF7-PF4) | |||
| DDRF &= ~B11110000; // inputs | |||
| PORTF |= B11110000; // enable internal pull-ups | |||
| DDRC &= ~B01000000; // input | |||
| PORTC |= B01000000; // enable internal pull-up | |||
| #ifdef DEBUG | |||
| Serial.begin(115200); | |||
| delay(4000); | |||
| #endif | |||
| delay(500); | |||
| detectControllerTypes(); | |||
| } | |||
| void loop() { while(1) | |||
| { | |||
| // See if enough time has passed since last button read | |||
| if((micros() - microsButtons) > BUTTON_READ_DELAY) | |||
| { | |||
| #ifdef DEBUG | |||
| microsStart = micros(); | |||
| #endif | |||
| // Pulse latch | |||
| sendLatch(); | |||
| for(uint8_t btn=0; btn<buttonCount; btn++) | |||
| { | |||
| for(gp=0; gp<GAMEPAD_COUNT; gp++) | |||
| (PINF & gpBit[gp]) ? buttons[gp] &= ~btnBits[btn] : buttons[gp] |= btnBits[btn]; | |||
| sendClock(); | |||
| } | |||
| // Check gamepad type | |||
| for(gp=0; gp<GAMEPAD_COUNT; gp++) | |||
| { | |||
| if(controllerType[gp] == NES) { // NES | |||
| bitWrite(buttons[gp], 5, bitRead(buttons[gp], 4)); | |||
| bitWrite(buttons[gp], 4, bitRead(buttons[gp], 6)); | |||
| buttons[gp] &= 0xC3F; | |||
| } | |||
| else if(controllerType[gp] == NTT) // SNES NTT Data Keypad | |||
| buttons[gp] &= 0x3FFFFFF; | |||
| else // SNES Gamepad | |||
| buttons[gp] &= 0xFFF; | |||
| } | |||
| for(gp=0; gp<GAMEPAD_COUNT; gp++) | |||
| { | |||
| // Has any buttons changed state? | |||
| if (buttons[gp] != buttonsPrev[gp]) | |||
| { | |||
| Gamepad[gp]._GamepadReport.buttons = (buttons[gp] >> 4); // First 4 bits are the axes | |||
| Gamepad[gp]._GamepadReport.Y = ((buttons[gp] & DOWN) >> 1) - (buttons[gp] & UP); | |||
| Gamepad[gp]._GamepadReport.X = ((buttons[gp] & RIGHT) >> 3) - ((buttons[gp] & LEFT) >> 2); | |||
| buttonsPrev[gp] = buttons[gp]; | |||
| Gamepad[gp].send(); | |||
| } | |||
| } | |||
| microsButtons = micros(); | |||
| #ifdef DEBUG | |||
| microsEnd = micros(); | |||
| if(counter < 20) { | |||
| Serial.println(microsEnd-microsStart); | |||
| counter++; | |||
| } | |||
| #endif | |||
| } | |||
| }} | |||
| void detectControllerTypes() | |||
| { | |||
| uint8_t buttonCountNew = 0; | |||
| // Read the controllers a few times to detect controller type | |||
| for(uint8_t i=0; i<4; i++) | |||
| { | |||
| // Pulse latch | |||
| sendLatch(); | |||
| // Read all buttons | |||
| for(uint8_t btn=0; btn<buttonCount; btn++) | |||
| { | |||
| for(gp=0; gp<GAMEPAD_COUNT; gp++) | |||
| (PINF & gpBit[gp]) ? buttons[gp] &= ~btnBits[btn] : buttons[gp] |= btnBits[btn]; | |||
| sendClock(); | |||
| } | |||
| // Check controller types and set buttonCount to max needed | |||
| for(gp=0; gp<GAMEPAD_COUNT; gp++) | |||
| { | |||
| if((buttons[gp] & 0xF3A0) == 0xF3A0) { // NES | |||
| if(controllerType[gp] != SNES && controllerType[gp] != NTT) | |||
| controllerType[gp] = NES; | |||
| if(buttonCountNew < 8) | |||
| buttonCountNew = 8; | |||
| } | |||
| else if(buttons[gp] & NTT_CONTROL_BIT) { // SNES NTT Data Keypad | |||
| controllerType[gp] = NTT; | |||
| buttonCountNew = 32; | |||
| } | |||
| else { // SNES Gamepad | |||
| if(controllerType[gp] != NTT) | |||
| controllerType[gp] = SNES; | |||
| if(buttonCountNew < 12) | |||
| buttonCountNew = 12; | |||
| } | |||
| } | |||
| } | |||
| #ifdef DEBUG | |||
| for(gp=0; gp<GAMEPAD_COUNT; gp++) | |||
| { | |||
| Serial.print("Controller "); | |||
| Serial.print(gp+1); | |||
| Serial.print(": "); | |||
| Serial.println(buttons[gp]); | |||
| } | |||
| #endif | |||
| // Set updated button count to avoid unneccesary button reads (for simpler controller types) | |||
| buttonCount = buttonCountNew; | |||
| } | |||
| void sendLatch() | |||
| { | |||
| // Send a latch pulse to (S)NES controller(s) | |||
| PORTD |= B00000010; // Set HIGH | |||
| DELAY_CYCLES(CYCLES_LATCH); | |||
| PORTD &= ~B00000010; // Set LOW | |||
| DELAY_CYCLES(CYCLES_PAUSE); | |||
| } | |||
| void sendClock() | |||
| { | |||
| // Send a clock pulse to (S)NES controller(s) | |||
| PORTD |= B10000001; // Set HIGH | |||
| DELAY_CYCLES(CYCLES_CLOCK); | |||
| PORTD &= ~B10000001; // Set LOW | |||
| DELAY_CYCLES(CYCLES_PAUSE); | |||
| } | |||
BIN
SNESNTTControllersUSB/images/snes-usb-adapter-wiring.png
View File
| Before | After |
|---|---|
|
|
| Width: 700 | Height: 544 | Size: 275 KiB |