七、赛普拉斯EZ-USB FX3 I2C

已于 2023-05-22 15:46:27 修改
阅读量529 收藏 5
点赞数 2
分类专栏： FX3 文章标签： 单片机 嵌入式硬件 c语言 stm32
于 2023-02-08 14:42:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maomaochong666/article/details/128934708
版权

一、简介

          1.1 I2C简介

                I2C(Inter-Integrated Circuit)是一种串行通信总线,由飞利浦公司在1980年代为了让主机连接其它外设而定制的一种低速通信协议，目前广泛应用于手机、电脑、家电等嵌入式设备。

图1.0 典型的I2C总线(挂载多个从设备)

         1.2 电气特性

                I2C使用两根数据总线，一根是数据线（SDA）,一根是时钟线（SCL），采用双向漏极开路，并使用电阻进行上拉，I2C允许比较大的工作电压范围，但一般采用3.3V或者5V。设备地址使用7位长度和10位长度。I2C 传输速率有不同的模式：

                ·标准模式：100Kbit/s

                ·快速模式：400Kbit/s

                ·高速模式：3.4Mbit/s

图1.1 I2C内部结构图

        1.3 I2C 协议层  

                        1.3.1 I2C读写帧格式

 图1.2 I2C写一个字节数据

 图1.3 I2C读一个字节数据

                         1.3.2 I2C起始信号

                                当主机要与从机开始通信时需要发送起始信号，SCL线在高电平时，SDA线由高变为低。一般流程是拉高SCL线与SDA线保持4us，再拉低SDA线保持4us,最后拉低SCL。

图1.4 I2C起始信号

                         1.3.3 I2C停止信号

                                当主机要与从机结束通信时需要发送停止信号，SCL线在高电平时，SDA线由低变为高。一般流程是拉低SCL线和SDA线保持4us，再拉高SCL线和SDA线保持4us。

 图1.5 I2C停止信号

                         1.3.4 I2C应答信号

                                应答信号也相当于一位数据，SCL为高时，数据线拉低，表示为应答。

图1.6 I2C应答信号 

                         1.3.5 I2C非应答信号 

                                非应答信号也相当于一位数据，SCL为高时，数据线拉高，表示为非应答。

 图1.7 I2C非应答信号

                         1.3.6 I2C数据

                                数据的传输格式，高位先发，SCL为高时数据有效，SCL为低时数据变化。

 图1.8 一个字节数据传输示例

二、程序

        I2C设备初始化函数

 extern CyU3PReturnStatus_t
CyU3PI2cInit (
        void);

        I2C配置函数

 extern CyU3PReturnStatus_t
CyU3PI2cSetConfig (
        CyU3PI2cConfig_t *config,       /**< I2C configuration settings */
        CyU3PI2cIntrCb_t cb             /**< Callback for getting the events */
        );

         I2C读数据函数

extern CyU3PReturnStatus_t
CyU3PI2cReceiveBytes (
        CyU3PI2cPreamble_t *preamble,   /**< Preamble information to be sent out before the data transfer. */
        uint8_t *data,                  /**< Pointer to buffer where the data is to be placed. */
        uint32_t byteCount,             /**< Size of the transfer in bytes. */
        uint32_t retryCount             /**< Number of times to retry request in case of a NAK response or error. */
        );

        I2C写数据函数

extern CyU3PReturnStatus_t
CyU3PI2cTransmitBytes (
        CyU3PI2cPreamble_t *preamble,   /**< Preamble information to be sent out before the data transfer. */
        uint8_t *data,                  /**< Pointer to buffer containing data to be written. */
        uint32_t byteCount,             /**< Size of the transfer in bytes. */
        uint32_t retryCount             /**< Number of times to retry request in case of a slave NAK response. */
        );

        I2C源文件

#include "cyfx3_i2c.h"
#include "cyu3error.h"
#include "cyu3gpio.h"
#include "cyu3utils.h"


