Using I2S on the RP2040 for an ADC....

[frohro]

@pschatzmann , After reading your great success and example to use an RP Pico and Audio Tools to send output to a DAC, I assumed Audio Tools was ready for an ADC and I modified your code so it looks like this:

#include "Adafruit_TinyUSB.h"
#include "AudioTools.h"
#include "AudioTools/Concurrency/RP2040.h"

AudioInfo info(48000, 2, 16);
Adafruit_USBD_Audio usb;
BufferRP2040 buffer(256, 20); // Thread safe circular buffer
QueueStream queue(buffer);
I2SStream i2s;
StreamCopy copier(queue, i2s);

size_t readCB(uint8_t *data, size_t len, Adafruit_USBD_Audio &ref)
{
  size_t bytes_read = 0;
  while (bytes_read < len && queue.available())
  {
    data[bytes_read] = queue.read();
    bytes_read++;
  }
  usb.setFeedbackPercent(buffer.size() * 100 / buffer.available());
  return bytes_read;
}

void setup()
{
  Serial.begin(115200);
  while (!Serial)
  {
    delay(100);
  } // Block until Serial ready
  Serial.println("\n\nCore0: Starting USB Audio");
  rp2040.fifo.push(0xAA); // Signal Core1
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Warning);
  // while(!Serial);  // wait for serial
  delay(1000);
  Serial.println("starting...");
  // start queue
  queue.begin(80);
  Serial.println("Queue started");

  // Start USB device as Audio Source
  usb.setFeedbackMethod(AUDIO_FEEDBACK_METHOD_DISABLED);
  usb.setReadCallback(readCB);
  if (!usb.begin(info.sample_rate, info.channels, info.bits_per_sample))
  {
    Serial.println("USB error");
  }
  Serial.println("USB started");

  // If already enumerated, additional class driverr begin() e.g msc, hid, midi won't take effect until re-enumeration
  if (TinyUSBDevice.mounted())
  {
    TinyUSBDevice.detach();
    delay(10);
    TinyUSBDevice.attach();
  }
}

void loop()
{
  static uint32_t last_print = 0;
  if (millis() - last_print > 1000)
  {
    Serial.printf("Buffer: %d/%d\n", buffer.size(), buffer.available());
    last_print = millis();
  }
  usb.updateLED();
}

void setup1()
{
  while (rp2040.fifo.pop() != 0xAA)
  {
    delay(10);
  } // Wait for Core0
  Serial.println("Core1: Starting I2S");
  auto cfg = i2s.defaultConfig(RX_MODE);
  cfg.copyFrom(info);
  cfg.pin_data = 2;
  cfg.pin_bck = 0;
  cfg.pin_ws = 1;
  cfg.pin_mck = 3;
  cfg.buffer_size = 256;
  cfg.buffer_count = 3;
  cfg.i2s_format = I2S_PHILIPS_FORMAT;
  // cfg.bits_per_sample = 16; 
  // cfg.mck_multiplier = 256; // Add MCLK multiplier

  if (!i2s.begin(cfg))
  {
    Serial.print("i2s error");
  }
  Serial.println("I2S started");
}

void loop1()
{
  copier.copy();
}

It builds just fine and appears to work but the results in Audacity look like this:

The ADC I am using is the PCM1808, and the code below works for getting the data into the RP Pico:

#include <I2S.h>

I2S i2s(INPUT);

int32_t r[500], l[500];

void setup()
{

    Serial.begin();

    i2s.setDATA(2);
    i2s.setBCLK(0);
    i2s.setMCLK(3);
    // Note: LRCK pin is BCK pin plus 1 (1 in this case).
    i2s.setBitsPerSample(24);
    i2s.setFrequency(8000);
    i2s.setMCLKmult(384);
    i2s.setSysClk(8000);
    i2s.setBuffers(64, 16, 0);
    i2s.begin();
}

void loop()
{
    int i;
    for (i = 0; i < 500; i++)
    {
        i2s.read32(l + i, r + i);
    }
    for (i = 0; i < 500; i++)
    {
        Serial.printf("> Right:%d, Left:%d\r\n", l[i] << 8, r[i] << 8);
    }
}

