visus
/
teensy-usbhost
Прати 1
Волим 0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 0 Вики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 Комити
1 Грана
Дрво: 14c1fe646d
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from '14c1fe646d'
${ noResults }
teensy-usbhost/joystick.cpp

1073 lines
36KB
Датотека Blame Историја 

  1. /* USB EHCI Host for Teensy 3.6

  2.  * Copyright 2017 Paul Stoffregen (paul@pjrc.com)

  3.  *

  4.  * Permission is hereby granted, free of charge, to any person obtaining a

  5.  * copy of this software and associated documentation files (the

  6.  * "Software"), to deal in the Software without restriction, including

  7.  * without limitation the rights to use, copy, modify, merge, publish,

  8.  * distribute, sublicense, and/or sell copies of the Software, and to

  9.  * permit persons to whom the Software is furnished to do so, subject to

  10.  * the following conditions:

  11.  *

  12.  * The above copyright notice and this permission notice shall be included

  13.  * in all copies or substantial portions of the Software.

  14.  *

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

  16.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  17.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

  18.  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

  19.  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

  20.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

  21.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  22.  */

  23. 

  24. #include <Arduino.h>

  25. #include "USBHost_t36.h"  // Read this header first for key info

  26. 

  27. #define print   USBHost::print_

  28. #define println USBHost::println_

  29. 

  30. //#define DEBUG_JOYSTICK

  31. #ifdef  DEBUG_JOYSTICK

  32. #define DBGPrintf USBHDBGSerial.printf

  33. #else

  34. #define DBGPrintf(...) 

  35. #endif

  36. 

  37. // PID/VID to joystick mapping - Only the XBOXOne is used to claim the USB interface directly, 

  38. // The others are used after claim-hid code to know which one we have and to use it for 

  39. // doing other features.  

  40. JoystickController::product_vendor_mapping_t JoystickController::pid_vid_mapping[] = {

  41. 	{ 0x045e, 0x02ea, XBOXONE, false },{ 0x045e, 0x02dd, XBOXONE, false },

  42. 	{ 0x045e, 0x0719, XBOX360, false},

  43. 	{ 0x054C, 0x0268, PS3, true}, 

  44. 	{ 0x054C, 0x042F, PS3, true},	// PS3 Navigation controller

  45. 	{ 0x054C, 0x03D5, PS3_MOTION, true},	// PS3 Motion controller

  46. 	{ 0x054C, 0x05C4, PS4, true}, {0x054C, 0x09CC, PS4, true }

  47. };

  48. 

  49. 

  50. 

  51. //-----------------------------------------------------------------------------

  52. void JoystickController::init()

  53. {

  54. 	contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));

  55. 	contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));

  56. 	contribute_String_Buffers(mystring_bufs, sizeof(mystring_bufs)/sizeof(strbuf_t));

  57. 	driver_ready_for_device(this);

  58. 	USBHIDParser::driver_ready_for_hid_collection(this);

  59. 	BluetoothController::driver_ready_for_bluetooth(this);

  60. }

  61. 

  62. //-----------------------------------------------------------------------------

  63. JoystickController::joytype_t JoystickController::mapVIDPIDtoJoystickType(uint16_t idVendor, uint16_t idProduct, bool exclude_hid_devices)

  64. {

  65. 	for (uint8_t i = 0; i < (sizeof(pid_vid_mapping)/sizeof(pid_vid_mapping[0])); i++) {

  66. 		if ((idVendor == pid_vid_mapping[i].idVendor) && (idProduct == pid_vid_mapping[i].idProduct)) {

  67. 			println("Match PID/VID: ", i, DEC);

  68. 			if (exclude_hid_devices && pid_vid_mapping[i].hidDevice) return UNKNOWN;

  69. 			return pid_vid_mapping[i].joyType;

  70. 		}

  71. 	}  

  72. 	return UNKNOWN; 	// Not in our list

  73. }

  74. 

  75. //*****************************************************************************

  76. // Some simple query functions depend on which interface we are using...

  77. //*****************************************************************************

  78. 

  79. uint16_t JoystickController::idVendor() 

  80. {

  81. 	if (device != nullptr) return device->idVendor;

  82. 	if (mydevice != nullptr) return mydevice->idVendor;

  83. 	return 0;

  84. }

  85. 

  86. uint16_t JoystickController::idProduct() 

  87. {

  88. 	if (device != nullptr) return device->idProduct;

  89. 	if (mydevice != nullptr) return mydevice->idProduct;

  90. 	return 0;

  91. }

  92. 

  93. const uint8_t *JoystickController::manufacturer()

  94. {

  95. 	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_MAN]];

  96. 	//if ((btdevice != nullptr) && (btdevice->strbuf != nullptr)) return &btdevice->strbuf->buffer[btdevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; 

  97. 	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_MAN]]; 

  98. 	return nullptr;

  99. }

  100. 

  101. const uint8_t *JoystickController::product()

  102. {

  103. 	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_PROD]];

  104. 	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_PROD]]; 

  105. 	if (btdevice != nullptr) return remote_name_;

  106. 	return nullptr;

  107. }

  108. 

  109. const uint8_t *JoystickController::serialNumber()

  110. {

  111. 	if ((device != nullptr) && (device->strbuf != nullptr)) return &device->strbuf->buffer[device->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]];

  112. 	if ((mydevice != nullptr) && (mydevice->strbuf != nullptr)) return &mydevice->strbuf->buffer[mydevice->strbuf->iStrings[strbuf_t::STR_ID_SERIAL]]; 

  113. 	return nullptr;

  114. }

  115. 

  116. 

  117. bool JoystickController::setRumble(uint8_t lValue, uint8_t rValue, uint8_t timeout)

  118. {

  119. 	// Need to know which joystick we are on.  Start off with XBox support - maybe need to add some enum value for the known

  120. 	// joystick types. 

  121. 	rumble_lValue_ = lValue; 

  122. 	rumble_rValue_ = rValue;

  123. 	rumble_timeout_ = timeout;

  124. 

  125. 	switch (joystickType_) {

  126. 		default:

  127. 			break;

  128. 		case PS3:

  129. 			return transmitPS3UserFeedbackMsg();

  130. 		case PS3_MOTION:

  131. 			return transmitPS3MotionUserFeedbackMsg();

  132. 		case PS4:

  133. 			return transmitPS4UserFeedbackMsg();

  134. 		case XBOXONE:

  135. 			// Lets try sending a request to the XBox 1.

  136. 			txbuf_[0] = 0x9;

  137. 			txbuf_[1] = 0x0;

  138. 			txbuf_[2] = 0x0;

  139. 			txbuf_[3] = 0x09; // Substructure (what substructure rest of this packet has)

  140. 			txbuf_[4] = 0x00; // Mode

  141. 			txbuf_[5] = 0x0f; // Rumble mask (what motors are activated) (0000 lT rT L R)

  142. 			txbuf_[6] = 0x0; // lT force

  143. 			txbuf_[7] = 0x0; // rT force

  144. 			txbuf_[8] = lValue; // L force

  145. 			txbuf_[9] = rValue; // R force

  146. 			txbuf_[10] = 0xff; // Length of pulse

  147. 			txbuf_[11] = 0x00; // Period between pulses			

  148. 			txbuf_[12] = 0x00; // Repeat			

  149. 			if (!queue_Data_Transfer(txpipe_, txbuf_, 13, this)) {

  150. 				println("XBoxOne rumble transfer fail");

  151. 			}

  152. 			return true;	// 

  153. 		case XBOX360:

  154. 			txbuf_[0] = 0x00;

  155. 			txbuf_[1] = 0x01;

  156. 			txbuf_[2] = 0x0F;

  157. 			txbuf_[3] = 0xC0;

  158. 			txbuf_[4] = 0x00;

  159. 			txbuf_[5] = lValue;

  160. 			txbuf_[6] = rValue;

  161. 			txbuf_[7] = 0x00;

  162. 			txbuf_[8] = 0x00;

  163. 			txbuf_[9] = 0x00;

  164. 			txbuf_[10] = 0x00;

  165. 			txbuf_[11] = 0x00;

  166. 			if (!queue_Data_Transfer(txpipe_, txbuf_, 12, this)) {

  167. 				println("XBox360 rumble transfer fail");

  168. 			}

  169. 			return true;

  170. 	} 

  171. 	return false;

  172. }

  173. 

  174. 

  175. bool JoystickController::setLEDs(uint8_t lr, uint8_t lg, uint8_t lb)

  176. {

  177. 	// Need to know which joystick we are on.  Start off with XBox support - maybe need to add some enum value for the known

  178. 	// joystick types. 

  179. 	if ((leds_[0] != lr) || (leds_[1] != lg) || (leds_[2] != lb)) {

  180. 		leds_[0] = lr;

  181. 		leds_[1] = lg;

  182. 		leds_[2] = lb;

  183. 

  184. 		switch (joystickType_) {

  185. 			case PS3:

  186. 				return transmitPS3UserFeedbackMsg();

  187. 			case PS3_MOTION:

  188. 				return transmitPS3MotionUserFeedbackMsg();

  189. 			case PS4:

  190. 				return transmitPS4UserFeedbackMsg();

  191. 			case XBOX360:

  192. 				// 0: off, 1: all blink then return to before

  193. 				// 2-5(TL, TR, BL, BR) - blink on then stay on

  194. 				// 6-9() - On 

  195. 			    // ...

  196. 				txbuf_[1] = 0x00;

  197. 				txbuf_[2] = 0x08;

  198. 				txbuf_[3] = 0x40 + lr;

  199. 				txbuf_[4] = 0x00;

  200. 				txbuf_[5] = 0x00;

  201. 				txbuf_[6] = 0x00;

  202. 				txbuf_[7] = 0x00;

  203. 				txbuf_[8] = 0x00;

  204. 				txbuf_[9] = 0x00;

  205. 				txbuf_[10] = 0x00;

  206. 				txbuf_[11] = 0x00;

  207. 				if (!queue_Data_Transfer(txpipe_, txbuf_, 12, this)) {

  208. 					println("XBox360 set leds fail");

  209. 				}

  210. 				return true;

  211. 			case XBOXONE:

  212. 			default:

  213. 				return false;

  214. 		} 

  215. 	}

  216. 	return false;

  217. }

  218. 

  219. bool JoystickController::transmitPS4UserFeedbackMsg() {

  220. 	if (driver_)  {

  221. 		uint8_t packet[32];

  222. 	    memset(packet, 0, sizeof(packet));

  223. 

  224. 	    packet[0] = 0x05; // Report ID

  225. 	    packet[1]= 0xFF;

  226. 

  227. 	    packet[4] = rumble_lValue_; // Small Rumble

  228. 	    packet[5] = rumble_rValue_; // Big rumble

  229. 	    packet[6] = leds_[0]; // RGB value 

  230. 	    packet[7] = leds_[1]; 

  231. 	    packet[8] = leds_[2];

  232. 	    // 9, 10 flash ON, OFF times in 100ths of second?  2.5 seconds = 255

  233. 	    DBGPrintf("Joystick update Rumble/LEDs\n");

  234. 		return driver_->sendPacket(packet, 32);

  235. 	} else if (btdriver_) {

  236. 		uint8_t packet[79];

  237. 	    memset(packet, 0, sizeof(packet));

  238. //0xa2, 0x11, 0xc0, 0x20, 0xf0, 0x04, 0x00

  239. 	    packet[0] = 0x52; 

  240. 	    packet[1] = 0x11;      // Report ID

  241. 		packet[2] = 0x80;

  242. 		//packet[3] = 0x20;

  243. 		packet[4] = 0xFF;

  244. 

  245. 	    packet[7] = rumble_lValue_; // Small Rumble

  246. 	    packet[8] = rumble_rValue_; // Big rumble

  247. 	    packet[9] = leds_[0]; // RGB value 

  248. 	    packet[10] = leds_[1]; 

  249. 	    packet[11] = leds_[2];

  250. 

  251. 	    // 12, 13 flash ON, OFF times in 100ths of sedond?  2.5 seconds = 255

  252. 	    DBGPrintf("Joystick update Rumble/LEDs\n");

  253.      	btdriver_->sendL2CapCommand(packet, sizeof(packet), 0x40);

  254. 

  255.      	return true;

  256. 	}

  257. 	return false;

  258. }

  259. 

  260. static const uint8_t PS3_USER_FEEDBACK_INIT[] = {

  261.         0x00, 0x00, 0x00, 0x00, 0x00,

  262.         0x00, 0x00, 0x00, 0x00, 0x00,

  263.         0xff, 0x27, 0x10, 0x00, 0x32,

  264.         0xff, 0x27, 0x10, 0x00, 0x32,

  265.         0xff, 0x27, 0x10, 0x00, 0x32,

  266.         0xff, 0x27, 0x10, 0x00, 0x32,

  267.         0x00, 0x00, 0x00, 0x00, 0x00,

  268.         0x00, 0x00, 0x00, 0x00, 0x00,

  269.         0x00, 0x00, 0x00, 0x00, 0x00,

  270.         0x00, 0x00, 0x00 };

  271. 

  272. bool JoystickController::transmitPS3UserFeedbackMsg() {

  273. 	if (driver_) {

  274. 	    memcpy(txbuf_, PS3_USER_FEEDBACK_INIT, 48);

  275. 

  276. 	    txbuf_[1] = rumble_lValue_? rumble_timeout_ : 0;

  277. 	    txbuf_[2] = rumble_lValue_; // Small Rumble

  278. 	    txbuf_[3] = rumble_rValue_? rumble_timeout_ : 0; 

  279. 	    txbuf_[4] = rumble_rValue_; // Big rumble

  280. 	    txbuf_[9] = leds_[2] << 1; // RGB value 	// using third led now...

  281. 	    //DBGPrintf("\nJoystick update Rumble/LEDs %d %d %d %d %d\n",  txbuf_[1], txbuf_[2],  txbuf_[3],  txbuf_[4],  txbuf_[9]);

  282. 		return driver_->sendControlPacket(0x21, 9, 0x201, 0, 48, txbuf_); 

  283. 	} else if (btdriver_) {

  284. 		txbuf_[0] = 0x52;

  285. 		txbuf_[1] = 0x1;

  286. 	    memcpy(&txbuf_[2], PS3_USER_FEEDBACK_INIT, 48);

  287. 

  288. 	    txbuf_[3] = rumble_lValue_? rumble_timeout_ : 0;

  289. 	    txbuf_[4] = rumble_lValue_; // Small Rumble

  290. 	    txbuf_[5] = rumble_rValue_? rumble_timeout_ : 0; 

  291. 	    txbuf_[6] = rumble_rValue_; // Big rumble

  292. 	    txbuf_[11] = leds_[2] << 1; // RGB value 

  293. 	    DBGPrintf("\nJoystick update Rumble/LEDs %d %d %d %d %d\n",  txbuf_[3], txbuf_[4],  txbuf_[5],  txbuf_[6],  txbuf_[11]);

  294.      	btdriver_->sendL2CapCommand(txbuf_, 50, BluetoothController::CONTROL_SCID);

  295.      	return true;

  296. 	}

  297. 	return false;

  298. }

  299. 

  300. #define MOVE_REPORT_BUFFER_SIZE 7

  301. #define MOVE_HID_BUFFERSIZE 50 // Size of the buffer for the Playstation Motion Controller

  302. 

  303. bool JoystickController::transmitPS3MotionUserFeedbackMsg() {

  304. 	if (driver_) {

  305.         txbuf_[0] = 0x02; // Set report ID, this is needed for Move commands to work

  306.         txbuf_[2] = leds_[0];

  307.         txbuf_[3] = leds_[1];

  308.         txbuf_[4] = leds_[2];

  309.         txbuf_[6] = rumble_lValue_; // Set the rumble value into the write buffer

  310. 

  311. 		//return driver_->sendControlPacket(0x21, 9, 0x201, 0, MOVE_REPORT_BUFFER_SIZE, txbuf_); 

  312. 		return driver_->sendPacket(txbuf_, MOVE_REPORT_BUFFER_SIZE);

  313. 

  314. 	} else if (btdriver_) {

  315.         txbuf_[0] = 0xA2; // HID BT DATA_request (0xA0) | Report Type (Output 0x02)

  316.         txbuf_[1] = 0x02; // Report ID

  317.         txbuf_[3] = leds_[0];

  318.         txbuf_[4] = leds_[1];

  319.         txbuf_[5] = leds_[2];

  320.         txbuf_[7] = rumble_lValue_;

  321.      	btdriver_->sendL2CapCommand(txbuf_, MOVE_HID_BUFFERSIZE, BluetoothController::INTERRUPT_SCID);

  322.      	return true;

  323. 	}

  324. 	return false;

  325. }

  326. 

  327. //*****************************************************************************

  328. // Support for Joysticks that Use HID data. 

  329. //*****************************************************************************

  330. 

  331. hidclaim_t JoystickController::claim_collection(USBHIDParser *driver, Device_t *dev, uint32_t topusage)

  332. {

  333. 	// only claim Desktop/Joystick and Desktop/Gamepad

  334. 	if (topusage != 0x10004 && topusage != 0x10005) return CLAIM_NO;

  335. 	// only claim from one physical device

  336. 	if (mydevice != NULL && dev != mydevice) return CLAIM_NO;

  337. 

  338. 	// Also don't allow us to claim if it is used as a standard usb object (XBox...)

  339. 	if (device != nullptr) return CLAIM_NO;

  340. 

  341. 	mydevice = dev;

  342. 	collections_claimed++;

  343. 	anychange = true; // always report values on first read

  344. 	driver_ = driver;	// remember the driver. 

  345. 	driver_->setTXBuffers(txbuf_, nullptr, sizeof(txbuf_));

  346. 	connected_ = true;		// remember that hardware is actually connected...

  347. 

  348. 	// Lets see if we know what type of joystick this is. That is, is it a PS3 or PS4 or ...

  349. 	joystickType_ = mapVIDPIDtoJoystickType(mydevice->idVendor, mydevice->idProduct, false);

  350. 	DBGPrintf("JoystickController::claim_collection joystickType_=%d\n", joystickType_);

  351. 	switch (joystickType_) {

  352. 		case PS3:

  353. 		case PS3_MOTION: // not sure yet

  354. 			additional_axis_usage_page_ = 0x1;

  355. 			additional_axis_usage_start_ = 0x100;

  356. 			additional_axis_usage_count_ = 39;

  357. 			axis_change_notify_mask_ = (uint64_t)-1;	// Start off assume all bits 

  358. 			break;

  359. 		case PS4:

  360. 			additional_axis_usage_page_ = 0xFF00;

  361. 			additional_axis_usage_start_ = 0x21;

  362. 			additional_axis_usage_count_ = 54;

  363. 			axis_change_notify_mask_ = (uint64_t)0xfffffffffffff3ffl;	// Start off assume all bits - 10 and 11

  364. 			break;

  365. 		default: 

  366. 			additional_axis_usage_page_ = 0x09;

  367. 			additional_axis_usage_start_ = 0x21;

  368. 			additional_axis_usage_count_ = 5;

  369. 			axis_change_notify_mask_ = 0x3ff;	// Start off assume only the 10 bits...

  370. 	}

  371. 	DBGPrintf("Claim Additional axis: %x %x %d\n", additional_axis_usage_page_, additional_axis_usage_start_, additional_axis_usage_count_);

  372. 	return CLAIM_REPORT;

  373. }

  374. 

  375. void JoystickController::disconnect_collection(Device_t *dev)

  376. {

  377. 	if (--collections_claimed == 0) {

  378. 		mydevice = NULL;

  379. 		driver_ = nullptr;

  380. 		axis_mask_ = 0;	

  381. 		axis_changed_mask_ = 0;

  382. 	}

  383. }

  384. 

  385. void JoystickController::hid_input_begin(uint32_t topusage, uint32_t type, int lgmin, int lgmax)

  386. {

  387. 	// TODO: set up translation from logical min/max to consistent 16 bit scale

  388. }

  389. 

  390. void JoystickController::hid_input_data(uint32_t usage, int32_t value)

  391. {

  392. 	DBGPrintf("Joystick: usage=%X, value=%d\n", usage, value);

  393. 	uint32_t usage_page = usage >> 16;

  394. 	usage &= 0xFFFF;

  395. 	if (usage_page == 9 && usage >= 1 && usage <= 32) {

  396. 		uint32_t bit = 1 << (usage -1);

  397. 		if (value == 0) {

  398. 			if (buttons & bit) {

  399. 				buttons &= ~bit;

  400. 				anychange = true;

  401. 			}

  402. 		} else {

  403. 			if (!(buttons & bit)) {

  404. 				buttons |= bit;

  405. 				anychange = true;

  406. 			}

  407. 		}

  408. 	} else if (usage_page == 1 && usage >= 0x30 && usage <= 0x39) {

  409. 		// TODO: need scaling of value to consistent API, 16 bit signed?

  410. 		// TODO: many joysticks repeat slider usage.  Detect & map to axis?

  411. 		uint32_t i = usage - 0x30;

  412. 		axis_mask_ |= (1 << i);		// Keep record of which axis we have data on.

  413. 		if (axis[i] != value) {

  414. 			axis[i] = value;

  415. 			axis_changed_mask_ |= (1 << i);

  416. 			if (axis_changed_mask_ & axis_change_notify_mask_)

  417. 				anychange = true;

  418. 		}

  419. 	} else if (usage_page == additional_axis_usage_page_) {

  420. 		// see if the usage is witin range.

  421. 		//DBGPrintf("UP: usage_page=%x usage=%x User: %x %d\n", usage_page, usage, user_buttons_usage_start, user_buttons_count_);

  422. 		if ((usage >= additional_axis_usage_start_) && (usage < (additional_axis_usage_start_ + additional_axis_usage_count_))) {

  423. 			// We are in the user range. 

  424. 			uint16_t usage_index = usage - additional_axis_usage_start_ + STANDARD_AXIS_COUNT;

  425. 			if (usage_index < (sizeof(axis)/sizeof(axis[0]))) {

  426. 				if (axis[usage_index] != value) {

  427. 					axis[usage_index] = value;

  428. 					if (usage_index > 63) usage_index = 63;	// don't overflow our mask

  429. 					axis_changed_mask_ |= ((uint64_t)1 << usage_index);		// Keep track of which ones changed.

  430. 					if (axis_changed_mask_ & axis_change_notify_mask_)

  431. 						anychange = true;	// We have changes... 

  432. 				}

  433. 				axis_mask_ |= ((uint64_t)1 << usage_index);		// Keep record of which axis we have data on.

  434. 			}

  435. 			//DBGPrintf("UB: index=%x value=%x\n", usage_index, value);

  436. 		}

  437. 

  438. 	} else {

  439. 		DBGPrintf("UP: usage_page=%x usage=%x add: %x %x %d\n", usage_page, usage, additional_axis_usage_page_, additional_axis_usage_start_, additional_axis_usage_count_);

  440. 

  441. 	}

  442. 	// TODO: hat switch?

  443. }

  444. 

  445. void JoystickController::hid_input_end()

  446. {

  447. 	if (anychange) {

  448. 		joystickEvent = true;

  449. 	}

  450. }

  451. 

  452. bool JoystickController::hid_process_out_data(const Transfer_t *transfer) 

  453. {

  454. 	//DBGPrintf("JoystickController::hid_process_out_data\n");

  455. 	return true;

  456. }

  457. 

  458. void JoystickController::joystickDataClear() {

  459. 	joystickEvent = false;

  460. 	anychange = false;

  461. 	axis_changed_mask_ = 0;

  462. 	axis_mask_ = 0;

  463. }

  464. 

  465. //*****************************************************************************

  466. // Support for Joysticks that are class specific and do not use HID

  467. // Example: XBox One controller. 

  468. //*****************************************************************************

  469. 

  470. static  uint8_t xboxone_start_input[] = {0x05, 0x20, 0x00, 0x01, 0x00};

  471. static  uint8_t xbox360w_inquire_present[] = {0x08, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

  472. 

  473. bool JoystickController::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)

  474. {

  475. 	println("JoystickController claim this=", (uint32_t)this, HEX);

  476. 

  477. 	// Don't try to claim if it is used as USB device or HID device

  478. 	if (mydevice != NULL) return false;

  479. 	if (device != nullptr) return false;

  480. 

  481. 	// Try claiming at the interface level.

  482. 	if (type != 1) return false;

  483. 	print_hexbytes(descriptors, len);

  484. 

  485. 	JoystickController::joytype_t jtype = mapVIDPIDtoJoystickType(dev->idVendor, dev->idProduct, true);

  486. 	println("Jtype=", (uint8_t)jtype, DEC);

  487. 	if (jtype == UNKNOWN)

  488. 		return false; 

  489. 

  490. 	// XBOX One

  491. 	//  0  1  2  3  4  5  6  7  8 *9 10  1  2  3  4  5 *6  7  8  9 20  1  2  3  4  5  6  7  8  9 30  1... 

  492. 	// 09 04 00 00 02 FF 47 D0 00 07 05 02 03 40 00 04 07 05 82 03 40 00 04 09 04 01 00 00 FF 47 D0 00 

  493. 	// Lets do some verifications to make sure. 

  494. 

  495. 	// XBOX 360 wireless... Has 8 interfaces.  4 joysticks (1, 3, 5, 7) and 4 headphones assume 2,4,6, 8... 

  496. 	// Shows data for #1 only... 

  497. 	// Also they have some unknown data type we need to ignore between interface and end points.

  498. 	//  0  1  2  3  4  5  6  7  8 *9 10  1  2  3  4  5 *6  7  8  9 20  1  2  3  4  5  6  7  8 

  499. 	// 09 04 00 00 02 FF 5D 81 00 14 22 00 01 13 81 1D 00 17 01 02 08 13 01 0C 00 0C 01 02 08 

  500. 

  501.   	// 29 30  1  2  3  4  5  6  7  8  9 40 41 42

  502. 	// 07 05 81 03 20 00 01 07 05 01 03 20 00 08 

  503. 

  504. 	if (len < 9+7+7) return false;

  505. 

  506. 	// Some common stuff for both XBoxs

  507. 	uint32_t count_end_points = descriptors[4];

  508. 	if (count_end_points < 2) return false;

  509. 	if (descriptors[5] != 0xff) return false; // bInterfaceClass, 3 = HID

  510. 	rx_ep_ = 0;

  511. 	uint32_t txep = 0;

  512. 	uint8_t rx_interval = 0;

  513. 	uint8_t tx_interval = 0;

  514. 	rx_size_ = 0;

  515. 	tx_size_ = 0;

  516. 	uint32_t descriptor_index = 9; 

  517. 	if (descriptors[descriptor_index+1] == 0x22)  {

  518. 		if (descriptors[descriptor_index] != 0x14) return false; // only support specific versions...

  519. 		descriptor_index += descriptors[descriptor_index]; // XBox360w ignore this unknown setup...

  520. 	}	

  521. 	while (count_end_points-- && ((rx_ep_ == 0) || txep == 0)) {

  522. 		if (descriptors[descriptor_index] != 7) return false; // length 7

  523. 		if (descriptors[descriptor_index+1] != 5) return false; // ep desc

  524. 		if ((descriptors[descriptor_index+3] == 3) 				// Type 3...

  525. 			&& (descriptors[descriptor_index+4] <= 64)

  526. 			&& (descriptors[descriptor_index+5] == 0)) {

  527. 			// have a bulk EP size 

  528. 			if (descriptors[descriptor_index+2] & 0x80 ) {

  529. 				rx_ep_ = descriptors[descriptor_index+2];

  530. 				rx_size_ = descriptors[descriptor_index+4];

  531. 				rx_interval = descriptors[descriptor_index+6];

  532. 			} else {

  533. 				txep = descriptors[descriptor_index+2]; 

  534. 				tx_size_ = descriptors[descriptor_index+4];

  535. 				tx_interval = descriptors[descriptor_index+6];

  536. 			}

  537. 		}

  538. 		descriptor_index += 7;  // setup to look at next one...

  539. 	}

  540. 	if ((rx_ep_ == 0) || (txep == 0)) return false; // did not find two end points.

  541. 	print("JoystickController, rx_ep_=", rx_ep_ & 15);

  542. 	print("(", rx_size_);

  543. 	print("), txep=", txep);

  544. 	print("(", tx_size_);

  545. 	println(")");

  546. 	rxpipe_ = new_Pipe(dev, 3, rx_ep_ & 15, 1, rx_size_, rx_interval);

  547. 	if (!rxpipe_) return false;

  548. 	txpipe_ = new_Pipe(dev, 3, txep, 0, tx_size_, tx_interval);

  549. 	if (!txpipe_) {

  550. 		//free_Pipe(rxpipe_);

  551. 		return false;

  552. 	}

  553. 	rxpipe_->callback_function = rx_callback;

  554. 	queue_Data_Transfer(rxpipe_, rxbuf_, rx_size_, this);

  555. 

  556. 	txpipe_->callback_function = tx_callback;

  557. 

  558. 	if (jtype == XBOXONE) {

  559. 		queue_Data_Transfer(txpipe_, xboxone_start_input, sizeof(xboxone_start_input), this);

  560. 		connected_ = true;		// remember that hardware is actually connected...

  561. 	} else if (jtype == XBOX360) {

  562. 		queue_Data_Transfer(txpipe_, xbox360w_inquire_present, sizeof(xbox360w_inquire_present), this);

  563. 		connected_ = 0;		// remember that hardware is actually connected...

  564. 	}

  565. 	memset(axis, 0, sizeof(axis));	// clear out any data. 

  566. 	joystickType_ = jtype;		// remember we are an XBox One. 

  567. 	DBGPrintf("   JoystickController::claim joystickType_ %d\n", joystickType_);

  568. 	return true;

  569. }

  570. 

  571. void JoystickController::control(const Transfer_t *transfer)

  572. {

  573. }

  574. 

  575. 

  576. /************************************************************/

  577. //  Interrupt-based Data Movement

  578. /************************************************************/

  579. 

  580. void JoystickController::rx_callback(const Transfer_t *transfer)

  581. {

  582. 	if (!transfer->driver) return;

  583. 	((JoystickController *)(transfer->driver))->rx_data(transfer);

  584. }

  585. 

  586. void JoystickController::tx_callback(const Transfer_t *transfer)

  587. {

  588. 	if (!transfer->driver) return;

  589. 	((JoystickController *)(transfer->driver))->tx_data(transfer);

  590. }

  591. 

  592. 

  593. 

  594. /************************************************************/

  595. //  Interrupt-based Data Movement

  596. // XBox one input data when type == 0x20

  597. // Information came from several places on the web including: 

  598. // https://github.com/quantus/xbox-one-controller-protocol

  599. /************************************************************/

  600. // 20 00 C5 0E 00 00 00 00 00 00 F0 06 AD FB 7A 0A DD F7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

  601. // 20 00 E0 0E 40 00 00 00 00 00 F0 06 AD FB 7A 0A DD F7 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

  602. typedef struct {

  603. 	uint8_t type;

  604. 	uint8_t const_0;

  605. 	uint16_t id;

  606. 	// From online references button order: 

  607. 	//     sync, dummy, start, back, a, b, x, y

  608. 	//     dpad up, down left, right

  609. 	//	   lb, rb, left stick, right stick

  610. 	// Axis: 

  611. 	//     lt, rt, lx, ly, rx, ry

  612. 	//     

  613. 	uint16_t buttons; 

  614. 	int16_t	axis[6];

  615. } xbox1data20_t;

  616. 

  617. typedef struct {

  618. 	uint8_t state;

  619. 	uint8_t id_or_type;

  620. 	uint16_t controller_status;

  621. 	uint16_t unknown;

  622. 	// From online references button order: 

  623. 	//     sync, dummy, start, back, a, b, x, y

  624. 	//     dpad up, down left, right

  625. 	//	   lb, rb, left stick, right stick

  626. 	// Axis: 

  627. 	//     lt, rt, lx, ly, rx, ry

  628. 	//

  629. 	uint16_t buttons; 

  630. 	uint8_t lt;

  631. 	uint8_t rt;

  632. 	int16_t	axis[4];

  633. } xbox360data_t;

  634. 

  635. static const uint8_t xbox_axis_order_mapping[] = {3, 4, 0, 1, 2, 5};

  636. 

  637. void JoystickController::rx_data(const Transfer_t *transfer)

  638. {

  639. 	print("JoystickController::rx_data (", joystickType_, DEC);

  640. 	print("): ");

  641. 	print_hexbytes((uint8_t*)transfer->buffer, transfer->length);

  642. 

  643. 	if (joystickType_ == XBOXONE) {

  644. 		// Process XBOX One data

  645. 		axis_mask_ = 0x3f;	

  646. 		axis_changed_mask_ = 0;	// assume none for now

  647. 		xbox1data20_t *xb1d = (xbox1data20_t *)transfer->buffer;

  648. 		if ((xb1d->type == 0x20) && (transfer->length >= sizeof (xbox1data20_t))) {

  649. 			// We have a data transfer.  Lets see what is new...

  650. 			if (xb1d->buttons != buttons) {

  651. 				buttons = xb1d->buttons;

  652. 				anychange = true;

  653. 				joystickEvent = true;

  654. 				println("  Button Change: ", buttons, HEX);

  655. 			}

  656. 			for (uint8_t i = 0; i < sizeof (xbox_axis_order_mapping); i++) {

  657. 				// The first two values were unsigned. 

  658. 				int axis_value = (i < 2)? (int)(uint16_t)xb1d->axis[i] : xb1d->axis[i];

  659. 				if (axis_value != axis[xbox_axis_order_mapping[i]]) {

  660. 					axis[xbox_axis_order_mapping[i]] = axis_value;

  661. 					axis_changed_mask_ |= (1 << xbox_axis_order_mapping[i]);

  662. 					anychange = true;

  663. 				}

  664. 			}

  665. 			joystickEvent = true;

  666. 		}

  667. 

  668. 	} else if (joystickType_ == XBOX360) {

  669. 		// First byte appears to status - if the byte is 0x8 it is a connect or disconnect of the controller. 

  670. 		xbox360data_t  *xb360d = (xbox360data_t *)transfer->buffer;

  671. 		if (xb360d->state == 0x08) {

  672. 			if (xb360d->id_or_type != connected_) {

  673. 				connected_ = xb360d->id_or_type;	// remember it... 

  674. 				if (connected_) {

  675. 					println("XBox360w - Connected type:", connected_, HEX);

  676. 					// rx_ep_ should be 1, 3, 5, 7 for the wireless convert to 2-5 on led

  677. 					setLEDs(2+rx_ep_/2);	// Right now hard coded to first joystick...

  678. 

  679. 				} else {

  680. 					println("XBox360w - disconnected");

  681. 				}

  682. 			}

  683. 		} else if((xb360d->id_or_type == 0x00) && (xb360d->controller_status & 0x1300)) {

  684. 			  // Controller status report - Maybe we should save away and allow the user access?

  685. 	            println("XBox360w - controllerStatus: ", xb360d->controller_status, HEX);

  686.         } else if(xb360d->id_or_type == 0x01) { // Lets only process report 1.

  687. 			//const uint8_t *pbuffer = (uint8_t*)transfer->buffer;

  688.         	//for (uint8_t i = 0; i < transfer->length; i++) DBGPrintf("%02x ", pbuffer[i]);

  689.         	//DBGPrintf("\n");

  690. 	        

  691. 	        if (buttons != xb360d->buttons) {

  692. 	        	buttons = xb360d->buttons;

  693. 	        	anychange = true;

  694. 	        }

  695. 			axis_mask_ = 0x3f;	

  696. 			axis_changed_mask_ = 0;	// assume none for now

  697. 

  698. 			for (uint8_t i = 0; i < 4; i++) {

  699. 				if (axis[i] != xb360d->axis[i]) {

  700. 					axis[i] = xb360d->axis[i];

  701. 					axis_changed_mask_ |= (1 << i);

  702. 					anychange = true;

  703. 				}

  704. 			}

  705. 			// the two triggers show up as 4 and 5

  706. 			if (axis[4] != xb360d->lt) {

  707. 				axis[4] = xb360d->lt;

  708. 				axis_changed_mask_ |= (1 << 4);

  709. 				anychange = true;

  710. 			}

  711. 

  712. 			if (axis[5] != xb360d->rt) {

  713. 				axis[5] = xb360d->rt;

  714. 				axis_changed_mask_ |= (1 << 5);

  715. 				anychange = true;

  716. 			}

  717. 

  718. 			if (anychange) joystickEvent = true;

  719. 		}

  720. 	}

  721. 

  722. 	queue_Data_Transfer(rxpipe_, rxbuf_, rx_size_, this);

  723. }

  724. 

  725. void JoystickController::tx_data(const Transfer_t *transfer)

  726. {

  727. }

  728. 

  729. void JoystickController::disconnect()

  730. {

  731. 	axis_mask_ = 0;	

  732. 	axis_changed_mask_ = 0;

  733. 	// TODO: free resources

  734. }

  735. 

  736. bool JoystickController::claim_bluetooth(BluetoothController *driver, uint32_t bluetooth_class, uint8_t *remoteName) 

  737. {

  738. 	if ((((bluetooth_class & 0xff00) == 0x2500) || (((bluetooth_class & 0xff00) == 0x500))) && ((bluetooth_class & 0x3C) == 0x08)) {

  739. 		DBGPrintf("JoystickController::claim_bluetooth TRUE\n");

  740. 		btdriver_ = driver;

  741. 		btdevice = (Device_t*)driver;	// remember this way 

  742. 		if (remoteName) mapNameToJoystickType(remoteName);

  743. 		return true;

  744. 	}

  745. 

  746. 	if (remoteName && mapNameToJoystickType(remoteName)) {

  747. 		if ((joystickType_ == PS3) || (joystickType_ == PS3_MOTION)) {

  748. 			DBGPrintf("JoystickController::claim_bluetooth TRUE PS3 hack...\n");

  749. 			btdriver_ = driver;

  750. 			btdevice = (Device_t*)driver;	// remember this way 

  751. 			special_process_required = SP_PS3_IDS; 		// PS3 maybe needs different IDS. 

  752. 			return true;

  753. 		}

  754. 	}

  755. 	return false;

  756. }

  757. 

  758. 

  759. bool JoystickController::process_bluetooth_HID_data(const uint8_t *data, uint16_t length) 

  760. {

  761. 	// Example data from PS4 controller

  762. 	//01 7e 7f 82 84 08 00 00 00 00

  763. 	//   LX LY RX RY BT BT PS LT RT

  764. 	DBGPrintf("JoystickController::process_bluetooth_HID_data: data[0]=%x\n", data[0]);

  765. 	// May have to look at this one with other controllers...

  766. 	if (data[0] == 1) {

  767. 		//print("  Joystick Data: ");

  768. 		// print_hexbytes(data, length);

  769. 		if (length > TOTAL_AXIS_COUNT) length = TOTAL_AXIS_COUNT;	// don't overflow arrays...

  770. 		DBGPrintf("  Joystick Data: ");

  771. 		for(uint16_t i =0; i < length; i++) DBGPrintf("%02x ", data[i]);

  772. 		DBGPrintf("\r\n");	

  773. 		if (joystickType_ == PS3) {

  774. 			// Quick and dirty hack to match PS3 HID data

  775. 			uint32_t cur_buttons = data[2] | ((uint16_t)data[3] << 8) | ((uint32_t)data[4] << 16); 

  776. 			if (cur_buttons != buttons) {

  777. 				buttons = cur_buttons;

  778. 				joystickEvent = true;	// something changed.

  779. 			}

  780. 

  781. 			uint64_t mask = 0x1;

  782. 			axis_mask_ = 0x27;	// assume bits 0, 1, 2, 5

  783. 			for (uint16_t i = 0; i < 3; i++) {

  784. 				if (axis[i] != data[i+6]) {

  785. 					axis_changed_mask_ |= mask;

  786. 					axis[i] = data[i+6];

  787. 				}

  788. 				mask <<= 1;	// shift down the mask.

  789. 			}

  790. 			if (axis[5] != data[9]) {

  791. 				axis_changed_mask_ |= (1<<5);

  792. 				axis[5] = data[9];

  793. 			}

  794. 			

  795. 			if (axis[3] != data[18]) {

  796. 				axis_changed_mask_ |= (1<<3);

  797. 				axis[3] = data[18];

  798. 			}

  799. 			

  800. 			if (axis[4] != data[19]) {

  801. 				axis_changed_mask_ |= (1<<4);

  802. 				axis[4] = data[19];

  803. 			}

  804. 			

  805. 			// Then rest of data

  806. 			mask = 0x1 << 10;	// setup for other bits

  807. 			for (uint16_t i = 10; i < length; i++ ) {

  808. 				axis_mask_ |= mask;

  809. 				if(data[i] != axis[i]) { 

  810. 					axis_changed_mask_ |= mask;

  811. 					axis[i] = data[i];

  812. 				} 

  813. 				mask <<= 1;	// shift down the mask.

  814. 			}

  815. 		} else if (joystickType_ == PS3_MOTION) {

  816. 			// Quick and dirty PS3_Motion data.

  817. 			uint32_t cur_buttons = data[1] | ((uint16_t)data[2] << 8) | ((uint32_t)data[3] << 16); 

  818. 			if (cur_buttons != buttons) {

  819. 				buttons = cur_buttons;

  820. 				joystickEvent = true;	// something changed.

  821. 			}

  822. 

  823. 			// Hard to know what is best here. for now just copy raw data over... 

  824. 			// will do this for now... Format of thought to be data.

  825. 			//  data[1-3] Buttons (mentioned 4 as well but appears to be counter

  826. 			// axis[0-1] data[5] Trigger, Previous trigger value

  827. 			// 2-5 Unknown probably place holders for Axis like data for other PS3

  828. 			// 6 - Time stamp

  829. 			// 7 - Battery

  830. 			// 8-19 - Accel: XL, XH, YL, YH, ZL, ZH, XL2, XH2, YL2, YH2, ZL2, ZH2

  831. 			// 20-31 - Gyro: Xl,Xh,Yl,Yh,Zl,Zh,Xl2,Xh2,Yl2,Yh2,Zl2,Zh2

  832. 			// 32 - Temp High

  833. 			// 33 - Temp Low (4 bits)  Maybe Magneto x High on other?? 

  834. 			uint64_t mask = 0x1;

  835. 			axis_mask_ = 0;	// assume bits 0, 1, 2, 5

  836. 			// Then rest of data

  837. 			mask = 0x1 << 10;	// setup for other bits

  838. 			for (uint16_t i = 5; i < length; i++ ) {

  839. 				axis_mask_ |= mask;

  840. 				if(data[i] != axis[i-5]) { 

  841. 					axis_changed_mask_ |= mask;

  842. 					axis[i-5] = data[i];

  843. 				} 

  844. 				mask <<= 1;	// shift down the mask.

  845. 			}

  846. 

  847. 		} else {

  848. 			uint64_t mask = 0x1;

  849. 			axis_mask_ = 0;

  850. 

  851. 			for (uint16_t i = 0; i < length; i++ ) {

  852. 				axis_mask_ |= mask;

  853. 				if(data[i] != axis[i]) { 

  854. 					axis_changed_mask_ |= mask;

  855. 					axis[i] = data[i];

  856. 				} 

  857. 				mask <<= 1;	// shift down the mask.

  858. //				DBGPrintf("%02x ", axis[i]);

  859. 			}

  860. 

  861. 		}

  862. 

  863. 		if (axis_changed_mask_ & axis_change_notify_mask_)

  864. 			joystickEvent = true;

  865. 		connected_ = true;

  866. 		return true;

  867. 

  868. 	} else if(data[0] == 0x11){

  869. 		DBGPrintf("\n  Joystick Data: ");

  870. 		uint64_t mask = 0x1;

  871. 		axis_mask_ = 0;

  872. 		axis_changed_mask_ = 0;

  873. 		

  874. 		//This moves data to be equivalent to what we see for

  875. 		//data[0] = 0x01

  876. 		uint8_t tmp_data[length-2];

  877. 		

  878. 		for (uint16_t i = 0; i < (length-2); i++ ) {

  879. 			tmp_data[i] = 0;

  880. 			tmp_data[i] = data[i+2];

  881. 		}

  882. 		

  883. 		/*

  884. 		 * [1] LX, [2] = LY, [3] = RX, [4] = RY

  885. 		 * [5] combo, tri, cir, x, sqr, D-PAD (4bits, 0-3

  886. 		 * [6] R3,L3, opt, share, R2, L2, R1, L1

  887. 		 * [7] Counter (bit7-2), T-PAD, PS

  888. 		 * [8] Left Trigger, [9] Right Trigger

  889. 		 * [10-11] Timestamp

  890. 		 * [12] Battery (0 to 0xff)

  891. 		 * [13-14] acceleration x

  892. 		 * [15-16] acceleration y

  893. 		 * [17-18] acceleration z

  894. 		 * [19-20] gyro x

  895. 		 * [21-22] gyro y

  896. 		 * [23-24] gyro z

  897. 		 * [25-29] unknown

  898. 		 * [30] 0x00,phone,mic, usb, battery level (4bits)

  899. 		 * rest is trackpad?  to do implement?

  900. 		 */

  901. 		//PS Bit

  902. 		tmp_data[7] = (tmp_data[7] >> 0) & 1;

  903. 		//set arrow buttons to axis[0]

  904. 		tmp_data[10] = tmp_data[5] & ((1 << 4) - 1);

  905. 		//set buttons for last 4bits in the axis[5]

  906. 		tmp_data[5] = tmp_data[5] >> 4;

  907. 		

  908. 	

  909. 		// Quick and dirty hack to match PS4 HID data

  910. 		uint32_t cur_buttons = tmp_data[7] | (tmp_data[10]) | ((tmp_data[6]*10)) | ((uint16_t)tmp_data[5] << 16) ; 

  911. 		if (cur_buttons != buttons) {

  912. 			buttons = cur_buttons;

  913. 			joystickEvent = true;	// something changed.

  914. 		}

  915. 		

  916. 		mask = 0x1;

  917. 		axis_mask_ = 0x27;	// assume bits 0, 1, 2, 5

  918. 		for (uint16_t i = 0; i < 3; i++) {

  919. 			if (axis[i] != tmp_data[i+1]) {

  920. 				axis_changed_mask_ |= mask;

  921. 				axis[i] = tmp_data[i+1];

  922. 			}

  923. 			mask <<= 1;	// shift down the mask.

  924. 		}

  925. 		if (axis[5] != tmp_data[4]) {

  926. 			axis_changed_mask_ |= (1<<5);

  927. 			axis[5] = tmp_data[4];

  928. 		}

  929. 		

  930. 		if (axis[3] != tmp_data[8]) {

  931. 			axis_changed_mask_ |= (1<<3);

  932. 			axis[3] = tmp_data[8];

  933. 		}

  934. 		

  935. 		if (axis[4] != tmp_data[9]) {

  936. 			axis_changed_mask_ |= (1<<4);

  937. 			axis[4] = tmp_data[9];

  938. 		}

  939. 		

  940. 		//limit for masking

  941. 		mask = 0x1;

  942. 		for (uint16_t i = 6; i < (64); i++ ) {

  943. 			axis_mask_ |= mask;

  944. 			if(tmp_data[i] != axis[i]) { 

  945. 				axis_changed_mask_ |= mask;

  946. 				axis[i] = tmp_data[i];

  947. 			}

  948. 			mask <<= 1;	// shift down the mask.

  949. 			DBGPrintf("%02x ", axis[i]);

  950. 		}

  951. 		DBGPrintf("\n");

  952. 		//DBGPrintf("Axis Mask (axis_mask_, axis_changed_mask_; %d, %d\n", axis_mask_,axis_changed_mask_);

  953. 		joystickEvent = true;

  954. 		connected_ = true;

  955. 	}

  956. 	return false;

  957. }

  958. 

  959. bool JoystickController::mapNameToJoystickType(const uint8_t *remoteName)

  960. {

  961. 	// Sort of a hack, but try to map the name given from remote to a type...

  962. 	if (strncmp((const char *)remoteName, "Wireless Controller", 19) == 0) {

  963. 		DBGPrintf("  JoystickController::mapNameToJoystickType %s - set to PS4\n", remoteName);

  964. 		joystickType_ = PS4;

  965. 	} else if (strncmp((const char *)remoteName, "PLAYSTATION(R)3", 15) == 0) {

  966. 		DBGPrintf("  JoystickController::mapNameToJoystickType %x %s - set to PS3\n", (uint32_t)this, remoteName);

  967. 		joystickType_ = PS3;

  968. 	} else if (strncmp((const char *)remoteName, "Navigation Controller", 21) == 0) {

  969. 		DBGPrintf("  JoystickController::mapNameToJoystickType %x %s - set to PS3\n", (uint32_t)this, remoteName);

  970. 		joystickType_ = PS3;

  971. 	} else if (strncmp((const char *)remoteName, "Motion Controller", 17) == 0) {

  972. 		DBGPrintf("  JoystickController::mapNameToJoystickType %x %s - set to PS3 Motion\n", (uint32_t)this, remoteName);

  973. 		joystickType_ = PS3_MOTION;

  974. 	} else if (strncmp((const char *)remoteName, "Xbox Wireless", 13) == 0) {

  975. 		DBGPrintf("  JoystickController::mapNameToJoystickType %x %s - set to XBOXONE\n", (uint32_t)this, remoteName);

  976. 		joystickType_ = XBOXONE;

  977. 	} else {

  978. 		DBGPrintf("  JoystickController::mapNameToJoystickType %s - Unknown\n", remoteName);

  979. 	}

  980. 	DBGPrintf("  Joystick Type: %d\n", joystickType_);

  981. 	return true;

  982. }

  983. 

  984. 

  985. bool JoystickController::remoteNameComplete(const uint8_t *remoteName) 

  986. {

  987. 	// Sort of a hack, but try to map the name given from remote to a type...

  988. 	if (mapNameToJoystickType(remoteName)) {

  989. 		switch (joystickType_) {

  990. 			case PS4: special_process_required = SP_NEED_CONNECT; break;

  991. 			case PS3: special_process_required = SP_PS3_IDS; break;

  992. 			case PS3_MOTION: special_process_required = SP_PS3_IDS; break;

  993. 			default: 

  994. 				break;

  995. 		}

  996. 	}

  997. 	return true;

  998. }

  999. 

  1000. void JoystickController::connectionComplete() 

  1001. {

  1002. 	DBGPrintf("  JoystickController::connectionComplete %x joystick type %d\n", (uint32_t)this, joystickType_);

  1003. 	switch (joystickType_) {

  1004. 	case PS4:

  1005. 		{

  1006. 			uint8_t packet[2];

  1007. 			packet[0] = 0x43; // HID BT Get_report (0x40) | Report Type (Feature 0x03)

  1008. 			packet[1] = 0x02; // Report ID

  1009. 			DBGPrintf("Set PS4 report\n");

  1010. 			delay(1);

  1011. 			btdriver_->sendL2CapCommand(packet, sizeof(packet), 0x40);			

  1012. 		}

  1013. 		break;

  1014. 	case PS3:

  1015. 		{

  1016. 			uint8_t packet[6];

  1017. 			packet[0] = 0x53; // HID BT Set_report (0x50) | Report Type (Feature 0x03)

  1018. 			packet[1] = 0xF4; // Report ID

  1019. 			packet[2] = 0x42; // Special PS3 Controller enable commands

  1020. 			packet[3] = 0x03;

  1021. 			packet[4] = 0x00;

  1022. 			packet[5] = 0x00;

  1023. 

  1024. 			DBGPrintf("enable six axis\n");

  1025. 			delay(1);

  1026. 			btdriver_->sendL2CapCommand(packet, sizeof(packet), BluetoothController::CONTROL_SCID);

  1027. 		}

  1028. 		break;

  1029. 	case PS3_MOTION:	

  1030. 		setLEDs(0, 0xff, 0);	// Maybe try setting to green? 

  1031. 	default:

  1032. 		break;	

  1033. 	}

  1034. }

  1035. 

  1036. void JoystickController::release_bluetooth() 

  1037. {

  1038. 	btdevice = nullptr;	// remember this way 

  1039. 	btdriver_ = nullptr;

  1040. 	connected_ = false;

  1041. 	special_process_required = false;

  1042. 

  1043. }

  1044. 

  1045. 

  1046. bool JoystickController::PS3Pair(uint8_t* bdaddr) {

  1047. 	if (!driver_) return false;

  1048.  	if (joystickType_ == PS3) {

  1049.  	    /* Set the internal Bluetooth address */

  1050. 	    txbuf_[0] = 0x01;

  1051. 	    txbuf_[1] = 0x00;

  1052. 

  1053. 	    for(uint8_t i = 0; i < 6; i++)

  1054. 	            txbuf_[i + 2] = bdaddr[5 - i]; // Copy into buffer, has to be written reversed, so it is MSB first

  1055. 

  1056. 	    // bmRequest = Host to device (0x00) | Class (0x20) | Interface (0x01) = 0x21, bRequest = Set Report (0x09), Report ID (0xF5), Report Type (Feature 0x03), interface (0x00), datalength, datalength, data

  1057. 		return driver_->sendControlPacket(0x21, 9, 0x3f5, 0, 8, txbuf_); 

  1058. 	} else if (joystickType_ == PS3_MOTION) {

  1059. 		// Slightly different than other PS3 units...

  1060. 	    txbuf_[0] = 0x05;

  1061. 	    for(uint8_t i = 0; i < 6; i++)

  1062. 	            txbuf_[i + 1] = bdaddr[i]; // Order different looks like LSB First?

  1063. 

  1064.         txbuf_[7] = 0x10;

  1065.         txbuf_[8] = 0x01;

  1066.         txbuf_[9] = 0x02;

  1067.         txbuf_[10] = 0x12;

  1068. 	    // bmRequest = Host to device (0x00) | Class (0x20) | Interface (0x01) = 0x21, bRequest = Set Report (0x09), Report ID (0xF5), Report Type (Feature 0x03), interface (0x00), datalength, datalength, data

  1069. 		return driver_->sendControlPacket(0x21, 9, 0x305, 0, 11, txbuf_); 

  1070. 	}

  1071. 	return false;

  1072. }