static CyU3PReturnStatus_t CyFx3GpioConfig(void)
{
	CyU3PReturnStatus_t CyFx3Status = CY_U3P_SUCCESS;

	//GPIO时钟配置（整个工程中只需要初始化一次）
	CyU3PGpioClock_t GpioClkConifg = {
		.fastClkDiv = 2,
		.slowClkDiv = 0,
		.halfDiv = 0,
		.simpleDiv = CY_U3P_GPIO_SIMPLE_DIV_BY_2,
		.clkSrc = CY_U3P_SYS_CLK,
	};
	CyFx3Status = CyU3PGpioInit(&GpioClkConifg,NULL);

#if !I2C_HARDWARE

	//重定向为普通IO
	CyU3PDeviceGpioOverride(I2C_SDA_GPIO_PIN,CyTrue);
	CyU3PDeviceGpioOverride(I2C_SCL_GPIO_PIN,CyTrue);

	//GPIO配置为输出模式，不使能中断
	CyU3PGpioSimpleConfig_t I2cSdaGpioConfig = {
			.outValue = CyTrue,
			.driveLowEn = CyTrue,
			.driveHighEn = CyTrue,
			.inputEn = CyFalse,
			.intrMode = CY_U3P_GPIO_NO_INTR,
	};
	CyFx3Status = CyU3PGpioSetSimpleConfig(I2C_SDA_GPIO_PIN,&I2cSdaGpioConfig);

	CyU3PGpioSimpleConfig_t I2cSclGpioConfig = {
				.outValue = CyTrue,
				.driveLowEn = CyTrue,
				.driveHighEn = CyTrue,
				.inputEn = CyFalse,
				.intrMode = CY_U3P_GPIO_NO_INTR,
		};
	CyFx3Status = CyU3PGpioSetSimpleConfig(I2C_SCL_GPIO_PIN,&I2cSclGpioConfig);

	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		return CyFx3Status;
	}

#endif

	return CyFx3Status;
}


CyU3PReturnStatus_t CyFx3I2cInit(void)
{
	CyU3PReturnStatus_t CyFx3Status;

#if I2C_HARDWARE
	CyFx3Status = CyU3PI2cInit();
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		return CyFx3Status;
	}

	CyU3PI2cConfig_t I2cConfig = {
		.bitRate = I2C_FREQUENCY,
		.isDma = CyFalse,
		.busTimeout = I2C_BUS_TIMEOUT_VALUE,
		.dmaTimeout = I2C_DMA_TIMEOUT_VALUE,
	};
	return CyU3PI2cSetConfig(&I2cConfig,NULL);

#else

	return CyFx3GpioConfig();
#endif
}

#if I2C_HARDWARE

CyU3PReturnStatus_t CyFx3I2cReadBytes(uint8_t  DevAddr,
									  uint16_t RegAddr,
									  uint8_t  *ReadData,
									  uint32_t ReadLen,
									  uint32_t RetryCnt,
									  uint8_t  RegBit)
{
	CyU3PI2cPreamble_t Preanble;

	if(RegBit == I2C_REG_8BIT_ADDR)
	{
		Preanble.buffer[0] = (DevAddr << 1) | I2C_CMD_WRITE;
		Preanble.buffer[1] = (RegAddr & 0xff);
		Preanble.buffer[2] = (DevAddr << 1) | I2C_CMD_READ;
		Preanble.length = 3;
		Preanble.ctrlMask = 0x0002;
	}
	else
	{
		Preanble.buffer[0] = (DevAddr << 1) | I2C_CMD_WRITE;
		Preanble.buffer[1] = (RegAddr >> 8);
		Preanble.buffer[2] = (RegAddr & 0xff);
		Preanble.buffer[3] = (DevAddr << 1) | I2C_CMD_READ;
		Preanble.length = 4;
		Preanble.ctrlMask = 0x0004;
	}

	return CyU3PI2cReceiveBytes(&Preanble,ReadData,ReadLen,RetryCnt);
}

