Embedded/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-01-17 05:32:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

tested midi example

Browse Source
This commit is contained in:
hathach 2019-07-03 00:52:25 +07:00
parent 62d3b91691
commit 1a0e02fa1b
7 changed files with 75 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/device/cdc_msc_hid/src/main.c
View File

@ -263,7 +263,7 @@ void led_blinking_task(void)
static uint32_t start_ms = 0;
static bool led_state = false;
// Blink every 1000 ms
// Blink every interval ms
if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
start_ms += blink_interval_ms;

2
examples/device/hid_generic_inout/src/main.c
View File

@ -154,7 +154,7 @@ void led_blinking_task(void)
static uint32_t start_ms = 0;
static bool led_state = false;
// Blink every 1000 ms
// Blink every interval ms
if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
start_ms += blink_interval_ms;

54
examples/device/midi/src/main.c
View File

@ -30,6 +30,12 @@
#include "bsp/board.h"
#include "tusb.h"
/* This MIDI example send sequence of note (on/off) repeatedly. To test on PC, you need to install
* synth software and midi connection management software. On
* - Linux (Ubuntu) : install qsynth, qjackctl. Then connect TinyUSB output port to FLUID Synth input port
*
*/
//--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF PROTYPES
//--------------------------------------------------------------------+
@ -48,6 +54,7 @@ enum {
static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
void led_blinking_task(void);
void midi_task(void);
/*------------- MAIN -------------*/
int main(void)
@ -62,6 +69,8 @@ int main(void)
tud_task();
led_blinking_task();
midi_task();
}
return 0;
@ -98,6 +107,49 @@ void tud_resume_cb(void)
blink_interval_ms = BLINK_MOUNTED;
}
//--------------------------------------------------------------------+
// MIDI Task
//--------------------------------------------------------------------+
// Variable that holds the current position in the sequence.
uint32_t note_pos = 0;
// Store example melody as an array of note values
uint8_t note_sequence[] =
{
74,78,81,86,90,93,98,102,57,61,66,69,73,78,81,85,88,92,97,100,97,92,88,85,81,78,
74,69,66,62,57,62,66,69,74,78,81,86,90,93,97,102,97,93,90,85,81,78,73,68,64,61,
56,61,64,68,74,78,81,86,90,93,98,102
};
void midi_task(void)
{
static uint32_t start_ms = 0;
// send note every 1000 ms
if (board_millis() - start_ms < 286) return; // not enough time
start_ms += 286;
// Previous positions in the note sequence.
int previous = note_pos - 1;
// If we currently are at position 0, set the
// previous position to the last note in the sequence.
if (previous < 0) previous = sizeof(note_sequence) - 1;
// Send Note On for current position at full velocity (127) on channel 1.
tudi_midi_write24(0, 0x90, note_sequence[note_pos], 127);
// Send Note Off for previous note.
tudi_midi_write24(0, 0x80, note_sequence[previous], 0);
// Increment position
note_pos++;
// If we are at the end of the sequence, start over.
if (note_pos >= sizeof(note_sequence)) note_pos = 0;
}
//--------------------------------------------------------------------+
// BLINKING TASK
//--------------------------------------------------------------------+
@ -106,7 +158,7 @@ void led_blinking_task(void)
static uint32_t start_ms = 0;
static bool led_state = false;
// Blink every 1000 ms
// Blink every interval ms
if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
start_ms += blink_interval_ms;

2
examples/device/msc_dual_lun/src/main.c
View File

@ -106,7 +106,7 @@ void led_blinking_task(void)
static uint32_t start_ms = 0;
static bool led_state = false;
// Blink every 1000 ms
// Blink every interval ms
if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
start_ms += blink_interval_ms;

2
examples/host/cdc_msc_hid/src/main.c
View File

@ -169,7 +169,7 @@ void led_blinking_task(void)
static bool led_state = false;
// Blink every 1000 ms
// Blink every interval ms
if ( board_millis() - start_ms < interval_ms) return; // not enough time
start_ms += interval_ms;

2
src/class/cdc/cdc_device.h
View File

@ -103,7 +103,7 @@ TU_ATTR_WEAK void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts);
TU_ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding);
//--------------------------------------------------------------------+
// Application API (Interface0) Implementation
// Inline Functions
//--------------------------------------------------------------------+
static inline bool tud_cdc_connected (void)
{

18
src/class/midi/midi_device.h
View File

@ -60,6 +60,8 @@ void tud_midi_n_read_flush (uint8_t itf, uint8_t jack_id);
uint32_t tud_midi_n_write (uint8_t itf, uint8_t jack_id, uint8_t const* buffer, uint32_t bufsize);
bool tud_midi_n_write_flush (uint8_t itf);
static inline uint32_t tud_midi_n_write24 (uint8_t itf, uint8_t jack_id, uint8_t b1, uint8_t b2, uint8_t b3);
//--------------------------------------------------------------------+
// Application API (Interface0)
//--------------------------------------------------------------------+
@ -68,6 +70,7 @@ static inline uint32_t tud_midi_available (void);
static inline uint32_t tud_midi_read (void* buffer, uint32_t bufsize);
static inline void tud_midi_read_flush (void);
static inline uint32_t tud_midi_write (uint8_t jack_id, void const* buffer, uint32_t bufsize);
static inline uint32_t tudi_midi_write24 (uint8_t jack_id, uint8_t b1, uint8_t b2, uint8_t b3);
static inline bool tud_midi_write_flush (void);
//--------------------------------------------------------------------+
@ -76,8 +79,15 @@ static inline bool tud_midi_write_flush (void);
TU_ATTR_WEAK void tud_midi_rx_cb(uint8_t itf);
//--------------------------------------------------------------------+
// Application API (Interface0) Implementation
// Inline Functions
//--------------------------------------------------------------------+
static inline uint32_t tud_midi_n_write24 (uint8_t itf, uint8_t jack_id, uint8_t b1, uint8_t b2, uint8_t b3)
{
uint8_t msg[3] = { b1, b2, b3 };
return tud_midi_n_write(itf, jack_id, msg, 3);
}
static inline bool tud_midi_connected (void)
{
return tud_midi_n_connected(0);
@ -103,6 +113,12 @@ static inline uint32_t tud_midi_write (uint8_t jack_id, void const* buffer, uint
return tud_midi_n_write(0, jack_id, buffer, bufsize);
}
static inline uint32_t tudi_midi_write24 (uint8_t jack_id, uint8_t b1, uint8_t b2, uint8_t b3)
{
uint8_t msg[3] = { b1, b2, b3 };
return tud_midi_write(jack_id, msg, 3);
}
static inline bool tud_midi_write_flush (void)
{
return tud_midi_n_write_flush(0);