359 lines
13 KiB
C
359 lines
13 KiB
C
/*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2020 Jerzy Kasenberg
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "bsp/board.h"
|
|
#include "tusb.h"
|
|
#include "usb_descriptors.h"
|
|
|
|
//--------------------------------------------------------------------+
|
|
// MACRO CONSTANT TYPEDEF PROTOTYPES
|
|
//--------------------------------------------------------------------+
|
|
|
|
/* Blink pattern
|
|
* - 25 ms : streaming data
|
|
* - 250 ms : device not mounted
|
|
* - 1000 ms : device mounted
|
|
* - 2500 ms : device is suspended
|
|
*/
|
|
enum {
|
|
BLINK_STREAMING = 25,
|
|
BLINK_NOT_MOUNTED = 250,
|
|
BLINK_MOUNTED = 1000,
|
|
BLINK_SUSPENDED = 2500,
|
|
};
|
|
|
|
enum {
|
|
VOLUME_CTRL_0_DB = 0,
|
|
VOLUME_CTRL_10_DB = 2560,
|
|
VOLUME_CTRL_20_DB = 5120,
|
|
VOLUME_CTRL_30_DB = 7680,
|
|
VOLUME_CTRL_40_DB = 10240,
|
|
VOLUME_CTRL_50_DB = 12800,
|
|
VOLUME_CTRL_60_DB = 15360,
|
|
VOLUME_CTRL_70_DB = 17920,
|
|
VOLUME_CTRL_80_DB = 20480,
|
|
VOLUME_CTRL_90_DB = 23040,
|
|
VOLUME_CTRL_100_DB = 25600,
|
|
VOLUME_CTRL_SILENCE = 0x8000,
|
|
};
|
|
|
|
static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
|
|
|
|
// Audio controls
|
|
// Current states
|
|
int8_t mute[CFG_TUD_AUDIO_N_CHANNELS_TX + 1]; // +1 for master channel 0
|
|
int16_t volume[CFG_TUD_AUDIO_N_CHANNELS_TX + 1]; // +1 for master channel 0
|
|
|
|
// Buffer for microphone data
|
|
int16_t mic_buf[1000];
|
|
// Buffer for speaker data
|
|
int16_t spk_buf[1000];
|
|
// Speaker data size received in the last frame
|
|
int spk_data_size;
|
|
|
|
void led_blinking_task(void);
|
|
void audio_task(void);
|
|
|
|
/*------------- MAIN -------------*/
|
|
int main(void) {
|
|
board_init();
|
|
|
|
tusb_init();
|
|
|
|
TU_LOG1("Headset running\r\n");
|
|
|
|
while (1) {
|
|
tud_task(); // TinyUSB device task
|
|
audio_task();
|
|
led_blinking_task();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------+
|
|
// Device callbacks
|
|
//--------------------------------------------------------------------+
|
|
|
|
// Invoked when device is mounted
|
|
void tud_mount_cb(void) {
|
|
blink_interval_ms = BLINK_MOUNTED;
|
|
}
|
|
|
|
// Invoked when device is unmounted
|
|
void tud_umount_cb(void) {
|
|
blink_interval_ms = BLINK_NOT_MOUNTED;
|
|
}
|
|
|
|
// Invoked when usb bus is suspended
|
|
// remote_wakeup_en : if host allow us to perform remote wakeup
|
|
// Within 7ms, device must draw an average of current less than 2.5 mA from bus
|
|
void tud_suspend_cb(bool remote_wakeup_en) {
|
|
(void) remote_wakeup_en;
|
|
blink_interval_ms = BLINK_SUSPENDED;
|
|
}
|
|
|
|
// Invoked when usb bus is resumed
|
|
void tud_resume_cb(void) {
|
|
blink_interval_ms = BLINK_MOUNTED;
|
|
}
|
|
|
|
typedef struct TU_ATTR_PACKED {
|
|
union {
|
|
struct TU_ATTR_PACKED {
|
|
uint8_t recipient: 5; ///< Recipient type tusb_request_recipient_t.
|
|
uint8_t type: 2; ///< Request type tusb_request_type_t.
|
|
uint8_t direction: 1; ///< Direction type. tusb_dir_t
|
|
} bmRequestType_bit;
|
|
|
|
uint8_t bmRequestType;
|
|
};
|
|
|
|
audio_cs_req_t bRequest;
|
|
uint8_t bChannelNumber;
|
|
uint8_t bControlSelector;
|
|
union {
|
|
uint8_t bInterface;
|
|
uint8_t bEndpoint;
|
|
};
|
|
uint8_t bEntityID;
|
|
uint16_t wLength;
|
|
} audio_control_request_t;
|
|
|
|
// Helper for clock get requests
|
|
static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t const *request) {
|
|
TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
|
|
|
|
// Example supports only single frequency, same value will be used for current value and range
|
|
if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ) {
|
|
if (request->bRequest == AUDIO_CS_REQ_CUR) {
|
|
TU_LOG2("Clock get current freq %u\r\n", AUDIO_SAMPLE_RATE);
|
|
|
|
audio_control_cur_4_t curf = {tu_htole32(AUDIO_SAMPLE_RATE)};
|
|
return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &curf,
|
|
sizeof(curf));
|
|
} else if (request->bRequest == AUDIO_CS_REQ_RANGE) {
|
|
audio_control_range_4_n_t(1) rangef =
|
|
{
|
|
.wNumSubRanges = tu_htole16(1),
|
|
.subrange[0] = {tu_htole32(AUDIO_SAMPLE_RATE), tu_htole32(AUDIO_SAMPLE_RATE), 0}
|
|
};
|
|
TU_LOG2("Clock get freq range (%d, %d, %d)\r\n", (int) rangef.subrange[0].bMin,
|
|
(int) rangef.subrange[0].bMax, (int) rangef.subrange[0].bRes);
|
|
return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &rangef,
|
|
sizeof(rangef));
|
|
}
|
|
} else if (request->bControlSelector == AUDIO_CS_CTRL_CLK_VALID &&
|
|
request->bRequest == AUDIO_CS_REQ_CUR) {
|
|
audio_control_cur_1_t cur_valid = {.bCur = 1};
|
|
TU_LOG2("Clock get is valid %u\r\n", cur_valid.bCur);
|
|
return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_valid,
|
|
sizeof(cur_valid));
|
|
}
|
|
TU_LOG1("Clock get request not supported, entity = %u, selector = %u, request = %u\r\n",
|
|
request->bEntityID, request->bControlSelector, request->bRequest);
|
|
return false;
|
|
}
|
|
|
|
// Helper for feature unit get requests
|
|
static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_request_t const *request) {
|
|
TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
|
|
|
|
if (request->bControlSelector == AUDIO_FU_CTRL_MUTE && request->bRequest == AUDIO_CS_REQ_CUR) {
|
|
audio_control_cur_1_t mute1 = {.bCur = mute[request->bChannelNumber]};
|
|
TU_LOG2("Get channel %u mute %d\r\n", request->bChannelNumber, mute1.bCur);
|
|
return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &mute1,
|
|
sizeof(mute1));
|
|
} else if (UAC2_ENTITY_SPK_FEATURE_UNIT && request->bControlSelector == AUDIO_FU_CTRL_VOLUME) {
|
|
if (request->bRequest == AUDIO_CS_REQ_RANGE) {
|
|
audio_control_range_2_n_t(1) range_vol = {
|
|
.wNumSubRanges = tu_htole16(1),
|
|
.subrange[0] = {.bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB),
|
|
tu_htole16(256)}
|
|
};
|
|
TU_LOG2("Get channel %u volume range (%d, %d, %u) dB\r\n", request->bChannelNumber,
|
|
range_vol.subrange[0].bMin / 256, range_vol.subrange[0].bMax / 256,
|
|
range_vol.subrange[0].bRes / 256);
|
|
return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request,
|
|
&range_vol, sizeof(range_vol));
|
|
} else if (request->bRequest == AUDIO_CS_REQ_CUR) {
|
|
audio_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[request->bChannelNumber])};
|
|
TU_LOG2("Get channel %u volume %u dB\r\n", request->bChannelNumber, cur_vol.bCur);
|
|
return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request,
|
|
&cur_vol, sizeof(cur_vol));
|
|
}
|
|
}
|
|
TU_LOG1("Feature unit get request not supported, entity = %u, selector = %u, request = %u\r\n",
|
|
request->bEntityID, request->bControlSelector, request->bRequest);
|
|
|
|
return false;
|
|
}
|
|
|
|
// Helper for feature unit set requests
|
|
static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_request_t const *request,
|
|
uint8_t const *buf) {
|
|
(void) rhport;
|
|
|
|
TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
|
|
TU_VERIFY(request->bRequest == AUDIO_CS_REQ_CUR);
|
|
|
|
if (request->bControlSelector == AUDIO_FU_CTRL_MUTE) {
|
|
TU_VERIFY(request->wLength == sizeof(audio_control_cur_1_t));
|
|
|
|
mute[request->bChannelNumber] = ((audio_control_cur_1_t *) buf)->bCur;
|
|
|
|
TU_LOG2("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]);
|
|
|
|
return true;
|
|
} else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME) {
|
|
TU_VERIFY(request->wLength == sizeof(audio_control_cur_2_t));
|
|
|
|
volume[request->bChannelNumber] = ((audio_control_cur_2_t const *) buf)->bCur;
|
|
|
|
TU_LOG2("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256);
|
|
|
|
return true;
|
|
} else {
|
|
TU_LOG1("Feature unit set request not supported, entity = %u, selector = %u, request = %u\r\n",
|
|
request->bEntityID, request->bControlSelector, request->bRequest);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------+
|
|
// Application Callback API Implementations
|
|
//--------------------------------------------------------------------+
|
|
|
|
// Invoked when audio class specific get request received for an entity
|
|
bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
|
|
audio_control_request_t *request = (audio_control_request_t *) p_request;
|
|
|
|
if (request->bEntityID == UAC2_ENTITY_CLOCK)
|
|
return tud_audio_clock_get_request(rhport, request);
|
|
if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT)
|
|
return tud_audio_feature_unit_get_request(rhport, request);
|
|
else {
|
|
TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n",
|
|
request->bEntityID, request->bControlSelector, request->bRequest);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Invoked when audio class specific set request received for an entity
|
|
bool tud_audio_set_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t *buf) {
|
|
audio_control_request_t const *request = (audio_control_request_t const *) p_request;
|
|
|
|
if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT)
|
|
return tud_audio_feature_unit_set_request(rhport, request, buf);
|
|
|
|
TU_LOG1("Set request not handled, entity = %d, selector = %d, request = %d\r\n",
|
|
request->bEntityID, request->bControlSelector, request->bRequest);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool tud_audio_set_itf_close_EP_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
|
|
(void) rhport;
|
|
|
|
uint8_t const itf = tu_u16_low(tu_le16toh(p_request->wIndex));
|
|
uint8_t const alt = tu_u16_low(tu_le16toh(p_request->wValue));
|
|
|
|
if (ITF_NUM_AUDIO_STREAMING_SPK == itf && alt == 0)
|
|
blink_interval_ms = BLINK_MOUNTED;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
|
|
(void) rhport;
|
|
uint8_t const itf = tu_u16_low(tu_le16toh(p_request->wIndex));
|
|
uint8_t const alt = tu_u16_low(tu_le16toh(p_request->wValue));
|
|
|
|
TU_LOG2("Set interface %d alt %d\r\n", itf, alt);
|
|
if (ITF_NUM_AUDIO_STREAMING_SPK == itf && alt != 0)
|
|
blink_interval_ms = BLINK_STREAMING;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool tud_audio_rx_done_cb(uint8_t rhport, uint8_t *buffer, uint16_t buf_size) {
|
|
(void) rhport;
|
|
|
|
spk_data_size = buf_size;
|
|
memcpy(spk_buf, buffer, buf_size);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, uint8_t itf, uint8_t ep_in, uint8_t cur_alt_setting) {
|
|
(void) rhport;
|
|
(void) itf;
|
|
(void) ep_in;
|
|
(void) cur_alt_setting;
|
|
|
|
// This callback could be used to fill microphone data separately
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------+
|
|
// AUDIO Task
|
|
//--------------------------------------------------------------------+
|
|
|
|
void audio_task(void) {
|
|
// When new data arrived, copy data from speaker buffer, to microphone buffer
|
|
// and send it over
|
|
if (spk_data_size) {
|
|
int16_t *src = spk_buf;
|
|
int16_t *limit = spk_buf + spk_data_size / 2;
|
|
int16_t *dst = mic_buf;
|
|
while (src < limit) {
|
|
// Combine two channels into one
|
|
int32_t left = *src++;
|
|
int32_t right = *src++;
|
|
*dst++ = (int16_t) ((left + right) / 2);
|
|
}
|
|
tud_audio_write((uint8_t *) mic_buf, spk_data_size / 2);
|
|
spk_data_size = 0;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------+
|
|
// BLINKING TASK
|
|
//--------------------------------------------------------------------+
|
|
void led_blinking_task(void) {
|
|
static uint32_t start_ms = 0;
|
|
static bool led_state = false;
|
|
|
|
// Blink every interval ms
|
|
if (board_millis() - start_ms < blink_interval_ms) return;
|
|
start_ms += blink_interval_ms;
|
|
|
|
board_led_write(led_state);
|
|
led_state = 1 - led_state;
|
|
}
|