SSBの生成のプログラムを作成し信号を観測した．プログラムは下図に従って作成．

入力信号は 1.5kHz の正弦波．キャリア周波数 24kHz でUSBを生成した．
よって出力は 25.5kHz の正弦波となる．

スペクトラムの実測結果は以下のとおり．

完全ディジタル処理によるSSB生成なので当然ではあるが，キャリア（24kHz）も逆サイドバンド（22.5kHz）もまったく観測できない．

測定側のダイナミックレンジが十分ではないが，少なくとも -70dB は抑圧されている．無調整で（調整のやりようがないが）十分な性能が得られている．

帯域を広げていくと少し問題点が見えてくる．

まず，100kHz まで観測すると信号（25.5kHz）の高調波が見える．

これはDAC（PCM5102A）の出力が 500mVpp のときだが，2次高調波は -60 数dB ．
これくらいであれば問題ないが，DAC出力を大きくすると悪化していく．

ちなみに，2Vpp のときには -50dB となった．送信時はDAC出力レベルは控えめがよさそう．

さらに観測帯域を 1MHz まで広げると下図のようになった．

384kHzとその整数倍の前後にスプリアスが生じている．これはPCM5102Aが最終的に384kHzまでオーバーサンプリングして信号を出力しているためで，波形を見ればよくわかる（下図）

0次ホールド特性どおりのスペクトラムといえる．

結論から言えば，問題点はすべてDACに起因するもので，実際に使用する場合は DACの出力に適切なフィルタが必要だろう．

復調ができたので次は変調を検討した．下図のような構成でプログラムをしてみようと思う．

SSBは実績があるので問題ない．AMとFMはデシメーションをしなくてもできそう．FMは理論上はこれでOKだと思うが実際どうなるか．

記事中のプログラムは，Arduino IDE 2.1.1, Board Manager esp32 ver. 2.0.9 で動作確認しています．

AM,FMの復調処理を加えて，クラシックなすべてのモードの復調ができるようにした．前の記事と重複する内容があるがあらためて記載する．

まず，デシメーションまでの構成は下図のとおり．

DeMod.　のブロックに各モードの復調処理が入る．内容は以下のとおり．

SSBの復調は以下のようなコードとなる．（前の記事と同じ）

     // USB
      dsps_fir_f32(&sfirRe, Lch_in, Lch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
      dsps_fir_f32(&sfirIm, Rch_in, Rch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
      for(int i=0; i<BLOCK_SAMPLES/DOWN_SAMPLE; i++){
        Lch_in[i] =Lch_out[i] - Rch_out[i];
      }
      
      // LSB
      dsps_fir_f32(&sfirRe, Lch_in, Lch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
      dsps_fir_f32(&sfirIm, Rch_in, Rch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
      for(int i=0; i<BLOCK_SAMPLES/DOWN_SAMPLE; i++){
        Lch_in[i] = Lch_out[i] + Rch_out[i]; 
      }
      

複素係数フィルタをとおして，実部と虚部を加算するだけなので非常にシンプル．

AMの復調は以下のとおり．

      // AM
      dsps_fir_f32(&sfirAMRe, Lch_in, Lch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
      dsps_fir_f32(&sfirAMIm, Rch_in, Rch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
      for(int i=0; i<BLOCK_SAMPLES/DOWN_SAMPLE; i++){
        Re=Lch_out[i];
        Im=Rch_out[i];
        float Demod_AM = sqrt(Re*Re+Im*Im); 
        Rch_in[i] = Demod_AM*0.003 + zDC*0.997; // DC component
        zDC = Rch_in[i];                        // DC component
        Lch_in[i] = 3.0f*(Demod_AM - zDC);
      }

複素係数フィルタの代わりに実部，虚部を同じ特性のLPFにとおし（デシメーションフィルタがあるのでこれはなくてもよい），その振幅 Demod_AM を求めている． Demod_AM にはキャリアに相当するDC成分が含まれているのでそれをカットし出力としている．
zDC は float のグローバル変数．

FMの復調は，一般的には信号の位相を求めてそれを微分する．微分は1サンプル前のデータの位相との差をとればよい．その通りやればいいのだが「微分＝ノイズ増長」というイメージがあってやりたくなかったので別の方法でFM復調をすることにした．

具体的には上の図にあるように，1サンプル前のデータの複素共役を掛けてその偏角を求める．複素数同士の乗算ではその偏角は加算されるが，複素共役をとった場合は偏角は差分（　≃　微分）となる．これによって差分や除算なしにFMの復調処理ができた．一般的な方法と比べてどれほどの効果があるかは確認していない．コードは以下のとおり．

      // FM
      for(int i=0; i<BLOCK_SAMPLES/DOWN_SAMPLE; i++){
        Re = Lch_in[i]*zRe + Rch_in[i]*zIm;
        Im = Rch_in[i]*zRe - Lch_in[i]*zIm;
        zRe = Lch_in[i];
        zIm = Rch_in[i];
        Lch_in[i] = 1e5 * atan2(Im, Re) * (float)(fsample/DOWN_SAMPLE);
      }

zRE，zIm　は，float のグローバル変数．

記事中のプログラムは，Arduino IDE 2.1.1, Board Manager esp32 ver. 2.0.9 で動作確認しています．

24kHzのSSB信号を復調する処理を組み込んでみた．
構成は下図のとおり．

96kHzサンプリングで入力した信号をダウンコンバートしたあとダウンサンプリングしているので，計算量はESP32でもまだ余裕があるくらいに抑えることができている．

コードは以下のとおり．
ただし各フィルタの係数に関してはまだ検討の余地があるため値を設定する処理は含めていない．
（雛形，参考用として開示しますので詳細な動作の説明やプログラムの追加，修正を求めることはご遠慮願います．）

// 24kHz SSB RX on ESP32-S3
// T.Uebo  October 17 , 2022

// I2S Master MODE 96kHz/32bit
//
//   Mclk  GPIO 39
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <esp_dsp.h>
#include <driver/i2s.h>
#define fsample 96000
#define DOWN_SAMPLE 6
#define BLOCK_SAMPLES (DOWN_SAMPLE*16)

//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];

// Decimation Filter
#define Ndec 512
float dec_fir_coeff[Ndec];   // フィルタ係数
float z_decL[Ndec], z_decR[Ndec];
fir_f32_t sfir_decL, sfir_decR;

// Complex coeff. Filter
#define Ncmplx 256
float CF_Re[Ncmplx], CF_Im[Ncmplx];  // フィルタ係数
float z_firRe[Ncmplx], z_firIm[Ncmplx];
fir_f32_t sfirRe, sfirIm;

// Anti-aliasing Filter
float IIR_coeff0[5], IIR_coeff1[5], IIR_coeff2[5], IIR_coeff3[5];  // フィルタ係数
float z_IIR0[2], z_IIR1[2], z_IIR2[2], z_IIR3[2];

// 24kHz Local OSC.
#define N_LO 4 
float LO_I[N_LO]={1.0f, 0, -1.0f, 0};
float LO_Q[N_LO]={0, -1.0f, 0, 1.0f};
int pt_LO = 0;

// for FFT
#define Nfft 4096
float dat[Nfft*2];
float wf[Nfft];
float pow_sp[Nfft];

//Ring Buffer
#define Ring_Buf_Size (Nfft+256)
volatile float d_Lch[Ring_Buf_Size];
volatile float d_Rch[Ring_Buf_Size];
volatile int pt = 0;


/*-----------------------------------------------------------------------------------------------
  Setup
-------------------------------------------------------------------------------------------------*/
void setup(void) {
  Serial.begin(115200);
  delay(50);

  digitalWrite(48, LOW);
  pinMode(48, OUTPUT);
  digitalWrite(48, LOW);
 

  // I2S setup (Lables are defined in i2s_types.h, esp_intr_alloc.h)----------------------------------------
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
    .dma_buf_count = 2,
    .dma_buf_len = BLOCK_SAMPLES*4, //*2
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
    .mclk_multiple = I2S_MCLK_MULTIPLE_256,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .mck_io_num = 39,
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

  // set up FIR --------------------------------------------------------
  // Decimation filter
  dsps_fird_init_f32(&sfir_decL, dec_fir_coeff, z_decL, Ndec, DOWN_SAMPLE, 0);
  dsps_fird_init_f32(&sfir_decR, dec_fir_coeff, z_decR, Ndec, DOWN_SAMPLE, 0);
  // Complex FIR Filter
  dsps_fir_init_f32(&sfirRe, CF_Re, z_firRe, Ncmplx);
  dsps_fir_init_f32(&sfirIm, CF_Im, z_firIm, Ncmplx);
}


/*-----------------------------------------------------------------------------------------------
  Signal Process Loop
-------------------------------------------------------------------------------------------------*/
void loop(void) {
  size_t readsize = 0;

  //Input from I2S codec
  esp_err_t rxfb = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (rxfb == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {

    digitalWrite(48, HIGH);

    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;

      d_Lch[pt]=Lch_in[i];
      d_Rch[pt]=Rch_in[i];
      pt++; if( pt == Ring_Buf_Size ) pt=0;
    }
    
    //-------Signal process -------------------------------
    
    // for (int i=0; i<BLOCK_SAMPLES; i++) {
    //   Lch_out[i] = Lch_in[i];
    //   Rch_out[i] = Rch_in[i];    
    // }

    // Down conversion,  24kHz to 0
    for(int i=0; i<BLOCK_SAMPLES; i++){
      Lch_out[i] = Lch_in[i]*LO_I[pt_LO] - Rch_in[i]*LO_Q[pt_LO];
      Rch_out[i] = Rch_in[i]*LO_I[pt_LO] + Lch_in[i]*LO_Q[pt_LO];
      pt_LO++; if(pt_LO==N_LO) pt_LO=0;
    }
    
    // Decimation (Down sampling) 
    dsps_fird_f32(&sfir_decL, Lch_out, Lch_in, BLOCK_SAMPLES);
    dsps_fird_f32(&sfir_decR, Rch_out, Rch_in, BLOCK_SAMPLES);
  
    // Demod.  -----------------------------------------------------------------------
    // SSB/CW
    // Complex coeff. Filter
    dsps_fir_f32(&sfirRe, Lch_in, Lch_out, BLOCK_SAMPLES/DOWN_SAMPLE);
    dsps_fir_f32(&sfirIm, Rch_in, Rch_out, BLOCK_SAMPLES/DOWN_SAMPLE);

    for(int i=0; i<BLOCK_SAMPLES/DOWN_SAMPLE; i++){
      Lch_in[i] = Lch_out[i] - Rch_out[i];
      //Lch_in[i] = Lch_out[i] + Rch_out[i]; 
    }
    // Demod. output : Lch_in[]


    // UP sampling (Interpolation)---------------------------------------
    for(int i=BLOCK_SAMPLES/DOWN_SAMPLE-1; i>=0;  i--){
      Lch_out[i*DOWN_SAMPLE]=Lch_in[i];
      for(int j=1; j<DOWN_SAMPLE; j++){
        Lch_out[i*DOWN_SAMPLE+j]=0;
      }
    }
    // Anti-aliasing Filter
    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, IIR_coeff0, z_IIR0);
    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, IIR_coeff1, z_IIR1);
    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, IIR_coeff2, z_IIR2);
    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, IIR_coeff3, z_IIR3);

    //Output to I2S codec
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j]   = (int) Lch_out[i];
      txbuf[j+1] = (int) Lch_out[i];
      j+=2;

      // d_Lch[pt]=Lch_out[i];
      // d_Rch[pt]=Rch_out[i];
      // pt++; if( pt == Ring_Buf_Size ) pt=0;
    }

    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);

  }
  digitalWrite(48, LOW);
}

