Ввод/вывод звука по I2S, используя ESP32

#include "aes256.h"
int a;
//    Библиотека "aes256.h"   начало кода
aes256_context ctxt;                          // команда библиотеки "aes256.h"     
uint8_t Data[] = { // Данные - 16 символа     // команда библиотеки "aes256.h"                    
                 0x01, 0x03, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x03, 0x01, 0x05, 0x03, 0x07, 0x05, 0x06, 0x02};  
uint8_t key[] = { // Ключ шифрования - 32 символа     // команда библиотеки "aes256.h"     
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
                 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};  
//    Библиотека "aes256.h"   конец кода
//    Библиотека <Crypto.h> <AES.h>  начало кода
#include <Crypto.h>
#include <AES.h>
AES256 aes256;
uint8_t  buffer_1[16];   
uint8_t  buffer_2[16];     
uint8_t* buffer_3;    
uint8_t* buffer_4;     
uint8_t  buf[16];  
uint8_t  buf1[16];
//    Библиотека <Crypto.h> <AES.h>  конец кода
 
void Init_Key_AES(BlockCipher *cipher) {  // Функция инициализации шифрования и ключа (Библиотека <Crypto.h> <AES.h>)
    crypto_feed_watchdog();
    cipher->setKey(key, cipher->keySize());
}
 
uint8_t* Encrypt_AES(BlockCipher *cipher, uint8_t* Data1) {  // Функция шифрования AES256 (Библиотека <Crypto.h> <AES.h>)
    cipher->encryptBlock(buffer_1, Data1);
    return &buffer_1[0];
}
 
uint8_t* Decrypt_AES(BlockCipher *cipher, uint8_t* Data2)  {  // Функция расшифрования AES256 (Библиотека <Crypto.h> <AES.h>)
    cipher->decryptBlock(buf, Data2);
    return &buf[0];
}
 
void setup() {
  Serial.begin(19200);     delay(1000);
//    Библиотека "aes256.h"   начало кода
  unsigned long start_1;    unsigned long start_2;    unsigned long start_3;
  unsigned long start_4;    unsigned long start_5;    unsigned long start_6;
  unsigned long elapsed_1;  unsigned long elapsed_2;  unsigned long elapsed_3;  
  unsigned long elapsed_4;  unsigned long elapsed_5;  unsigned long elapsed_6;  
  Serial.println("  ");
  
  Serial.println("Тест библиотеки aes256.h");
  Serial.print("Открытые данные в HEX:       ");
  for (a = 0; a < 16; a++){
     Serial.print(Data[a], HEX); Serial.print(" ");
  }
  Serial.println("  ");
  
  start_1 = micros();
  aes256_init(&ctxt, key);                // команда библиотеки "aes256.h"     
  elapsed_1 = micros() - start_1;
  start_2 = micros();
  aes256_encrypt_ecb(&ctxt, Data);       // команда библиотеки "aes256.h"     
  elapsed_2 = micros() - start_2;
  
  Serial.print("Зашифрованные данные в HEX:  ");
  for (a = 0; a < 16; a++){
     Serial.print(Data[a], HEX); Serial.print(" ");
  }
  Serial.println("   ");
  
  start_3 = micros();
  aes256_decrypt_ecb(&ctxt, Data);      // команда библиотеки "aes256.h"     
  elapsed_3 = micros() - start_3;
  
  Serial.print("Расшифрованные данные в HEX: ");
  for (a = 0; a < 16; a++){
     Serial.print(Data[a], HEX); Serial.print(" ");
  }
  Serial.println("   ");
  
  Serial.print("Задержка на инициализацию ключа:   ");  Serial.print(elapsed_1);  Serial.println(" мкс");
  Serial.print("Задержка на шифрование:            ");  Serial.print(elapsed_2);  Serial.println(" мкс");
  Serial.print("Задержка на расшифрование:         ");  Serial.print(elapsed_3);  Serial.println(" мкс");
  Serial.println("   ");
//    Библиотека "aes256.h"   конец кода
 
//    Библиотека <Crypto.h> <AES.h>  начало кода
  start_4 = micros();
  Init_Key_AES(&aes256);
  elapsed_4 = micros() - start_4;
  Serial.println("Тест библиотеки Crypto.h, AES.h");
  
  Serial.print("Открытые данные в HEX:       ");
  for (a = 0; a < 16; a++){
     Serial.print(Data[a], HEX); Serial.print(" ");
  }
  Serial.println("  ");
 
  start_5 = micros();
  buffer_3 = Encrypt_AES(&aes256, Data);
  elapsed_5 = micros() - start_5;
 
  Serial.print("Зашифрованные данные в HEX:  ");
  for (a = 0; a < 16; a++){
     Serial.print(buffer_3[a], HEX); Serial.print(" ");
  }
  Serial.println("   ");
 
  start_6 = micros();
  buffer_4 = Decrypt_AES(&aes256, buffer_3);
  elapsed_6 = micros() - start_6;
 
  Serial.print("Расшифрованные данные в HEX: ");
  for (a = 0; a < 16; a++){
     Serial.print(buffer_4[a], HEX); Serial.print(" ");
  }
  Serial.println("   ");
 
  Serial.print("Задержка на инициализацию ключа:   ");  Serial.print(elapsed_4);  Serial.println(" мкс");
  Serial.print("Задержка на шифрование:            ");  Serial.print(elapsed_5);  Serial.println(" мкс");
  Serial.print("Задержка на расшифрование:         ");  Serial.print(elapsed_6);  Serial.println(" мкс");
 
//    Библиотека <Crypto.h> <AES.h>  конец кода
}
 