The PCM1808 can either use 24 or 32 bits, which seems to be more than the USB can handle, so we need to do some shifts to make int32_t r[500] and l[500] into int16_t. It does not handle 16 bits over I2S. I went looking at I2SRP2040.h to see what I should shift things over and saw notes that it only works for TX (to a DAC). It also looked like you made some changes very recently, so I assume you might be working on this now.
I have another way of doing this without Audio Tools that isn't quite working yet, but probably because I need to put the I2S on the second core. I didn't do that because I got excited about your code that showed how to use Audio Tools for the DAC and so I made the first code above. Here is the other way I put by the side when I saw your nice example:

// #include <cmath>
#include "Adafruit_TinyUSB.h"
// #include "AudioTools.h"
#include <Arduino.h>
#include <I2S.h>

I2S i2s;
const int RATE = 48000;             
const int BITS_PER_SAMPLE_SENT = 32; 
const int MCLK_MULT = 256;  

Adafruit_USBD_Audio usb;

size_t readCB(uint8_t* data, size_t len, Adafruit_USBD_Audio& ref) {
  int16_t* data16 = (int16_t*)data;
  // Serial.println(len);
  size_t samples = len / sizeof(int16_t);
  // Serial.println(samples);
  size_t result = 0;
  int32_t r[samples], l[samples];

  for (size_t j = 0; j < samples-1; j += 2) {  // -1 is a work around for a bug in the library
    int k = j/2;
    i2s.read32(l + k, r + k);
    data16[j] = (l[k] << 0) & 0xFFFF;       // Take the lower 16 bits of l
    data16[j+1] = (r[k] << 0) & 0xFFFF;     // Take the lower 16 bits of r
    result += sizeof(int16_t) * 2;
  }
  Serial.printf("l: 0x%lx, r: 0x%lx\n", l, r);
  return result;
}

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

    i2s.setDATA(2); // These are the pins for the data on the SDR-TRX
    i2s.setBCLK(0);
    i2s.setMCLK(3);
    // Note: LRCK pin is always BCK pin plus 1 (1 in this case).
    i2s.setSysClk(RATE);
    i2s.setBitsPerSample(BITS_PER_SAMPLE_SENT);
    i2s.setFrequency(RATE);
    i2s.setMCLKmult(MCLK_MULT);
    i2s.setBuffers(32, 0, 0);
    i2s.begin();

  // Start USB device as Microphone
  usb.setReadCallback(readCB);
  usb.begin(RATE, 2, 16); 

  if (TinyUSBDevice.mounted()) {
    TinyUSBDevice.detach();
    delay(10);
    TinyUSBDevice.attach();
  }
}

void loop() {
  // optionally use LED to display status
  usb.updateLED();
}

I am planning to use this code for my Electronics II class spring quarter this year. Do you recommend I work on modifying the I2SRP2040.h so it works for me, or do you recommend I modify my code below so it uses both cores and gives me good data, or do you suspect you will be working on this and might have it working by the time I need it?

[pschatzmann]

Why do you think you need to modify the I2SRP2040.h ?

My recommendation would be to keep things as simple as possible and if the one core solution is working, stick with that!

I think that would be also a great opportunity to show maybe different solutions and ask the students for advantages and disadvantages of each approach.

The AudioTools is using the I2S.h so any API should work in the end: I would propose a third solution which would use the data conversion functionality of the AudioTools with something like the follows:

AudioInfo infoI2S(44100, 32, 2);
AudioInfo infoUSB(44100,16,2);
I2SStream i2s;
FormatConverterStream converter(i2s);

size_t readCB(uint8_t* data, size_t len, Adafruit_USBD_Audio& ref) {
  // provide data in 16 bits
  return converter.readBytes(data, size);
}

void setup() {
  // setup i2s for 32 bits
  auto cfgI2s = i2s.defaultConfig(RX_MODE);
  cfgi2s.copyFrom(infoI2S);
  i2s.begin(cfgI2S);

  // convert from 32 bits to 16
  converter.begin(infoI2S, infoUSB);

  // setup usb
  usb.setReadCallback(readCB);
  usb.begin(infoUSB.sample_rate, infoUSB.channels, infoUSB.bits_per_sample); 

I personally prefer the shorter more declarative versions because it makes it easier to reason about the code and play with different varients.

[pschatzmann]

ps. I just remembered that you could also use this approach to convert more efficiently:

NumberFormatConverterStreamT<int32_t, int16_t> converter(i2s);