CyU3PReturnStatus_t CyFx3WriteBytes(uint8_t  DevAddr,
									uint16_t RegAddr,
									uint8_t  *WriteData,
									uint32_t WriteLen,
									uint32_t RetryCnt,
									uint8_t  RegBit)
{
	CyU3PI2cPreamble_t Preanble;

	if(RegBit == I2C_REG_8BIT_ADDR)
	{
		Preanble.buffer[0] = (DevAddr << 1) | I2C_CMD_WRITE;
		Preanble.buffer[1] = (RegAddr & 0xff);
		Preanble.length = 2;
		Preanble.ctrlMask = 0x0000;
	}
	else
	{
		Preanble.buffer[0] = (DevAddr << 1) | I2C_CMD_WRITE;
		Preanble.buffer[1] = (RegAddr >> 8);
		Preanble.buffer[2] = (RegAddr & 0xff);
		Preanble.length = 3;
		Preanble.ctrlMask = 0x0000;
	}

	return CyU3PI2cTransmitBytes(&Preanble,WriteData,WriteLen,RetryCnt);
}

#else

CyU3PReturnStatus_t I2cSdaIn(void)
{
	//GPIO配置为输出模式，不使能中断
	CyU3PGpioSimpleConfig_t I2cSdaGpioConfig = {
			.outValue = CyTrue,
			.driveLowEn = CyFalse,
			.driveHighEn = CyFalse,
			.inputEn = CyTrue,
			.intrMode = CY_U3P_GPIO_NO_INTR,
	};
	return CyU3PGpioSetSimpleConfig(I2C_SDA_GPIO_PIN,&I2cSdaGpioConfig);
}


CyU3PReturnStatus_t I2cSdaOut(void)
{
	CyU3PGpioSimpleConfig_t I2cSdaGpioConfig = {
				.outValue = CyTrue,
				.driveLowEn = CyTrue,
				.driveHighEn = CyTrue,
				.inputEn = CyFalse,
				.intrMode = CY_U3P_GPIO_NO_INTR,
		};
	return CyU3PGpioSetSimpleConfig(I2C_SDA_GPIO_PIN,&I2cSdaGpioConfig);
}


static CyU3PReturnStatus_t I2cSetSdaValue(CyBool_t isHigh)
{
	return CyU3PGpioSetValue(I2C_SDA_GPIO_PIN,isHigh);
}

static CyU3PReturnStatus_t I2cSetSclValue(CyBool_t isHigh)
{
	return CyU3PGpioSetValue(I2C_SCL_GPIO_PIN,isHigh);
}

static CyBool_t I2cGetSdaValue(void)
{
	return CyFx3GpioReadBit(I2C_SDA_GPIO_PIN);
}


void I2CStart(void)
{
	I2cSdaOut();
	I2cSetSdaValue(CyTrue);
	I2cSetSclValue(CyTrue);
	CyU3PBusyWait(4);
	I2cSetSdaValue(CyFalse);
	CyU3PBusyWait(4);
	I2cSetSclValue(CyFalse);
}

void I2cStop(void)
{
	I2cSdaOut();
	I2cSetSclValue(CyFalse);
	I2cSetSdaValue(CyFalse);
	CyU3PBusyWait(4);
	I2cSetSclValue(CyTrue);
	I2cSetSdaValue(CyTrue);
	CyU3PBusyWait(4);
}

CyBool_t I2cWaitAck(void)
{
	uint8_t ErrTime = 0;

	I2cSdaIn();
	I2cSetSdaValue(CyTrue);
	CyU3PBusyWait(1);
	I2cSetSclValue(CyTrue);
	CyU3PBusyWait(1);
	while(I2cGetSdaValue() == CyTrue)
	{
		ErrTime++;
		if(ErrTime > 250)
		{
			I2cStop();
			return CyTrue;
		}
	}
	I2cSetSclValue(CyFalse);
	return CyFalse;
}

void I2cAck(void)
{
	I2cSdaOut();
	I2cSetSclValue(CyFalse);
	I2cSetSdaValue(CyFalse);
	CyU3PBusyWait(2);
	I2cSetSclValue(CyTrue);
	CyU3PBusyWait(2);
	I2cSetSclValue(CyFalse);
}