void loop() {
 
}

// Библиотека I2S
#include <driver/i2s.h>
const int sample_rate = 32000;
esp_err_t err1;   esp_err_t err2;
int buf_len = 64;
char *buf = (char*) calloc(buf_len, sizeof(char));
 
// Библиотека шифрования <Crypto.h> <AES.h>
uint8_t Data[] = { // Данные - 32 символа     
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};  
uint8_t key[] = { // Ключ шифрования - 32 символа     
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};  
#include <Crypto.h>
#include <AES.h>
AES256 aes256;             int a;
//uint8_t  buffer_1[16];     
//uint8_t* buffer_2;      uint8_t* buffer_3;    // uint8_t  buffer_4[16];
 
//uint8_t *BlockA = (uint8_t* ) malloc(sizeof(uint8_t)*16);
//uint8_t *BlockB = (uint8_t* ) malloc(sizeof(uint8_t)*buf_len);
 
   uint8_t* BlockC;   
//uint8_t *BlockC = (uint8_t*) calloc(buf_len, sizeof(uint8_t));
   uint8_t* BlockD;   
//uint8_t *BlockD = (uint8_t*) calloc(buf_len, sizeof(uint8_t));
 
void setup() {
  Serial.begin(115200);
  delay(100);
  Serial.println("  ");  Serial.println("Setup I2S ...");    Serial.println("  "); 
  delay(1000);
  i2s_install();
  i2s_setpin();
  delay(500);
//  Init_Key_AES(&aes256); // Инициализация библиотеки и ключа шифрования
}
 
void loop() {
   Init_Key_AES(&aes256);
   int bytes_read = 0;
   
   while(bytes_read == 0) {
      bytes_read = i2s_read_bytes(I2S_NUM_1, buf, buf_len, 0);
   }
   //uint8_t* BlockC;   
   BlockC = AES_ENcrypt_to(Data,   buf_len);    // - функция шифрования массива, размер которого должен быть кратен 16
//delay(1);
   //uint8_t* BlockD;   
   BlockD = AES_DEcrypt_to(BlockC, buf_len);    // - функция расшифрования массива, размер которого должен быть кратен 16
 
   i2s_write_bytes(I2S_NUM_0, buf, bytes_read, portMAX_DELAY);
//   free(BlockC);
//   free(BlockD);
}
 