とりあえず問題なく動作しているので，今後詳細に動作を確認していくことにする．
特にADCに内蔵の入力フィルタの切れがあまりよくなさそうで，48kHz以上が折り返してきて56kHzくらいでようやく見えなくなるのが気になる．

記事中のプログラムは，Arduino IDE 2.1.1, Board Manager esp32 ver. 2.0.9 で動作確認しています．

Teensy4はデシメーションの必要がないくらい処理性能が高いが，ESP32-S3はTeensy4に比べて非力なので，デシメーションが必要となるケースが多いかもしれない．

ライブラリには Decimation FIR filter が用意されているので試してみた．デシメーションフィルタは普通のFIRフィルタに比べ，同じタップ数でもダウンサンプル比をNとすれば，ポリフェーズ分解によってフィルタ処理自体も理想的には1/Nになる．またサンプリング周波数も以降は1/Nとなるのであとの処理も軽くなる．

以下のコードを実行させて，ダウンサンプル比4のデシメーションフィルタと通常のFIRフィルタの処理時間と入出力信号を確認した．タップ数はいずれも1024．

#include <esp_dsp.h>

#define BLOCK_SAMPLES 64 
#define Ndec 1024

fir_f32_t fir_dec;
float coeffs_fir_dec[Ndec];
float z_fir_dec[Ndec];

void setup(void) {
  Serial.begin(115200);
  delay(50);

  digitalWrite(48, LOW);
  pinMode(48, OUTPUT);
  digitalWrite(48, LOW);  

  float si[BLOCK_SAMPLES];   // Input signal
  float so[BLOCK_SAMPLES]; // Output of FIR
  float sod[BLOCK_SAMPLES]; // Output of Decimation FIR

  // 入力信号（SIN波）
  for(int i; i<BLOCK_SAMPLES; i++){
    si[i] = sin(2.0f*2.0f*M_PI*(float)i/BLOCK_SAMPLES);
  }

  // FIR 係数（入力を2倍にするフィルタ）
  dsps_d_gen_f32(coeffs_fir_dec, Ndec, 0);
  coeffs_fir_dec[0] =2.0f;

  // fir_dec をデシメーションフィルタとして初期化
  //（ダウンサンプル比4） 
  dsps_fird_init_f32(&fir_dec, coeffs_fir_dec, z_fir_dec, Ndec, 4, 0);
    digitalWrite(48, HIGH);
  dsps_fird_f32(&fir_dec, si, sod, BLOCK_SAMPLES);
    digitalWrite(48, LOW);

  // fir_dec を通常のFIRフィルタとして初期化 
  dsps_fir_init_f32(&fir_dec, coeffs_fir_dec, z_fir_dec, Ndec);
    digitalWrite(48, HIGH);
  dsps_fir_f32(&fir_dec, si, so, BLOCK_SAMPLES);
    digitalWrite(48, LOW);
    
   for(int i; i<BLOCK_SAMPLES; i++){
     Serial.printf("%f %f %f;\n",si[i], so[i], sod[i] );
   }
}