void I2cNAck(void)
{
	I2cSdaOut();
	I2cSetSclValue(CyFalse);
	I2cSetSdaValue(CyTrue);
	CyU3PBusyWait(2);
	I2cSetSclValue(CyTrue);
	CyU3PBusyWait(2);
	I2cSetSclValue(CyFalse);
}

void I2cWriteByte(uint8_t Data)
{
    uint8_t i;

    I2cSdaOut();
    I2cSetSclValue(CyFalse);
    for(i = 0;i < 8;i++)
    {
		if((Data & 0x80) >> 7)
		{
			I2cSetSdaValue(CyTrue);
		}
		else
		{
			I2cSetSdaValue(CyFalse);
		}
		Data <<= 1;
		CyU3PBusyWait(2);
		I2cSetSclValue(CyTrue);
		CyU3PBusyWait(2);
		I2cSetSclValue(CyFalse);
		CyU3PBusyWait(2);
    }
}

uint8_t I2cReadByte(CyBool_t isAck)
{
	uint8_t i;
	uint8_t Data = 0x0;

	I2cSdaIn();

    for(i = 0;i < 8;i++ )
	{
    	I2cSetSclValue(CyFalse);
    	CyU3PBusyWait(2);
		I2cSetSclValue(CyTrue);
		Data <<= 1;
        if(I2cGetSdaValue() == CyTrue)
		{
        	Data++;
		}
        CyU3PBusyWait(1);
    }
    if(isAck)
	{
    	I2cAck();
	}
    else
	{
    	I2cNAck();
	}
    return Data;
}

CyU3PReturnStatus_t CyFx3I2cReadBytes(uint8_t  DevAddr,
									  uint16_t RegAddr,
									  uint8_t  *ReadData,
									  uint32_t ReadLen,
									  uint32_t RetryCnt,
									  uint8_t  RegBit)
{
	uint32_t i = 0;

	I2CStart();
	I2cWriteByte((DevAddr << 1) | I2C_CMD_WRITE);
	I2cWaitAck();
	if(RegBit == I2C_REG_8BIT_ADDR)
	{
		I2cWriteByte(RegAddr);
		I2cWaitAck();
	}
	else
	{
		I2cWriteByte((uint8_t)(RegAddr >> 8));
		I2cWaitAck();
		I2cWriteByte((uint8_t)(RegAddr & 0xFF));
		I2cWaitAck();
	}

	I2CStart();
	I2cWriteByte((DevAddr << 1) | I2C_CMD_READ);
	I2cWaitAck();

	if(ReadLen > 1)
	{
		for(i = 0 ;i < ReadLen - 1;i++)
		{
			ReadData[i] = I2cReadByte(CyTrue);
		}
	}
	ReadData[i] = I2cReadByte(CyFalse);
	I2cStop();

	return CY_U3P_SUCCESS;
}

CyU3PReturnStatus_t CyFx3WriteBytes(uint8_t  DevAddr,
									uint16_t RegAddr,
									uint8_t  *WriteData,
									uint32_t WriteLen,
									uint32_t RetryCnt,
									uint8_t  RegBit)
{
	uint32_t i;

	I2CStart();
	I2cWriteByte((DevAddr << 1) | I2C_CMD_WRITE);
	I2cWaitAck();
	if(RegBit == I2C_REG_8BIT_ADDR)
	{
		I2cWriteByte(RegAddr);
		I2cWaitAck();
	}
	else
	{
		I2cWriteByte((uint8_t)(RegAddr >> 8));
		I2cWaitAck();
		I2cWriteByte((uint8_t)(RegAddr & 0xFF));
		I2cWaitAck();
	}

	for(i = 0 ;i < WriteLen;i++)
	{
		I2cWriteByte(WriteData[i]);
		if(I2cWaitAck())
		{
			I2cStop();
			return CY_U3P_ERROR_TIMEOUT;
		}
		CyU3PBusyWait(2);
	}
	I2cStop();

	return CY_U3P_SUCCESS;
}