void Init_Key_AES(BlockCipher *cipher) {  // Функция инициализации шифрования и ключа (Библиотека <Crypto.h> <AES.h>)
    crypto_feed_watchdog();
    cipher->setKey(key, cipher->keySize());
}
 
uint8_t* Encrypt_AES(BlockCipher *cipher, uint8_t* Data1) {  // Функция шифрования AES256 (Библиотека <Crypto.h> <AES.h>)
//    uint8_t *buffer_1 = (uint8_t* ) malloc(sizeof(uint8_t) * 16);
    uint8_t  buffer_1[16];
    cipher->encryptBlock(buffer_1, Data1);
    return &buffer_1[0];
//    free(buffer_1);
}
 
uint8_t* Decrypt_AES(BlockCipher *cipher, uint8_t* Data2)  {  // Функция расшифрования AES256 (Библиотека <Crypto.h> <AES.h>)
//    uint8_t *buffer_4 = (uint8_t* ) malloc(sizeof(uint8_t) * 16);
    uint8_t  buffer_4[16];
    cipher->decryptBlock(buffer_4, Data2);
    return &buffer_4[0];
//    free(buffer_4);
}
 
uint8_t* AES_ENcrypt_to(uint8_t* Data_t, int buf_len_t) {
   uint8_t BlockA[16];
   uint8_t BlockB[32];
//   uint8_t *BlockA = (uint8_t* ) malloc(sizeof(uint8_t) * 16);
//   uint8_t *BlockB = (uint8_t* ) malloc(sizeof(uint8_t) * buf_len_t );
   uint8_t* buffer_2;
   int blockCode = buf_len_t/16;   // считаем на сколько блоков нужно разбить данные
   int blockCodeAES;
   if (buf_len_t%16 == 0){
    blockCodeAES = blockCode;   // - считаем на сколько блоков нужно разбить данные
   }
   else if (buf_len_t%16 != 0){
    Serial.println("Разбито с остатком! ОШИБКА! Размер входного массива не кратен 16-ти"); 
   }
   int i; int b; int g = 0; int d; int v = 0;
   for (i = 0; i < blockCodeAES; i++){
    for (b = 0; b < 16; b++){
      g = b + 16*i;
      BlockA[b] = Data_t[g];   // 
      }
//    uint8_t* buffer_2;
    buffer_2 = Encrypt_AES(&aes256, BlockA);
    for (d = 0; d < 16; d++){
      v = d + 16*i;
      BlockB[v] = buffer_2[d];
    }
   }
return &BlockB[0];
 
//free(BlockA);  
//free(BlockB);
//free(buffer_2);
}
 
uint8_t* AES_DEcrypt_to(uint8_t* Data_r, int buf_len_r){
   uint8_t BlockA[16];
   uint8_t BlockB[32];
//   uint8_t *BlockA = (uint8_t* ) malloc(sizeof(uint8_t) * 16);
//   uint8_t *BlockB = (uint8_t* ) malloc(sizeof(uint8_t) * buf_len_r);
   uint8_t* buffer_3;
   int blockCode = buf_len_r/16;   // считаем на сколько блоков нужно разбить данные
   int blockCodeAES;
   if (buf_len_r%16 == 0){
    blockCodeAES = blockCode;   // - считаем на сколько блоков нужно разбить данные
   }
   else if (buf_len_r%16 != 0){
    Serial.println("Разбито с остатком! ОШИБКА! Размер входного массива не кратен 16-ти"); 
   }
   int i; int b; int g = 0; int d; int v = 0; 
   for (i = 0; i < blockCodeAES; i++){
    for (b = 0; b < 16; b++){
      g = b + 16*i;
      BlockA[b] = Data_r[g];  
      }
    buffer_3 = Decrypt_AES(&aes256, BlockA);
    for (d = 0; d < 16; d++){
      v = d + 16*i;
      BlockB[v] = buffer_3[d];
    }
   }
return &BlockB[0];
 
//free(BlockA);  
//free(BlockB);
//free(buffer_3);
}
 
