├── demo.jpg
├── README.md
└── Nano_33_Gamepad.ino


/demo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bitbank2/Nano_33_Gamepad/HEAD/demo.jpg


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Nano 33 Gamepad<br>
 2 | Project started 10/26/2019<br>
 3 | Copyright (c) 2019 BitBank Software, Inc.<br>
 4 | Written by Larry Bank<br>
 5 | bitbank@pobox.com<br>
 6 | <br>
 7 | ![Nano 33 Gamepad](/demo.jpg?raw=true "Nano 33 Gamepad")
 8 | <br>
 9 | The purpose of this code is to use BLE HID gamepads with the Arduino Nano 33 BLE.
10 | The Nano 33 BLE libraries don't include any HID support, so this code is
11 | very rudamentary and instead of properly parsing the HID reports, it makes
12 | assumptions to work with 2 popular devices (ACGAM R1 and MINI PLUS).
13 | There is a #define switch to send the output to either the serial monitor
14 | or a 128x64 SSD1306 OLED display. The code was written to learn about HID
15 | over GATT and how difficult it would be to implement a minimal HID host
16 | using the Nano 33 BLE board.
17 | <br>
18 | 
19 | 


--------------------------------------------------------------------------------
/Nano_33_Gamepad.ino:
--------------------------------------------------------------------------------
  1 | //
  2 | // Sample sketch to connect a BLE HID Gamepad to the Arduino Nano 33 BLE
  3 | // This code doesn't implement a full HID report parser and instead
  4 | // supports only the 2 most popular devices I could find (ACGAM R1 and MINI PLUS)
  5 | //
  6 | // Copyright (c) 2019 BitBank Software, Inc.
  7 | // written by Larry Bank (bitbank@pobox.com)
  8 | // project started 10/26/2019
  9 | //
 10 | 
 11 | #include <ArduinoBLE.h>
 12 | 
 13 | void ProcessHIDReport(uint8_t *ucData, int iLen);
 14 | void ShowMsg(char *msg, int iLine);
 15 | 
 16 | //
 17 | // Define this to display results on a 128x64 OLED
 18 | // otherwise output will be sent to the serial monitor
 19 | #define USE_OLED
 20 | 
 21 | #ifdef USE_OLED
 22 | #include <ss_oled.h>
 23 | #endif
 24 | 
 25 | enum {
 26 |   CONTROLLER_ACGAM_R1 = 0,
 27 |   CONTROLLER_MINIPLUS,
 28 |   CONTROLLER_UNKNOWN
 29 | };
 30 | 
 31 | char *szACGAM = (char *)"ACGAM R1          ";
 32 | char *szMINIPLUS = (char *)"MINI PLUS";
 33 | static int iControllerType;
 34 | volatile static int bConnected, bChanged;
 35 | 
 36 | // Current button state
 37 | // The first 8 bits are for the (up to 8) push buttons
 38 | static uint16_t u16Buttons;
 39 | // bits to define the direction pad since it's not analog
 40 | #define BUTTON_LEFT 0x100
 41 | #define BUTTON_RIGHT 0x200
 42 | #define BUTTON_UP 0x400
 43 | #define BUTTON_DOWN 0x800
 44 | 
 45 | // Graphics for the controller real time display
 46 | const uint8_t ucArrow[] PROGMEM = {
 47 |  0x01,0x80,0x02,0x40,0x04,0x20,0x08,0x10,0x10,0x08,0x20,0x04,0x40,0x02,0x80,0x01,
 48 |  0x80,0x01,0xfc,0x3f,0x04,0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x07,0xe0
 49 | };
 50 | 
 51 | const uint8_t ucFilledArrow[] PROGMEM = {
 52 |  0x01,0x80,0x03,0xc0,0x07,0xe0,0x0f,0xf0,0x1f,0xf8,0x3f,0xfc,0x7f,0xfe,0xff,0xff,
 53 |  0xff,0xff,0xff,0xff,0x07,0xe0,0x07,0xe0,0x07,0xe0,0x07,0xe0,0x07,0xe0,0x07,0xe0
 54 | };
 55 | 
 56 | const uint8_t ucSquare[] PROGMEM = {
 57 |  0x00,0x00,0x00,0x00,0x3f,0xfc,0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x04,
 58 |  0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x04,0x3f,0xfc,0x00,0x00,0x00,0x00
 59 | };
 60 | 
 61 | const uint8_t ucFilledSquare[] PROGMEM = {
 62 |  0x00,0x00,0x00,0x00,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,
 63 |  0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x3f,0xfc,0x00,0x00,0x00,0x00
 64 | };
 65 | 
 66 | void setup()
 67 | {
 68 | #ifdef USE_OLED
 69 |   oledInit(OLED_128x64, 0,0, -1, -1, 400000L);
 70 |   oledFill(0, 1);
 71 | #else
 72 |   Serial.begin(115200);
 73 |   while (!Serial);
 74 | #endif
 75 | 
 76 |   ShowMsg("Scanning for BLE ctrl", 0);
 77 | 
 78 |   // begin initialization
 79 |   if (!BLE.begin())
 80 |   {
 81 |     ShowMsg("starting BLE failed!", 0);
 82 |     while (1);
 83 |   }
 84 |   // start scanning for peripheral
 85 |   BLE.scan();
 86 |   
 87 |   u16Buttons = 0;
 88 | } /* setup() */
 89 | 
 90 | void loop()
 91 | {
 92 | char szTemp[64];
 93 | 
 94 |   bConnected = 0;
 95 |   // check if a peripheral has been discovered
 96 |   BLEDevice peripheral = BLE.available();
 97 | 
 98 |   if (peripheral) {
 99 |     // discovered a peripheral, print out address, local name, and advertised service
100 |     sprintf(szTemp, "Found %s", peripheral.address().c_str());
101 |     ShowMsg(szTemp,1);
102 |     sprintf(szTemp, "%s - %s", peripheral.localName().c_str(), peripheral.advertisedServiceUuid().c_str());
103 |     ShowMsg(szTemp, 2);
104 | 
105 | 
106 |   // Compare it to known controllers
107 |     iControllerType = CONTROLLER_UNKNOWN;
108 |     if (strcmp(peripheral.localName().c_str(), szACGAM) == 0)
109 |        iControllerType = CONTROLLER_ACGAM_R1;
110 |     else if (strcmp(peripheral.localName().c_str(), szMINIPLUS) == 0)
111 |        iControllerType = CONTROLLER_MINIPLUS;
112 |        
113 |     // Check if the peripheral is a HID device
114 |     if (peripheral.advertisedServiceUuid() == "1812" && iControllerType != CONTROLLER_UNKNOWN) {
115 |       // stop scanning
116 |       BLE.stopScan();
117 | 
118 |       monitorActions(peripheral);
119 | 
120 |       // peripheral disconnected, start scanning again
121 |       BLE.scan();
122 |       }
123 |     }
124 | } /* loop() */
125 | 
126 | //
127 | // Callback which handles HID report updates
128 | //
129 | void HIDReportWritten(BLEDevice central, BLECharacteristic characteristic)
130 | {
131 | int iLen, i;
132 | uint8_t ucTemp[128];
133 | 
134 |   // central wrote new HID report info
135 |   iLen = characteristic.readValue(ucTemp, sizeof(ucTemp));
136 |   ProcessHIDReport(ucTemp, iLen);
137 | } /* HIDReportWritten() */
138 | void monitorActions(BLEDevice peripheral) {
139 | 
140 | char ucTemp[128];
141 | int i, iLen, iCount;
142 | //BLECharacteristic hidRep[16];
143 | BLEService hidService;
144 | //int ihidCount = 0;
145 | 
146 |   // connect to the peripheral
147 |   ShowMsg("Connecting...", 4);
148 |   if (peripheral.connect()) {
149 |     ShowMsg("Connected", 5);
150 |   } else {
151 |     ShowMsg("Failed to connect!", 5);
152 |     return;
153 |   }
154 | 
155 |   // discover peripheral attributes
156 | //  Serial.println("Discovering service 0x1812 ...");
157 |   if (peripheral.discoverService("1812")) {
158 |     ShowMsg("0x1812 discovered", 6);
159 |   } else {
160 |     ShowMsg("0x1812 disc failed", 6);
161 |     peripheral.disconnect();
162 | 
163 |     while (1);
164 |     return;
165 |   }
166 | 
167 |   hidService = peripheral.service("1812"); // get the HID service
168 | 
169 | //  Serial.print("characteristic count = "); Serial.println(hidService.characteristicCount(), DEC);
170 | 
171 |   iCount = hidService.characteristicCount();
172 |   for (i=0; i<iCount; i++)
173 |   {
174 |     BLECharacteristic bc = hidService.characteristic(i);
175 | //    Serial.print("characteristic "); Serial.print(i, DEC);
176 | //    Serial.print(" = "); Serial.println(bc.uuid());
177 | //    Serial.print("Descriptor count = "); Serial.println(bc.descriptorCount(), DEC);
178 |     if (strcasecmp(bc.uuid(),"2a4D") == 0) // enable notify
179 |     {
180 | //      hidRep[ihidCount++] = bc;
181 |       bc.subscribe();
182 |       bc.setEventHandler(BLEWritten, HIDReportWritten);
183 |     }
184 |   }
185 |     
186 |   BLECharacteristic protmodChar = hidService.characteristic("2A4E"); // get protocol mode characteristic
187 |   if (protmodChar != NULL)
188 |   {
189 | //    Serial.println("Setting Protocol mode to REPORT_MODE");
190 |     protmodChar.writeValue((uint8_t)0x01); // set protocol report mode (we want reports) 
191 |   }
192 | 
193 | // DEBUG - for now, we're not parsing the report map
194 | //  BLECharacteristic reportmapChar = hidService.characteristic("2A4B");
195 | //  if (reportmapChar != NULL)
196 | //  {
197 | //    iLen = reportmapChar.readValue(ucTemp, 128);
198 | //    Serial.print("Read report map: ");
199 | //    for (i=0; i<iLen; i++)
200 | //    {
201 | //      Serial.print("0x"); Serial.print(ucTemp[i], HEX); Serial.print(", ");
202 | //    }
203 | //    Serial.println(" ");
204 | //  }
205 | 
206 | // subscribe to the HID report characteristic
207 | //  Serial.println("Subscribing to HID report characteristic(s) ...");
208 | //  if (!ihidCount) {
209 | //    ShowMsg("no HID report characteristics found!", 0);
210 | //    peripheral.disconnect();
211 | //    return;
212 | //  }
213 | //  else
214 | //  {
215 | //    for (i=0; i<ihidCount; i++) // The reports are split among multiple characteristics (different buttons/controls)
216 | //    {
217 | //      hidRep[i].subscribe(); // subscribe to all of them
218 | //      hidRep[i].setEventHandler(BLEWritten, HIDReportWritten);
219 | //    }
220 | //  }
221 |   ShowMsg("Ready to use!", 7);
222 |   delay(2000);
223 | #ifdef USE_OLED
224 |   oledFill(0,1);
225 | #endif
226 |   bChanged = 1; // force a repaint before the controls are touched, otherwise it will look like it's hung
227 |   
228 |   while (peripheral.connected()) {
229 |     // while the peripheral is connected
230 |     if (bChanged)
231 |     {
232 |       bChanged = 0;
233 | #ifdef USE_OLED
234 |       ShowControllerState(u16Buttons); // update OLED graphic display
235 | #else
236 |       sprintf(ucTemp, "Buttons changed: 0x%04x", u16Buttons);
237 |       ShowMsg(ucTemp, 0);
238 | #endif
239 |     }
240 |   } // while connected
241 | 
242 | //  Serial.println("HID device disconnected!");
243 | } /* monitorActions() */
244 | 
245 | //
246 | // Convert HID report bytes into
247 | // my button and joystick variables
248 | //
249 | void ProcessHIDReport(uint8_t *ucData, int iLen)
250 | {
251 | int i;
252 | 
253 |   bChanged = 1;
254 |   switch (iControllerType)
255 |   {
256 |     case CONTROLLER_ACGAM_R1:
257 |       if (iLen == 2) // it always writes 2 byte reports
258 |       {
259 |         // assumes it's in "Game Mode"
260 |         u16Buttons = ucData[0]; // 6 buttons
261 |         i = ucData[1] & 0xc0; // Y axis (0x40 == centered)
262 |         if (i == 0) // up
263 |            u16Buttons |= BUTTON_UP;
264 |         else if (i == 0x80) // down
265 |            u16Buttons |= BUTTON_DOWN;
266 |         i = ucData[1] & 0x30; // X axis (0x10 == centered)
267 |         if (i == 0) // left
268 |            u16Buttons |= BUTTON_LEFT;
269 |         else if (i == 0x20)
270 |            u16Buttons |= BUTTON_RIGHT;
271 |       }
272 |       break;
273 |     case CONTROLLER_MINIPLUS:
274 |       if (iLen == 9) // it always writes 9 byte reports
275 |       {
276 |         // directions
277 |         u16Buttons &= ~(BUTTON_UP | BUTTON_DOWN | BUTTON_LEFT | BUTTON_RIGHT);
278 |         if (ucData[2] == 0x81) // left
279 |            u16Buttons |= BUTTON_LEFT;
280 |         else if (ucData[2] == 0x7f) // right
281 |            u16Buttons |= BUTTON_RIGHT;
282 |         if (ucData[3] == 0x81) // up
283 |            u16Buttons |= BUTTON_UP;
284 |         else if (ucData[3] == 0x7f) // down
285 |            u16Buttons |= BUTTON_DOWN;
286 |         u16Buttons &= 0xff00; // gather other buttons
287 |         u16Buttons |= ucData[0]; // A/B/C/D buttons
288 |         u16Buttons |= (ucData[1] << 3); // start + select
289 |       }
290 |       break;
291 |   } // switch on controller type
292 | } /* ProcessHIDReport() */
293 | 
294 | #ifdef USE_OLED
295 | //
296 | // Display the current state of the controller
297 | // with graphics on the OLED
298 | //
299 | void ShowControllerState(uint16_t butts)
300 | {
301 | int i;
302 | uint8_t ucDirX[] = {0,32,16,16,16,48,64};
303 | uint8_t ucDirY[] = {4,4,2,6,4,4,4};
304 | uint8_t ucButtX[] = {64, 80, 96, 112, 64, 80, 96, 112};
305 | uint8_t ucButtY[] = {2,2,2,2, 6,6,6,6};
306 | const uint8_t *pEmpty[] = {ucArrow, ucArrow,ucArrow,ucArrow};
307 | const uint8_t *pFilled[] = {ucFilledArrow, ucFilledArrow, ucFilledArrow, ucFilledArrow};
308 | uint8_t ucAngle[] = {ANGLE_270, ANGLE_90, ANGLE_0, ANGLE_FLIPY, ANGLE_0,ANGLE_0,ANGLE_0,ANGLE_0};
309 | uint8_t *pImage;
310 | 
311 |   // Draw the directional arrows
312 |   for (i=0; i<4; i++)
313 |   {
314 |     if (butts & (0x100 << i))
315 |       pImage = (uint8_t *)pFilled[i];
316 |     else
317 |       pImage = (uint8_t *)pEmpty[i];     
318 |     oledDrawTile((const uint8_t *)pImage, ucDirX[i], ucDirY[i], ucAngle[i], 0, 1);  
319 |   }
320 |   // Print the button bits
321 |   oledWriteString(4, 64,1," 0 1 2 3", FONT_NORMAL, 0, 1); // use the scroll offset to center the numbers
322 |   oledWriteString(4, 64,5," 4 5 6 7", FONT_NORMAL, 0, 1);
323 |   // Draw the buttons
324 |   for (i=0; i<8; i++)
325 |   {
326 |     if (butts & (0x1 << i))
327 |       pImage = (uint8_t *)ucFilledSquare;
328 |     else
329 |       pImage = (uint8_t *)ucSquare;     
330 |     oledDrawTile((const uint8_t *)pImage, ucButtX[i], ucButtY[i], 0, 0, 1);  
331 |   }
332 | } /* ShowControllerstate() */
333 | #endif // USE_OLED
334 | //
335 | // Display a string message
336 | // On the OLED, you pass the line number
337 | // On the serial monitor, it just gets written continuously
338 | //
339 | void ShowMsg(char *msg, int iLine)
340 | {
341 | #ifdef USE_OLED
342 |   int iFont = (strlen(msg) >= 16) ? FONT_SMALL : FONT_NORMAL;
343 |   oledWriteString(0,0,iLine,msg, iFont, 0, 1);
344 | #else
345 |   Serial.println(msg);
346 | #endif  
347 | } /* ShowMsg() */
348 | 


--------------------------------------------------------------------------------