#endif

        I2C头文件

#ifndef CYFX3_I2C_H_
#define CYFX3_I2C_H_

#include "cyu3i2c.h"
#include "gpio_regs.h"

#define I2C_BUS_TIMEOUT_VALUE			0xFFFFFFFFU
#define I2C_DMA_TIMEOUT_VALUE			0xFFFFU
#define I2C_FREQUENCY					100000U
#define I2C_REG_8BIT_ADDR				8
#define I2C_REG_16BIT_ADDR				16

#define I2C_CMD_WRITE               	0
#define I2C_CMD_READ                	1

#define I2C_HARDWARE					1			//0软件模拟I2C 1硬件I2C

#if !I2C_HARDWARE

#define CyFx3GpioReadBit(GpioPin)	    ((GPIO->lpp_gpio_simple[GpioPin]& CY_U3P_LPP_GPIO_IN_VALUE) >> 1)
#define CyFx3GpioSetBit(GpioPin)		((*(uvint32_t *)&GPIO->lpp_gpio_simple[GpioPin]) |= CY_U3P_LPP_GPIO_OUT_VALUE)
#define CyFx3GpioResetBit(GpioPin)		((*(uvint32_t *)&GPIO->lpp_gpio_simple[GpioPin]) &= ~CY_U3P_LPP_GPIO_OUT_VALUE)

#define I2C_SDA_GPIO_PIN				59
#define I2C_SCL_GPIO_PIN				58

void I2CStart(void);
void I2cStop(void);
CyBool_t I2cWaitAck(void);
void I2cAck(void);
void I2cNAck(void);
void I2cWriteByte(uint8_t Data);
uint8_t I2cReadByte(CyBool_t isAck);

#endif


CyU3PReturnStatus_t CyFx3I2cInit(void);

CyU3PReturnStatus_t CyFx3I2cReadBytes(uint8_t  DevAddr,
									  uint16_t RegAddr,
									  uint8_t  *ReadData,
									  uint32_t ReadLen,
									  uint32_t RetryCnt,
									  uint8_t  RegBit);

CyU3PReturnStatus_t CyFx3WriteBytes(uint8_t  DevAddr,
									uint16_t RegAddr,
									uint8_t  *WriteData,
									uint32_t WriteLen,
									uint32_t RetryCnt,
									uint8_t  RegBit);
#endif /* CYFX3_I2C_H_ */

         M24M02源文件

#include "m24m02.h"
#include "cyu3error.h"

CyU3PReturnStatus_t M24M02WriteBytes(uint16_t WriteAddr,uint8_t *WriteData,uint32_t WriteByteNum)
{
	 return CyFx3WriteBytes(M24M02_ADDRESS,
							WriteAddr,
							WriteData,
							WriteByteNum,
							2,
							I2C_REG_16BIT_ADDR);
}

CyU3PReturnStatus_t M24M02ReadBytes(uint16_t ReadAddr,uint8_t *ReadData,uint32_t ReadByteNum)
{
	return CyFx3I2cReadBytes(M24M02_ADDRESS,
							 ReadAddr,
							 ReadData,
							 ReadByteNum,
							 2,
							 I2C_REG_16BIT_ADDR);
}

        M24M02头文件

#ifndef M24M02_H_
#define M24M02_H_

#include "cyfx3_i2c.h"

#define M24M02_ADDRESS               0x50

CyU3PReturnStatus_t M24M02WriteBytes(uint16_t WriteAddr,uint8_t *WriteData,uint32_t WriteByteNum);
CyU3PReturnStatus_t M24M02ReadBytes(uint16_t ReadAddr,uint8_t *ReadData,uint32_t ReadByteNum);

#endif /* M24M02_H_ */

        主函数

#include "cyu3os.h"
#include "cyu3error.h"
#include "cyu3uart.h"
#include "cyfx3_i2c.h"
#include "m24m02.h"

CyU3PThread I2cThreadHandler;

#define I2C_THREAD_PRIORITY			8
#define I2C_THREAD_STACK_SIZE		512


