ESP32那些事儿(七)：功能开发之I2S和I2C驱动

1、I2S的使用     

I2S为三线总线，3个信号分别为：
① 串行时钟SCK，也叫位时钟（BCK）。即每发送1位数字音频数据，SCK上都有1个脉冲。SCK的频率=2×采样频率×采样位数。在数据传输过程中，I2S总线的发送器和接收器都可以作为系统的主机来提供系统的时钟频率。
② 帧时钟WS，即命令（声道）选择，用于切换左右声道的数据。WS的频率等于采样频率，由系统主机提供。WS为“1”表示传输的是左声道的数据，WS为“0”表示传输的是右声道的数据。
③ 串行数据信号SD，用于传输二进制补码表示的音频数据。

其初始化流程如下：
static void init_i2s()
{
    i2s_mode_t mode = I2S_MODE_MASTER | I2S_MODE_TX;
    i2s_comm_format_t comm_fmt = I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB;
    
    i2s_config_t i2s_config = {
            .mode = mode,          // Only TX
            .sample_rate = 44100,
            .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
            .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,   // 2-channels
            .communication_format = comm_fmt,
            .dma_buf_count = 32,                            // number of buffers, 128 max.
            .dma_buf_len = 64,                          // size of each buffer
            .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1        // Interrupt level 1
    };

    i2s_pin_config_t pin_config = {
            .bck_io_num = GPIO_NUM_26,
            .ws_io_num = GPIO_NUM_25,
            .data_out_num = GPIO_NUM_22,
            .data_in_num = I2S_PIN_NO_CHANGE
    };

    i2s_driver_install(config->i2s_num, &i2s_config, 1, &i2s_event_queue);

    i2s_set_pin(config->i2s_num, &pin_config);

}

2、I2C总线使用

I2C总线是2条双向串行线，一条数据线SDA，一条时钟线SCL。
SDA传输数据是大端传输，每次传输8bit，即一字节。
支持多主控(multimastering)，任何时间点只能有一个主控。
总线上每个设备都有自己的一个addr，共7个bit，广播地址全0.
系统中可能有多个同种芯片，为此addr分为固定部分和可编程部份，细节视芯片而定，看datasheet。

2.1、使用ESP32的API
    ESP32有使用I2C的API，已经封装的非常完善。如果使用的I2C从设备没有特殊要求，则可以直接使用这些API，其示例代码如下：
    
esp_err_t example_i2c_master_read_slave(uint8_t register_addr)
{
    uint8_t data_rd[2] = { 0x00, 0x00    };
     
    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    //i2c_master_write_byte(cmd, ( ESP_SLAVE_ADDR << 1 ) | WRITE_BIT, ACK_CHECK_EN);
    i2c_master_write_byte(cmd,  ESP_SLAVE_ADDR , ACK_CHECK_EN);
    i2c_master_write_byte(cmd, register_addr, ACK_CHECK_EN);
   
    i2c_master_start(cmd);
    //i2c_master_write_byte(cmd, ( ESP_SLAVE_ADDR << 1 ) | READ_BIT, ACK_CHECK_EN);
    i2c_master_write_byte(cmd, ESP_SLAVE_ADDR+1 , ACK_CHECK_EN);
    i2c_master_read_byte(cmd, data_rd, ACK_VAL);
    i2c_master_read_byte(cmd, data_rd + 1, NACK_VAL);
    i2c_master_stop(cmd);
    esp_err_t ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 1000 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);
    if (ret != ESP_OK ) {
        ESP_LOGW(TAG, "example_i2c_master_read_slave error: ret=%d ",ret);
    }
    else {
        ESP_LOGW(TAG, "amplifier_i2c_master_read_slave: register=0x%02x, 0x%02x, 0x%02x ",
            register_addr, data_rd[0], data_rd[1]);
    }

    return ret;
}

esp_err_t example_i2c_master_write_slave(uint8_t register_addr, uint8_t data_h, uint8_t data_l)
{
    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    //ESP_LOGW(TAG, "amplifier_i2c_master_write_slave 1\n");
    //i2c_master_write_byte(cmd, ( ESP_SLAVE_ADDR << 1 ) | WRITE_BIT, ACK_CHECK_EN);
    i2c_master_write_byte(cmd,  ESP_SLAVE_ADDR , ACK_CHECK_EN);
    //ESP_LOGW(TAG, "amplifier_i2c_master_write_slave 2\n");
    i2c_master_write_byte(cmd, register_addr, ACK_CHECK_EN);
    //ESP_LOGW(TAG, "amplifier_i2c_master_write_slave 3\n");
    i2c_master_write_byte(cmd, data_h, ACK_CHECK_EN);
    i2c_master_write_byte(cmd, data_l, ACK_CHECK_EN);
    i2c_master_stop(cmd);
    //ESP_LOGW(TAG, "amplifier_i2c_master_write_slave 4\n");
    esp_err_t ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 1000 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);
    if (ret != ESP_OK)
        ESP_LOGW(TAG, "example_i2c_master_write_slave error: register=0x%02x, ret=%d", register_addr, ret);
    return ret;
}

