Changeset 703832c in avrstuff

Timestamp:

Sep 26, 2021, 10:16:19 AM (3 years ago)

Author:

Adrien Destugues <pulkomandy@…>

Branches:

main

Children:

e545350

Parents:

81b8d53

Message:

GrIP2HID: actually do HID (using the LUFA USB stack)

Location:

grip2hid

Files:

• Config/LUFAConfig.h (added)
• Descriptors.c (added)
• Descriptors.h (added)
• Joystick.c (added)
• Joystick.h (added)
• Makefile (deleted)
• README.md (modified) (1 diff)
• grip.cpp (moved) (moved from grip2hid/main.cpp ) (12 diffs)
• makefile (added)

grip2hid/README.md

@@ -11 +11 @@
 (2 gameports, each allowing to use 2 gamepads thanks to Gravis chaining system).
 
+The gamepads are each reported as a separate USB report, and show up as 4 independant
+gamepads on both Windows and Haiku. Buttons are assigned in this order:
+green, yellow, red, blue, L1, R1, start, select, R2, L2. This order is reasonable
+(but not perfect) while allowing to reuse the bits received from the gamepad almost
+directly to fill the HID report. The only change needed is inverting the Y axis,
+because USB wants the up direction to be lowest values.
+
 It is powered by an AT90USB AVR microcontroller, because these implement USB in
-hardware and have easily usable external interupts (PCINT) making it much easier
-to implement the protocol (this helps because the gamepad is the master and
-drives the clock).
+hardware and make it easy to implement an HID device.
+
+You need the LUFA USB stack to compile this project. I am not including it to
+avoid code duplication. Download and extract it yourself, or set the LUFA_PATH variable
+to where you already have it when compiling.
 
 [Further reading on GrIP](http://pulkomandy.tk/_/_Electronique/_Gravis%20Interface%20Protocol)

grip2hid/grip.cpp

@@ -1 +1 @@
 #include <avr/io.h>
-#include <avr/interrupt.h>
-#include <avr/wdt.h>
-#include <avr/pgmspace.h>
-#include <util/delay.h>
 
-#include <string.h>
 #include <stdbool.h>
 
-#include "../libs/usart/usart.h"
-
+// The UART is on PD2 (Rx) and PD3 (Tx)
+// The gamepads are all connected on port B
 #define GRIP_PORT PORTB
 #define GRIP_DDR  DDRB
@@ -32 +27 @@
         }
 
+        // Push the next bit and returns true if it completes a word.
+        // The whole 24 bit word is stored in "word" and consists of:
+        // - One 7-bit sync pattern: always 0111111
+        // - Three 6-bit blocks starting with a 0 followed by 5 button bits
         bool PushBit(uint32_t bit)
         {
-                word = (word << 1) | (bit & 1);
+                word = (word >> 1) | ((bit & 1) << 31);
                 count++;
 
                 switch (state) {
                         case 0:
-                                if ((word & 0x3F) != 0x1F) return false;
-                                count = 6;
+                                if ((word & 0xFE000000) != 0x7C000000) return false;
+                                count = 7;
                                 state = 1;
                                 break;
@@ -55 +54 @@
         }
 
-        void Dump() {
-                USARTWriteHex(word >> 16);
-                USARTWriteHex(word >> 8);
-                USARTWriteHex(word);
-        }
-
+public:
+        uint32_t word;
 private:
-        uint32_t word;
         uint8_t count;
-        uint8_t state;
+        uint8_t state; // 0 = looking for sync, 1 = synchronized (we received 0111111)
 };
 
 
-int main() {
-        wdt_enable(WDTO_2S);
-
+extern "C" void GrIP_Init() {
         // GrIP input
         GRIP_PORT = 0xFF; // Enable pull-ups
         GRIP_DDR = 0;  // Port as input
+}
 
-        USARTInit();
-        USARTWriteChar('h');
-        USARTWriteChar('\r');
-        USARTWriteChar('\n');
-
+extern "C" uint8_t GrIP_Read(uint32_t* v, uint8_t k2) {
         // Initial value of oldv for edge detection
         uint8_t oldv = GRIP_PIN;
+        static uint8_t k = 0;
+        if (k2 != 0)
+                k = k2 - 1;
+        else {
+                k++; if (k > 3) k = 0;
+        }
 
-        for (;;) {
                 // Because the CPU is too slow, if we try to scan all pads at once we
                 // don't manage to decode them (missed transitions). So we scan them
@@ -95 +89 @@
                 // also fixes the problem mentionned below that when less pads are
                 // connected, it will not slowdown waiting for one of them to timeout.
+                //
+                // When a gamepad is plugged, the loop seems to complete in around 1000 iterations.
+                // When no gamepad is plugged, that's a timeout.
 
-                // FIXME the loop to 255 here to wait for a bit isn't too nice. We
-                // should rather use a timer with a known period?
                 // Process pad1
                 GrIP pad;
-                uint8_t i;
-                for (i = 0; i < 255; i++) {
-                        wdt_reset();
+                uint16_t i;
 
+                if (k == 0)
+                for (i = 0; i < 2048; i++) {
                         uint8_t newv = GRIP_PIN;
-
                         if (!(newv & GRIP_CLK_A)) { // clock is down
                                 if (oldv & GRIP_CLK_A) { // and it was up at previous read
@@ -111 +105 @@
                                         uint32_t bit = (newv & GRIP_DAT_A) != 0;
                                         if (pad.PushBit(bit)) {
+                                                *v = pad.word;
                                                 break;
                                         }
@@ -118 +113 @@
                 }
 
-                pad.Dump();
-                USARTWriteChar(' ');
-
                 // Process pad 2
-                for (i = 0; i < 255; i++) {
-                        wdt_reset();
-
+                if (k == 1)
+                for (i = 0; i < 2048; i++) {
                         uint8_t newv = GRIP_PIN;
                         if (!(newv & GRIP_CLK_B)) { // clock is down
@@ -131 +122 @@
                                         uint32_t bit = (newv & GRIP_DAT_B) != 0;
                                         if (pad.PushBit(bit)) {
+                                                *v = pad.word;
                                                 break;
                                         }
@@ -138 +130 @@
                 }
 
-                pad.Dump();
-                USARTWriteChar(' ');
-
                 // Process pad 3
-                for (i = 0; i < 255; i++) {
-                        wdt_reset();
-
+                if (k == 2)
+                for (i = 0; i < 2048; i++) {
                         uint8_t newv = GRIP_PIN;
                         if (!(newv & GRIP_CLK_C)) { // clock is down
@@ -151 +139 @@
                                         uint32_t bit = (newv & GRIP_DAT_C) != 0;
                                         if (pad.PushBit(bit)) {
+                                                *v = pad.word;
                                                 break;
                                         }
@@ -158 +147 @@
                 }
 
-                pad.Dump();
-                USARTWriteChar(' ');
-
                 // Process pad 4
-                for (i = 0; i < 255; i++) {
-                        wdt_reset();
-
+                if (k == 3)
+                for (i = 0; i < 2048; i++) {
                         uint8_t newv = GRIP_PIN;
                         if (!(newv & GRIP_CLK_D)) { // clock is down
@@ -171 +156 @@
                                         uint32_t bit = (newv & GRIP_DAT_D) != 0;
                                         if (pad.PushBit(bit)) {
+                                                *v = pad.word;
                                                 break;
                                         }
@@ -178 +164 @@
                 }
 
-                pad.Dump();
-                USARTWriteChar('\r');
-                USARTWriteChar('\n');
-        }
-
-        return 0;
+                return k;
 }