3. Introducción a I2C del módulo M601

1 Uso de I2C

1.1 Resumen

El módulo admite una interfaz I2C de hardware. Solo puede usar PINNAME_I2C_SCL como SCL y
PINNAME_I2C_SDA como SDA. Si desea usar otros pines, solo puede usar la interfaz analógica I2C. Los
desarrolladores pueden agregarlos en la APLICACIÓN o comunicarse con nuestra empresa para proporcionarlos.
La estructura de datos y la API que se presentan en este artículo pueden hacer referencia al archivo Zyf_I2C.h en el SDK.

1.2 Uso

Los pasos para usar la función I2C son los siguientes:
Paso 1: Inicialice la interfaz I2C. Llame a la función ZYF_I2clnit para inicializar el canal I2C, incluidos los pines GPIO especiales y los números de canal.
Paso 2: Configure la interfaz I2C. Llame a la función ZYF_I2cConfig para configurar los parámetros que necesita el esclavo. Para obtener más información, consulte la descripción de la API.
Paso 3: lee los datos. Llame a la función ZYF_I2cReadBytes para leer datos de un esclavo específico.
Paso 4: envía datos. Llame a la función ZYF_I2cWriteBytes para enviar datos a un esclavo específico.

1.3 funciones API

1.3.1 ZYF_I2cInit I2C inicialización
función prototipo
int32_t ZYF_I2cInit (uint32_t chnnlNo, Enum_PinName pinSCL , Enum_PinName pinSDA, bool I2Ctype)
Parámetros
chnnlNo:
[Entrada] canales I2C
pinSCL:
[Entrada] I2C la SCL pin
pinSDA:
[Entrada] I2C el pin SDA
I2Ctype :
[Entrada] tipo I2C, 0: analógico; 1: hardware;
devuelve el resultado
ZYF_RET_OK, esta función es exitosa.
ZYFIRETERR_NOSUPPORTPIN, el pin de entrada no es válido.
ZYF_RET_ERR_NOSUPPORTMODE, el pin de entrada no tiene modo I2C
ZYF_RET_ERR_PINALREADYSUBCRIBE, este pin se ha utilizado en otras ubicaciones. Por ejemplo, este pin se ha utilizado como EINT o gpio.

1.3.2 ZYF_I2cConfig Configurar I2C

Prototipo de función
int32_t ZYF_I2cConfig (uint32_t chnnlNo, uint32_t chnnlNo, uint8_t slaveAddr, uint32_t speed)

Parámetro
chnnlNo:
[entrada] I2C channel
slaveAddr:
[entrada] dirección de esclavo.
velocidad:
[entrada] velocidad, 100 Kbps ~ 3,5 Mbps
devuelve el resultado
ZYF_RET_OK, esta función es correcta.
ZYFIRETERR_I2C_SAME_SLAVE_ADDRESS, se ha configurado la dirección de esclavo que desea configurar o se ha utilizado la dirección.
ZYF__RET_ERR_NORIGHTOPERATE, el PIN no está en modo I2C o no está inicializado.

1.3.3 ZYF_I2cReadBytes Get y leer datos I2C
función prototipo
int32_t ZYF_I2cReadBytes (uint32_t chnnlNo, uint32_t chnnlNo, uint8_t
RegAddr, uint8_t * pBuffer, uint16_t len)
parámetro
chnnlNo: [entrada de
registro ] I2C dirección de entrada: [Registro de entrada
] Los datos leídos del registro especificado
len: [entrada] Leer longitud de datos. 1 <= len <= 8. El controlador I2C admite hasta 8 bytes por transmisión
Devuelve el resultado
Si no hay ningún error, devuelve la longitud de los datos leídos.
ZYF_RET_ERR_PARAM, error de parámetro.
ZYF__RET_ERR_I2CHWFAILED, tal vez haya un problema de hardware.
ZYF_RET_ERR_NORIGHTOPERATE, el PIN no está en modo I2C o no está inicializado.
ZYF_RET_ERR I2C_SLAVE NOT_FOUND, no se puede encontrar el esclavo especificado.

1.3.4 ZYF_I2cWriteBytes Escribir y escribir datos I2C

Prototipo de la función
int32_t ZYF_I2cWriteBytes (uint32_t chnnlNo, uint32_t
chnnlNo, uint8_t RegAddr, uint8_t * pData, uint16_t len)
Parámetros
chnnlNo: [entrada] canal I2C
RegAddr: [entrada] entrada de datos del Registro
pData: [
len ] registro de escritura ] Longitud de datos. 1 <= len <= 8. El controlador I2C admite hasta 8 bytes por transmisión El
resultado devuelto
es la longitud de los datos escritos si no hay retorno de error. ZYF_RET_ERR_PARAM, error de parámetro. ZYF_RET_ERR_I2CHWFAILED, tal vez haya un problema de hardware. ZYF_RET_ERR_NORIGHTOPERATE, el PIN no está en modo I2C o no está inicializado. ZYF_RET_ERR_I2C_SLAVE_NOT_FOUND, no se encontró el esclavo especificado.

1.3.5 ZYF_I2cUninit libera el
prototipo de función I2C
int32_t ZYF_I2cUninit (uint32_t chnnlNo)
parámetro
chnnlNo: [entrada]
resultado de retorno del canal I2C
ZYF_RET_OK éxito
ZYF_RET_ERR_PINALREADYSUBCRIBE en otro El pin ha sido usado. Por ejemplo, este pin se ha utilizado como EINT o gpio.

