WWW.LAB-Z.COM

#include <arduino.h>
#include "soc/gpio_struct.h" // GPIO

void setup() {
  pinMode(20,OUTPUT);
}

void loop() {
  GPIO.out_w1ts.val = 1<<20;
  GPIO.out_w1tc.val = 1<<20;
  GPIO.out_w1ts.val = 1<<20;
  GPIO.out_w1tc.val = 1<<20;
  GPIO.out_w1ts.val = 1<<20;  
  delay(100);
}

ESP_LOGI(TAG, "USB initialization");
  const tinyusb_config_t tusb_cfg = {
    .device_descriptor = NULL,
    .string_descriptor = NULL,
    .external_phy = false,
    .configuration_descriptor = NULL,
  };
  ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));
  tinyusb_config_cdcacm_t acm_cfg = {
    .usb_dev = TINYUSB_USBDEV_0,
    .cdc_port = TINYUSB_CDC_ACM_0,
    .rx_unread_buf_sz = 64,
    .callback_rx = &tinyusb_cdc_rx_callback, // the first way to register a callback
    .callback_rx_wanted_char = NULL,
    .callback_line_state_changed = &tinyusb_cdc_line_state_changed_callback,
    .callback_line_coding_changed = &tinyusb_cdc_line_coding_changed_callback
  };
  ESP_ERROR_CHECK(tusb_cdc_acm_init(&acm_cfg));
  ESP_LOGI(TAG, "USB initialization DONE");

void tinyusb_cdc_rx_callback(int itf, cdcacm_event_t *event)
{
  // USB CDC 接收的处理
  uint8_t rx_buf[CONFIG_TINYUSB_CDC_RX_BUFSIZE];
  size_t rx_size = 0;
  // 读取放入 rx_buf 缓冲区
  esp_err_t ret = tinyusb_cdcacm_read(itf, rx_buf, CONFIG_TINYUSB_CDC_RX_BUFSIZE, &rx_size);
  if (ret == ESP_OK) {
    // 根据资料，如果缓冲区有足够的空间，那么不会阻塞
    uart_write_bytes(UART_NUM_1,rx_buf,rx_size);
  } else {
    ESP_LOGE(TAG, "Read Error");
  }
}

// 设置波特率的回调函数
void tinyusb_cdc_line_coding_changed_callback(int itf, cdcacm_event_t *event)
{
  cdc_line_coding_t *line_coding = event->line_coding_changed_data.p_line_coding;
  Baudrate = line_coding->bit_rate;
  if (previous_Baudrate != Baudrate) {
    ESP_LOGI(TAG, "Change Baudrate from %lu to %lu", previous_Baudrate, Baudrate);
    
    // 如果出现从 9600 波特率到 115200 的切换，那么说明是要进入下载模式
    if ((previous_Baudrate==9600)&&(Baudrate==115200)) {
        DownloadMode=true;
    }
    if ((Baudrate==115200)||(Baudrate==921600)) {
        uart_set_baudrate(UART_NUM_1, Baudrate);
    }
    previous_Baudrate=Baudrate;
  }
}

Esptool5 --trace -c esp32s3 -p com19 read-mac

#include <Uefi.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PrintLib.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/SimpleFileSystem.h>
#include <Guid/FileInfo.h>

/**
 * 基本的_getch()函数 - 等待并获取一个字符
 * @return 返回按下的字符，如果是特殊键则返回扩展码
 */
CHAR16 _getch(VOID)
{
    EFI_INPUT_KEY Key;
    EFI_STATUS Status;
    
    // 等待按键事件
    Status = gST->ConIn->ReadKeyStroke(gST->ConIn, &Key);
    
    // 如果没有按键，等待按键事件
    while (Status == EFI_NOT_READY) {
        gBS->WaitForEvent(1, &gST->ConIn->WaitForKey, NULL);
        Status = gST->ConIn->ReadKeyStroke(gST->ConIn, &Key);
    }
    
    if (EFI_ERROR(Status)) {
        return 0;
    }
    
    // 如果是普通字符，直接返回
    if (Key.UnicodeChar != 0) {
        return Key.UnicodeChar;
    }
    
    // 如果是特殊键，返回扫描码
    return (CHAR16)(0x100 + Key.ScanCode);
}