void loop(void) {
}

実行時間は下図のとおり，デシメーションフィルタは通常のフィルタに比べおよそ1/3の処理時間になった．1/4でないのはオーバーヘッドなどを考えれば当然かと思うが，デシメーションFIRフィルタによってダウンサンプルを同時に行えば，処理時間をかなり減らすことができそう．もちろん信号帯域は狭くなるが．

入出力信号は下図のようになった．サンプル数が64 から1/4 の16に減少しているのがわかる（17個目以降はゴミ）．フィルタ処理としては通常のFIRと同じ処理が行われている（2倍）．

記事中のプログラムは，Arduino IDE 2.1.1, Board Manager esp32 ver. 2.0.9 で動作確認しています．

Espressif DSP Library のFFT関数を使ってみた．ポイント数は4096までサポートされている．信号処理のパフォーマンスを落としたくないのでFFTは信号処理とは別のコアで実行させたい．信号はリングバッファ経由で渡すようにした．

// I2S on ESP32-S3
// T.Uebo  October 12 , 2022

// I2S Master MODE 48kHz/32bit
//
//   Mclk  GPIO 39
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <esp_dsp.h>
#include <driver/i2s.h>
#define fsample 48000
#define BLOCK_SAMPLES 64
#define MUTE 40 // MUTE control (LOW: Mute)

//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];

// for Filter work
float zL0[2], zR0[2], coeffs0[5];
float zL1[2], zR1[2], coeffs1[5];

#define Nfir 512
fir_f32_t firL_st, firR_st;
float coeffs_firL[Nfir], coeffs_firR[Nfir];
float z_firL[Nfir], z_firR[Nfir];

#define Nfft 4096
float dat[Nfft*2];
float wf[Nfft];          // 窓関数
float pow_sp[Nfft];  // パワースペクトル

//リングバッファ
#define Ring_Buf_Size (Nfft+256)
volatile float d_Lch[Ring_Buf_Size];
volatile float d_Rch[Ring_Buf_Size];
volatile int pt = 0; // リングバッファのポインタ


TaskHandle_t H_Task;//タスクハンドル


/*--------------------------------------------------
   core 0 で処理するTask   Alt_Thread()
---------------------------------------------------*/
void Alt_Thread(void *args) {

  dsps_fft2r_init_fc32(NULL, Nfft);  // 回転因子生成
  dsps_wind_hann_f32(wf, Nfft);   // 窓関数生成

  /*----------------------------------------------------
    Loop
  ------------------------------------------------------*/
  while (1) {
    // リングバッファから信号をコピー
    int ptc = pt;
    ptc -= Nfft; if(ptc < 0) ptc += Ring_Buf_Size;
    int j=0;
    for(int i = 0; i<Nfft; i++){
      dat[j]   = d_Lch[ptc];       // Re 
      dat[j+1] = d_Rch[ptc];    //Im
      ptc++; if(ptc == Ring_Buf_Size) ptc=0;
      j+=2;
    }

    // 窓関数を掛ける
    j=0;
    for(int i = 0; i<Nfft; i++){
      dat[j]   *= wf[i];
      dat[j+1] *= wf[i];
      j+=2;
    }

    // FFT
    dsps_fft2r_fc32(dat, Nfft);
    dsps_bit_rev2r_fc32(dat, Nfft);
    
    // パワースペクトルの計算
    float Re, Im;
    j=0;
    for(int i=0; i<Nfft; i++){
      Re=dat[j]; Im=dat[j+1];
      pow_sp[i] = Re*Re + Im*Im;
      pow_sp[i]=10.0f*log10(pow_sp[i]) -120;
      if(pow_sp[i]<0) pow_sp[i]=0;
      j+=2;
    }
    // パワースペクトル[dB]　pow_sp[i]

    delay(1);
  }

}



/*-----------------------------------------------------------------------------------------------
  Setup
-------------------------------------------------------------------------------------------------*/
void setup(void) {
  Serial.begin(115200);
  delay(50);

  xTaskCreatePinnedToCore(Alt_Thread, "Alt_Thread", 8192, NULL, 4, &H_Task, 0); 

  //Mute Control
  pinMode(MUTE, OUTPUT);
  digitalWrite(MUTE, HIGH); //unmute

  pinMode(48, OUTPUT);

  //-- Filter settings -------------------------------------
  // set IIR Filter Coeffs. 
  dsps_biquad_gen_lpf_f32(coeffs0, 0.45f, 0.71f);
  dsps_biquad_gen_lpf_f32(coeffs1, 0.45f, 0.71f);

  // set up FIR
  dsps_fir_init_f32(&firL_st, coeffs_firL, z_firL, Nfir);
  dsps_fir_init_f32(&firR_st, coeffs_firR, z_firR, Nfir);
  // set FIR Filter Coeffs. 
  dsps_d_gen_f32(coeffs_firL, Nfir, 0);
  dsps_d_gen_f32(coeffs_firR, Nfir, 0);


  // I2S setup (Lables are defined in i2s_types.h, esp_intr_alloc.h)----------------------------------------
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
    .dma_buf_count = 2,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
    .mclk_multiple = I2S_MCLK_MULTIPLE_256,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .mck_io_num = 39,
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

}


/*-----------------------------------------------------------------------------------------------
  Signal Process Loop
-------------------------------------------------------------------------------------------------*/
void loop(void) {
  size_t readsize = 0;

  //Input from I2S codec
  esp_err_t rxfb = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (rxfb == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {

    digitalWrite(48, HIGH);

    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;
    }   
    
    //-------Signal process -------------------------------
    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs0, zL0);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs0, zR0);

    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, coeffs1, zL1);
    dsps_biquad_f32(Rch_out, Rch_in, BLOCK_SAMPLES, coeffs1, zR1);

    dsps_fir_f32(&firL_st, Lch_in, Lch_out, BLOCK_SAMPLES);
    dsps_fir_f32(&firR_st, Rch_in, Rch_out, BLOCK_SAMPLES);

    //Output to I2S codec
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j]   = (int) Lch_out[i];
      txbuf[j+1] = (int) Rch_out[i];
      j+=2;
    }
    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);


    //core0 のTaskでFFTを実行するために信号をリングバッファにコピー
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      d_Lch[pt]=Lch_out[i];
      d_Rch[pt]=Rch_out[i];
      pt++; if( pt == Ring_Buf_Size ) pt=0;
    }


  }

  digitalWrite(48, LOW);
}