static CyU3PReturnStatus_t CyFx3LogInit(void)
{
	CyU3PReturnStatus_t CyFx3Status;

	//初始化串口设备
	CyFx3Status = CyU3PUartInit();

	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		return CyFx3Status;
	}

	//配置uart
	CyU3PUartConfig_t  UartConfig = {
		.txEnable = CyTrue,
		.rxEnable = CyFalse,
		.flowCtrl = CyFalse,
		.isDma    = CyTrue,
		.baudRate = 115200,
		.stopBit = CY_U3P_UART_ONE_STOP_BIT,
		.parity = CY_U3P_UART_NO_PARITY,
	};
	CyFx3Status = CyU3PUartSetConfig(&UartConfig,NULL);
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		return CyFx3Status;
	}

	//设置发送字节大小
	CyFx3Status = CyU3PUartTxSetBlockXfer(0xFFFFFFFF);
	if (CyFx3Status != CY_U3P_SUCCESS)
	{
		return CyFx3Status;
	}

	//不输出8字节前导数据
	CyU3PDebugPreamble(CyFalse);

	//初始化串口日志功能
	CyFx3Status = CyU3PDebugInit(CY_U3P_LPP_SOCKET_UART_CONS,8);
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		return CyFx3Status;
	}

	return CY_U3P_SUCCESS;
}

void I2cThread(uint32_t arg)
{
	CyU3PReturnStatus_t CyFx3Status;
	uint8_t WriteData[] = "m24m02 i2c read write test!!!";
	uint8_t ReadData[50] = {0};

	CyFx3I2cInit();
	CyFx3LogInit();

	CyFx3Status = M24M02WriteBytes(0x00,WriteData,sizeof(WriteData));
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		CyU3PDebugPrint(6,"Write Error\r\n");
	}

	CyU3PThreadSleep(50);

	CyFx3Status = M24M02ReadBytes(0x00,ReadData,sizeof(WriteData));
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		CyU3PDebugPrint(6,"Read Error\r\n");
	}

	CyU3PDebugPrint(6,"result：%s\r\n",ReadData);


	while(1)
	{

		CyU3PThreadSleep(1000);
	}
}


void CyFxApplicationDefine(void)
{

	void *I2cStackStart = CyU3PMemAlloc(I2C_THREAD_STACK_SIZE);
	if(I2cStackStart != NULL)
	{
		CyU3PThreadCreate((CyU3PThread*		 ) &I2cThreadHandler,
						  (char*			 ) "21:I2c Thread 1",
						  (CyU3PThreadEntry_t) I2cThread,
						  (uint32_t          ) 0,
						  (void*			 ) I2cStackStart,
						  (uint32_t          ) I2C_THREAD_STACK_SIZE,
						  (uint32_t          ) I2C_THREAD_PRIORITY,
						  (uint32_t          ) I2C_THREAD_PRIORITY,
						  (uint32_t          ) CYU3P_NO_TIME_SLICE,
						  (uint32_t          ) CYU3P_AUTO_START);
	}
}



int main(void)
{
	CyU3PReturnStatus_t CyFx3Status;

	//初始化FX3设备
	CyFx3Status = CyU3PDeviceInit(NULL);
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		goto HandleFatalError;
	}

	//初始化FX3内核缓存
	CyFx3Status = CyU3PDeviceCacheControl(CyTrue,CyTrue,CyTrue);
	if(CyFx3Status != CY_U3P_SUCCESS)
	{
		goto HandleFatalError;
	}

	//配置IO矩阵(16位数据总线 + UART + GPIO)
	CyU3PIoMatrixConfig_t MatrixcConfig = {
		.isDQ32Bit = CyFalse,
		.s0Mode = CY_U3P_SPORT_INACTIVE,
		.s1Mode = CY_U3P_SPORT_INACTIVE,
		.useUart   = CyTrue,
#if I2C_HARDWARE
		.useI2C    = CyTrue,
		.gpioComplexEn[0] = 0,
#else
		.useI2C    = CyFalse,
#endif
		.useI2S    = CyFalse,
		.useSpi    = CyFalse,
		.lppMode   = CY_U3P_IO_MATRIX_LPP_UART_ONLY,
		.gpioSimpleEn[0]  = 0,
		.gpioSimpleEn[1]  = 0,
		.gpioComplexEn[0] = 0,
		.gpioComplexEn[1] = 0,
	};
	CyFx3Status = CyU3PDeviceConfigureIOMatrix(&MatrixcConfig);
    if (CyFx3Status != CY_U3P_SUCCESS)
    {
        goto HandleFatalError;
    }

    //初始化RTOS内核
	CyU3PKernelEntry();

