[参考译文] TAS2563：MCU 集成

#include "AmplifierController.h"

bool amp_init()
{
    // I2S setup
    i2s_config_t i2s_config = {
        .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
        .sample_rate = 44100,
        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
        .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
        .communication_format = I2S_COMM_FORMAT_I2S,
        .intr_alloc_flags = 0, // Default interrupt priority
        .dma_buf_count = 8,
        .dma_buf_len = 512,
        .use_apll = false,
        .tx_desc_auto_clear = true, // Auto clear if underflow
        .fixed_mclk = 0};

    // I2S pin configuration
    i2s_pin_config_t pin_config = {
        .bck_io_num = I2S_BCLK,
        .ws_io_num = I2S_WORD,
        .data_out_num = I2S_SDO,
        .data_in_num = I2S_SDI};

    i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
    i2s_set_pin(I2S_NUM_0, &pin_config);
    i2s_set_clk(I2S_NUM_0, 44100, I2S_BITS_PER_SAMPLE_16BIT, I2S_CHANNEL_MONO);

    // TAS2563 Setup
    tas2563_config_registers(TAS2563_LEFT_I2C_ADDRESS, 1); // power down reset
    tas2563_config_registers(TAS2563_LEFT_I2C_ADDRESS, 2); // program
    tas2563_config_registers(TAS2563_LEFT_I2C_ADDRESS, 3); // config
    tas2563_config_registers(TAS2563_LEFT_I2C_ADDRESS, 4); // power up
    tas2563_config_registers(TAS2563_LEFT_I2C_ADDRESS, 5); // unmute

    return true;
}

void amp_play_wav()
{
    readRegister(TAS2563_TDM_DET);
    readRegister(TAS2563_TDM_CONFIG_REG0);

    readRegister(TAS2563_INT_LTCH0);
    readRegister(TAS2563_INT_LTCH1);
    readRegister(TAS2563_INT_LTCH2);
    readRegister(TAS2563_INT_LTCH3);

    // Open the .wav file
    File wavFile = SD.open("/Lord of the Rangs Short.wav");
    if (!wavFile)
    {
        Serial.println("Failed to open file for reading");
        return;
    }

    // Skip the WAV header (typically 44 bytes)
    wavFile.seek(44);

    // Buffer for reading WAV data
    byte buffer[512];
    size_t bytes_written;
    int num = 0;
    while (wavFile.available())
    {
        int bytesRead = wavFile.read(buffer, sizeof(buffer));

        // Write the buffer to the I2S interface
        i2s_write(I2S_NUM_0, buffer, bytesRead, &bytes_written, portMAX_DELAY);

        if (num % 1000 == 0)
        {
            readRegister(TAS2563_TDM_DET);
            readRegister(TAS2563_TDM_CONFIG_REG0);
            readRegister(TAS2563_INT_LTCH0);
            readRegister(TAS2563_INT_LTCH1);
            readRegister(TAS2563_INT_LTCH2);
            readRegister(TAS2563_INT_LTCH3);
        }

        // Check if the bytes written match the bytes read from the file
        if (bytes_written != bytesRead)
        {
            Serial.println("I2S write error");
        }
        num++;
    }

    wavFile.close();
    Serial.println("Playback finished");

    readRegister(TAS2563_TDM_DET);
    readRegister(TAS2563_TDM_CONFIG_REG0);
}

// Function to write to a TAS2563 register
void writeRegister(uint8_t reg, uint8_t value)
{
    Wire.beginTransmission(TAS2563_LEFT_I2C_ADDRESS); // Begin I2C communication with TAS2563
    Wire.write(reg);                                  // Send the register address
    Wire.write(value);                                // Send the data to write to the register
    Wire.endTransmission();                           // End transmission

    // Optionally, print out the operation for debugging
    Serial.print("Wrote to reg 0x");
    Serial.print(reg, HEX);
    Serial.print(": 0x");
    Serial.println(value, HEX);
}

// Function to read from a TAS2563 register (for debugging)
uint8_t readRegister(uint8_t reg)
{
    Wire.beginTransmission(TAS2563_LEFT_I2C_ADDRESS); // Begin I2C communication with TAS2563
    Wire.write(reg);                                  // Send the register address
    Wire.endTransmission(false);                      // End transmission but keep the connection alive

    Wire.requestFrom(TAS2563_LEFT_I2C_ADDRESS, (uint8_t)1); // Request 1 byte of data from the register
    uint8_t value = Wire.read();                            // Read the byte

    // Optionally, print out the operation for debugging
    Serial.print("Read from reg 0x");
    Serial.print(reg, HEX);
    Serial.print(": 0x");
    Serial.println(value, HEX);

    return value;
}

// I2C Transfer Function (Stub for actual I2C implementation)
uint16 PltI2cTransfer(uint8 address, uint8 *tx, uint16 tx_len, uint8 *rx, uint16 rx_len)
{
    Wire.beginTransmission(address >> 1); // Arduino Wire library uses 7-bit address
    Wire.write(tx, tx_len);
    Wire.endTransmission();
    if (rx_len > 0)
    {
        uint8_t response = Wire.requestFrom(address >> 1, rx_len);

        for (int i = 0; i < rx_len && Wire.available(); i++)
        {
            rx[i] = Wire.read();
        }
    }
    return I2C_TEST_PASSED;
}

uint16 tas2563_write_reg(uint8 SlaveAddr, uint8 *regValue, uint16 count)
{
    SlaveAddr = (SlaveAddr << 1) | WRITE_I2C;
    Serial.println("Writing");
    return PltI2cTransfer(SlaveAddr, regValue, count, 0, 0);
}

uint16 tas2563_read_reg(uint8 SlaveAddr, uint8 *regValue, uint16 count)
{
    SlaveAddr = (SlaveAddr << 1) | READ_I2C;
    Serial.println("Reading");
    return PltI2cTransfer(SlaveAddr, 0, 0, regValue, count);
}

void tas2563_transmit_registers(uint8 SlaveAddr, cfg_reg *r, int n)
{
    int i = 0;
    while (i < n)
    {
        switch (r[i].command)
        {
        case CFG_META_SWITCH:
            // Used in legacy applications. Ignored here.
            break;
        case CFG_META_DELAY:
            delay(r[i].param);
            break;
        case CFG_META_BURST:
            tas2563_write_reg(SlaveAddr, (unsigned char *)&r[i + 1], r[i].param);
            i += (r[i].param / 2) + 1;
            break;
        default:
            tas2563_write_reg(SlaveAddr, (unsigned char *)&r[i], 1);
            break;
        }
        i++;
    }
}

void tas2563_config_registers(uint8 SlaveAddr, uint8 id)
{
    if (id == 1)
        tas2563_transmit_registers(SlaveAddr, power_down_reset, power_down_reset_size);
    if (id == 2)
        tas2563_transmit_registers(SlaveAddr, program, program_size);
    if (id == 3)
        tas2563_transmit_registers(SlaveAddr, configuration, configuration_size);
    if (id == 4)
        tas2563_transmit_registers(SlaveAddr, powerup, powerup_size);
    if (id == 5)
        tas2563_transmit_registers(SlaveAddr, unmute, unmute_size);
}

void amp_loop()
{
    // nothing
}