/**
 * 启动指定路径的 EFI 应用程序
 */
EFI_STATUS
StartEfiApplication (
  IN EFI_HANDLE        ParentImageHandle,
  IN CHAR16           *ApplicationPath
  )
{
    EFI_STATUS                      Status;
    EFI_HANDLE                      ChildImageHandle;
    EFI_DEVICE_PATH_PROTOCOL        *DevicePath;
    EFI_LOADED_IMAGE_PROTOCOL       *ParentLoadedImage;
    UINTN                           ExitDataSize;
    CHAR16                          *ExitData;

    Print(L"=== Starting EFI Application: %s ===\n", ApplicationPath);

    // 步骤 1: 获取父镜像的 LoadedImage 协议
    Status = gBS->HandleProtocol(
        ParentImageHandle,
        &gEfiLoadedImageProtocolGuid,
        (VOID**)&ParentLoadedImage
    );
    if (EFI_ERROR(Status)) {
        Print(L"ERROR: Failed to get parent LoadedImage protocol: %r\n", Status);
        return Status;
    }
    Print(L"SUCCESS: Got parent LoadedImage protocol\n");

    // 步骤 2: 构建目标应用的设备路径
    DevicePath = FileDevicePath(ParentLoadedImage->DeviceHandle, ApplicationPath);
    if (DevicePath == NULL) {
        Print(L"ERROR: Failed to create device path for %s\n", ApplicationPath);
        return EFI_OUT_OF_RESOURCES;
    }
    Print(L"SUCCESS: Created device path\n");

    // 步骤 3: 加载目标镜像
    Status = gBS->LoadImage(
        FALSE,                  // BootPolicy - FALSE 表示不是启动策略
        ParentImageHandle,      // ParentImageHandle - 父镜像句柄
        DevicePath,             // DevicePath - 目标文件的设备路径
        NULL,                   // SourceBuffer - NULL 表示从设备路径加载
        0,                      // SourceSize - 0 表示从设备路径加载
        &ChildImageHandle       // ImageHandle - 返回的子镜像句柄
    );

    // 释放设备路径内存
    FreePool(DevicePath);

    if (EFI_ERROR(Status)) {
        Print(L"ERROR: LoadImage failed: %r\n", Status);
        return Status;
    }
    Print(L"SUCCESS: Image loaded successfully, Handle = 0x%lx\n", (UINTN)ChildImageHandle);

    // 等待用户按键
    Print(L"Press any key to exit...\n");
    _getch();
	
    // 步骤 4: 启动镜像
    Print(L"Starting image...\n");
    Status = gBS->StartImage(
        ChildImageHandle,       // ImageHandle - 要启动的镜像句柄
        &ExitDataSize,          // ExitDataSize - 返回退出数据大小
        &ExitData               // ExitData - 返回退出数据
    );

    // 步骤 5: 处理启动结果
    if (EFI_ERROR(Status)) {
        Print(L"ERROR: StartImage failed: %r\n", Status);
        
        // 如果有退出数据，显示它
        if (ExitData != NULL && ExitDataSize > 0) {
            Print(L"Exit Data Size: %d bytes\n", ExitDataSize);
            Print(L"Exit Data: %s\n", ExitData);
            
            // 释放退出数据内存
            gBS->FreePool(ExitData);
        }
    } else {
        Print(L"SUCCESS: Image started and returned: %r\n", Status);
        
        // 处理正常退出的数据
        if (ExitData != NULL && ExitDataSize > 0) {
            Print(L"Application returned data: %s\n", ExitData);
            gBS->FreePool(ExitData);
        }
    }

    // 步骤 6: 卸载镜像（如果需要）
    Print(L"Unloading image...\n");
    gBS->UnloadImage(ChildImageHandle);

    Print(L"=== Application execution completed ===\n\n");
    return Status;
}