2 Introducción a las rutinas I2C

Este capítulo presenta principalmente cómo usar example_i2c.c en el SDK para probar la función I2C por separado.
Método de compilación:. \ Examples \ build \ corresponde al archivo .bat haciendo doble clic para ejecutarlo o abriéndolo para compilar.
Archivo generado:. \ Out \ directorio correspondiente \ hex \ M601_example _ **. Pac

  Utilice ZYF_I2cInit () para inicializar los canales y pines I2C. Utilice ZYF_I2cConfig () para configurar los parámetros relacionados con la tasa. La prueba es la siguiente: Use AT24xx_WriteTest () para escribir datos en la dirección especificada, luego use AT24xx_ReadTest () para leer la dirección especificada y finalmente libere el I2C a través de ZYF_I2cUninit ().

#include <stdint.h>

#include "zyf_trace.h"
#include "zyf_iic.h"
#include "zyf_gpio.h"
#include "zyf_app.h"
#include "zyf_uart.h"
#include "zyf_thread.h"
#include "OLED_I2C.h"


static Uart_Param_t g_uart1param;

void UartWriteCallBack(void* Param) // general com
{
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 
    if(Param == NULL)
    {
        return;
    }    

    ZYF_UartWrite(uartparam->port,(uint8_t *)"UartWrite succeed\r\n",strlen("UartWrite succeed\r\n"));
    ZYF_UartWriteCallbackSwitch(uartparam->port,false);

}

void UartReadCallBack(void* Param) // 
{
    uint32_t recvlen = 0;
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 

    ZYF_LOG("Uart%d recv",uartparam->port);

    while(ZYF_UartRead(uartparam->port, &(uartparam->uartbuf[recvlen]), 1))
    {
        ZYF_LOG("recv :%02x",uartparam->uartbuf[recvlen]);
        recvlen++;
    }
    ZYF_UartWrite(uartparam->port,uartparam->uartbuf,recvlen);
    ZYF_UartWriteCallbackSwitch(uartparam->port,true);
}


static void AppUartInit(void)
{
    int32_t ret;
    g_uart1param.port = DEBUG_PORT;
    ZYF_UartRegister(g_uart1param.port, UartReadCallBack,&g_uart1param);
    ZYF_UartWriteCbRegister(g_uart1param.port,UartWriteCallBack,&g_uart1param);
    ZYF_UartOpen(g_uart1param.port, 115200, ZYF_FC_NONE);

    ZYF_LOG("AppUartInit");
    return;
}

/*
void AT24xx_WriteTest(void)
{
    uint8_t data[8] = {0x3A, 0x4B, 0x1C, 0xD6, 0x7F, 0x5E, 0xD9, 0xA4};
    uint16_t len;

    ZYF_LOG("I2C write test ...");
    len = ZYF_I2cWriteBytes(ZYF_I2C_1, 0, data, 8);
    if (8 == len) {
        ZYF_LOG("I2C write OK !");
    }
}

void AT24xx_ReadTest(void)
{
    uint8_t data[8] = {0};
    uint16_t len;
    
    ZYF_LOG("I2C read test ...");
    len = ZYF_I2cReadBytes(ZYF_I2C_1, 0, data, 8);
    if (8 == len) {
        ZYF_LOG("I2C read OK ! => %02X,%02X,%02X,%02X,%02X,%02X,%02X,%02X", 
                data[0],data[1],data[2],data[3],data[4],data[5],data[6],data[7]);
    }
}

void ZYF_AppI2cTest(void *param)
{
    ZYF_I2cInit(ZYF_I2C_1, PINNAME_I2C_SCL, PINNAME_I2C_SDA, ZYF_I2C_TYPE_HW);
    ZYF_I2cConfig(ZYF_I2C_1, 0xA0 >> 1, ZYF_I2C_BPS_100K);
    AT24xx_WriteTest();
    ZYF_ThreadSleep(500);
    AT24xx_ReadTest();
    ZYF_ThreadSleep(500);
    ZYF_I2cUninit(ZYF_I2C_1);
}
*/
void IICThread_Example(void * Param)
{
    ZYF_MsgQ_t *ptMsg;
    ZYF_AppMsg_t tMsg;
    int iRet = -1;
    ptMsg = ZYF_MsgQCreate(10, sizeof(ZYF_AppMsg_t));
    ZYF_LOG("thread enter!");

//    ZYF_AppI2cinit();
    OLED_Init();
    
    OLED_Test();


}

static void prvInvokeGlobalCtors(void)
{
    extern void (*__init_array_start[])();
    extern void (*__init_array_end[])();

    size_t count = __init_array_end - __init_array_start;
    for (size_t i = 0; i < count; ++i)
        __init_array_start[i]();
}

int appimg_enter(void *param)
{
    AppUartInit();
    ZYF_LOG("application image enter, param 0x%x", param);

    prvInvokeGlobalCtors();

    ZYF_ThreadCreate("IICThread_Example", IICThread_Example, NULL, ZYF_PRIORITY_NORMAL, 4*1024);
    return 0;
}

void appimg_exit(void)
{
    OSI_LOGI(0, "application image exit");
}