FFTの処理をまとめると以下とおり．
１．#define Nfft でポイント数定義
２．配列を準備　float dat[Nfft*2];　float wf[Nfft];
３．dsps_fft2r_init_fc32(NULL, Nfft);　で回転因子を生成
４．dsps_wind_hann_f32(wf, Nfft);　で窓関数生成．（hann 窓しか用意されてない）
５．処理する信号に窓関数を掛けてdat[ ]に入れる．実部：偶数番目，虚部：奇数番目
６．dsps_fft2r_fc32(dat, Nfft);　FFT処理
７．dsps_bit_rev2r_fc32(dat, Nfft);　ビットリバース処理
８．結果は，dat[ ] に上書きされる．実部：偶数番目，虚部：奇数番目

あとは必要に応じてパワースペクトルにするなりすればOK．上のコードでは 最終 pow_sp[ ] にパワースペクトルを入れている．

ビットリバース関数が用意されているが，これを使う必要があるかどうかドキュメントからは読み取れなかった．動作させて確認したところ dsps_fft2r_fc32にはビットリバース処理は含まれておらず，この関数は必須だった．また1/Nfftの係数もかかっていないようで，結局 dsps_fft2r_fc32 は純粋にバタフライ演算のみをしていると思われる．いちいち係数をかけるのもめんどうなので上のコードではパワーをdBに変換した後で適当な定数を引いている．

I2Sのレイテンシーをチェックした．楽器用エフェクタの場合レイテンシーが大きいと演奏に支障をきたすなど問題が大きい．いろんな意見をいただいた結果 2ms 以下を目標としている．

一方，SDR受信機単独なら数10msのレイテンシーは問題ないだろう．トランシーバーの場合は送受切り替えがあるのでレイテンシーが大きいのはまずいがどの辺が限界かよくわからない．CWの高速短点よりは十分小さい方がよいのかもしれない．

ちなみに Teensy 4.0で同様のシステムを組んだ場合は， fs=48kHz，BLOCK_SAMPLES=16 のとき 1.88ms だった．

ESP32-S3 では　fs=48kHz，BLOCK_SAMPLES=64 としているが，このとき下図のとおりレイテンシーは 32.6ms で 2ms よりはるかに大きくなってしまった（信号周波数は1kHz）．

そこで BLOCK_SAMPLES=4 とし DMAバッファ数も限界まで減らた （　.dma_buf_count = ２　）ところ，下図のとおり 1.86ms となり 2ms を切ることができた．

この値は Teesy4.0ではBLOCK_SAMPLES=16で実現できたのだが…　ESP32-S3 では 4ブロックごとに処理しているようなので実質 BLOCK_SAMPLES=4 の 4倍で 16 ということか？

BLOCK_SAMPLES が少ないと I2S 処理のオーバーヘッドの割合が増し，信号処理量の限界が下がる．ちなみにこの状態だと IIR Biquad x 20個，512Tap FIR x 2個 は処理しきれない．400Tap FIR x 2 くらいまで減らせばOKだった．

ESP32は Dual Core なので1つのコアを信号処理に専念させて，他の処理を別のコアで処理すればパフォーマンスがよくなる．
setup(), loop() はCore1 で実行される．ここには信号処理のみ記述することにして，Core0で実行するTaskにその他の処理を入れていくことにする．

参考にさせていただいたサイト
mgo-tec電子工作
ESP32でマルチコアを試す

Core0で実行するTaskを追加したコードを下に示す．

// I2S on ESP32-S3
// T.Uebo  October 7, 2022

// I2S Master MODE 48kHz/32bit
//
//   Mclk  GPIO 39
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <esp_dsp.h>
#include <driver/i2s.h>
#define fsample 48000
#define BLOCK_SAMPLES 64
#define MUTE 40 // MUTE control (LOW: Mute)


//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];

// for IIR Filter
float zL0[2], zR0[2], coeffs0[5];


TaskHandle_t H_Task;  //タスクハンドル

/*--------------------------------------------------
   core 0 で処理するTask   Alt_Thread()
---------------------------------------------------*/
void Alt_Thread(void *args) {
  //
  //  このTask の setup() に相当する処理
  //
  float fc;
  static int tc;

  tc=0;

  while (1) { 
    //
    //  この Task の loop() に相当する処理
    //
    fc = (float)tc/30000.0f;
    dsps_biquad_gen_lpf_f32(coeffs0, fc, 1.0f); 
    tc++; if(tc>=3000) tc=0;


    delay(1);  // 必須
  }

}


/*-----------------------------------------------------------------------------------------------
  Setup
-------------------------------------------------------------------------------------------------*/
void setup(void) {
  Serial.begin(115200);
  delay(50);
   
  xTaskCreatePinnedToCore(Alt_Thread, "Alt_Thread", 8192, NULL, 4, &H_Task, 0);
  // 
  // xTaskCreatePinnedToCore(
  //     [タスク名],  "[タスク名]",  [スタックメモリサイズ],
  //     NULL,  [タスク優先順位](0-24)],
  //     [タスクハンドルのポインタ(&H_Task)],
  //     [Core ID(0 or 1)]
  //  ); 

  
  //Mute Control
  pinMode(MUTE, OUTPUT);
  digitalWrite(MUTE, HIGH); //unmute

  pinMode(48, OUTPUT);

  // set IIR Filter Coeffs.(as LPF)
  dsps_biquad_gen_lpf_f32(coeffs0, 0.1f, 1.0f); // fc = 0.1*fsample[Hz], Q=1.0


  // I2S setup (Lables are defined in i2s_types.h, esp_intr_alloc.h)----------------------------------------
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
    .dma_buf_count = 6,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
    .mclk_multiple = I2S_MCLK_MULTIPLE_256,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .mck_io_num = 39,
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

}


/*-----------------------------------------------------------------------------------------------
  Signal Process Loop
-------------------------------------------------------------------------------------------------*/
void loop(void) {
  size_t readsize = 0; 
 
  //Input from I2S codec
  esp_err_t rxfb = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (rxfb == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {

    digitalWrite(48, HIGH);

    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;
    }   
    
    //-------Signal process -------------------------------
    //IIR Filter
    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs0, zL0);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs0, zR0);
    //------------------------------------------------------

    //Output to I2S codec
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j]   = (int) Lch_out[i];
      txbuf[j+1] = (int) Rch_out[i];
      j+=2;
    }
    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY); 

  }
  digitalWrite(48, LOW);
}

追加分はハイライト表示している．まとめると，
１．setup() の前にタスクハンドルを定義 TaskHandle_t H_Task;
２．setup() の中にTask 宣言をする一文を入れる．xTaskCreatePinnedToCore
３．宣言したTaskの関数を記述 Alt_Thread()

Alt_Thread() では，一例として IIR LPF のカットオフ周波数をスイープする処理を記述した（動作確認済）．

