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.

1778 lines
41 KiB

  1. /*
  2. MicroMDAEPiano
  3. MicroMDAEPiano is a port of the MDA-EPiano sound engine
  4. (https://sourceforge.net/projects/mda-vst/) for the Teensy-3.5/3.6 with audio shield.
  5. (c)2019 H. Wirtz <wirtz@parasitstudio.de>
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 3 of the License, or
  9. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; if not, write to the Free Software Foundation,
  16. Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #ifndef MIDI_DEVICES_H
  19. #define MIDI_DEVICES_H
  20. #include "config.h"
  21. extern config_t configuration;
  22. /* #if defined(MIDI_DEVICE_USB)
  23. #include <midi_UsbTransport.h>
  24. #endif */
  25. #ifdef MIDI_DEVICE_USB_HOST
  26. #include <USBHost_t36.h>
  27. #endif
  28. #ifdef MIDI_DEVICE_DIN
  29. MIDI_CREATE_INSTANCE(HardwareSerial, MIDI_DEVICE_DIN, midi_serial);
  30. #endif
  31. #ifdef MIDI_DEVICE_USB_HOST
  32. USBHost usb_host;
  33. MIDIDevice midi_usb(usb_host);
  34. #endif
  35. /* #ifdef MIDI_DEVICE_USB
  36. static const unsigned sUsbTransportBufferSize = 16;
  37. typedef midi::UsbTransport<sUsbTransportBufferSize> UsbTransport;
  38. UsbTransport sUsbTransport;
  39. MIDI_CREATE_INSTANCE(UsbTransport, sUsbTransport, midi_onboard_usb);
  40. #endif */
  41. void handleNoteOn(byte inChannel, byte inNumber, byte inVelocity);
  42. void handleNoteOff(byte inChannel, byte inNumber, byte inVelocity);
  43. void handleControlChange(byte inChannel, byte inData1, byte inData2);
  44. void handleAfterTouch(byte inChannel, byte inPressure);
  45. void handlePitchBend(byte inChannel, int inPitch);
  46. void handleProgramChange(byte inChannel, byte inProgram);
  47. void handleSystemExclusive(byte *data, uint len);
  48. //void handleSystemExclusiveChunk(const byte *data, uint len, bool last);
  49. void handleTimeCodeQuarterFrame(byte data);
  50. void handleAfterTouchPoly(byte inChannel, byte inNumber, byte inVelocity);
  51. void handleSongSelect(byte inSong);
  52. void handleTuneRequest(void);
  53. void handleClock(void);
  54. void handleStart(void);
  55. void handleContinue(void);
  56. void handleStop(void);
  57. void handleActiveSensing(void);
  58. void handleSystemReset(void);
  59. //void handleRealTimeSystem(void);
  60. /*****************************************
  61. MIDI_DEVICE_DIN
  62. *****************************************/
  63. #ifdef MIDI_DEVICE_DIN
  64. void handleNoteOn_MIDI_DEVICE_DIN(byte inChannel, byte inNumber, byte inVelocity)
  65. {
  66. handleNoteOn(inChannel, inNumber, inVelocity);
  67. #ifdef SHOW_DEBUG
  68. Serial.print(F("[MIDI_DIN] NoteOn"));
  69. #endif
  70. #ifdef MIDI_MERGE_THRU
  71. if (configuration.midi_soft_thru == true)
  72. {
  73. #ifdef MIDI_DEVICE_USB_HOST
  74. midi_usb.sendNoteOn(inNumber, inVelocity, inChannel);
  75. #ifdef SHOW_DEBUG
  76. Serial.print(F(" THRU->MIDI_USB_HOST"));
  77. #endif
  78. #endif
  79. #ifdef MIDI_DEVICE_USB
  80. usbMIDI.sendNoteOn(inNumber, inVelocity, inChannel);
  81. #ifdef SHOW_DEBUG
  82. Serial.print(F(" THRU->MIDI_USB"));
  83. #endif
  84. #endif
  85. }
  86. #ifdef SHOW_DEBUG
  87. Serial.println();
  88. #endif
  89. #endif
  90. }
  91. void handleNoteOff_MIDI_DEVICE_DIN(byte inChannel, byte inNumber, byte inVelocity)
  92. {
  93. handleNoteOff(inChannel, inNumber, inVelocity);
  94. #ifdef SHOW_DEBUG
  95. Serial.print(F("[MIDI_DIN] NoteOff"));
  96. #endif
  97. #ifdef MIDI_MERGE_THRU
  98. if (configuration.midi_soft_thru == true)
  99. {
  100. #ifdef MIDI_DEVICE_USB_HOST
  101. midi_usb.sendNoteOff(inNumber, inVelocity, inChannel);
  102. #ifdef SHOW_DEBUG
  103. Serial.print(F(" THRU->MIDI_USB_HOST"));
  104. #endif
  105. #endif
  106. #ifdef MIDI_DEVICE_USB
  107. usbMIDI.sendNoteOff(inNumber, inVelocity, inChannel);
  108. #ifdef SHOW_DEBUG
  109. Serial.print(F(" THRU->MIDI_USB"));
  110. #endif
  111. #endif
  112. }
  113. #ifdef SHOW_DEBUG
  114. Serial.println();
  115. #endif
  116. #endif
  117. }
  118. void handleControlChange_MIDI_DEVICE_DIN(byte inChannel, byte inData1, byte inData2)
  119. {
  120. handleControlChange(inChannel, inData1, inData2);
  121. #ifdef SHOW_DEBUG
  122. Serial.print(F("[MIDI_DIN] CC"));
  123. #endif
  124. #ifdef MIDI_MERGE_THRU
  125. if (configuration.midi_soft_thru == true)
  126. {
  127. #ifdef MIDI_DEVICE_USB_HOST
  128. midi_usb.sendControlChange(inData1, inData2, inChannel);
  129. #ifdef SHOW_DEBUG
  130. Serial.print(F(" THRU->MIDI_USB_HOST"));
  131. #endif
  132. #endif
  133. #ifdef MIDI_DEVICE_USB
  134. usbMIDI.sendControlChange(inData1, inData2, inChannel);
  135. #ifdef SHOW_DEBUG
  136. Serial.print(F(" THRU->MIDI_USB"));
  137. #endif
  138. #endif
  139. }
  140. #ifdef SHOW_DEBUG
  141. Serial.println();
  142. #endif
  143. #endif
  144. }
  145. void handleAfterTouch_MIDI_DEVICE_DIN(byte inChannel, byte inPressure)
  146. {
  147. handleAfterTouch(inChannel, inPressure);
  148. #ifdef SHOW_DEBUG
  149. Serial.print(F("[MIDI_DIN] AT"));
  150. #endif
  151. #ifdef MIDI_MERGE_THRU
  152. if (configuration.midi_soft_thru == true)
  153. {
  154. #ifdef MIDI_DEVICE_USB_HOST
  155. midi_usb.sendAfterTouch(inPressure, inChannel);
  156. #ifdef SHOW_DEBUG
  157. Serial.print(F(" THRU->MIDI_USB_HOST"));
  158. #endif
  159. #endif
  160. #ifdef MIDI_DEVICE_USB
  161. usbMIDI.sendAfterTouch(inPressure, inChannel);
  162. #ifdef SHOW_DEBUG
  163. Serial.print(F(" THRU->MIDI_USB"));
  164. #endif
  165. #endif
  166. }
  167. #ifdef SHOW_DEBUG
  168. Serial.println();
  169. #endif
  170. #endif
  171. }
  172. void handlePitchBend_MIDI_DEVICE_DIN(byte inChannel, int inPitch)
  173. {
  174. handlePitchBend(inChannel, inPitch);
  175. #ifdef SHOW_DEBUG
  176. Serial.print(F("[MIDI_DIN] PB"));
  177. #endif
  178. #ifdef MIDI_MERGE_THRU
  179. if (configuration.midi_soft_thru == true)
  180. {
  181. #ifdef MIDI_DEVICE_USB_HOST
  182. midi_usb.sendPitchBend(inPitch, inChannel);
  183. #ifdef SHOW_DEBUG
  184. Serial.print(F(" THRU->MIDI_USB_HOST"));
  185. #endif
  186. #endif
  187. #ifdef MIDI_DEVICE_USB
  188. usbMIDI.sendPitchBend(inPitch, inChannel);
  189. #ifdef SHOW_DEBUG
  190. Serial.print(F(" THRU->MIDI_USB"));
  191. #endif
  192. #endif
  193. }
  194. #ifdef SHOW_DEBUG
  195. Serial.println();
  196. #endif
  197. #endif
  198. }
  199. void handleProgramChange_MIDI_DEVICE_DIN(byte inChannel, byte inProgram)
  200. {
  201. handleProgramChange(inChannel, inProgram);
  202. #ifdef SHOW_DEBUG
  203. Serial.print(F("[MIDI_DIN] PC"));
  204. #endif
  205. #ifdef MIDI_MERGE_THRU
  206. if (configuration.midi_soft_thru == true)
  207. {
  208. #ifdef MIDI_DEVICE_USB_HOST
  209. midi_usb.sendProgramChange(inProgram, inChannel);
  210. #ifdef SHOW_DEBUG
  211. Serial.print(F(" THRU->MIDI_USB_HOST"));
  212. #endif
  213. #endif
  214. #ifdef MIDI_DEVICE_USB
  215. usbMIDI.sendProgramChange(inProgram, inChannel);
  216. #ifdef SHOW_DEBUG
  217. Serial.print(F(" THRU->MIDI_USB"));
  218. #endif
  219. #endif
  220. }
  221. #ifdef SHOW_DEBUG
  222. Serial.println();
  223. #endif
  224. #endif
  225. }
  226. void handleSystemExclusive_MIDI_DEVICE_DIN(byte *data, uint len)
  227. {
  228. handleSystemExclusive(data, len);
  229. #ifdef SHOW_DEBUG
  230. Serial.print(F("[MIDI_DIN] SysEx"));
  231. #endif
  232. #ifdef MIDI_MERGE_THRU
  233. if (configuration.midi_soft_thru == true)
  234. {
  235. #ifdef MIDI_DEVICE_USB_HOST
  236. midi_usb.sendSysEx(len, data);
  237. #ifdef SHOW_DEBUG
  238. Serial.print(F(" THRU->MIDI_USB_HOST"));
  239. #endif
  240. #endif
  241. #ifdef MIDI_DEVICE_USB
  242. usbMIDI.sendSysEx(len, data);
  243. #ifdef SHOW_DEBUG
  244. Serial.print(F(" THRU->MIDI_USB"));
  245. #endif
  246. #endif
  247. }
  248. #ifdef SHOW_DEBUG
  249. Serial.println();
  250. #endif
  251. #endif
  252. }
  253. /* void handleSystemExclusiveChunk_MIDI_DEVICE_DIN(byte *data, uint len, bool last)
  254. {
  255. handleSystemExclusiveChunk(data, len, last);
  256. #ifdef SHOW_DEBUG
  257. Serial.print(F("[MIDI_DIN] SysExChunk"));
  258. #endif
  259. #ifdef MIDI_MERGE_THRU
  260. if (configuration.midi_soft_thru == true)
  261. {
  262. #ifdef MIDI_DEVICE_USB_HOST
  263. midi_usb.sendSysEx(len, data, last);
  264. #ifdef SHOW_DEBUG
  265. Serial.print(F(" THRU->MIDI_USB_HOST"));
  266. #endif
  267. #endif
  268. #ifdef MIDI_DEVICE_USB
  269. usbMIDI.sendSysEx(len, data, last);
  270. #ifdef SHOW_DEBUG
  271. Serial.print(F(" THRU->MIDI_USB"));
  272. #endif
  273. #endif
  274. }
  275. #ifdef SHOW_DEBUG
  276. Serial.println();
  277. #endif
  278. #endif
  279. } */
  280. void handleTimeCodeQuarterFrame_MIDI_DEVICE_DIN(byte data)
  281. {
  282. handleTimeCodeQuarterFrame(data);
  283. #ifdef SHOW_DEBUG
  284. Serial.print(F("[MIDI_DIN] TimeCodeQuarterFrame"));
  285. #endif
  286. #ifdef MIDI_MERGE_THRU
  287. if (configuration.midi_soft_thru == true)
  288. {
  289. #ifdef MIDI_DEVICE_USB_HOST
  290. midi_usb.sendTimeCodeQuarterFrame(0xF1, data);
  291. #ifdef SHOW_DEBUG
  292. Serial.print(F(" THRU->MIDI_USB_HOST"));
  293. #endif
  294. #endif
  295. #ifdef MIDI_DEVICE_USB
  296. usbMIDI.sendTimeCodeQuarterFrame(0xF1, data);
  297. #ifdef SHOW_DEBUG
  298. Serial.print(F(" THRU->MIDI_USB"));
  299. #endif
  300. #endif
  301. }
  302. #ifdef SHOW_DEBUG
  303. Serial.println();
  304. #endif
  305. #endif
  306. }
  307. void handleAfterTouchPoly_MIDI_DEVICE_DIN(byte inChannel, byte inNumber, byte inVelocity)
  308. {
  309. handleAfterTouchPoly(inChannel, inNumber, inVelocity);
  310. #ifdef SHOW_DEBUG
  311. Serial.print(F("[MIDI_DIN] AT-Poly"));
  312. #endif
  313. #ifdef MIDI_MERGE_THRU
  314. if (configuration.midi_soft_thru == true)
  315. {
  316. #ifdef MIDI_DEVICE_USB_HOST
  317. midi_usb.sendAfterTouch(inNumber, inVelocity, inChannel);
  318. #ifdef SHOW_DEBUG
  319. Serial.print(F(" THRU->MIDI_USB_HOST"));
  320. #endif
  321. #endif
  322. #ifdef MIDI_DEVICE_USB
  323. usbMIDI.sendAfterTouch(inNumber, inVelocity, inChannel);
  324. #ifdef SHOW_DEBUG
  325. Serial.print(F(" THRU->MIDI_USB"));
  326. #endif
  327. #endif
  328. }
  329. #ifdef SHOW_DEBUG
  330. Serial.println();
  331. #endif
  332. #endif
  333. }
  334. void handleSongSelect_MIDI_DEVICE_DIN(byte inSong)
  335. {
  336. handleSongSelect(inSong);
  337. #ifdef SHOW_DEBUG
  338. Serial.print(F("[MIDI_DIN] SongSelect"));
  339. #endif
  340. #ifdef MIDI_MERGE_THRU
  341. if (configuration.midi_soft_thru == true)
  342. {
  343. #ifdef MIDI_DEVICE_USB_HOST
  344. midi_usb.sendSongSelect(inSong);
  345. #ifdef SHOW_DEBUG
  346. Serial.print(F(" THRU->MIDI_USB_HOST"));
  347. #endif
  348. #endif
  349. #ifdef MIDI_DEVICE_USB
  350. usbMIDI.sendSongSelect(inSong);
  351. #ifdef SHOW_DEBUG
  352. Serial.print(F(" THRU->MIDI_USB"));
  353. #endif
  354. #endif
  355. }
  356. #ifdef SHOW_DEBUG
  357. Serial.println();
  358. #endif
  359. #endif
  360. }
  361. void handleTuneRequest_MIDI_DEVICE_DIN(void)
  362. {
  363. handleTuneRequest();
  364. #ifdef SHOW_DEBUG
  365. Serial.print(F("[MIDI_DIN] TuneRequest"));
  366. #endif
  367. #ifdef MIDI_MERGE_THRU
  368. if (configuration.midi_soft_thru == true)
  369. {
  370. #ifdef MIDI_DEVICE_USB_HOST
  371. midi_usb.sendTuneRequest();
  372. #ifdef SHOW_DEBUG
  373. Serial.print(F(" THRU->MIDI_USB_HOST"));
  374. #endif
  375. #endif
  376. #ifdef MIDI_DEVICE_USB
  377. usbMIDI.sendTuneRequest();
  378. #ifdef SHOW_DEBUG
  379. Serial.print(F(" THRU->MIDI_USB"));
  380. #endif
  381. #endif
  382. }
  383. #ifdef SHOW_DEBUG
  384. Serial.println();
  385. #endif
  386. #endif
  387. }
  388. void handleClock_MIDI_DEVICE_DIN(void)
  389. {
  390. handleClock();
  391. #ifdef SHOW_DEBUG
  392. Serial.print(F("[MIDI_DIN] Clock"));
  393. #endif
  394. #ifdef MIDI_MERGE_THRU
  395. if (configuration.midi_soft_thru == true)
  396. {
  397. #ifdef MIDI_DEVICE_USB_HOST
  398. midi_usb.sendRealTime(midi::Clock);
  399. #ifdef SHOW_DEBUG
  400. Serial.print(F(" THRU->MIDI_USB_HOST"));
  401. #endif
  402. #endif
  403. #ifdef MIDI_DEVICE_USB
  404. usbMIDI.sendRealTime(midi::Clock);
  405. #ifdef SHOW_DEBUG
  406. Serial.print(F(" THRU->MIDI_USB"));
  407. #endif
  408. #endif
  409. }
  410. #ifdef SHOW_DEBUG
  411. Serial.println();
  412. #endif
  413. #endif
  414. }
  415. void handleStart_MIDI_DEVICE_DIN(void)
  416. {
  417. handleStart();
  418. #ifdef SHOW_DEBUG
  419. Serial.print(F("[MIDI_DIN] Start"));
  420. #endif
  421. #ifdef MIDI_MERGE_THRU
  422. if (configuration.midi_soft_thru == true)
  423. {
  424. #ifdef MIDI_DEVICE_USB_HOST
  425. midi_usb.sendRealTime(midi::Start);
  426. #ifdef SHOW_DEBUG
  427. Serial.print(F(" THRU->MIDI_USB_HOST"));
  428. #endif
  429. #endif
  430. #ifdef MIDI_DEVICE_USB
  431. usbMIDI.sendRealTime(midi::Start);
  432. #ifdef SHOW_DEBUG
  433. Serial.print(F(" THRU->MIDI_USB"));
  434. #endif
  435. #endif
  436. }
  437. #ifdef SHOW_DEBUG
  438. Serial.println();
  439. #endif
  440. #endif
  441. }
  442. void handleContinue_MIDI_DEVICE_DIN(void)
  443. {
  444. handleContinue();
  445. #ifdef SHOW_DEBUG
  446. Serial.print(F("[MIDI_DIN] Continue"));
  447. #endif
  448. #ifdef MIDI_MERGE_THRU
  449. if (configuration.midi_soft_thru == true)
  450. {
  451. #ifdef MIDI_DEVICE_USB_HOST
  452. midi_usb.sendRealTime(midi::Continue);
  453. #ifdef SHOW_DEBUG
  454. Serial.print(F(" THRU->MIDI_USB_HOST"));
  455. #endif
  456. #endif
  457. #ifdef MIDI_DEVICE_USB
  458. usbMIDI.sendRealTime(midi::Continue);
  459. #ifdef SHOW_DEBUG
  460. Serial.print(F(" THRU->MIDI_USB"));
  461. #endif
  462. #endif
  463. }
  464. #ifdef SHOW_DEBUG
  465. Serial.println();
  466. #endif
  467. #endif
  468. }
  469. void handleStop_MIDI_DEVICE_DIN(void)
  470. {
  471. handleStop();
  472. #ifdef SHOW_DEBUG
  473. Serial.print(F("[MIDI_DIN] Stop"));
  474. #endif
  475. #ifdef MIDI_MERGE_THRU
  476. if (configuration.midi_soft_thru == true)
  477. {
  478. #ifdef MIDI_DEVICE_USB_HOST
  479. midi_usb.sendRealTime(midi::Stop);
  480. #ifdef SHOW_DEBUG
  481. Serial.print(F(" THRU->MIDI_USB_HOST"));
  482. #endif
  483. #endif
  484. #ifdef MIDI_DEVICE_USB
  485. usbMIDI.sendRealTime(midi::Stop);
  486. #ifdef SHOW_DEBUG
  487. Serial.print(F(" THRU->MIDI_USB"));
  488. #endif
  489. #endif
  490. }
  491. #ifdef SHOW_DEBUG
  492. Serial.println();
  493. #endif
  494. #endif
  495. }
  496. void handleActiveSensing_MIDI_DEVICE_DIN(void)
  497. {
  498. handleActiveSensing();
  499. #ifdef SHOW_DEBUG
  500. Serial.print(F("[MIDI_DIN] ActiveSensing"));
  501. #endif
  502. #ifdef MIDI_MERGE_THRU
  503. if (configuration.midi_soft_thru == true)
  504. {
  505. #ifdef MIDI_DEVICE_USB_HOST
  506. midi_usb.sendRealTime(midi::ActiveSensing);
  507. #ifdef SHOW_DEBUG
  508. Serial.print(F(" THRU->MIDI_USB_HOST"));
  509. #endif
  510. #endif
  511. #ifdef MIDI_DEVICE_USB
  512. usbMIDI.sendRealTime(midi::ActiveSensing);
  513. #ifdef SHOW_DEBUG
  514. Serial.print(F(" THRU->MIDI_USB"));
  515. #endif
  516. #endif
  517. }
  518. #ifdef SHOW_DEBUG
  519. Serial.println();
  520. #endif
  521. #endif
  522. }
  523. void handleSystemReset_MIDI_DEVICE_DIN(void)
  524. {
  525. handleSystemReset();
  526. #ifdef SHOW_DEBUG
  527. Serial.print(F("[MIDI_DIN] SystemReset"));
  528. #endif
  529. #ifdef MIDI_MERGE_THRU
  530. if (configuration.midi_soft_thru == true)
  531. {
  532. #ifdef MIDI_DEVICE_USB_HOST
  533. midi_usb.sendRealTime(midi::SystemReset);
  534. #ifdef SHOW_DEBUG
  535. Serial.print(F(" THRU->MIDI_USB_HOST"));
  536. #endif
  537. #endif
  538. #ifdef MIDI_DEVICE_USB
  539. usbMIDI.sendRealTime(midi::SystemReset);
  540. #ifdef SHOW_DEBUG
  541. Serial.print(F(" THRU->MIDI_USB"));
  542. #endif
  543. #endif
  544. }
  545. #ifdef SHOW_DEBUG
  546. Serial.println();
  547. #endif
  548. #endif
  549. }
  550. /* void handlRealTimeSysteme_MIDI_DEVICE_DIN(byte inRealTime)
  551. {
  552. handleRealTimeSystem();
  553. #ifdef SHOW_DEBUG
  554. Serial.print(F("[MIDI_DIN] RealTimeSystem"));
  555. #endif
  556. #ifdef MIDI_MERGE_THRU
  557. if (configuration.midi_soft_thru == true)
  558. {
  559. #ifdef MIDI_DEVICE_USB_HOST
  560. midi_usb.sendRealTime(inRealTime);
  561. #ifdef SHOW_DEBUG
  562. Serial.print(F(" THRU->MIDI_USB_HOST"));
  563. #endif
  564. #endif
  565. #ifdef MIDI_DEVICE_USB
  566. //usbMIDI.sendRealTime(inRealTIme);
  567. #ifdef SHOW_DEBUG
  568. Serial.print(F(" THRU->MIDI_USB[NOTSUPPORTED]"));
  569. #endif
  570. #endif
  571. }
  572. #ifdef SHOW_DEBUG
  573. Serial.println();
  574. #endif
  575. #endif
  576. } */
  577. #endif // MIDI_DEVICE_DIN
  578. /*****************************************
  579. MIDI_DEVICE_USB_HOST
  580. *****************************************/
  581. #ifdef MIDI_DEVICE_USB_HOST
  582. void handleNoteOn_MIDI_DEVICE_USB_HOST(byte inChannel, byte inNumber, byte inVelocity)
  583. {
  584. handleNoteOn(inChannel, inNumber, inVelocity);
  585. #ifdef SHOW_DEBUG
  586. Serial.print(F("[MIDI_USB_HOST] NoteOn"));
  587. #endif
  588. #ifdef MIDI_MERGE_THRU
  589. if (configuration.midi_soft_thru == true)
  590. {
  591. #ifdef MIDI_DEVICE_DIN
  592. midi_serial.sendNoteOn(inNumber, inVelocity, inChannel);
  593. #ifdef SHOW_DEBUG
  594. Serial.print(F(" THRU->MIDI_DIN"));
  595. #endif
  596. #endif
  597. #ifdef MIDI_DEVICE_USB
  598. usbMIDI.sendNoteOn(inNumber, inVelocity, inChannel);
  599. #ifdef SHOW_DEBUG
  600. Serial.print(F(" THRU->MIDI_USB"));
  601. #endif
  602. #endif
  603. }
  604. #ifdef SHOW_DEBUG
  605. Serial.println();
  606. #endif
  607. #endif
  608. }
  609. void handleNoteOff_MIDI_DEVICE_USB_HOST(byte inChannel, byte inNumber, byte inVelocity)
  610. {
  611. handleNoteOff(inChannel, inNumber, inVelocity);
  612. #ifdef SHOW_DEBUG
  613. Serial.print(F("[MIDI_USB_HOST] NoteOff"));
  614. #endif
  615. #ifdef MIDI_MERGE_THRU
  616. if (configuration.midi_soft_thru == true)
  617. {
  618. #ifdef MIDI_DEVICE_DIN
  619. midi_serial.sendNoteOff(inNumber, inVelocity, inChannel);
  620. #ifdef SHOW_DEBUG
  621. Serial.print(F(" THRU->MIDI_DIN"));
  622. #endif
  623. #endif
  624. #ifdef MIDI_DEVICE_USB
  625. usbMIDI.sendNoteOff(inNumber, inVelocity, inChannel);
  626. #ifdef SHOW_DEBUG
  627. Serial.print(F(" THRU->MIDI_USB"));
  628. #endif
  629. #endif
  630. }
  631. #ifdef SHOW_DEBUG
  632. Serial.println();
  633. #endif
  634. #endif
  635. }
  636. void handleControlChange_MIDI_DEVICE_USB_HOST(byte inChannel, byte inData1, byte inData2)
  637. {
  638. handleControlChange(inChannel, inData1, inData2);
  639. #ifdef SHOW_DEBUG
  640. Serial.print(F("[MIDI_USB_HOST] CC"));
  641. #endif
  642. #ifdef MIDI_MERGE_THRU
  643. if (configuration.midi_soft_thru == true)
  644. {
  645. #ifdef MIDI_DEVICE_DIN
  646. midi_serial.sendControlChange(inData1, inData2, inChannel);
  647. #ifdef SHOW_DEBUG
  648. Serial.print(F(" THRU->MIDI_DIN"));
  649. #endif
  650. #endif
  651. #ifdef MIDI_DEVICE_USB
  652. usbMIDI.sendControlChange(inData1, inData2, inChannel);
  653. #ifdef SHOW_DEBUG
  654. Serial.print(F(" THRU->MIDI_USB"));
  655. #endif
  656. #endif
  657. }
  658. #ifdef SHOW_DEBUG
  659. Serial.println();
  660. #endif
  661. #endif
  662. }
  663. void handleAfterTouch_MIDI_DEVICE_USB_HOST(byte inChannel, byte inPressure)
  664. {
  665. handleAfterTouch(inChannel, inPressure);
  666. #ifdef SHOW_DEBUG
  667. Serial.print(F("[MIDI_USB_HOST] AT"));
  668. #endif
  669. #ifdef MIDI_MERGE_THRU
  670. if (configuration.midi_soft_thru == true)
  671. {
  672. #ifdef MIDI_DEVICE_DIN
  673. midi_serial.sendAfterTouch(inPressure, inChannel);
  674. #ifdef SHOW_DEBUG
  675. Serial.print(F(" THRU->MIDI_DIN"));
  676. #endif
  677. #endif
  678. #ifdef MIDI_DEVICE_USB
  679. usbMIDI.sendAfterTouch(inPressure, inChannel);
  680. #ifdef SHOW_DEBUG
  681. Serial.print(F(" THRU->MIDI_USB"));
  682. #endif
  683. #endif
  684. }
  685. #ifdef SHOW_DEBUG
  686. Serial.println();
  687. #endif
  688. #endif
  689. }
  690. void handlePitchBend_MIDI_DEVICE_USB_HOST(byte inChannel, int inPitch)
  691. {
  692. handlePitchBend(inChannel, inPitch);
  693. #ifdef SHOW_DEBUG
  694. Serial.print(F("[MIDI_USB_HOST] PB"));
  695. #endif
  696. #ifdef MIDI_MERGE_THRU
  697. if (configuration.midi_soft_thru == true)
  698. {
  699. #ifdef MIDI_DEVICE_DIN
  700. midi_serial.sendPitchBend(inPitch, inChannel);
  701. #ifdef SHOW_DEBUG
  702. Serial.print(F(" THRU->MIDI_DIN"));
  703. #endif
  704. #endif
  705. #ifdef MIDI_DEVICE_USB
  706. usbMIDI.sendPitchBend(inPitch, inChannel);
  707. #ifdef SHOW_DEBUG
  708. Serial.print(F(" THRU->MIDI_USB"));
  709. #endif
  710. #endif
  711. }
  712. #ifdef SHOW_DEBUG
  713. Serial.println();
  714. #endif
  715. #endif
  716. }
  717. void handleProgramChange_MIDI_DEVICE_USB_HOST(byte inChannel, byte inProgram)
  718. {
  719. handleProgramChange(inChannel, inProgram);
  720. #ifdef SHOW_DEBUG
  721. Serial.print(F("[MIDI_USB_HOST] PC"));
  722. #endif
  723. #ifdef MIDI_MERGE_THRU
  724. if (configuration.midi_soft_thru == true)
  725. {
  726. #ifdef MIDI_DEVICE_DIN
  727. midi_serial.sendProgramChange(inProgram, inChannel);
  728. #ifdef SHOW_DEBUG
  729. Serial.print(F(" THRU->MIDI_DIN"));
  730. #endif
  731. #endif
  732. #ifdef MIDI_DEVICE_USB
  733. usbMIDI.sendProgramChange(inProgram, inChannel);
  734. #ifdef SHOW_DEBUG
  735. Serial.print(F(" THRU->MIDI_USB"));
  736. #endif
  737. #endif
  738. }
  739. #ifdef SHOW_DEBUG
  740. Serial.println();
  741. #endif
  742. #endif
  743. }
  744. void handleSystemExclusive_MIDI_DEVICE_USB_HOST(byte *data, uint len)
  745. {
  746. handleSystemExclusive(data, len);
  747. #ifdef SHOW_DEBUG
  748. Serial.print(F("[MIDI_USB_HOST] SysEx"));
  749. #endif
  750. #ifdef MIDI_MERGE_THRU
  751. if (configuration.midi_soft_thru == true)
  752. {
  753. #ifdef MIDI_DEVICE_DIN
  754. midi_serial.sendSysEx(len, data);
  755. #ifdef SHOW_DEBUG
  756. Serial.print(F(" THRU->MIDI_DIN"));
  757. #endif
  758. #endif
  759. #ifdef MIDI_DEVICE_USB
  760. usbMIDI.sendSysEx(len, data);
  761. #ifdef SHOW_DEBUG
  762. Serial.print(F(" THRU->MIDI_USB"));
  763. #endif
  764. #endif
  765. }
  766. #ifdef SHOW_DEBUG
  767. Serial.println();
  768. #endif
  769. #endif
  770. }
  771. /* void handleSystemExclusiveChunk_MIDI_DEVICE_USB_HOST(byte *data, uint len, bool last)
  772. {
  773. handleSystemExclusiveChunk(data, len, last);
  774. #ifdef SHOW_DEBUG
  775. Serial.print(F("[MIDI_USB_HOST] SysExChunk"));
  776. #endif
  777. #ifdef MIDI_MERGE_THRU
  778. if (configuration.midi_soft_thru == true)
  779. {
  780. #ifdef MIDI_DEVICE_DIN
  781. midi_serial.sendSysEx(len, data, last);
  782. #ifdef SHOW_DEBUG
  783. Serial.print(F(" THRU->MIDI_DIN"));
  784. #endif
  785. #endif
  786. #ifdef MIDI_DEVICE_USB
  787. usbMIDI.sendSysEx(len, data, last);
  788. #ifdef SHOW_DEBUG
  789. Serial.print(F(" THRU->MIDI_USB"));
  790. #endif
  791. #endif
  792. }
  793. #ifdef SHOW_DEBUG
  794. Serial.println();
  795. #endif
  796. #endif
  797. } */
  798. void handleTimeCodeQuarterFrame_MIDI_DEVICE_USB_HOST(midi::DataByte data)
  799. {
  800. handleTimeCodeQuarterFrame(data);
  801. #ifdef SHOW_DEBUG
  802. Serial.print(F("[MIDI_USB_HOST] TimeCodeQuarterFrame"));
  803. #endif
  804. #ifdef MIDI_MERGE_THRU
  805. if (configuration.midi_soft_thru == true)
  806. {
  807. #ifdef MIDI_DEVICE_DIN
  808. midi_serial.sendTimeCodeQuarterFrame(data);
  809. #ifdef SHOW_DEBUG
  810. Serial.print(F(" THRU->MIDI_DIN"));
  811. #endif
  812. #endif
  813. #ifdef MIDI_DEVICE_USB
  814. usbMIDI.sendTimeCodeQuarterFrame(0xF1, data);
  815. #ifdef SHOW_DEBUG
  816. Serial.print(F(" THRU->MIDI_USB"));
  817. #endif
  818. #endif
  819. }
  820. #ifdef SHOW_DEBUG
  821. Serial.println();
  822. #endif
  823. #endif
  824. }
  825. void handleAfterTouchPoly_MIDI_DEVICE_USB_HOST(byte inChannel, byte inNumber, byte inVelocity)
  826. {
  827. handleAfterTouchPoly(inChannel, inNumber, inVelocity);
  828. #ifdef SHOW_DEBUG
  829. Serial.print(F("[MIDI_USB_HOST] AT-Poly"));
  830. #endif
  831. #ifdef MIDI_MERGE_THRU
  832. if (configuration.midi_soft_thru == true)
  833. {
  834. #ifdef MIDI_DEVICE_DIN
  835. midi_serial.sendAfterTouch(inNumber, inVelocity, inChannel);
  836. #ifdef SHOW_DEBUG
  837. Serial.print(F(" THRU->DIN"));
  838. #endif
  839. #endif
  840. #ifdef MIDI_DEVICE_USB
  841. usbMIDI.sendAfterTouch(inNumber, inVelocity, inChannel);
  842. #ifdef SHOW_DEBUG
  843. Serial.print(F(" THRU->MIDI_USB"));
  844. #endif
  845. #endif
  846. }
  847. #ifdef SHOW_DEBUG
  848. Serial.println();
  849. #endif
  850. #endif
  851. }
  852. void handleSongSelect_MIDI_DEVICE_USB_HOST(byte inSong)
  853. {
  854. handleSongSelect(inSong);
  855. #ifdef SHOW_DEBUG
  856. Serial.print(F("[MIDI_USB_HOST] SongSelect"));
  857. #endif
  858. #ifdef MIDI_MERGE_THRU
  859. if (configuration.midi_soft_thru == true)
  860. {
  861. #ifdef MIDI_DEVICE_DIN
  862. midi_serial.sendSongSelect(inSong);
  863. #ifdef SHOW_DEBUG
  864. Serial.print(F(" THRU->MIDI_DIN"));
  865. #endif
  866. #endif
  867. #ifdef MIDI_DEVICE_USB
  868. usbMIDI.sendSongSelect(inSong);
  869. #ifdef SHOW_DEBUG
  870. Serial.print(F(" THRU->MIDI_USB"));
  871. #endif
  872. #endif
  873. }
  874. #ifdef SHOW_DEBUG
  875. Serial.println();
  876. #endif
  877. #endif
  878. }
  879. void handleTuneRequest_MIDI_DEVICE_USB_HOST(void)
  880. {
  881. handleTuneRequest();
  882. #ifdef SHOW_DEBUG
  883. Serial.print(F("[MIDI_USB_HOST] TuneRequest"));
  884. #endif
  885. #ifdef MIDI_MERGE_THRU
  886. if (configuration.midi_soft_thru == true)
  887. {
  888. #ifdef MIDI_DEVICE_DIN
  889. midi_serial.sendTuneRequest();
  890. #ifdef SHOW_DEBUG
  891. Serial.print(F(" THRU->MIDI_DIN"));
  892. #endif
  893. #endif
  894. #ifdef MIDI_DEVICE_USB
  895. usbMIDI.sendTuneRequest();
  896. #ifdef SHOW_DEBUG
  897. Serial.print(F(" THRU->MIDI_USB"));
  898. #endif
  899. #endif
  900. }
  901. #ifdef SHOW_DEBUG
  902. Serial.println();
  903. #endif
  904. #endif
  905. }
  906. void handleClock_MIDI_DEVICE_USB_HOST(void)
  907. {
  908. handleClock();
  909. #ifdef SHOW_DEBUG
  910. Serial.print(F("[MIDI_USB_HOST] Clock"));
  911. #endif
  912. #ifdef MIDI_MERGE_THRU
  913. if (configuration.midi_soft_thru == true)
  914. {
  915. #ifdef MIDI_DEVICE_DIN
  916. midi_serial.sendRealTime(midi::Clock);
  917. #ifdef SHOW_DEBUG
  918. Serial.print(F(" THRU->MIDI_DIN"));
  919. #endif
  920. #endif
  921. #ifdef MIDI_DEVICE_USB
  922. usbMIDI.sendRealTime(midi::Clock);
  923. #ifdef SHOW_DEBUG
  924. Serial.print(F(" THRU->MIDI_USB"));
  925. #endif
  926. #endif
  927. }
  928. #ifdef SHOW_DEBUG
  929. Serial.println();
  930. #endif
  931. #endif
  932. }
  933. void handleStart_MIDI_DEVICE_USB_HOST(void)
  934. {
  935. handleStart();
  936. #ifdef SHOW_DEBUG
  937. Serial.print(F("[MIDI_USB_HOST] Start"));
  938. #endif
  939. #ifdef MIDI_MERGE_THRU
  940. if (configuration.midi_soft_thru == true)
  941. {
  942. #ifdef MIDI_DEVICE_DIN
  943. midi_serial.sendRealTime(midi::Start);
  944. #ifdef SHOW_DEBUG
  945. Serial.print(F(" THRU->MIDI_DIN"));
  946. #endif
  947. #endif
  948. #ifdef MIDI_DEVICE_USB
  949. usbMIDI.sendRealTime(midi::Start);
  950. #ifdef SHOW_DEBUG
  951. Serial.print(F(" THRU->MIDI_USB"));
  952. #endif
  953. #endif
  954. }
  955. #ifdef SHOW_DEBUG
  956. Serial.println();
  957. #endif
  958. #endif
  959. }
  960. void handleContinue_MIDI_DEVICE_USB_HOST(void)
  961. {
  962. handleContinue();
  963. #ifdef SHOW_DEBUG
  964. Serial.print(F("[MIDI_USB_HOST] Continue"));
  965. #endif
  966. #ifdef MIDI_MERGE_THRU
  967. if (configuration.midi_soft_thru == true)
  968. {
  969. #ifdef MIDI_DEVICE_DIN
  970. midi_serial.sendRealTime(midi::Continue);
  971. #ifdef SHOW_DEBUG
  972. Serial.print(F(" THRU->MIDI_DIN"));
  973. #endif
  974. #endif
  975. #ifdef MIDI_DEVICE_USB
  976. usbMIDI.sendRealTime(midi::Continue);
  977. #ifdef SHOW_DEBUG
  978. Serial.print(F(" THRU->MIDI_USB"));
  979. #endif
  980. #endif
  981. }
  982. #ifdef SHOW_DEBUG
  983. Serial.println();
  984. #endif
  985. #endif
  986. }
  987. void handleStop_MIDI_DEVICE_USB_HOST(void)
  988. {
  989. handleStop();
  990. #ifdef SHOW_DEBUG
  991. Serial.print(F("[MIDI_USB_HOST] Stop"));
  992. #endif
  993. #ifdef MIDI_MERGE_THRU
  994. if (configuration.midi_soft_thru == true)
  995. {
  996. #ifdef MIDI_DEVICE_DIN
  997. midi_serial.sendRealTime(midi::Stop);
  998. #ifdef SHOW_DEBUG
  999. Serial.print(F(" THRU->MIDI_DIN"));
  1000. #endif
  1001. #endif
  1002. #ifdef MIDI_DEVICE_USB
  1003. usbMIDI.sendRealTime(midi::Stop);
  1004. #ifdef SHOW_DEBUG
  1005. Serial.print(F(" THRU->MIDI_USB"));
  1006. #endif
  1007. #endif
  1008. }
  1009. #ifdef SHOW_DEBUG
  1010. Serial.println();
  1011. #endif
  1012. #endif
  1013. }
  1014. void handleActiveSensing_MIDI_DEVICE_USB_HOST(void)
  1015. {
  1016. handleActiveSensing();
  1017. #ifdef SHOW_DEBUG
  1018. Serial.print(F("[MIDI_USB_HOST] ActiveSensing"));
  1019. #endif
  1020. #ifdef MIDI_MERGE_THRU
  1021. if (configuration.midi_soft_thru == true)
  1022. {
  1023. #ifdef MIDI_DEVICE_DIN
  1024. midi_serial.sendRealTime(midi::ActiveSensing);
  1025. #ifdef SHOW_DEBUG
  1026. Serial.print(F(" THRU->MIDI_DIN"));
  1027. #endif
  1028. #endif
  1029. #ifdef MIDI_DEVICE_USB
  1030. usbMIDI.sendRealTime(midi::ActiveSensing);
  1031. #ifdef SHOW_DEBUG
  1032. Serial.print(F(" THRU->MIDI_USB"));
  1033. #endif
  1034. #endif
  1035. }
  1036. #ifdef SHOW_DEBUG
  1037. Serial.println();
  1038. #endif
  1039. #endif
  1040. }
  1041. void handleSystemReset_MIDI_DEVICE_USB_HOST(void)
  1042. {
  1043. handleSystemReset();
  1044. #ifdef SHOW_DEBUG
  1045. Serial.print(F("[MIDI_USB_HOST] SystemReset"));
  1046. #endif
  1047. #ifdef MIDI_MERGE_THRU
  1048. if (configuration.midi_soft_thru == true)
  1049. {
  1050. #ifdef MIDI_DEVICE_DIN
  1051. midi_serial.sendRealTime(midi::SystemReset);
  1052. #ifdef SHOW_DEBUG
  1053. Serial.print(F(" THRU->MIDI_DIN"));
  1054. #endif
  1055. #endif
  1056. #ifdef MIDI_DEVICE_USB
  1057. usbMIDI.sendRealTime(midi::SystemReset);
  1058. #ifdef SHOW_DEBUG
  1059. Serial.print(F(" THRU->MIDI_USB"));
  1060. #endif
  1061. #endif
  1062. }
  1063. #ifdef SHOW_DEBUG
  1064. Serial.println();
  1065. #endif
  1066. #endif
  1067. }
  1068. /* void handlRealTimeSysteme_MIDI_DEVICE_USB_HOST(midi::MidiType inRealTime)
  1069. {
  1070. handleRealTimeSystem();
  1071. #ifdef SHOW_DEBUG
  1072. Serial.print(F("[MIDI_USB_HOST] RealTimeSystem"));
  1073. #endif
  1074. #ifdef MIDI_MERGE_THRU
  1075. if (configuration.midi_soft_thru == true)
  1076. {
  1077. #ifdef MIDI_DEVICE_DIN
  1078. midi_serial.sendRealTime(inRealTime);
  1079. #ifdef SHOW_DEBUG
  1080. Serial.print(F(" THRU->MIDI_DIN"));
  1081. #endif
  1082. #endif
  1083. #ifdef MIDI_DEVICE_USB
  1084. usbMIDI.sendRealTime(inRealTime);
  1085. #ifdef SHOW_DEBUG
  1086. Serial.print(F(" THRU->MIDI_USB"));
  1087. #endif
  1088. #endif
  1089. }
  1090. #ifdef SHOW_DEBUG
  1091. Serial.println();
  1092. #endif
  1093. #endif
  1094. } */
  1095. #endif // MIDI_DEVICE_USB_HOST
  1096. /*****************************************
  1097. MIDI_DEVICE_USB
  1098. *****************************************/
  1099. #ifdef MIDI_DEVICE_USB
  1100. void handleNoteOn_MIDI_DEVICE_USB(byte inChannel, byte inNumber, byte inVelocity)
  1101. {
  1102. handleNoteOn(inChannel, inNumber, inVelocity);
  1103. #ifdef SHOW_DEBUG
  1104. Serial.print(F("[MIDI_USB] NoteOn"));
  1105. #endif
  1106. #ifdef MIDI_MERGE_THRU
  1107. if (configuration.midi_soft_thru == true)
  1108. {
  1109. #ifdef MIDI_DEVICE_DIN
  1110. midi_serial.sendNoteOn(inNumber, inVelocity, inChannel);
  1111. #ifdef SHOW_DEBUG
  1112. Serial.print(F(" THRU->MIDI_DIN"));
  1113. #endif
  1114. #endif
  1115. #ifdef MIDI_DEVICE_USB_HOST
  1116. midi_usb.sendNoteOn(inNumber, inVelocity, inChannel);
  1117. #ifdef SHOW_DEBUG
  1118. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1119. #endif
  1120. #endif
  1121. }
  1122. #ifdef SHOW_DEBUG
  1123. Serial.println();
  1124. #endif
  1125. #endif
  1126. }
  1127. void handleNoteOff_MIDI_DEVICE_USB(byte inChannel, byte inNumber, byte inVelocity)
  1128. {
  1129. handleNoteOff(inChannel, inNumber, inVelocity);
  1130. #ifdef SHOW_DEBUG
  1131. Serial.print(F("[MIDI_USB] NoteOff"));
  1132. #endif
  1133. #ifdef MIDI_MERGE_THRU
  1134. if (configuration.midi_soft_thru == true)
  1135. {
  1136. #ifdef MIDI_DEVICE_DIN
  1137. midi_serial.sendNoteOff(inNumber, inVelocity, inChannel);
  1138. #ifdef SHOW_DEBUG
  1139. Serial.print(F(" THRU->MIDI_DIN"));
  1140. #endif
  1141. #endif
  1142. #ifdef MIDI_DEVICE_USB_HOST
  1143. midi_usb.sendNoteOff(inNumber, inVelocity, inChannel);
  1144. #ifdef SHOW_DEBUG
  1145. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1146. #endif
  1147. #endif
  1148. }
  1149. #ifdef SHOW_DEBUG
  1150. Serial.println();
  1151. #endif
  1152. #endif
  1153. }
  1154. void handleControlChange_MIDI_DEVICE_USB(byte inChannel, byte inData1, byte inData2)
  1155. {
  1156. handleControlChange(inChannel, inData1, inData2);
  1157. #ifdef SHOW_DEBUG
  1158. Serial.print(F("[MIDI_USB] CC"));
  1159. #endif
  1160. #ifdef MIDI_MERGE_THRU
  1161. if (configuration.midi_soft_thru == true)
  1162. {
  1163. #ifdef MIDI_DEVICE_DIN
  1164. midi_serial.sendControlChange(inData1, inData2, inChannel);
  1165. #ifdef SHOW_DEBUG
  1166. Serial.print(F(" THRU->MIDI_DIN"));
  1167. #endif
  1168. #endif
  1169. #ifdef MIDI_DEVICE_USB_HOST
  1170. midi_usb.sendControlChange(inData1, inData2, inChannel);
  1171. #ifdef SHOW_DEBUG
  1172. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1173. #endif
  1174. #endif
  1175. }
  1176. #ifdef SHOW_DEBUG
  1177. Serial.println();
  1178. #endif
  1179. #endif
  1180. }
  1181. void handleAfterTouch_MIDI_DEVICE_USB(byte inChannel, byte inPressure)
  1182. {
  1183. handleAfterTouch(inChannel, inPressure);
  1184. #ifdef SHOW_DEBUG
  1185. Serial.print(F("[MIDI_USB] AT"));
  1186. #endif
  1187. #ifdef MIDI_MERGE_THRU
  1188. if (configuration.midi_soft_thru == true)
  1189. {
  1190. #ifdef MIDI_DEVICE_DIN
  1191. midi_serial.sendAfterTouch(inPressure, inChannel);
  1192. #ifdef SHOW_DEBUG
  1193. Serial.print(F(" THRU->MIDI_DIN"));
  1194. #endif
  1195. #endif
  1196. #ifdef MIDI_DEVICE_USB_HOST
  1197. midi_usb.sendAfterTouch(inPressure, inChannel);
  1198. #ifdef SHOW_DEBUG
  1199. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1200. #endif
  1201. #endif
  1202. }
  1203. #ifdef SHOW_DEBUG
  1204. Serial.println();
  1205. #endif
  1206. #endif
  1207. }
  1208. void handlePitchBend_MIDI_DEVICE_USB(byte inChannel, int inPitch)
  1209. {
  1210. handlePitchBend(inChannel, inPitch);
  1211. #ifdef SHOW_DEBUG
  1212. Serial.print(F("[MIDI_USB] PB"));
  1213. #endif
  1214. #ifdef MIDI_MERGE_THRU
  1215. if (configuration.midi_soft_thru == true)
  1216. {
  1217. #ifdef MIDI_DEVICE_DIN
  1218. midi_serial.sendPitchBend(inPitch, inChannel);
  1219. #ifdef SHOW_DEBUG
  1220. Serial.print(F(" THRU->MIDI_DIN"));
  1221. #endif
  1222. #endif
  1223. #ifdef MIDI_DEVICE_USB_HOST
  1224. midi_usb.sendPitchBend(inPitch, inChannel);
  1225. #ifdef SHOW_DEBUG
  1226. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1227. #endif
  1228. #endif
  1229. }
  1230. #ifdef SHOW_DEBUG
  1231. Serial.println();
  1232. #endif
  1233. #endif
  1234. }
  1235. void handleProgramChange_MIDI_DEVICE_USB(byte inChannel, byte inProgram)
  1236. {
  1237. handleProgramChange(inChannel, inProgram);
  1238. #ifdef SHOW_DEBUG
  1239. Serial.print(F("[MIDI_USB] PC"));
  1240. #endif
  1241. #ifdef MIDI_MERGE_THRU
  1242. if (configuration.midi_soft_thru == true)
  1243. {
  1244. #ifdef MIDI_DEVICE_DIN
  1245. midi_serial.sendProgramChange(inProgram, inChannel);
  1246. #ifdef SHOW_DEBUG
  1247. Serial.print(F(" THRU->MIDI_DIN"));
  1248. #endif
  1249. #endif
  1250. #ifdef MIDI_DEVICE_USB_HOST
  1251. midi_usb.sendProgramChange(inProgram, inChannel);
  1252. #ifdef SHOW_DEBUG
  1253. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1254. #endif
  1255. #endif
  1256. }
  1257. #ifdef SHOW_DEBUG
  1258. Serial.println();
  1259. #endif
  1260. #endif
  1261. }
  1262. void handleSystemExclusive_MIDI_DEVICE_USB(byte *data, uint len)
  1263. {
  1264. handleSystemExclusive(data, len);
  1265. #ifdef SHOW_DEBUG
  1266. Serial.print(F("[MIDI_USB] SysEx"));
  1267. #endif
  1268. #ifdef MIDI_MERGE_THRU
  1269. if (configuration.midi_soft_thru == true)
  1270. {
  1271. #ifdef MIDI_DEVICE_DIN
  1272. midi_serial.sendSysEx(len, data);
  1273. #ifdef SHOW_DEBUG
  1274. Serial.print(F(" THRU->MIDI_DIN"));
  1275. #endif
  1276. #endif
  1277. #ifdef MIDI_DEVICE_USB_HOST
  1278. midi_usb.sendSysEx(len, data);
  1279. #ifdef SHOW_DEBUG
  1280. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1281. #endif
  1282. #endif
  1283. }
  1284. #ifdef SHOW_DEBUG
  1285. Serial.println();
  1286. #endif
  1287. #endif
  1288. }
  1289. /* void handleSystemExclusiveChunk_MIDI_DEVICE_USB(byte *data, uint len, bool last)
  1290. {
  1291. handleSystemExclusiveChunk(data, len, last);
  1292. #ifdef SHOW_DEBUG
  1293. Serial.print(F("[MIDI_USB] SysExChunk"));
  1294. #endif
  1295. #ifdef MIDI_MERGE_THRU
  1296. if (configuration.midi_soft_thru == true)
  1297. {
  1298. #ifdef MIDI_DEVICE_DIN
  1299. midi_serial.sendSysEx(len, data, last);
  1300. #ifdef SHOW_DEBUG
  1301. Serial.print(F(" THRU->MIDI_DIN"));
  1302. #endif
  1303. #endif
  1304. #ifdef MIDI_DEVICE_USB_HOST
  1305. midi_usb.sendSysEx(len, data, last);
  1306. #ifdef SHOW_DEBUG
  1307. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1308. #endif
  1309. #endif
  1310. }
  1311. #ifdef SHOW_DEBUG
  1312. Serial.println();
  1313. #endif
  1314. #endif
  1315. } */
  1316. void handleTimeCodeQuarterFrame_MIDI_DEVICE_USB(midi::DataByte data)
  1317. {
  1318. handleTimeCodeQuarterFrame(data);
  1319. #ifdef SHOW_DEBUG
  1320. Serial.print(F("[MIDI_USB] TimeCodeQuarterFrame"));
  1321. #endif
  1322. #ifdef MIDI_MERGE_THRU
  1323. if (configuration.midi_soft_thru == true)
  1324. {
  1325. #ifdef MIDI_DEVICE_DIN
  1326. midi_serial.sendTimeCodeQuarterFrame(data);
  1327. #ifdef SHOW_DEBUG
  1328. Serial.print(F(" THRU->MIDI_DIN"));
  1329. #endif
  1330. #endif
  1331. #ifdef MIDI_DEVICE_USB_HOST
  1332. midi_usb.sendTimeCodeQuarterFrame(0xF1, data);
  1333. #ifdef SHOW_DEBUG
  1334. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1335. #endif
  1336. #endif
  1337. }
  1338. #ifdef SHOW_DEBUG
  1339. Serial.println();
  1340. #endif
  1341. #endif
  1342. }
  1343. void handleAfterTouchPoly_MIDI_DEVICE_USB(byte inChannel, byte inNumber, byte inVelocity)
  1344. {
  1345. handleAfterTouchPoly(inChannel, inNumber, inVelocity);
  1346. #ifdef SHOW_DEBUG
  1347. Serial.print(F("[MIDI_USB] AT-Poly"));
  1348. #endif
  1349. #ifdef MIDI_MERGE_THRU
  1350. if (configuration.midi_soft_thru == true)
  1351. {
  1352. #ifdef MIDI_DEVICE_DIN
  1353. midi_serial.sendAfterTouch(inNumber, inVelocity, inChannel);
  1354. #ifdef SHOW_DEBUG
  1355. Serial.print(F(" THRU->DIN"));
  1356. #endif
  1357. #endif
  1358. #ifdef MIDI_DEVICE_USB_HOST
  1359. midi_usb.sendAfterTouch(inNumber, inVelocity, inChannel);
  1360. #ifdef SHOW_DEBUG
  1361. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1362. #endif
  1363. #endif
  1364. }
  1365. #ifdef SHOW_DEBUG
  1366. Serial.println();
  1367. #endif
  1368. #endif
  1369. }
  1370. void handleSongSelect_MIDI_DEVICE_USB(byte inSong)
  1371. {
  1372. handleSongSelect(inSong);
  1373. #ifdef SHOW_DEBUG
  1374. Serial.print(F("[MIDI_USB] SongSelect"));
  1375. #endif
  1376. #ifdef MIDI_MERGE_THRU
  1377. if (configuration.midi_soft_thru == true)
  1378. {
  1379. #ifdef MIDI_DEVICE_DIN
  1380. midi_serial.sendSongSelect(inSong);
  1381. #ifdef SHOW_DEBUG
  1382. Serial.print(F(" THRU->MIDI_DIN"));
  1383. #endif
  1384. #endif
  1385. #ifdef MIDI_DEVICE_USB_HOST
  1386. midi_usb.sendSongSelect(inSong);
  1387. #ifdef SHOW_DEBUG
  1388. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1389. #endif
  1390. #endif
  1391. }
  1392. #ifdef SHOW_DEBUG
  1393. Serial.println();
  1394. #endif
  1395. #endif
  1396. }
  1397. void handleTuneRequest_MIDI_DEVICE_USB(void)
  1398. {
  1399. handleTuneRequest();
  1400. #ifdef SHOW_DEBUG
  1401. Serial.print(F("[MIDI_USB] TuneRequest"));
  1402. #endif
  1403. #ifdef MIDI_MERGE_THRU
  1404. if (configuration.midi_soft_thru == true)
  1405. {
  1406. #ifdef MIDI_DEVICE_DIN
  1407. midi_serial.sendTuneRequest();
  1408. #ifdef SHOW_DEBUG
  1409. Serial.print(F(" THRU->MIDI_DIN"));
  1410. #endif
  1411. #endif
  1412. #ifdef MIDI_DEVICE_USB_HOST
  1413. midi_usb.sendTuneRequest();
  1414. #ifdef SHOW_DEBUG
  1415. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1416. #endif
  1417. #endif
  1418. }
  1419. #ifdef SHOW_DEBUG
  1420. Serial.println();
  1421. #endif
  1422. #endif
  1423. }
  1424. void handleClock_MIDI_DEVICE_USB(void)
  1425. {
  1426. handleClock();
  1427. #ifdef SHOW_DEBUG
  1428. Serial.print(F("[MIDI_USB] Clock"));
  1429. #endif
  1430. #ifdef MIDI_MERGE_THRU
  1431. if (configuration.midi_soft_thru == true)
  1432. {
  1433. #ifdef MIDI_DEVICE_DIN
  1434. midi_serial.sendRealTime(midi::Clock);
  1435. #ifdef SHOW_DEBUG
  1436. Serial.print(F(" THRU->MIDI_DIN"));
  1437. #endif
  1438. #endif
  1439. #ifdef MIDI_DEVICE_USB_HOST
  1440. midi_usb.sendRealTime(midi::Clock);
  1441. #ifdef SHOW_DEBUG
  1442. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1443. #endif
  1444. #endif
  1445. }
  1446. #ifdef SHOW_DEBUG
  1447. Serial.println();
  1448. #endif
  1449. #endif
  1450. }
  1451. void handleStart_MIDI_DEVICE_USB(void)
  1452. {
  1453. handleStart();
  1454. #ifdef SHOW_DEBUG
  1455. Serial.print(F("[MIDI_USB] Start"));
  1456. #endif
  1457. #ifdef MIDI_MERGE_THRU
  1458. if (configuration.midi_soft_thru == true)
  1459. {
  1460. #ifdef MIDI_DEVICE_DIN
  1461. midi_serial.sendRealTime(midi::Start);
  1462. #ifdef SHOW_DEBUG
  1463. Serial.print(F(" THRU->MIDI_DIN"));
  1464. #endif
  1465. #endif
  1466. #ifdef MIDI_DEVICE_USB_HOST
  1467. midi_usb.sendRealTime(midi::Start);
  1468. #ifdef SHOW_DEBUG
  1469. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1470. #endif
  1471. #endif
  1472. }
  1473. #ifdef SHOW_DEBUG
  1474. Serial.println();
  1475. #endif
  1476. #endif
  1477. }
  1478. void handleContinue_MIDI_DEVICE_USB(void)
  1479. {
  1480. handleContinue();
  1481. #ifdef SHOW_DEBUG
  1482. Serial.print(F("[MIDI_USB] Continue"));
  1483. #endif
  1484. #ifdef MIDI_MERGE_THRU
  1485. if (configuration.midi_soft_thru == true)
  1486. {
  1487. #ifdef MIDI_DEVICE_DIN
  1488. midi_serial.sendRealTime(midi::Continue);
  1489. #ifdef SHOW_DEBUG
  1490. Serial.print(F(" THRU->MIDI_DIN"));
  1491. #endif
  1492. #endif
  1493. #ifdef MIDI_DEVICE_USB_HOST
  1494. midi_usb.sendRealTime(midi::Continue);
  1495. #ifdef SHOW_DEBUG
  1496. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1497. #endif
  1498. #endif
  1499. }
  1500. #ifdef SHOW_DEBUG
  1501. Serial.println();
  1502. #endif
  1503. #endif
  1504. }
  1505. void handleStop_MIDI_DEVICE_USB(void)
  1506. {
  1507. handleStop();
  1508. #ifdef SHOW_DEBUG
  1509. Serial.print(F("[MIDI_USB] Stop"));
  1510. #endif
  1511. #ifdef MIDI_MERGE_THRU
  1512. if (configuration.midi_soft_thru == true)
  1513. {
  1514. #ifdef MIDI_DEVICE_DIN
  1515. midi_serial.sendRealTime(midi::Stop);
  1516. #ifdef SHOW_DEBUG
  1517. Serial.print(F(" THRU->MIDI_DIN"));
  1518. #endif
  1519. #endif
  1520. #ifdef MIDI_DEVICE_USB_HOST
  1521. midi_usb.sendRealTime(midi::Stop);
  1522. #ifdef SHOW_DEBUG
  1523. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1524. #endif
  1525. #endif
  1526. }
  1527. #ifdef SHOW_DEBUG
  1528. Serial.println();
  1529. #endif
  1530. #endif
  1531. }
  1532. void handleActiveSensing_MIDI_DEVICE_USB(void)
  1533. {
  1534. handleActiveSensing();
  1535. #ifdef SHOW_DEBUG
  1536. Serial.print(F("[MIDI_USB] ActiveSensing"));
  1537. #endif
  1538. #ifdef MIDI_MERGE_THRU
  1539. if (configuration.midi_soft_thru == true)
  1540. {
  1541. #ifdef MIDI_DEVICE_DIN
  1542. midi_serial.sendRealTime(midi::ActiveSensing);
  1543. #ifdef SHOW_DEBUG
  1544. Serial.print(F(" THRU->MIDI_DIN"));
  1545. #endif
  1546. #endif
  1547. #ifdef MIDI_DEVICE_USB_HOST
  1548. midi_usb.sendRealTime(midi::ActiveSensing);
  1549. #ifdef SHOW_DEBUG
  1550. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1551. #endif
  1552. #endif
  1553. }
  1554. #ifdef SHOW_DEBUG
  1555. Serial.println();
  1556. #endif
  1557. #endif
  1558. }
  1559. void handleSystemReset_MIDI_DEVICE_USB(void)
  1560. {
  1561. handleSystemReset();
  1562. #ifdef SHOW_DEBUG
  1563. Serial.print(F("[MIDI_USB] SystemReset"));
  1564. #endif
  1565. #ifdef MIDI_MERGE_THRU
  1566. if (configuration.midi_soft_thru == true)
  1567. {
  1568. #ifdef MIDI_DEVICE_DIN
  1569. midi_serial.sendRealTime(midi::SystemReset);
  1570. #ifdef SHOW_DEBUG
  1571. Serial.print(F(" THRU->MIDI_DIN"));
  1572. #endif
  1573. #endif
  1574. #ifdef MIDI_DEVICE_USB_HOST
  1575. midi_usb.sendRealTime(midi::SystemReset);
  1576. #ifdef SHOW_DEBUG
  1577. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1578. #endif
  1579. #endif
  1580. }
  1581. #ifdef SHOW_DEBUG
  1582. Serial.println();
  1583. #endif
  1584. #endif
  1585. }
  1586. /* void handleRealTimeSystem_MIDI_DEVICE_USB(byte inRealTime)
  1587. {
  1588. handleRealTimeSystem();
  1589. #ifdef SHOW_DEBUG
  1590. Serial.print(F("[MIDI_USB] RealTimeSystem"));
  1591. #endif
  1592. #ifdef MIDI_MERGE_THRU
  1593. if (configuration.midi_soft_thru == true)
  1594. {
  1595. #ifdef MIDI_DEVICE_DIN
  1596. midi_serial.sendRealTime((midi::MidiType)inRealTime);
  1597. #ifdef SHOW_DEBUG
  1598. Serial.print(F(" THRU->MIDI_DIN"));
  1599. #endif
  1600. #endif
  1601. #ifdef MIDI_DEVICE_USB_HOST
  1602. midi_usb.sendRealTime(inRealTime);
  1603. #ifdef SHOW_DEBUG
  1604. Serial.print(F(" THRU->MIDI_USB_HOST"));
  1605. #endif
  1606. #endif
  1607. }
  1608. #ifdef SHOW_DEBUG
  1609. Serial.println();
  1610. #endif
  1611. #endif
  1612. } */
  1613. #endif // MIDI_DEVICE_USB
  1614. /*****************************************
  1615. HELPER FUCNTIONS
  1616. *****************************************/
  1617. void setup_midi_devices(void)
  1618. {
  1619. #ifdef MIDI_DEVICE_DIN
  1620. // Start serial MIDI
  1621. midi_serial.begin(DEFAULT_MIDI_CHANNEL);
  1622. midi_serial.setHandleNoteOn(handleNoteOn_MIDI_DEVICE_DIN);
  1623. midi_serial.setHandleNoteOff(handleNoteOff_MIDI_DEVICE_DIN);
  1624. midi_serial.setHandleControlChange(handleControlChange_MIDI_DEVICE_DIN);
  1625. midi_serial.setHandleAfterTouchChannel(handleAfterTouch_MIDI_DEVICE_DIN);
  1626. midi_serial.setHandlePitchBend(handlePitchBend_MIDI_DEVICE_DIN);
  1627. midi_serial.setHandleProgramChange(handleProgramChange_MIDI_DEVICE_DIN);
  1628. midi_serial.setHandleSystemExclusive(handleSystemExclusive_MIDI_DEVICE_DIN);
  1629. //midi_serial.setHandleSystemExclusiveChunk(handleSystemExclusiveChunk_MIDI_DEVICE_DIN);
  1630. midi_serial.setHandleTimeCodeQuarterFrame(handleTimeCodeQuarterFrame_MIDI_DEVICE_DIN);
  1631. midi_serial.setHandleAfterTouchPoly(handleAfterTouchPoly_MIDI_DEVICE_DIN);
  1632. midi_serial.setHandleSongSelect(handleSongSelect_MIDI_DEVICE_DIN);
  1633. midi_serial.setHandleTuneRequest(handleTuneRequest_MIDI_DEVICE_DIN);
  1634. midi_serial.setHandleClock(handleClock_MIDI_DEVICE_DIN);
  1635. midi_serial.setHandleStart(handleStart_MIDI_DEVICE_DIN);
  1636. midi_serial.setHandleContinue(handleContinue_MIDI_DEVICE_DIN);
  1637. midi_serial.setHandleStop(handleStop_MIDI_DEVICE_DIN);
  1638. midi_serial.setHandleActiveSensing(handleActiveSensing_MIDI_DEVICE_DIN);
  1639. midi_serial.setHandleSystemReset(handleSystemReset_MIDI_DEVICE_DIN);
  1640. //midi_serial.setHandleRealTimeSystem(handleRealTimeSystem_MIDI_DEVICE_DIN);
  1641. Serial.println(F("MIDI_DEVICE_DIN enabled"));
  1642. #endif
  1643. // start up USB host
  1644. #ifdef MIDI_DEVICE_USB_HOST
  1645. usb_host.begin();
  1646. midi_usb.setHandleNoteOn(handleNoteOn_MIDI_DEVICE_USB_HOST);
  1647. midi_usb.setHandleNoteOff(handleNoteOff_MIDI_DEVICE_USB_HOST);
  1648. midi_usb.setHandleControlChange(handleControlChange_MIDI_DEVICE_USB_HOST);
  1649. midi_usb.setHandleAfterTouchChannel(handleAfterTouch_MIDI_DEVICE_USB_HOST);
  1650. midi_usb.setHandlePitchChange(handlePitchBend_MIDI_DEVICE_USB_HOST);
  1651. midi_usb.setHandleProgramChange(handleProgramChange_MIDI_DEVICE_USB_HOST);
  1652. midi_usb.setHandleSystemExclusive(handleSystemExclusive_MIDI_DEVICE_USB_HOST);
  1653. //midi_usb.setHandleSystemExclusiveChunk(handleSystemExclusiveChunk_MIDI_DEVICE_USB_HOST);
  1654. midi_usb.setHandleTimeCodeQuarterFrame(handleTimeCodeQuarterFrame_MIDI_DEVICE_USB_HOST);
  1655. midi_usb.setHandleAfterTouchPoly(handleAfterTouchPoly_MIDI_DEVICE_USB_HOST);
  1656. midi_usb.setHandleSongSelect(handleSongSelect_MIDI_DEVICE_USB_HOST);
  1657. midi_usb.setHandleTuneRequest(handleTuneRequest_MIDI_DEVICE_USB_HOST);
  1658. midi_usb.setHandleClock(handleClock_MIDI_DEVICE_USB_HOST);
  1659. midi_usb.setHandleStart(handleStart_MIDI_DEVICE_USB_HOST);
  1660. midi_usb.setHandleContinue(handleContinue_MIDI_DEVICE_USB_HOST);
  1661. midi_usb.setHandleStop(handleStop_MIDI_DEVICE_USB_HOST);
  1662. midi_usb.setHandleActiveSensing(handleActiveSensing_MIDI_DEVICE_USB_HOST);
  1663. midi_usb.setHandleSystemReset(handleSystemReset_MIDI_DEVICE_USB_HOST);
  1664. //midi_usb.setHandleRealTimeSystem(handleRealTimeSystem_MIDI_DEVICE_USB_HOST);
  1665. Serial.println(F("MIDI_DEVICE_USB_HOST enabled."));
  1666. #endif
  1667. // check for onboard USB-MIDI
  1668. #ifdef MIDI_DEVICE_USB
  1669. usbMIDI.begin();
  1670. usbMIDI.setHandleNoteOn(handleNoteOn_MIDI_DEVICE_USB);
  1671. usbMIDI.setHandleNoteOff(handleNoteOff_MIDI_DEVICE_USB);
  1672. usbMIDI.setHandleControlChange(handleControlChange_MIDI_DEVICE_USB);
  1673. usbMIDI.setHandleAfterTouchChannel(handleAfterTouch_MIDI_DEVICE_USB);
  1674. usbMIDI.setHandlePitchChange(handlePitchBend_MIDI_DEVICE_USB);
  1675. usbMIDI.setHandleProgramChange(handleProgramChange_MIDI_DEVICE_USB);
  1676. usbMIDI.setHandleSystemExclusive(handleSystemExclusive_MIDI_DEVICE_USB);
  1677. //usbMIDI.setHandleSystemExclusiveChunk(handleSystemExclusiveChunk_MIDI_DEVICE_USB);
  1678. usbMIDI.setHandleTimeCodeQuarterFrame(handleTimeCodeQuarterFrame_MIDI_DEVICE_USB);
  1679. usbMIDI.setHandleAfterTouchPoly(handleAfterTouchPoly_MIDI_DEVICE_USB);
  1680. usbMIDI.setHandleSongSelect(handleSongSelect_MIDI_DEVICE_USB);
  1681. usbMIDI.setHandleTuneRequest(handleTuneRequest_MIDI_DEVICE_USB);
  1682. usbMIDI.setHandleClock(handleClock_MIDI_DEVICE_USB);
  1683. usbMIDI.setHandleStart(handleStart_MIDI_DEVICE_USB);
  1684. usbMIDI.setHandleContinue(handleContinue_MIDI_DEVICE_USB);
  1685. usbMIDI.setHandleStop(handleStop_MIDI_DEVICE_USB);
  1686. usbMIDI.setHandleActiveSensing(handleActiveSensing_MIDI_DEVICE_USB);
  1687. usbMIDI.setHandleSystemReset(handleSystemReset_MIDI_DEVICE_USB);
  1688. //usbMIDI.setHandleRealTimeSystem(handleRealTimeSystem_MIDI_DEVICE_USB);
  1689. Serial.println(F("MIDI_DEVICE_USB enabled."));
  1690. #endif
  1691. }
  1692. void check_midi_devices(void)
  1693. {
  1694. #ifdef MIDI_DEVICE_DIN
  1695. midi_serial.read();
  1696. #endif
  1697. #ifdef MIDI_DEVICE_USB
  1698. usbMIDI.read();
  1699. #endif
  1700. #ifdef MIDI_DEVICE_USB_HOST
  1701. usb_host.Task();
  1702. midi_usb.read();
  1703. #endif
  1704. }
  1705. #endif // MIDI_DEVICES_H