void i2s_install(){
    /* TX: I2S_NUM_0 */
  const i2s_config_t i2s_config_tx = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_TX),
    .sample_rate = sample_rate,
    .bits_per_sample = i2s_bits_per_sample_t(16),
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // default interrupt priority
    .dma_buf_count = 32,
    .dma_buf_len = buf_len,  // 2
     // .use_apll = false,
     // .tx_desc_auto_clear = false,  // I2S автоматически очищает дескриптор tx, если есть состояние недостаточного заполнения (помогает избежать шума в случае недоступности данных)
     // .fixed_mclk = 0 // I2S с использованием фиксированного выхода MCLK. Если use_apll = true и fixed_mclk> 0, то выходной сигнал часов для i2s фиксирован и равен значению fixed_mclk.
  };
  err1 = i2s_driver_install(I2S_NUM_0, &i2s_config_tx, 0, NULL);
  if (err1 != ESP_OK) {
  Serial.printf("Failed installing driver_1: %d\n", err1);
  while (true);
  }
       /* RX: I2S_NUM_1 */
  const i2s_config_t i2s_config_rx = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = sample_rate,
    .bits_per_sample = i2s_bits_per_sample_t(16), //32
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // default interrupt priority
    .dma_buf_count = 32,    // 32
    .dma_buf_len = buf_len,  //32*2
     // .use_apll = false,
     // .tx_desc_auto_clear = false,  // I2S автоматически очищает дескриптор tx, если есть состояние недостаточного заполнения (помогает избежать шума в случае недоступности данных)
     // .fixed_mclk = 0 // I2S с использованием фиксированного выхода MCLK. Если use_apll = true и fixed_mclk> 0, то выходной сигнал часов для i2s фиксирован и равен значению fixed_mclk.
  };
  err2 = i2s_driver_install(I2S_NUM_1, &i2s_config_rx, 0, NULL);
  if (err2 != ESP_OK) {
  Serial.printf("Failed installing driver_2: %d\n", err2);
  while (true);
  }
  Serial.println("I2S driver installed.");
}
 
void i2s_setpin(){
     /* TX: I2S_NUM_0 */
  const i2s_pin_config_t pin_config_tx = {
    .bck_io_num =   26,
    .ws_io_num =    25,
    .data_out_num = 22,
    .data_in_num =  I2S_PIN_NO_CHANGE  };
    
    err1 = i2s_set_pin(I2S_NUM_0, &pin_config_tx);
    if (err1 != ESP_OK) {
    Serial.printf("Failed setting pin_1: %d\n", err1);
    while (true);
    }
    /* RX: I2S_NUM_1 */
  const i2s_pin_config_t pin_config_rx = {
    .bck_io_num =   17,
    .ws_io_num =    27,
    .data_out_num = I2S_PIN_NO_CHANGE,
    .data_in_num =  33  };
 
    err2 = i2s_set_pin(I2S_NUM_1, &pin_config_rx);
    if (err2 != ESP_OK) {
    Serial.printf("Failed setting pin_2: %d\n", err2);
    while (true);
    }
  Serial.println("I2S pins installed.");
}

// Библиотека I2S
#include <driver/i2s.h>
const int sample_rate = 32000;
esp_err_t err1;   esp_err_t err2;
uint16_t buf_len = 64; 
uint8_t *buf = (uint8_t*) calloc(buf_len, sizeof(uint8_t));
 
// Библиотека шифрования <Crypto.h> <AES.h>
uint8_t Data[] = { // Данные - 32 символа     
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x1d, 0x1e, 0x1f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x1d, 0x1e, 0x1f};  
uint8_t key[] = { // Ключ шифрования - 32 символа     
                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}; 
#include <Crypto.h>
#include <AES.h>
AES256 aes256;             int a;
uint8_t  buffer_1[16];     uint8_t  buffer_4[16];
 