I2S接続のCODECはとりあえず動いているが，設定に関してもう少し把握しておきたいので調べてみた．具体的にはヘッダファイル i2s.h じっくりながめただけ．

気になっていたのは，MCLKに関しては何も設定を書いていないのにGPIO0から出ていること．GPIO0はストラップピンで　boot　スイッチにつながっているので気持ちが悪い． ESP32-S3のスペックとしてはどのピンにもアサインできるので MCLK は別のポートに変更したい．

参考にしたサイトのコードにはそれらしい部分はなかったが，ヘッダファイルをみると i2s_pin_config_t;　のメンバーの中に　int mck_io_num; がいた．
そこで下のように自分のソースコードに 1行（ハイライト部分）追加した．

  i2s_pin_config_t pin_config = {
        .mck_io_num = 39,
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

これで，MCLK がGPIO39から出てくるようになった．
回路も修正して問題なく動作している．

もう一つ，MCLKの周波数も特に設定していないが256fs が出てきている．これは変更することはないと思うが確認しておかないと気持ちが悪い．

こちらも　i2s_config_t　のメンバーに　mclk_multiple　がいるようで，これをセットすればよさそう．

  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
    .dma_buf_count = 6,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
    .mclk_multiple = I2S_MCLK_MULTIPLE_256,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

その他の変更はないが，i2s_types.h, esp_intr_alloc.h を参照してそこで定義されているものはラベルに変更した．

記事中のプログラムは，Arduino IDE 2.1.1, Board Manager esp32 ver. 2.0.9 で動作確認しています．

信号処理をするにはDSPライブラリがあると大変ありがたい，というか必須かもしれない．ESP32ではどうなっているのか調べると，Espressif DSP Library があり一通りメジャーな処理は用意されている．ただ，Arduino IDE で使えるかどうかが問題．

ESP32のボードマネージャがインストールされたフォルダを調べてみると，かなり深い階層の非常に見つけ難いところに，ヘッダファイル（esp_dsp.h）が置かれていた．どうやらソースコードはないがライブラリも入っている様子．

試しに，IIRフィルタ（2次LPF）を実装してみた．
コードを下に示す．前回からに変更部分はハイライト表示してある．

// I2S on ESP32-S3
// T.Uebo  October 1 , 2022

// I2S Master MODE 48kHz/32bit
//
//   Mclk  GPIO 0
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <esp_dsp.h>
#include <driver/i2s.h>
#define fsample 48000
#define BLOCK_SAMPLES 64
#define MUTE 40 // MUTE control (LOW: Mute)


//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];

// for IIR Filter
float zL0[2], zR0[2];
float coeffs[5];


/*-----------------------------------------------------------------------------------------------
  Setup
-------------------------------------------------------------------------------------------------*/
void setup(void) {
  Serial.begin(115200);
  delay(50);

  //Mute Control
  pinMode(MUTE, OUTPUT);
  digitalWrite(MUTE, HIGH); //unmute

  pinMode(48, OUTPUT);

  // set IIR Filter Coeffs.(as LPF)
  dsps_biquad_gen_lpf_f32(coeffs, 0.01f, 1.0f); // fc = 0.01*fsample[Hz], Q=1.0


  // I2S setup ------------------------------------------------------------
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = (i2s_bits_per_sample_t)32,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_I2S),
    .intr_alloc_flags = 0,
    .dma_buf_count = 6,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

}


/*-----------------------------------------------------------------------------------------------
  Signal Process Loop
-------------------------------------------------------------------------------------------------*/
void loop(void) {
  size_t readsize = 0; 
 
  //Input from I2S codec
  esp_err_t rxfb = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (rxfb == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {

    digitalWrite(48, HIGH);

    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;
    }   
    
    //-------Signal process -------------------------------
    //IIR Filter
    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs, zL0);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs, zR0);

    //------------------------------------------------------


    //Output to I2S codec
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j]   = (int) Lch_out[i];
      txbuf[j+1] = (int) Rch_out[i];
      j+=2;
    }
    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY); 

  }
  digitalWrite(48, LOW);
}

I2Sで24bit整数データを取得し，float 32bit で処理しそれを24bit整数にしてI2Sで出力．
これであっさり動作した．float で処理できるのはオーバーフローを気にしなくていいので助かる．
係数生成用の関数も用意されていて動的にパラメータを変えていくような時には便利．自分で作っても大した手間ではないが（Teensyのときはそうした）．
高次のチェビシェフとかの係数は作れない．そういう場合も含めてフィルタ設計にはOctaveが便利なので普段はそちらを常用している．

信号処理量の限界を知るために，GPIO48 に信号処理中はHIGHそれ以外はLOWを出力するようにしてその信号を観測してみた．
(GPIO48 はオンボードのRGB LEDに接続されているので信号によってLEDの状態も変化するが，LED制御用の信号ではないのでLEDがどうなるかは不定)

IIR Biquad フィルタがLch,Rch それぞれ1段なので，処理にかかる時間の割合は非常に小さい．ただHIGHのところが一定でないようなので，拡大すると下のようになっていた．

どうも４ブロック分連続して処理するようになっているらしい．理由はI2Sドライバのソースコードがないのでよくわからない（見てもわからないか…）．そういうものとして理解しておこう．

次に，信号処理を限界まで追加してみる．
Lch，Rch それぞれに 512Tap の FIR + 10段のIIR Biquad を設定した． IIRフィルタの係数はL,R同じ．
コードは以下のとおり．

// I2S on ESP32-S3
// T.Uebo  October 4, 2022

// I2S Master MODE 48kHz/32bit
//
//   Mclk  GPIO 0
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <esp_dsp.h>
#include <driver/i2s.h>
#define fsample 48000
#define BLOCK_SAMPLES 64
#define MUTE 40 // MUTE control (LOW: Mute)

//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];

// for IIR Filter
float zL0[2], zR0[2], coeffs0[5];  // Z^-1配列(Lch)，Z^-1配列(Rch)，係数
float zL1[2], zR1[2], coeffs1[5];
float zL2[2], zR2[2], coeffs2[5];
float zL3[2], zR3[2], coeffs3[5];
float zL4[2], zR4[2], coeffs4[5];
float zL5[2], zR5[2], coeffs5[5];
float zL6[2], zR6[2], coeffs6[5];
float zL7[2], zR7[2], coeffs7[5];
float zL8[2], zR8[2], coeffs8[5];
float zL9[2], zR9[2], coeffs9[5];

// for FIR filter
#define Nfir 512
fir_f32_t firL_st, firR_st;      //  FIRではワーク用の構造体を用意する必要がある
float coeffs_firL[Nfir], coeffs_firR[Nfir];  // 係数用配列
float z_firL[Nfir], z_firR[Nfir];  // Z^-1配列

