visus
/
teensy-usbhost
Obserwuj 1
Polub 0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
224 Commity
1 Gałąź
Drzewo: 5b85e608b7
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '5b85e608b7'
${ noResults }
teensy-usbhost/examples/JoystickBT/JoystickBT.ino

329 lines
10KB
Czysty Wina Historia 

  1. 

  2. // Simple test of USB Host Mouse/Keyboard

  3. //

  4. // This example is in the public domain

  5. 

  6. #include "USBHost_t36.h"

  7. //#include "debug_tt.h"

  8. 

  9. USBHost myusb;

  10. USBHub hub1(myusb);

  11. USBHub hub2(myusb);

  12. USBHIDParser hid1(myusb);

  13. USBHIDParser hid2(myusb);

  14. USBHIDParser hid3(myusb);

  15. USBHIDParser hid4(myusb);

  16. USBHIDParser hid5(myusb);

  17. JoystickController joystick1(myusb);

  18. //BluetoothController bluet(myusb, true, "0000");   // Version does pairing to device

  19. BluetoothController bluet(myusb);   // version assumes it already was paired

  20. int user_axis[64];

  21. uint16_t buttons_prev = 0;

  22. uint16_t buttons;

  23. RawHIDController rawhid1(myusb);

  24. RawHIDController rawhid2(myusb, 0xffc90004);

  25. 

  26. USBDriver *drivers[] = {&hub1, &hub2, &joystick1, &bluet, &hid1, &hid2, &hid3, &hid4, &hid5};

  27. 

  28. #define CNT_DEVICES (sizeof(drivers)/sizeof(drivers[0]))

  29. const char * driver_names[CNT_DEVICES] = {"Hub1","Hub2", "JOY1D", "Bluet", "HID1" , "HID2", "HID3", "HID4", "HID5"};

  30. 

  31. bool driver_active[CNT_DEVICES] = {false, false, false, false};

  32. 

  33. // Lets also look at HID Input devices

  34. USBHIDInput *hiddrivers[] = {&joystick1, &rawhid1, &rawhid2};

  35. 

  36. #define CNT_HIDDEVICES (sizeof(hiddrivers)/sizeof(hiddrivers[0]))

  37. const char * hid_driver_names[CNT_DEVICES] = {"Joystick1", "RawHid1", "RawHid2"};

  38. 

  39. bool hid_driver_active[CNT_DEVICES] = {false, false, false};

  40. bool show_changed_only = false; 

  41. bool show_raw_data = false;

  42. 

  43. uint8_t joystick_left_trigger_value = 0;

  44. uint8_t joystick_right_trigger_value = 0;

  45. uint64_t joystick_full_notify_mask = (uint64_t)-1;

  46. 

  47. int psAxis[64];

  48. bool first_joystick_message = true;

  49. 

  50. void setup()

  51. {

  52. /*  Serial4.begin( 1843200 );

  53.   debBegin_tt( &Serial4, LED_BUILTIN, 12);

  54.   debTraceShow_tt( -1, "", "", "" );

  55.   Serial4.println("\n" __FILE__ " " __DATE__ " " __TIME__);

  56.   Serial4.println("\n********\n T4 connected Serial1 *******\n");

  57.   Serial4.println("\n" __FILE__ " " __DATE__ " " __TIME__);

  58.   Serial4.println("\n********\n T4 connected Serial4 *******\n");

  59. */

  60. Serial1.begin(2000000);

  61.   while (!Serial) ; // wait for Arduino Serial Monitor

  62.   //debTraceShow_tt( -2, "", "", "" );

  63.   //Serial4.println("\n" __FILE__ " " __DATE__ " " __TIME__);

  64.   //Serial1.begin( 1843200 );

  65.   Serial.println("\n\nUSB Host Testing");

  66.   Serial.println(sizeof(USBHub), DEC);

  67.   myusb.begin();

  68. 

  69.   delay(2000);

  70. 

  71.   rawhid1.attachReceive(OnReceiveHidData);

  72.   rawhid2.attachReceive(OnReceiveHidData);

  73. }

  74. 

  75. 

  76. void loop()

  77. {

  78.   myusb.Task();

  79.  

  80.   if (Serial.available()) {

  81.     int ch = Serial.read(); // get the first char. 

  82.     while (Serial.read() != -1) ; 

  83.     if ((ch == 'b') || (ch == 'B')) {

  84.       Serial.println("Only notify on Basic Axis changes");

  85.       joystick1.axisChangeNotifyMask(0x3ff);

  86.     } else if ((ch == 'f') || (ch == 'F')) {

  87.       Serial.println("Only notify on Full Axis changes");

  88.       joystick1.axisChangeNotifyMask(joystick_full_notify_mask);

  89. 

  90.     } else {

  91.       if (show_changed_only) {

  92.         show_changed_only = false;

  93.         Serial.println("\n*** Show All fields mode ***");

  94.       } else {

  95.         show_changed_only = true;

  96.         Serial.println("\n*** Show only changed fields mode ***");

  97.       }

  98.     }

  99.  }

  100. 

  101.   for (uint8_t i = 0; i < CNT_DEVICES; i++) {

  102.     if (*drivers[i] != driver_active[i]) {

  103.       if (driver_active[i]) {

  104.         Serial.printf("*** Device %s - disconnected ***\n", driver_names[i]);

  105.         driver_active[i] = false;

  106.       } else {

  107.         Serial.printf("*** Device %s %x:%x - connected ***\n", driver_names[i], drivers[i]->idVendor(), drivers[i]->idProduct());

  108.         driver_active[i] = true;

  109. 

  110.         const uint8_t *psz = drivers[i]->manufacturer();

  111.         if (psz && *psz) Serial.printf("  manufacturer: %s\n", psz);

  112.         psz = drivers[i]->product();

  113.         if (psz && *psz) Serial.printf("  product: %s\n", psz);

  114.         psz = drivers[i]->serialNumber();

  115.         if (psz && *psz) Serial.printf("  Serial: %s\n", psz);

  116.       }

  117.     }

  118.   }

  119. 

  120.   for (uint8_t i = 0; i < CNT_HIDDEVICES; i++) {

  121.     if (*hiddrivers[i] != hid_driver_active[i]) {

  122.       if (hid_driver_active[i]) {

  123.         Serial.printf("*** HID Device %s - disconnected ***\n", hid_driver_names[i]);

  124.         hid_driver_active[i] = false;

  125.       } else {

  126.         Serial.printf("*** HID Device %s %x:%x - connected ***\n", hid_driver_names[i], hiddrivers[i]->idVendor(), hiddrivers[i]->idProduct());

  127.         hid_driver_active[i] = true;

  128. 

  129.         const uint8_t *psz = hiddrivers[i]->manufacturer();

  130.         if (psz && *psz) Serial.printf("  manufacturer: %s\n", psz);

  131.         psz = hiddrivers[i]->product();

  132.         if (psz && *psz) Serial.printf("  product: %s\n", psz);

  133.         psz = hiddrivers[i]->serialNumber();

  134.         if (psz && *psz) Serial.printf("  Serial: %s\n", psz);

  135.       }

  136.     }

  137.   }

  138. 

  139.   if (joystick1.available()) {

  140.       if (first_joystick_message) {

  141.         Serial.printf("*** First Joystick message %x:%x ***\n", 

  142.             joystick1.idVendor(), joystick1.idProduct());

  143.         first_joystick_message = false;

  144. 

  145.         const uint8_t *psz = joystick1.manufacturer();

  146.         if (psz && *psz) Serial.printf("  manufacturer: %s\n", psz);

  147.         psz = joystick1.product();

  148.         if (psz && *psz) Serial.printf("  product: %s\n", psz);

  149.         psz =joystick1.serialNumber();

  150.         if (psz && *psz) Serial.printf("  Serial: %s\n", psz);        

  151.       }

  152.       

  153.       for (uint8_t i = 0; i<64; i++) {

  154.           psAxis[i] = joystick1.getAxis(i);

  155.       }

  156.       switch (joystick1.joystickType) {

  157.         case JoystickController::UNKNOWN:

  158.         case JoystickController::PS4:

  159.           displayPS4Data();

  160.           break;

  161.         case JoystickController::PS3:

  162.           displayPS3Data();

  163.           break;

  164.         case JoystickController::XBOXONE:

  165.         case JoystickController::XBOX360:;

  166.           displayRawData();

  167.           break;

  168.       }

  169.       //for (uint8_t i = 0; i < 24; i++) {

  170.       //  Serial.printf(" %d:%d", i, psAxis[i]);

  171.       //}

  172.       //Serial.println();

  173.         

  174. 

  175.      joystick1.joystickDataClear();

  176.   }

  177. 

  178.   // See if we have some RAW data

  179.   if (rawhid1) {

  180.     int ch;

  181.     uint8_t buffer[64];

  182.     uint8_t count_chars = 0; 

  183.     memset(buffer, 0, sizeof(buffer));

  184.     if (Serial.available()) {

  185.       while (((ch = Serial.read()) != -1) && (count_chars < sizeof(buffer))) {

  186.         buffer[count_chars++] = ch;

  187.       }

  188.       rawhid1.sendPacket(buffer);

  189.     }

  190.   }

  191. }

  192. 

  193. void displayPS4Data()

  194. {

  195.   Serial.printf("LX: %d, LY: %d, RX: %d, RY: %d \r\n", psAxis[1], psAxis[2], psAxis[3], psAxis[4]);

  196.   Serial.printf("L-Trig: %d, R-Trig: %d, Trig-Button: %d \r\n", psAxis[8], psAxis[9], psAxis[6]);

  197.   Serial.printf("Buttons: %d, PS: %d\r\n", psAxis[5], psAxis[7]);

  198.   Serial.printf("Arrows: %d\r\n", psAxis[0]);

  199.   Serial.printf("Battery level percentage: %2f.0 \r\n", (((float) psAxis[12])/255.0f)*100.0f);

  200. 

  201.   Serial.println();

  202. 

  203.   uint8_t ltv;

  204.   uint8_t rtv;

  205. 

  206.     ltv = psAxis[8];

  207.     rtv = psAxis[9];

  208. 

  209.     if ((ltv != joystick_left_trigger_value) || (rtv != joystick_right_trigger_value)) {

  210.       joystick_left_trigger_value = ltv;

  211.       joystick_right_trigger_value = rtv;

  212.       Serial.printf("Rumbling: %d, %d\r\n", ltv, rtv);

  213.       joystick1.setRumble(ltv, rtv);

  214.     }

  215.     

  216.   /* Arrow Buttons (psAxis[0]):

  217.    *    0x08 is released, 

  218.    *    0=N, 1=NE, 2=E, 3=SE, 4=S, 

  219.    *    5=SW, 6=W, 7=NW)

  220.    */

  221. 

  222.   if (psAxis[5] != buttons_prev) {

  223.       uint8_t lr = (psAxis[5] & 1) ? 0xff : 0;   //Srq

  224.       uint8_t lg = (psAxis[5] & 4) ? 0xff : 0;   //Cir

  225.       uint8_t lb = (psAxis[5] & 8) ? 0xff : 0;   //Tri

  226.                                                  //Cross = 2

  227.       Serial.print(psAxis[5]); Serial.print(", ");

  228.       Serial.print(lr); Serial.print(", "); 

  229.       Serial.print(lg); Serial.print(", "); 

  230.       Serial.println(lb); 

  231. 

  232.       joystick1.setLEDs(lr, lg, lb);

  233.       buttons_prev =psAxis[5];

  234.   }

  235. }

  236. 

  237. void displayPS3Data()

  238. 

  239. {

  240.   buttons = psAxis[2] | ((uint16_t)psAxis[3] << 8);

  241. 

  242.   // Use L3 (Left joystick button) to toggle Show Raw or not...

  243.   if ((buttons & 0x02) && !(buttons_prev & 0x02)) show_raw_data = !show_raw_data;

  244.   if (show_raw_data)  {

  245.     displayRawData();

  246.   } else {

  247.     Serial.printf("LX: %d, LY: %d, RX: %d, RY: %d \r\n", psAxis[6], psAxis[7], psAxis[8], psAxis[9]);

  248.     Serial.printf("L-Trig: %d, R-Trig: %d\r\n", psAxis[18], psAxis[19]);

  249.     Serial.printf("Buttons: %x\r\n", buttons);

  250.   }

  251.     uint8_t ltv;

  252.     uint8_t rtv;

  253. 

  254.     ltv = psAxis[18];

  255.     rtv = psAxis[19];

  256. 

  257.     if ((ltv != joystick_left_trigger_value) || (rtv != joystick_right_trigger_value)) {

  258.       joystick_left_trigger_value = ltv;

  259.       joystick_right_trigger_value = rtv;

  260.       Serial.printf("Rumbling: %d, %d\r\n", ltv, rtv);

  261.       joystick1.setRumble(ltv, rtv);

  262.     }

  263. 

  264.     if (buttons != buttons_prev) {

  265.       uint8_t leds = 0;

  266.       if (buttons & 0x8000) leds = 1;   //Srq

  267.       if (buttons & 0x2000) leds = 2;   //Cir

  268.       if (buttons & 0x1000) leds = 3;   //Tri

  269.                                                  //Cross = 2

  270.       joystick1.setLEDs(leds);

  271.       buttons_prev = buttons;

  272.   }

  273. }

  274.  

  275. 

  276. void displayRawData() {

  277.   uint64_t axis_mask = joystick1.axisMask();

  278.   uint64_t changed_mask = joystick1.axisChangedMask();

  279.   if (!changed_mask) return;

  280. 

  281.   Serial.printf("%lx %lx:", axis_mask, changed_mask);

  282.   for (uint16_t index=0; axis_mask; index++) {

  283.     Serial.printf("%02x ", psAxis[index]);

  284.     axis_mask >>= 1;

  285.   }

  286.   Serial.println();

  287.   //for (uint8_t i = 0; i < 24; i++) {

  288.   //  Serial.printf(" %d:%d", i, psAxis[i]);

  289.   //}

  290.   //Serial.println();

  291.  

  292. }

  293. 

  294. 

  295. bool OnReceiveHidData(uint32_t usage, const uint8_t *data, uint32_t len) {

  296.   // Called for maybe both HIDS for rawhid basic test.  One is for the Teensy

  297.   // to output to Serial. while still having Raw Hid... 

  298.   if (usage == 0xffc90004) {

  299.     // Lets trim off trailing null characters.

  300.     while ((len > 0) && (data[len-1] == 0)) {

  301.       len--;

  302.     }

  303.     if (len) {

  304.       Serial.print("RawHid Serial: ");

  305.       Serial.write(data, len);

  306.     }

  307.   } else {

  308.     Serial.print("RawHID data: ");

  309.     Serial.println(usage, HEX);

  310.     while (len) {

  311.       uint8_t cb = (len > 16)? 16 : len;

  312.       const uint8_t *p = data;

  313.       uint8_t i;

  314.       for (i = 0; i < cb; i++) {

  315.         Serial.printf("%02x ", *p++);

  316.       }

  317.       Serial.print(": ");

  318.       for (i = 0; i < cb; i++) {

  319.         Serial.write(((*data >= ' ')&&(*data <= '~'))? *data : '.');

  320.         data++;

  321.       }

  322.       len -= cb;

  323.       Serial.println();

  324.     }

  325.   }

  326. 

  327.   return true;

  328. }