uint8_t BlockA[16];
uint8_t *BlockB = (uint8_t* ) malloc(sizeof(uint8_t)*buf_len);
uint8_t BlockE[16];
uint8_t *BlockF = (uint8_t* ) malloc(sizeof(uint8_t)*buf_len);
 
uint8_t* BlockC;   
uint8_t* BlockD;   
 
void setup() {
  Serial.begin(500000);
  delay(100);
  Serial.println("  ");  Serial.println("Setup I2S ...");    Serial.println("  "); 
  delay(1000);
  i2s_install();
  i2s_setpin();
  delay(500);
  Init_Key_AES(&aes256); // Инициализация библиотеки и ключа шифрования
  
   xTaskCreate(     vTask1,        
                    "vTask1",    
                    10000,         
                    NULL,          
                    1,           
                    NULL);          
   xTaskCreate(     vTask2,        
                    "vTask2",      
                    10000,            
                    NULL,             
                    2,                
                    NULL);     
}
 
void vTask1( void * pvParameters ) {
   for( ;; ){
   Serial.println("Обработка задания vTask_1");   vTaskDelay( pdMS_TO_TICKS( 1000 ) );
   
   Serial.print("buf:  ");
   for (a = 0; a < buf_len; a++){
      Serial.print(buf[a], DEC); Serial.print(" ");
   }
   Serial.println("  ");
 
   Serial.print("Шифр: ");
   for (a = 0; a < buf_len; a++){
      Serial.print(BlockC[a], DEC); Serial.print(" ");
   }
   Serial.println("  ");
 
   Serial.print("Откр: ");
   for (a = 0; a < buf_len; a++){
      Serial.print(BlockD[a], DEC); Serial.print(" ");
   }
   Serial.println("  "); Serial.println("  ");
   
    }
}
 
void vTask2( void * pvParameters) {
    for( ;; ){
    Serial.println("Обработка задания vTask_2");    vTaskDelay( pdMS_TO_TICKS( 1000 ) );
    } 
}
 
void loop() {
   int bytes_read = 0;
 
   while(bytes_read == 0) {
      bytes_read = i2s_read_bytes(I2S_NUM_1, buf, buf_len, 0);
   }
 
   BlockC = AES_ENcrypt_to(&aes256, buf,   buf_len);    // - функция шифрования массива, размер которого должен быть кратен 16
 
   BlockD = AES_DEcrypt_to(&aes256, BlockC, buf_len);    // - функция расшифрования массива, размер которого должен быть кратен 16
 
   i2s_write_bytes(I2S_NUM_0, BlockD, bytes_read, portMAX_DELAY);
}
 
void Init_Key_AES(BlockCipher *cipher) {  // Функция инициализации шифрования и ключа (Библиотека <Crypto.h> <AES.h>)
    crypto_feed_watchdog();
    cipher->setKey(key, cipher->keySize());
}
 
uint8_t* AES_ENcrypt_to(BlockCipher *cipher, uint8_t* Data_t, uint16_t buf_len_t) {
   int blockCode = buf_len_t/16;   // считаем на сколько блоков нужно разбить данные
   int blockCodeAES;
   if (buf_len_t%16 == 0){
    blockCodeAES = blockCode;   // - считаем на сколько блоков нужно разбить данные
   }
   else if (buf_len_t%16 != 0){
    Serial.println("Разбито с остатком! ОШИБКА_1! Размер входного массива не кратен 16-ти"); 
   }
   int i; int b; int g = 0; int d; int v = 0;
   for (i = 0; i < blockCodeAES; i++){
    for (b = 0; b < 16; b++){
      g = b + 16*i;
      BlockA[b] = Data_t[g];   // 
      }
    cipher->encryptBlock(buffer_1, BlockA);
    for (d = 0; d < 16; d++){
      v = d + 16*i;
      BlockB[v] = buffer_1[d];
    }
   }
return &BlockB[0];
}
 