/*-----------------------------------------------------------------------------------------------
  Setup
-------------------------------------------------------------------------------------------------*/
void setup(void) {
  Serial.begin(115200);
  delay(50);

  //Mute Control
  pinMode(MUTE, OUTPUT);
  digitalWrite(MUTE, HIGH); //unmute

  pinMode(48, OUTPUT);

  // I2S setup ------------------------------------------------------------
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = (i2s_bits_per_sample_t)32,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_I2S),
    .intr_alloc_flags = 0,
    .dma_buf_count = 6,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

  //-- Filter settings -------------------------------------
  // IIR Filter の係数を生成 
  dsps_biquad_gen_lpf_f32(coeffs0, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs1, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs2, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs3, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs4, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs5, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs6, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs7, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs8, 0.45f, 1.0f);
  dsps_biquad_gen_lpf_f32(coeffs9, 0.45f, 1.0f);

  //  FIR構造体の初期化
  dsps_fir_init_f32(&firL_st, coeffs_firL, z_firL, Nfir);
  dsps_fir_init_f32(&firR_st, coeffs_firR, z_firR, Nfir);

  //  FIR Filter の係数を生成. 
  dsps_d_gen_f32(coeffs_firL, Nfir, 0);  // 係数列の先頭を1，その他0
  dsps_d_gen_f32(coeffs_firR, Nfir, Nfir-1); // 係数列の最後1，その他0
}

/*-----------------------------------------------------------------------------------------------
  Signal Process Loop
-------------------------------------------------------------------------------------------------*/
void loop(void) {
  size_t readsize = 0;

  //Input from I2S codec
  esp_err_t rxfb = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (rxfb == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {

    digitalWrite(48, HIGH);

    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;
    }   
    
    //-------Signal process -------------------------------
    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs0, zL0);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs0, zR0);

    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, coeffs1, zL1);
    dsps_biquad_f32(Rch_out, Rch_in, BLOCK_SAMPLES, coeffs1, zR1);

    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs2, zL2);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs2, zR2);

    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, coeffs3, zL3);
    dsps_biquad_f32(Rch_out, Rch_in, BLOCK_SAMPLES, coeffs3, zR3);

    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs4, zL4);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs4, zR4);

    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, coeffs5, zL5);
    dsps_biquad_f32(Rch_out, Rch_in, BLOCK_SAMPLES, coeffs5, zR5);

    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs6, zL6);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs6, zR6);

    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, coeffs7, zL7);
    dsps_biquad_f32(Rch_out, Rch_in, BLOCK_SAMPLES, coeffs7, zR7);

    dsps_biquad_f32(Lch_in, Lch_out, BLOCK_SAMPLES, coeffs8, zL8);
    dsps_biquad_f32(Rch_in, Rch_out, BLOCK_SAMPLES, coeffs8, zR8);

    dsps_biquad_f32(Lch_out, Lch_in, BLOCK_SAMPLES, coeffs9, zL9);
    dsps_biquad_f32(Rch_out, Rch_in, BLOCK_SAMPLES, coeffs9, zR9);

    dsps_fir_f32(&firL_st, Lch_in, Lch_out, BLOCK_SAMPLES);
    dsps_fir_f32(&firR_st, Rch_in, Rch_out, BLOCK_SAMPLES);

    //------------------------------------------------------

    //Output to I2S codec
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j]   = (int) Lch_out[i];
      txbuf[j+1] = (int) Rch_out[i];
      j+=2;
    }
    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);

  }
  digitalWrite(48, LOW);
}

これでGPIO48の信号を見てみると下のようにほぼ限界になっている．

260μsの隙間があるのでもう少し詰められる．試しのFIRのタップ数を増やしていくと580くらいで出力の音がおかしくなった．

ほぼ予想どおり．
これくらいの処理能力ならデシメーション無しでSSBのベースバンド処理はいけそう．エフェクタならFIRは使わないのでかなり余裕をもって使える．

前回の記事に書いたものは回路図も書かずI2Sの動作の確認のためだけに適当につくったものだったが，きちんと情報をまとめておくためにもあらためて詳しく記事にしていく．

これをもとに何をしたいかというと，SDR（趣味）と楽器用のエフェクタ（仕事）．どちらもやることはよく似ている．さすがにエフェクタの方に複素係数フィルタの出番はないが．

まずは回路図を作成した．
（見づらい場合は，「名前を付けて画像を保存」してからViewerで拡大して閲覧ください）

CODECは前回の記事から変更して，DACにはPCM5102A，ADCにはPCM1808を使用した．限られた手持ちのデバイス中ではこの組み合わせが一番ノイズが少なかった．
PCM5102Aは単体のデバイスではなくモジュールを使った（紫色の基板）．アマゾンで検索するとたくさんでてくる．

PCM1808のI2S制御信号にはダンピング抵抗を入れている．これがないと出力にプチプチとノイズが入る．抵抗値は適当なので最適値があるかもしれない．

LCD用のポートも確保しておいた．一応8bitパラレルを想定しているが今後ポートが足りなくなるようならSPIにする．ESP32よりポート数は増えているが十分ではないかもしれない．

以下にこの回路で動作するコードを示す．
環境は Arduino IDE + ESP32ボードマネージャ(2.0.5)
（折り返し等で見づらい場合は全コピーしてテキストエディタに貼り付けてください）

// I2S on ESP32-S3
// T.Uebo  October 4 , 2022

// I2S Master MODE 48kHz/32bit
//
//   Mclk  GPIO 0
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <driver/i2s.h>
#define fsample 48000
#define BLOCK_SAMPLES 64

//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];

#define MUTE 40 // MUTE control (LOW: Mute)

/*-----------------------------------------------------------------------------------------------
  Setup
-------------------------------------------------------------------------------------------------*/
void setup(void) {

  Serial.begin(115200);
  delay(50);

  pinMode(MUTE, OUTPUT);
  digitalWrite(MUTE, HIGH); // unmute

  // I2S setup ------------------------------------------------------------
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fsample,
    .bits_per_sample = (i2s_bits_per_sample_t)32,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_I2S),
    .intr_alloc_flags = 0,
    .dma_buf_count = 6,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);

}


/*-----------------------------------------------------------------------------------------------
  Signal Process Loop
-------------------------------------------------------------------------------------------------*/
void loop(void) {
  size_t readsize = 0;  
  //Input
  esp_err_t res = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (res == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {
    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;
    }   
    
    //-------Signal process -------------------------------
    for (int i=0; i<BLOCK_SAMPLES; i++) {   
      Lch_out[i] = Lch_in[i];
      Rch_out[i] = Rch_in[i];           
    }

    //------------------------------------------------------

    //Output
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j]   = (int) Lch_out[i];
      txbuf[j+1] = (int) Rch_out[i];
      j+=2;
    }
    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);

  }

}

動作は，入力された信号をそのまま出力する．
GPIO 40をミュート制御用の信号としているが，回路は対応していないので今のところ意味はない．

今後，//——-Signal process —————- の部分に処理を追加していく．

ESP32ではバックグラウンドでfreeRTOSが動作しているそうでなかなか理解が難しい（Teensy もそうだったか？）．i2s.h （ I2S.h ではない）に書かれてある内容を頼りに用意されている関数を使ってとりあえず動作はしたが，自分自身はよく理解しているとは言い難い．とはいえやりたいことは信号処理なので，それ以外は先人の成果をありがたく使わせていただくことにしたいと思う．