HandleFatalError:
	//复位
	CyU3PDeviceReset(CyTrue);
}

三、验证

        验证I2C读写开发板上的M24M02芯片，芯片地址为A0

李法师_
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
EZ-USB-FX3的GPIF-II接口时序设计.pdf
08-29
EZ-USB-FX3的GPIF-II接口时序设计
一、赛普拉斯EZ-USB FX3开发环境安装
李法师的博客
11-02 2670
CYUSB3014 FX3 开发环境安装
FX3学习笔记3-i2c
错过以后 终究是路人
12-30 6504
1、实验环境硬件平台：CYUSB3KIT-003 EZ-USB® FX3™ SuperSpeed Explorer Kitsdk版本：EZ-USB FX3 SDK1.3 / SuperSpeed Explorer Kit 1.0实验例程：cyfxuvc_an75779（cypress官网下载demo）i2c设备：lsm6ds32、实验目的测试CYUSB3KIT-003的i2c接口，本例采用st的一颗
八、赛普拉斯EZ-USB FX3 SPI
李法师的博客
02-21 376
赛普拉斯EZ-USB FX3 SPI
六、赛普拉斯EZ-USB FX3 UART
李法师的博客
02-07 641
赛普拉斯EZ-USB FX3 UART通信实验
FX3/CX3 模拟i2c
混沌的博客
10-10 700
void delay(uint32_t t) { while(--t);//CyU3PBusyWait (t); }CyU3PReturnStatus_t IIC_Set_SDA(CyBool_t isHigh) { CyU3PReturnStatus_t status; status = CyU3PGpioSetValue (FX3_I2C_SDA, isHigh);
赛普拉斯 Cypress EZ-USB FX2 系列微控制器 的芯片支持包_C语言_代码_相关文件_下载
07-07
libfx2是 Cypress EZ-USB FX2 系列微控制器的芯片支持包。 有关详细信息，请参阅完整的文档。 更多详情、使用方法，请下载后阅读README.md文件
赛普拉斯EZ-Color控制器实现高亮度LED智能照明设计革...
12-03
基于赛普拉斯的全新EZ-Color系列HB LED控制器的产品开发，可由嵌入式可视化设计工具PSoC Express软件配合支持。设计师们只需要输入选定的LED并选择好颜色，独特的EZ-Color架构和PSoC Express软件组合就可以提供完整...
通信与网络中的PnPNetwork采用赛普拉斯的EZ-USB FX2LP USB控制器验证T-DMB基带解码器
11-28
赛普拉斯半导体公司 (Cypress Semiconductor Corp.)宣布PnPNetwork技术公司选择了Cypress的EZ-USB? FX2LP控制器，以在其开发平台上验证其PN3030 T-DMB（地面数字多媒体广播）基带解码器的质量。PnPNetwork技术公司是...
Cypress - 赛普拉斯全新EZ-PD CCG3控制器简化USB Type-C主机、配件以及电源适配器设计
10-16
市场领先的USB创新者赛普拉斯半导体公司（NASDAQ：CY）今日宣布推出一款全新USB Type-C控制器，具备电力传输（PD）功能，从而简化了dongle、电源适配器和充电宝等USB Type-C附件的设计。全新EZ-PD? CCG3控制器提供...
fxload-win32:赛普拉斯EZ-USB系列的编程工具fxload的Wi​​n32 + libusb-1.0 API端口
05-24
fxload-win32 fxload的Wi​​n32 + libusb-1.0 API端口，这是赛普拉斯EZ-USB系列的编程工具。
EZ-USB-FX3 slavefifo调试
YDY5659150的专栏
08-18 2059
最近使用fx3-usb-3.0调试slave fifo的传输，期间遇到许多难以理解的问题。在这里分享给大家，希望可以少走一些弯路，我自己是这样走过来的。 1,首先去官网下载原始的参考设计，并安装所提供的SDK软件：FX3SDKSetup_1.3.4.exe 2,接着把参考设计文档AN65974阅读一遍，分别创建新的SDK工程和FPGA工程。如果使用的原厂的开发板，那么可以按照文档提示，可以很顺畅的跑完整过测试。否则需要匹配自己的硬件，做针对性的更改和移植，而我走的是后一条路，于是开始了漫长的调试之路。.
FX3/CX3 I2C error
混沌的博客
09-27 711
status = CyU3PI2cReceiveBytes(&preamble, buf, count, 0); if(status == CY_U3P_ERROR_FAILURE){ CyU3PI2cGetErrorCode(&err);//CY_U3P_I2C_ERROR_NAK_BYTE_0 }单步调试发现CyU3PI2cReceiveB
Ez-USB FX3开发板的使用
码农17年的博客
11-04 3484
SuerSpeed Explorer Kit为支持FX3开发的一个开发板，它提供了便于访问FX3的便捷接口，如GPIF II, I2C, SPI, UART, I2S，80引脚的GPIF II方便对接对其他单板，如FPGAs、cpld、图像传感器或微控制器等。 通过跳线帽可以实现1、供电方式的选择，2、供电电压的选择，3、I2C EEPROM、RAM、USB来引导启动的选择 配套工具有1、Cypress EZ USB Suite， ...
从0开始创建FX3工程之四 - I2C
混沌的博客
07-05 1333
添加i2c功能 1. 启动i2c功能#ifdef MY_I2C io_cfg.useI2C = CyTrue; #else io_cfg.useI2C = CyFalse; #endif 初始化i2c模块 #ifdef MY_I2C CyU3PReturnStatus_t My_I2c_Init (void) { CyU3PI2cConfig_t i2cConf
CYPRESS usb开发相关
爱她就要努力
09-20 1708
https://blog.csdn.net/a379039233/article/details/74390152 从0开始创建FX3工程之三 - GPIO https://blog.csdn.net/a379039233/article/details/74421908 从0开始创建FX3工程之四 - I2C https://blog.csdn.net/a379039233/article/de...
Cypress(赛普拉斯)电容式感应(CapSense)触摸按键应用笔记（工程配置+功能调校+IIC通讯）
qq_43568457的博客
10-05 5231
文章目录前言一、 CapSense技术1.基本原理2.感应方式（1）自电容感应(CSD)（2）互电容感应(CSX)3.信噪比4.CapSense Widget5.防水特性二、CapSense CSD 感应方式1.引入库2.读入数据总结 前言 电容式触摸感应技术（CapSense）正逐步进入移动电话、个人电脑、消费类电子产品、汽车和白色家电等产品的工业设计里。与传统的机械按键相比，CapSense具有更加可靠易用的功能。同时赛普拉斯（Cypress）提供了一系列完整的解决方案，能够快速上手，使用灵活，大幅.
二、赛普拉斯EZ-USB FX3示例烧录验证
李法师的博客
12-22 1789
FX3示例烧录
三、斯普拉斯EZ-USB FX3 GPIO点灯
李法师的博客
02-02 638
斯普拉斯EZ-USB FX3 GPIO点灯
赛普拉斯cy7c6803a-x
最新发布
01-14
CY7C6803A-X具有端口灵活性，能够以多种不同的配置方式工作，包括串行外设接口（SPI）、I2C和GPIO等。这使得它可以轻松地集成到各种不同的应用中，如工业控制、汽车电子和智能家居等领域。 此外，CY7C6803A-X还拥有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值