/**
 * 检查文件是否存在
 */
EFI_STATUS
CheckFileExists (
  IN EFI_HANDLE     DeviceHandle,
  IN CHAR16        *FilePath
  )
{
    EFI_STATUS                      Status;
    EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;
    EFI_FILE_PROTOCOL               *Root;
    EFI_FILE_PROTOCOL               *File;

    // 获取文件系统协议
    Status = gBS->HandleProtocol(
        DeviceHandle,
        &gEfiSimpleFileSystemProtocolGuid,
        (VOID**)&FileSystem
    );
    if (EFI_ERROR(Status)) {
        return Status;
    }

    // 打开根目录
    Status = FileSystem->OpenVolume(FileSystem, &Root);
    if (EFI_ERROR(Status)) {
        return Status;
    }

    // 尝试打开目标文件
    Status = Root->Open(
        Root,
        &File,
        FilePath,
        EFI_FILE_MODE_READ,
        0
    );

    if (!EFI_ERROR(Status)) {
        Print(L"File exists: %s\n", FilePath);
        File->Close(File);
    } else {
        Print(L"File not found: %s (Status: %r)\n", FilePath, Status);
    }

    Root->Close(Root);
    return Status;
}



/**
 * 主入口函数
 */
EFI_STATUS
EFIAPI
UefiMain (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
    EFI_STATUS                Status;
    EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;

    // 清屏
    gST->ConOut->ClearScreen(gST->ConOut);
    
    Print(L"UEFI StartImage Example Application\n");
    Print(L"====================================\n\n");

    // 获取当前镜像信息
    Status = gBS->HandleProtocol(
        ImageHandle,
        &gEfiLoadedImageProtocolGuid,
        (VOID**)&LoadedImage
    );
    if (EFI_ERROR(Status)) {
        Print(L"Failed to get LoadedImage protocol: %r\n", Status);
        return Status;
    }


    // 示例 : 启动 Windows Boot Manager
    Print(L"Example 1: Starting Windows Boot Manager\n");
    CheckFileExists(LoadedImage->DeviceHandle, L"EFI\\Microsoft\\boot\\bootbk.efi");
    Status = StartEfiApplication(ImageHandle, L"EFI\\Microsoft\\boot\\bootbk.efi");
    Print(L"Windows Boot Manager result: %r\n\n", Status);
    return EFI_SUCCESS;
}

## @file
#   A simple, basic, application showing how the Hello application could be
#   built using the "Standard C Libraries" from StdLib.
#
#  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
#  This program and the accompanying materials
#  are licensed and made available under the terms and conditions of the BSD License
#  which accompanies this distribution. The full text of the license may be found at
#  http://opensource.org/licenses/bsd-license.
#
#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
##

[Defines]
  INF_VERSION                    = 0x00010006
  BASE_NAME                      = bootmgfw
  FILE_GUID                      = 4ea97c46-7491-2025-1125-747010f3ce5f
  MODULE_TYPE                    = UEFI_APPLICATION
  VERSION_STRING                 = 0.1
  ENTRY_POINT                    = UefiMain

#   
#  VALID_ARCHITECTURES           = IA32 X64 IPF
#

[Sources]
  StartImageTest.c

[Packages]
  MdePkg/MdePkg.dec

[LibraryClasses]
  UefiApplicationEntryPoint
  UefiLib
  UefiBootServicesTableLib
  
[Protocols]
  gEfiLoadedImageProtocolGuid
  gEfiSimpleFileSystemProtocolGuid
  gEfiSimpleTextInProtocolGuid
  gEfiSimpleTextOutProtocolGuid

  
[BuildOptions]

[Guids]