void example_write_register(uint8_t register_addr, uint8_t data_h, uint8_t data_l)
{
    esp_err_t ret = ESP_OK;
    do {
        ret = amplifier_i2c_master_write_slave(register_addr,data_h,data_l);
    } while (ret != ESP_OK);
}

2.2、GPIO模拟的I2C操作
    很不幸，有时候有些I2C从设备有些特殊要求，比方说我们用的从设备就要求每一个Bit和每个命令都有不同时延限制，而此时ESP32的API就不能满足要求了，只能用GPIO模拟的方式，其示例代码如下：

#define SDA_IN  gpio_set_direction(g_sda_pin,GPIO_MODE_INPUT)
#define SDA_OUT  gpio_set_direction(g_sda_pin,GPIO_MODE_OUTPUT)

#define SDA_H gpio_set_level(g_sda_pin,1)
#define SDA_L gpio_set_level(g_sda_pin,0)

#define SCL_H gpio_set_level(g_scl_pin,1)
#define SCL_L gpio_set_level(g_scl_pin,0)

#define SDAX gpio_get_level(g_sda_pin)
#define SCLX gpio_get_level(g_scl_pin)

void i2c_start(void)
{
    SDA_H;
    DELAY_5_US;
    SCL_H;
    DELAY_5_US;
    SDA_L;
    DELAY_5_US;
}

void i2c_stop(void)
{
    SDA_L;
    DELAY_5_US;
    SCL_H;
    DELAY_5_US;
    SDA_H;
    DELAY_5_US;
}

void waitack(void)
{
    int j;
    uint8_t a;
    SDA_IN;    
    for (j=0; j<1000; j++) {
        a = SDAX;
        if (a == 0)
            break;
    }
    
    if (j >= 1000) {
        //TODO: What's the meaning of waitSta
        //waitSta = 0x0a;
    }
    
    SCL_H;
    DELAY_5_US;
    SCL_L;
    DELAY_5_US;
    SDA_OUT;   
}

void noack(void)
{
    SDA_H;
    DELAY_5_US;
    SCL_H;
    DELAY_5_US;
    SCL_L;
    DELAY_5_US;
    SDA_L;
    DELAY_5_US;
}

void ack(void)
{
    SDA_L;
    DELAY_5_US;
    SCL_H;
    DELAY_5_US;
    SCL_L;
    DELAY_5_US;
    SDA_H;
    DELAY_5_US;
}

void write8bit(uint8_t data)
{
    int i;
    SCL_L;
    DELAY_5_US;

    for (i = 0; i < 8; i++)
    {
        if ((data<<i) & 0x80)
            SDA_H;
        else
            SDA_L;
        DELAY_5_US;

        SCL_H;
        DELAY_5_US;
        
        SCL_L;
        DELAY_5_US;
    }
    SCL_L;
    DELAY_5_US;

    SDA_H;  
    DELAY_5_US;
}

uint8_t read8bit(void)
{
    int temp ;
    uint8_t rbyte = 0x00;

    SDA_IN;    
    for (temp=0; temp<8; temp++) {
        rbyte = rbyte <<1;
        SCL_H;
        DELAY_5_US;
        if (SDAX)
            rbyte = rbyte | 0x01;
        SCL_L;
        DELAY_5_US;
    }
    SDA_OUT;   
    SCL_L;
    SDA_H;
    DELAY_5_US;
    
    return rbyte;
}

void writebyte(uint8_t addr, uint8_t dat)
{
    i2c_start();

    write8bit(I2C_ADDRESS);
    DELAY_50_US;
    waitack();
    DELAY_50_US;
    write8bit(addr);
    DELAY_50_US;
    waitack();
    DELAY_50_US;

    write8bit(dat);
    DELAY_50_US;
    waitack();
    DELAY_50_US;

    i2c_stop();
}

uint8_t readbyte(uint8_t addr)
{
    uint8_t byte;

    i2c_start();

    write8bit(I2C_ADDRESS);
    DELAY_50_US;
    waitack();
    DELAY_50_US;
    write8bit(addr);
    DELAY_50_US;
    waitack();
    DELAY_50_US;

    i2c_start();
    write8bit(I2C_ADDRESS_R);
    DELAY_50_US;
    waitack();
    DELAY_50_US;
    
    byte = read8bit();
    DELAY_50_US;
    noack();
    DELAY_50_US;
    
    i2c_stop();

    return byte;
}

void write_register(uint8_t addr, uint8_t dat)
{
    do {
        writebyte(addr, dat);
        DELAY_50_US;
    }while(dat != readbyte(addr));
}