参考にさせていただいたサイト

• [#24] ESP32 – I2S Audio Loopback with MCLK
• https://github.com/YetAnotherElectronicsChannel/ESP32_DSP_I2S_SET

備忘録代わりの投稿．
ESP32-S3-DevKitC-1 を入手したので，I2S接続の Audio CODEC つなげて動かしてみた．
開発環境はArduino IDE．ESP32のボードマネージャはバージョン2.0.5をインストールした．
（2.0.3以降でS3に対応しているらしい）

CODECには PCM3060PW を使った．
まずESP32用のI2Sのスケッチ例があったので試してみたがまともに動作せず．これらは libraries フォルダにある　I2S.h， I2S.cpp 　を使っていたのでその中身を見てみると，サンプリング周波数が16kHz以下かつ16bitで使うようにコメントされていて無駄な時間を費やしてしまった．
結局 driver フォルダの i2s.h を使い，下記のコードでうまく動作した．

// I2S on ESP32-S3
// T.Uebo  October 1 , 2022

// I2S Master MODE 48kHz/32bit
//
//   Mclk  GPIO 0
//   Bclk  GPIO 42
//   LRclk GPIO 2
//   Dout  GPIO 41
//   Din   GPIO 1

#include <driver/i2s.h>

#define fs 48000
#define BLOCK_SAMPLES 128

#define Reset_CODEC 40 // HW Reset signal for CODEC 

//buffers
int rxbuf[BLOCK_SAMPLES*2], txbuf[BLOCK_SAMPLES*2];
float Lch_in[BLOCK_SAMPLES], Rch_in[BLOCK_SAMPLES];
float Lch_out[BLOCK_SAMPLES], Rch_out[BLOCK_SAMPLES];


void setup(void) {
  //HW Reset for CODEC
  pinMode(Reset_CODEC, OUTPUT);
  digitalWrite(Reset_CODEC, HIGH);
  delay(1);
  digitalWrite(Reset_CODEC, LOW);
  delay(1);
  digitalWrite(Reset_CODEC, HIGH);

  // setup I2S 
  i2s_config_t i2s_config = {
    .mode =  (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX  | I2S_MODE_RX),
    .sample_rate = fs,
    .bits_per_sample = (i2s_bits_per_sample_t)32,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_I2S),
    .intr_alloc_flags = 0,
    .dma_buf_count = 6,
    .dma_buf_len = BLOCK_SAMPLES*4,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0,
  };
  i2s_driver_install( I2S_NUM_0, &i2s_config, 0, NULL);

  i2s_pin_config_t pin_config = {
        .bck_io_num = 42,
        .ws_io_num = 2,
        .data_out_num = 41,
        .data_in_num = 1                                                       
    };
  i2s_set_pin( I2S_NUM_0, &pin_config);
  i2s_zero_dma_buffer(I2S_NUM_0);
}


void loop(void) {
  size_t readsize = 0; 

  //Input from I2S codec
  esp_err_t rxfb = i2s_read(I2S_NUM_0, &rxbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);
  if (rxfb == ESP_OK && readsize==BLOCK_SAMPLES*2*4) {
    
    int j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      Lch_in[i] = (float) rxbuf[j];
      Rch_in[i] = (float) rxbuf[j+1];
      j+=2;
    }    
    
    //-------Signal process -------------------------------
    for (int i=0; i<BLOCK_SAMPLES; i++) {
    
      Lch_out[i] = Lch_in[i];
      Rch_out[i] = Rch_in[i];
            
    }
    //------------------------------------------------------


    //Output to I2S codec
    j=0;
    for (int i=0; i<BLOCK_SAMPLES; i++) {
      txbuf[j] = (int) Lch_out[i];
      txbuf[j+1] = (int) Rch_out[i];
      j+=2;
    }
    i2s_write( I2S_NUM_0, &txbuf[0], BLOCK_SAMPLES*2*4, &readsize, portMAX_DELAY);    	  	    
  }

}

Teensy 4 でリバーブの処理をさせようと思い，ライブラリにあるFreeverb を試してみたところ，FIRフィルタと同様信号レベルが低下してくるとノイズが生じてくる（残響音の減衰の最後の方は特に顕著）．やはりこれも16bit整数処理の影響かと思われるので，32bitフロートで書き直すことにする．

書き直すにあたってまず，ライブラリのソースを調べて具体的な処理内容を確認した．

Freeverbの中身はSchroederのアルゴリズムがベースになっていた．ただし，よく見かける 4個のComb filterと2個のAllpass filter によるものではなく，下図のようにそれぞれ2倍の 8個と4個になっていて，”High quality Reverb effect”との表記があった．

ただし，この処理ブロックは，残響のテイルの部分を生成するものなので，空間の残響をそれなりにシミュレートするには，Early reflection の生成や Pre delay の処理を追加する必要がある．

Comb filter は以下のようになっていた．

図のようにダンピング処理のための1次LPFを持っているので自然なリバーブが得られそう．
（このフィルタをBPFとかにすれば，Shimmer Reverb になるのかも？）

Allpass filter は以下のとおり．

ライブラリソースでは a=0.5 に固定されているようだが，その場合 1-a^2 = 0.75 でなければならない．コードをみるとこれ（1-a^2）も 0.5 になっているように解釈できた（自分の読み間違いかもしれないが）．単なるバグなのか何か意図があってそうしているのかわからないがもしそうなら特性はAllpass にはなっていない．とはいえ残響音の密度を上げるという観点からは聴感上大きな違いが出るようにも思えないのであまり気にしないでもいいか…　書き直しの際はセオリー通り 1-a^2=0.75 にする．

Teensy 4 でオーディオ信号処理を行うにはAudioライブラリを用いるのが簡便でよいが，以下のような制限がある．

(1) 処理が16bit整数のみ
(2) FIRフィルタのタップ数が200まで
(3) SDRで必要となる処理が用意されていない（直交・極変換，微分，平方根など）
など．

まず，2048タップのFIRフィルタを作ろうとして (2) の制限に引っかかった．
そこで，タップ数の少ないFIRフィルタを複数用いそれらを適切な Delay を通して駆動し，
出力をMIXする方法を試してみた（下図）．

128タップのFIRフィルタを16個並べて2048タップのFIRフィルタを構成している．これはうまく動作していて問題は無いように思えたが，動作確認を続けていくうちに，信号レベルが低下してくるとバックグラウンドノイズではない別のノイズが生成されてくることに気づいた（信号レベルが大きいときは気にならない）．これは以前に16bit整数処理のIIRフィルタ（８次）の動作確認したときと同様の現象で，このFIRフィルタもおそらくアンダーフローを起こしていると思われた（IIRのときよりは顕著でないが）．

となるとAudioライブラリは16bit整数処理のみなので，このライブラリ使う限り改善は望めそうにない．そこで Audioライブラリでは I2S と queue のみを使用し，信号処理はコードで書くことにする（下図）．