uint8_t* AES_DEcrypt_to(BlockCipher *cipher, uint8_t* Data_r, uint16_t buf_len_r){
   int blockCode = buf_len_r/16;   // считаем на сколько блоков нужно разбить данные
   int blockCodeAES;
   if (buf_len_r%16 == 0){
    blockCodeAES = blockCode;   // - считаем на сколько блоков нужно разбить данные
   }
   else if (buf_len_r%16 != 0){
    Serial.println("Разбито с остатком! ОШИБКА_2! Размер входного массива не кратен 16-ти"); 
   }
   int i; int b; int g = 0; int d; int v = 0; 
   for (i = 0; i < blockCodeAES; i++){
    for (b = 0; b < 16; b++){
      g = b + 16*i;
      BlockE[b] = Data_r[g];
      }
    cipher->decryptBlock(buffer_4, BlockE);
    for (d = 0; d < 16; d++){
      v = d + 16*i;
      BlockF[v] = buffer_4[d];
    }
   }
return &BlockF[0];
}
 
void i2s_install(){
    /* TX: I2S_NUM_0 */
  const i2s_config_t i2s_config_tx = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_TX),
    .sample_rate = sample_rate,
    .bits_per_sample = i2s_bits_per_sample_t(16),
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // default interrupt priority
    .dma_buf_count = 32,
    .dma_buf_len = buf_len,  // 2
     // .use_apll = false,
     // .tx_desc_auto_clear = false,  // I2S автоматически очищает дескриптор tx, если есть состояние недостаточного заполнения (помогает избежать шума в случае недоступности данных)
     // .fixed_mclk = 0 // I2S с использованием фиксированного выхода MCLK. Если use_apll = true и fixed_mclk> 0, то выходной сигнал часов для i2s фиксирован и равен значению fixed_mclk.
  };
  err1 = i2s_driver_install(I2S_NUM_0, &i2s_config_tx, 0, NULL);
  if (err1 != ESP_OK) {
  Serial.printf("Failed installing driver_1: %d\n", err1);
  while (true);
  }
       /* RX: I2S_NUM_1 */
  const i2s_config_t i2s_config_rx = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = sample_rate,
    .bits_per_sample = i2s_bits_per_sample_t(16), //32
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // default interrupt priority
    .dma_buf_count = 32,    // 32
    .dma_buf_len = buf_len,  //32*2
     // .use_apll = false,
     // .tx_desc_auto_clear = false,  // I2S автоматически очищает дескриптор tx, если есть состояние недостаточного заполнения (помогает избежать шума в случае недоступности данных)
     // .fixed_mclk = 0 // I2S с использованием фиксированного выхода MCLK. Если use_apll = true и fixed_mclk> 0, то выходной сигнал часов для i2s фиксирован и равен значению fixed_mclk.
  };
  err2 = i2s_driver_install(I2S_NUM_1, &i2s_config_rx, 0, NULL);
  if (err2 != ESP_OK) {
  Serial.printf("Failed installing driver_2: %d\n", err2);
  while (true);
  }
  Serial.println("I2S driver installed.");
}
 
void i2s_setpin(){
     /* TX: I2S_NUM_0 */
  const i2s_pin_config_t pin_config_tx = {
    .bck_io_num =   26,
    .ws_io_num =    25,
    .data_out_num = 22,
    .data_in_num =  I2S_PIN_NO_CHANGE  };
    
    err1 = i2s_set_pin(I2S_NUM_0, &pin_config_tx);
    if (err1 != ESP_OK) {
    Serial.printf("Failed setting pin_1: %d\n", err1);
    while (true);
    }
    /* RX: I2S_NUM_1 */
  const i2s_pin_config_t pin_config_rx = {
    .bck_io_num =   17,
    .ws_io_num =    27,
    .data_out_num = I2S_PIN_NO_CHANGE,
    .data_in_num =  33  };
 
    err2 = i2s_set_pin(I2S_NUM_1, &pin_config_rx);
    if (err2 != ESP_OK) {
    Serial.printf("Failed setting pin_2: %d\n", err2);
    while (true);
    }
  Serial.println("I2S pins installed.");
}