#ifndef USER_USB_RAM
#error "This example needs to be compiled with a USER USB setting"
#endif
#include "src/userUsbCdc/USBCDC.h"
#include
#include "DataFlash.H"
#include "include/ch5xx.h"
 
#define NUM_LEDS 2
#define COLOR_PER_LEDS 3
#define NUM_BYTES (NUM_LEDS*COLOR_PER_LEDS)
__xdata uint8_t ledData[NUM_BYTES];
 
#define BIT1 2
 
// USB 串口 Buffer
uint8_t recvStr[6];
uint8_t recvStrPtr = 0;
// 之前保存的颜色值
uint8_t rValue, gValue, bValue;
uint16_t TimeLighting;
 
// 定义电源控制引脚
#define POWERCTRL 15
// 定义LED信号线
#define LEDCOLOR 14
#define NEOPIXELSHOW neopixel_show_P1_4
 
unsigned long ElspLighten = 0;
unsigned long Elsp = 0;
 
void SetLEDColor(uint8_t r, uint8_t g, uint8_t b) {
  for (uint8_t i = 0; i   {
    set_pixel_for_GRB_LED(ledData, i, r,g,b);
    NEOPIXELSHOW(ledData, NUM_BYTES);
    delay(10);
  }
}
void setup() {
  // 供电引脚接管电源
  pinMode(POWERCTRL, OUTPUT);
  digitalWrite(POWERCTRL, HIGH);
 
  // LED 颜色控制
  pinMode(LEDCOLOR, OUTPUT);
 

  USBInit();
 
  // 读取颜色信息
  Flash_Op_Check_Byte1 = 0x00;
  Flash_Op_Check_Byte2 = 0x00;
  ReadDataFlash(0, 1, &rValue);
  ReadDataFlash(1, 1, &gValue);
  ReadDataFlash(2, 1, &bValue);
 
  // 读取时长
  ReadDataFlash(3, 2, &TimeLighting);
 
  // 这里需要写成这样，避免上电亮一下的问题
  delay(10);
  //set_pixel_for_GRB_LED(ledData, 0, 0, 0, 0);
  //NEOPIXELSHOW(ledData, NUM_BYTES);
  SetLEDColor(0,0,0);
  delay(10);
 
  // 读取之前保存的灯颜色
  //set_pixel_for_GRB_LED(ledData, 0, rValue, gValue, bValue);
  //NEOPIXELSHOW(ledData, NUM_BYTES);
  SetLEDColor(rValue, gValue, bValue);
  delay(100);
 
  ElspLighten = millis();
}
 
void Enter_DeepSleep(void)
{
  // 第一步：关闭所有外设模块
  SAFE_MOD = 0x55;       // 进入安全模式
  SAFE_MOD = 0xAA;       // 解锁寄存器写保护
  PCON &= ~BIT1;         // 确保PD位初始为0
  IE_EX = 0x00;          // 关闭扩展中断
  IE = 0x00;             // 关闭所有中断
  TCON = 0x00;           // 关闭定时器控制
  TMOD = 0x00;           // 关闭定时器模式
  SAFE_MOD = 0x00;       // 恢复安全模式
 
  // 第二步：设置IO口为低功耗状态
  P1_DIR_PU = 0x00;         // 所有IO设为输入模式
  P3_DIR_PU = 0x00;         // 所有IO设为输入模式
 
  // 第三步：进入停机模式
  SAFE_MOD = 0x55;       // 二次确认安全模式
  SAFE_MOD = 0xAA;
  PCON |= BIT1;           // 置位PD位进入停机模式
  PCON |= BIT1;           // 推荐重复写入确保执行
 
  while (1);
}
 

void loop() {
  while (USBSerial_available()) {
    char serialChar = USBSerial_read();
    recvStr[recvStrPtr++] = serialChar;
 
    if (recvStrPtr == 5) {
      // 测试命令
      if ((recvStr[0] == 0x55) && (recvStr[1] == 0xCC)) {
        USBSerial_print(rValue);
        USBSerial_flush();
        USBSerial_print(gValue);
        USBSerial_flush();
        USBSerial_print(bValue);
        USBSerial_flush();
        USBSerial_println(TimeLighting);
        USBSerial_flush();
      }
 
      // 设置颜色
      if ((recvStr[0] == 0x55) && (recvStr[1] == 0xAA)) {
        // 记录收到的颜色信息
        rValue = recvStr[2];
        gValue = recvStr[3];
        bValue = recvStr[4];
 
        // 将颜色信息写入 eeprom
        Flash_Op_Check_Byte1 = DEF_FLASH_OP_CHECK1;
        Flash_Op_Check_Byte2 = DEF_FLASH_OP_CHECK2;
        uint8_t result = WriteDataFlash(0, &recvStr[2], 3);
        if (result == 0) {
          // 写入成功
          USBSerial_println(result);
          USBSerial_flush();
        } else {
          // 写入失败
          USBSerial_println(result);
          USBSerial_println("f1");
          USBSerial_flush();
        }
 
        //set_pixel_for_GRB_LED(ledData, 0, rValue, gValue, bValue);
        //NEOPIXELSHOW(ledData, NUM_BYTES);
        SetLEDColor(rValue, gValue, bValue);
 
      }
 
      // 设定时长的命令
      if ((recvStr[0] == 0x55) && (recvStr[1] == 0xBB)) {
        // 记录收到的颜色信息
        TimeLighting = (recvStr[2]) + (recvStr[3] 200) {
    recvStrPtr = 0;
    Elsp = millis();
  }
 
  // 到达点亮的时间后关闭，如果是插在电脑上则不关闭
  if ((millis() - ElspLighten > TimeLighting * 1000UL) && (USBConfiged == 0)) {
    // 关灯
    //set_pixel_for_GRB_LED(ledData, 0, 0, 0, 0);
    //NEOPIXELSHOW(ledData, NUM_BYTES);
    SetLEDColor(0, 0, 0);
 
    digitalWrite(POWERCTRL, LOW);
    // 进入省电模式
    Enter_DeepSleep();
  }
 

}

/**
   @file streams-i2s-i2s-2.ino
   @brief Copy audio from I2S to I2S: We use 2 different i2s ports!
   @author Phil Schatzmann
   @copyright GPLv3
*/
#include
#include "AudioTools.h"
AudioInfo IN_info(16000, 1, 32);
AudioInfo OUT_info(16000, 1, 32);
I2SStream in;
I2SStream out;
VolumeStream vol(in);
StreamCopy copier(out, vol); // copies sound into i2s
//FormatConverterStream converter(in);  // or use converter(out)
//StreamCopy copier(out, converter);       //        copier(converter, sound);
// HT513 音量
uint16_t Volume;
// 最小音量
#define LOWESTVOLUME 1
#define TOLENCE 16
#define HT513_ADDR_L 0x6c
/**
   @brief  ht513写寄存器
   @param  addr 寄存器地址
   @param  val 要写的值
   @retval None
*/
void HT513_WriteOneByte(uint8_t addr, uint8_t val)
{
  Wire.beginTransmission(HT513_ADDR_L);
  Wire.write(addr);
  Wire.write(val);
  int ack = Wire.endTransmission(true);
  Serial.print("Ack ");
  Serial.println(ack, HEX);
}
/**
   @brief  ht513读寄存器
   @param  addr 寄存器地址
   @retval 读取到的寄存器值
*/
uint8_t HT513_ReadOneByte(uint8_t addr)
{
  uint8_t temp = 0;
  Wire.beginTransmission(HT513_ADDR_L);
  Wire.write(addr);
  Wire.endTransmission(false);
  uint8_t bytesReceived = 0;
  bytesReceived = Wire.requestFrom(HT513_ADDR_L, (uint8_t)1, true);
  if (bytesReceived == 1) {
    temp = Wire.read();
  }
  else {
    Serial.println("Read Error ");
  }
  return temp;
}
// Arduino Setup
void setup(void) {
  delay(5000);
  // HT513 SD Pin 需要设置为 High
  pinMode(8, OUTPUT);
  digitalWrite(8, HIGH);
  analogReadResolution(9);
  // Open Serial
  Serial.begin(115200);
  // change to Warning to improve the quality
  //AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
  Wire.begin(18, 17);
  int nDevices;
  byte error, address;
  Serial.println("Scanning...");
  nDevices = 0;
  for ( address = 1; address     Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address         Serial.print("0");
      }
      Serial.println(address, HEX);
      nDevices++;
    }
    else if (error == 4) {
      Serial.print("Unknow error at address 0x");
      if (address         Serial.print("0");
      }
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0) {
    Serial.println("No I2C devices found\n");
  }
  else {
    Serial.println("done\n");
  }
  //  设置 SD 为LOW
  HT513_WriteOneByte(0x12, 0b11110000);
  // 设置数据格式为 I2S, 32Bits
  HT513_WriteOneByte(0x13, 0b00000000);
  // 读取音量设置
  Volume = analogRead(3);
  uint8_t Vol=(Volume,0,511,0x07,0xff);
  HT513_WriteOneByte(0x16, Vol);
  HT513_WriteOneByte(0x15, Vol);
  Serial.println(Volume, HEX);
  // 调整声道
  HT513_WriteOneByte(0x17, 0b10110000);
  Serial.println("++++++++++++++++");
  //  设置 SD 为HIGH
  HT513_WriteOneByte(0x12, 0b11110100);
  uint8_t Value = HT513_ReadOneByte(0x12);
  Serial.println(Value, HEX);
  Value = HT513_ReadOneByte(0x13);
  Serial.println(Value, HEX);
  Value = HT513_ReadOneByte(0x16);
  Serial.println(Value, HEX);
  Value = HT513_ReadOneByte(0x17);
  Serial.println(Value, HEX);
  // Define Converter
  //converter.begin(IN_info, OUT_info);
  // start I2S in
  Serial.println("starting I2S...");
  auto config_in = in.defaultConfig(RX_MODE);
  config_in.copyFrom(IN_info);
  config_in.i2s_format = I2S_STD_FORMAT;
  config_in.is_master = true;
  config_in.port_no = 1;
  config_in.pin_bck = 37;
  config_in.pin_ws = 38;
  config_in.pin_data = 36;
  // config_in.fixed_mclk = sample_rate * 256
  // config_in.pin_mck = 2
  in.begin(config_in);
  // start I2S out
  auto config_out = out.defaultConfig(TX_MODE);
  config_out.copyFrom(OUT_info);
  config_out.i2s_format = I2S_STD_FORMAT;
  config_out.is_master = true;
  config_out.port_no = 0;
  config_out.pin_bck = 15;
  config_out.pin_ws = 6;
  config_out.pin_data = 7;
  config_out.pin_mck = 16;
  out.begin(config_out);
  // set initial volume
  vol.begin(IN_info); // we need to provide the bits_per_sample and channels
  vol.setVolume(0.3);
  
  Serial.println("I2S started...");

}
// Arduino loop - copy sound to out
void loop() {
  copier.copy();
  if (abs(analogRead(3) - Volume) > TOLENCE) {
    // 读取音量设置
    Volume = analogRead(3);
    //  设置 SD 为LOW
    HT513_WriteOneByte(0x12, 0b11110000);
    uint8_t Vol=map(Volume,0,511,0x07,0xff);
    HT513_WriteOneByte(0x16, Vol);
    //  设置 SD 为HIGH
    HT513_WriteOneByte(0x12, 0b11110100);
    Serial.print(analogRead(3), HEX);
    Serial.print("  ");
    Serial.print(Volume, HEX);
    Serial.print("  ");
    Serial.println(Vol, HEX);
  }

}

// 标准模式配置
i2s_std_config_t std_cfg =
{
.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),
.slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(
    I2S_DATA_BIT_WIDTH_32BIT,
    I2S_SLOT_MODE_MONO
),
//.slot_cfg.slot_mask = I2S_STD_SLOT_LEFT,
.gpio_cfg = {
.bclk = I2S_BCK_GPIO,
.ws = I2S_WS_GPIO,
.din = I2S_DATA_GPIO,
.invert_flags = {
.bclk_inv = false, //时钟空闲时为 High
.ws_inv = false
}
}
};
std_cfg.slot_cfg.slot_mode=I2S_SLOT_MODE_MONO;
std_cfg.slot_cfg.slot_mask=I2S_STD_SLOT_LEFT;

void audio_v1_init(uint8_t busid, uintptr_t reg_base)
{
    //  创建同步信号
    sign_tx = xSemaphoreCreateBinary();
    //  数据队列
s_receive_queue = xQueueCreate(10, sizeof(i2c_mic_rx_data_t));
//创建接收任务
xTaskCreatePinnedToCore(task_func, "task", 4096, NULL, 10, NULL, tskNO_AFFINITY);
 
 
    ESP_ERROR_CHECK(esp_task_wdt_add_user("usb", &twdt_usb));
 
    usbd_desc_register(busid, audio_v1_descriptor);
    usbd_add_interface(busid, usbd_audio_init_intf(busid, &intf0, 0x0100, audio_entity_table, 1));
    usbd_add_interface(busid, usbd_audio_init_intf(busid, &intf1, 0x0100, audio_entity_table, 1));
    usbd_add_endpoint(busid, &audio_in_ep);
 
    usbd_initialize(busid, reg_base, usbd_event_handler);
}

void usbd_audio_iso_callback(uint8_t busid, uint8_t ep, uint32_t nbytes)
{
    //USB_LOG_RAW("actual in len:%d\r\n", nbytes);
    ep_tx_busy_flag = false;
    if (0 == tx_flag)
    {
        printf("usbd_audio_iso_callback tx_flag = 0\n");
    }
    
    //  释放信号，让Main那边可以发送了
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(sign_tx, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 如果当前没有发送
if (ep_tx_busy_flag != true)
{
ep_tx_busy_flag = true;
 
                xSemaphoreTake(sign_tx, 0);
 
if(gpio_get_level(GPIO_NUM_9) == 0) {  // 低电平触发
// 发送数据到 USB 
usbd_ep_start_write(0, AUDIO_IN_EP, rx_data.buffer, rx_data.size);
} else {
usbd_ep_start_write(0, AUDIO_IN_EP, NullBuffer, AUDIO_IN_PACKET);
}
 
 
                
                xSemaphoreTake(sign_tx, 10);
                
while (ep_tx_busy_flag)
{
if (tx_flag == false)
{
break;
}
}
//发送完成，释放缓冲区
rx_data.size = 0;
free(rx_data.buffer);

void USBCDC::begin(unsigned long baud) {
  if (itf >= CFG_TUD_CDC) {
    return;
  }
  if (tx_lock == NULL) {
    tx_lock = xSemaphoreCreateMutex();
  }
  // if rx_queue was set before begin(), keep it
  if (!rx_queue) {
    //ZivDebug setRxBufferSize(256);  //default if not preset
setRxBufferSize(64*1024);  //ZivDebug 64K Buffer
  }
  devices[itf] = this;
}

class ESPUSB {
public:
  //ZivDebug  ESPUSB(size_t event_task_stack_size = 2048, uint8_t event_task_priority = 5);
  ESPUSB(size_t event_task_stack_size = 20480, uint8_t event_task_priority = 5);
  ~ESPUSB();
  void onEvent(esp_event_handler_t callback);
  void onEvent(arduino_usb_event_t event, esp_event_handler_t callback);