queue_send から信号をコードに取り込み，処理したあと queue_ret に信号を返す．
信号処理には CMSIS DSP Software Library で用意されている関数を用いる．信号処理関数が豊富に，かつ float で処理する関数も用意されているのでそれらを使えば上述のノイズの問題は解消できるはず．

ということで，以下のようなコード作成して動作確認をしてみた．
（なお，コードを見やすくするために実際に動作確認できた状態から抜粋して示しています．このままでおそらく動作するとは思いますが保証はしません．間違いのご指摘は歓迎いたしますが「動作しない」というクレームはご遠慮願います．）

//#include <arm_math.h>
#include <Audio.h>

AudioInputI2S            i2s_IN;
AudioMixer4              mixer_IN;
AudioRecordQueue         queue_send;
AudioPlayQueue           queue_ret;
AudioOutputI2S           i2s_OUT;
AudioConnection          patchCord1(i2s_IN, 0, mixer_IN, 0);
AudioConnection          patchCord2(i2s_IN, 1, mixer_IN, 1);
AudioConnection          patchCord3(mixer_IN, queue_send);
AudioConnection          patchCord4(queue_ret, 0, i2s_OUT, 0);
AudioConnection          patchCord5(queue_ret, 0, i2s_OUT, 1);

#define NtapFIR 2048
float32_t fircoeffs[ NtapFIR ];
float32_t firState[ NtapFIR + 2*AUDIO_BLOCK_SAMPLES - 1 ];

arm_fir_instance_f32 firEQ;

float32_t sigf_IN [AUDIO_BLOCK_SAMPLES];
float32_t sigf_OUT[AUDIO_BLOCK_SAMPLES];
int16_t sig16[AUDIO_BLOCK_SAMPLES];

#include <FlexiTimer2.h>


//Signal process --------------------
void sig_proc()
{
  int i;
  int16_t *p_sig;  
  if(queue_send.available() != 0){

    //INPUT
    p_sig = queue_send.readBuffer();
    for(i=0; i<AUDIO_BLOCK_SAMPLES; i++) 
              sigf_IN[i]=(float32_t)p_sig[i];
    
    //FIR
    arm_fir_f32(
          &firEQ,
          sigf_IN, 
          sigf_OUT, 
          AUDIO_BLOCK_SAMPLES
    );

    //OUTPUT
    for(i=0; i<AUDIO_BLOCK_SAMPLES; i++) 
              sig16[i]=(int16_t)(sigf_OUT[i]);
    queue_ret.play(sig16, AUDIO_BLOCK_SAMPLES);
    queue_send.freeBuffer();
  }
 
}

//--------------------------------------
void setup() {
  
  arm_fir_init_f32(
    &firEQ, 
    NtapFIR, 
    fircoeffs, 
    firState, 
    AUDIO_BLOCK_SAMPLES
  );

  //Set freq. response to flat   (Impulse)
  for(int i=0; i<NtapFIR; i++) fircoeffs[i] = 0;
  fircoeffs[1024] = 1.0f;
  
  //Reset CODEC
  pinMode(22, OUTPUT);
  digitalWrite(22, LOW);
  delay(100);
  digitalWrite(22, HIGH);
  
  AudioMemory(100);
  mixer_IN.gain(0, 1.0f);
  mixer_IN.gain(1, 1.0f);
  mixer_IN.gain(2, 0.0f);
  mixer_IN.gain(3, 0.0f);


  // call "sig_proc" every 2ms
  FlexiTimer2::set(2, 1.0/1000, sig_proc);
  FlexiTimer2::start();
 
  queue_send.begin();  
}

//------------------------------------------
void loop() {
      //Set fircoeffs[] 
}

動作確認の結果 32bit float 処理にすることでノイズが消えた．やはり16bit整数処理が問題だったようだ．
AudioライブラリはGUIでシステムを構築できるので取っつきやすいが，結局コードで書いた方がfloat 処理ができるしFIRフィルタの処理も1行で済むので楽（設定はいろいろ必要だがそれはAudioライブラリも同じ）．
あとは I2S のブロックが16bitでなく32bitでインターフェースできれば，CODECのダイナミックレンジを十分に活かせるのだが…
とはいえ内部処理は 32bit float にできたので微分処理なども少し安心してできると思う．

トップページにアコースティックギター用ピックアップシステムの紹介を追加しました．

3か所，音の出ない鍵盤があるとのことで修理を依頼された．
PS3は最も初期のポータサウンドの一つらしい．

 

とりあえず開腹して，一枚目の基板を外した．
YAMAHAのオリジナルICを使用している．
年代を感じさせる作りで，ピッチの基準はLC発振のようだ．

 

鍵盤下の基板を外したところ．

音の出ない鍵盤に対応する接点をショートさせてみても，やはり音が出ない．
ということで接点不良ではなさそう．

 

該当する接点につながっているパターンをたどっていくと，電池の液漏れによるパターンの腐食があった．
調べてみると導通がない．音の出ない鍵盤に対応する接点はすべてこのラインにつながっているので，故障の原因はこれだろう．

 

 

ということで，バイパス．
隣りのパターンも怪しかったので処置しておいた．

 

これで音も出るようになり，修理完了．

最近は中国製の安いヘッドマイクが購入できる．これらはほぼエレクトレットコンデンサマイクでバイアス電源が要る．
一方ミキサのXLRマイク入力には，大抵ファンタム電源が供給できるようになっているが，これはコンデンサマイク用でエレクトレットコンデンサマイクのバイアスには使えない．
また，エレクトレットコンデンサマイクの出力は不平衡なので，そのまま長く引き回すとノイズがのる．
そのようなわけで，ヘッドマイクをミキサのマイク入力（XLRコネクタ)につなぐためのアダプタケーブルを製作した．

ケースの中身は，ファンタム電源からエレクトレットコンデンサマイク用のバイアスを作る分圧回路と不平衡を平衡に変換する差動アンプである．
試作ということで，ケースを３Dプリンタで作り空中配線で仕上げたが，結構面倒でユニバーサル基板を使えばよかったかもしれない．

ケースにはベルトなどに引っ掛けるようクリップをつけた．
こういうのは3Dプリンタのおかげで簡単にできるのでありがたい．

以前は40KHzのトランスデューサ（写真左）を使ってバットディテクターを製作していたが，
40KHz付近しか観測できない，という制約があった．
今回のバットディテクターでは，
広帯域で超音波を観測するためにMEMSマイク(写真右）を使っている．
ただ，トランスデューサは40KHz付近の感度は高く，
40KHzに限った感度の比較では，MEMSマイクは今一つな感じがする．

写真を見ればわかるように，
MEMSマイクの音響ホールは直径0.5mmしかない．
トランスデューサの方は，内部の振動板らしきものは，直径8mmほどある．
開口面積がMEMSマイクの方が格段に小さいため，
感度が悪いのも無理はない．

そこで，音響ホーンを用いて開口面積を大きくし，感度の向上を試みた．

3Dプリンタで作成した超音波用の音響ホーン．

定量的なデータはとっていないが，聞き比べた感じでは，
トランスデューサと同等以上の感度が得られているようだ．