NCA9555驱动

最新推荐文章于 2024-06-24 08:51:05 发布
最新推荐文章于 2024-06-24 08:51:05 发布
阅读量672 收藏 3
点赞数
文章标签： 单片机 stm32 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42822630/article/details/131094366
版权

NCA9555驱动
nca9555.c


#define MCP23017_I2C_ADDR_WR					0x48

/*Command byte*/
#define  REGISTER_0_INPUT_PORT					0X00
#define  REGISTER_1_INPUT_PORT					0X01
#define  REGISTER_0_OUTPUT_PORT					0X02
#define  REGISTER_1_OUTPUT_PORT					0X03
#define  REGISTER_0_POLARITY_INVERSION_PORT		0X04
#define  REGISTER_1_POLARITY_INVERSION_PORT		0X05
#define  REGISTER_0_CONFIGURATION_PORT			0X06
#define  REGISTER_1_CONFIGURATION_PORT			0X07


static unsigned int timeCount = 0;
static unsigned char setBuff[4]={0x00,0x00,0xff,0xff};



unsigned char NCA9555_Write_Data(unsigned char address,unsigned char command,unsigned short int length,unsigned char *data)
{
	unsigned  char ret = 0;
	unsigned  char i_temp = 0;

	I2cStart(I2C_TYPE_1);
    I2cSendByte(I2C_TYPE_1,address);
    I2cWaitAck(I2C_TYPE_1);
    I2cSendByte(I2C_TYPE_1,command);
    
    I2cWaitAck(I2C_TYPE_1);
	for(i_temp=0;i_temp<(length);i_temp++)
	{
        I2cSendByte(I2C_TYPE_1,data[i_temp]);
        
        I2cWaitAck(I2C_TYPE_1);
	}
	I2cStop(I2C_TYPE_1);

	return(0);
}

void NCA9555_Read_Data(unsigned  char address,unsigned  char command,unsigned  short int length,unsigned  char *data)
{
	unsigned  char ret = 0;
	unsigned  char i_temp = 0;
	unsigned  char DataTemp = 0;

	I2cStart(I2C_TYPE_1);

    I2cSendByte(I2C_TYPE_1,address);
        I2cWaitAck(I2C_TYPE_1);
    I2cSendByte(I2C_TYPE_1,command);
    
        I2cWaitAck(I2C_TYPE_1);

	I2cStart(I2C_TYPE_1);
    I2cSendByte(I2C_TYPE_1,(unsigned  char)(address|0x01));
	
    I2cWaitAck(I2C_TYPE_1);
	for(i_temp=0;i_temp<(length-1);i_temp++)
	{
		DataTemp = I2cReadByte(I2C_TYPE_1,ACK);
		*data++ = DataTemp;
	}
	DataTemp = I2cReadByte(I2C_TYPE_1,NOACK);;
	*data = DataTemp;

	I2cStop(I2C_TYPE_1);
}
void NCA9555_int( void )
{
                		//设置所有pin
    NCA9555_Write_Data(MCP23017_I2C_ADDR_WR,REGISTER_0_CONFIGURATION_PORT,2,&setBuff[0]);
	NCA9555_Write_Data(MCP23017_I2C_ADDR_WR,REGISTER_0_OUTPUT_PORT,2,&setBuff[2]); 
    
}
/*
按位写输出GPIO寄存器
led：GPIO0-GPIO15
state：0输出低电平，1输出高电平。
*/
void NCA9555_writer_bit( int led ,int state)
{
    if(led>=16)
        return;
     unsigned char readData[2] = {0};
     NCA9555_Read_Data(MCP23017_I2C_ADDR_WR,REGISTER_0_OUTPUT_PORT,2,readData);
     if(state)
     {
         if(led>=8)
         {
             readData[0]= readData[0] ;
             readData[1]= readData[1] | (char)(1<<(led-8));
         }else{
             readData[0]= readData[0] | (char)(1<<(led));
             readData[1]= readData[1];
         }
     }else
     {
         if(led>=8)
         {
             readData[0]= readData[0] ;
             readData[1]= readData[1] & ~(char)(1<<(led-8));
         }else{
             readData[0]= readData[0] & ~(char)(1<<(led));
             readData[1]= readData[1];
         }
     }
	 NCA9555_Write_Data(MCP23017_I2C_ADDR_WR,REGISTER_0_OUTPUT_PORT,2,&readData[0]);
}

//流水灯
void NCA9555_Task( void )
{
    
	timeCount++;
	if(timeCount == 10000)//10000次才接近1s
    {
        NCA9555_writer_bit(2,0);
	}
    	else if(timeCount == 20000)
	{     
        
        NCA9555_writer_bit(2,1);
        NCA9555_writer_bit(1,0);

	}
    	else if(timeCount == 30000)
	{  
        
        NCA9555_writer_bit(1,1);
        NCA9555_writer_bit(0,0);

	}
    	else if(timeCount == 40000)
	{   
        
        NCA9555_writer_bit(0,1);
        NCA9555_writer_bit(15,0);

	}
    	else if(timeCount == 50000)
	{ 
        
        NCA9555_writer_bit(15,1);
        NCA9555_writer_bit(14,0);

	}
    	else if(timeCount == 60000)
	{   
        
        NCA9555_writer_bit(14,1);
        NCA9555_writer_bit(13,0);

	}
    	else if(timeCount == 70000)
	{    
        
        NCA9555_writer_bit(13,1);
        NCA9555_writer_bit(9,0);

	}
        else if(timeCount == 80000)
	{    
        
        NCA9555_writer_bit(9,1);
        NCA9555_writer_bit(8,0);

	}
    	else if(timeCount == 90000)
	{   
        
        NCA9555_writer_bit(8,1);
        NCA9555_writer_bit(5,0);

	}
    	else if(timeCount == 100000)
	{    
        
        NCA9555_writer_bit(5,1);
        NCA9555_writer_bit(4,0);

	}
    	else if(timeCount == 110000)
	{   
        
        NCA9555_writer_bit(4,1);
        NCA9555_writer_bit(3,0);

	}   else if(timeCount == 120000)
	{
		timeCount = 0;     
        
        NCA9555_writer_bit(3,1);

	}
    
}

I2c.c



#define  I2C1_ENABLE

INT8U GLOBLE_START = 0; 

/* IO方向设置 */
#if (defined(I2C1_ENABLE) || defined(I2C2_ENABLE) || defined(I2C3_ENABLE) || defined(I2C4_ENABLE))

/* 输入模式 - 浮空输入 */
#define GPIO_DIR_SET_INPUT(GPIOx, GPIO_Pin_Num)  {                                                                 \
													 GPIO_CTL(GPIOx) &= ~GPIO_MODE_MASK(GPIO_Pin_Num);             \
												 }

/* 输出模式 - 开漏输出 */
#define GPIO_DIR_SET_PPOUT(GPIOx, GPIO_Pin_Num)  {                                                                 \
													 GPIO_CTL(GPIOx) &= ~GPIO_MODE_MASK(GPIO_Pin_Num);             \
													 GPIO_CTL(GPIOx) |=  GPIO_MODE_SET(GPIO_Pin_Num,0x01);         \
													 GPIO_OMODE(GPIOx) |= BIT(GPIO_Pin_Num);					   \
												 }

#endif

#if defined(I2C1_ENABLE)
/* I2C1时钟线 */
#define I2C1_SCL_H     gpio_bit_set(GPIOC, GPIO_PIN_5)
#define I2C1_SCL_L     gpio_bit_reset(GPIOC, GPIO_PIN_5)
/* I2C1数据线 */
#define I2C1_SDA_H     gpio_bit_set(GPIOC, GPIO_PIN_4)
#define I2C1_SDA_L     gpio_bit_reset(GPIOC, GPIO_PIN_4)
#define I2C1_READ      gpio_input_bit_get (GPIOC, GPIO_PIN_4)
#define I2C1_SDA_IN    GPIO_DIR_SET_INPUT(GPIOC, 4)
#define I2C1_SDA_OUT   GPIO_DIR_SET_PPOUT(GPIOC, 4)
#endif


void I2cInit(E_I2C_TYPE type)
{
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            rcu_periph_clock_enable(RCU_GPIOC);
            
			/* 配置 IIC_SCL --> PA4 引脚为开漏输出 */ 
			gpio_mode_set(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_4);
			gpio_output_options_set(GPIOC, GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN_4);
			/* 配置 IIC_SDA --> PA5 引脚为开漏输出 */ 
			gpio_mode_set(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_5);
			gpio_output_options_set(GPIOC, GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN_5);
            
            /* 拉高通信线 */
            I2C1_SCL_H;
            I2C1_SDA_H;
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            rcu_periph_clock_enable(RCU_GPIOB);
            
			/* 配置 IIC_SCL --> PB8 引脚为开漏输出 */ 
			gpio_init(GPIOB, GPIO_MODE_OUT_OD, GPIO_OSPEED_2MHZ, GPIO_PIN_8);
			/* 配置 IIC_SDA --> PB9 引脚为开漏输出 */ 
			gpio_init(GPIOB, GPIO_MODE_OUT_OD, GPIO_OSPEED_2MHZ, GPIO_PIN_9);
            
            /* 拉高通信线 */
            I2C2_SCL_H;
            I2C2_SDA_H;
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            rcu_periph_clock_enable(RCU_GPIOA);
            rcu_periph_clock_enable(RCU_GPIOC);
                   
            /* 拉高通信线 */
            I2C3_SCL_H;
            I2C3_SDA_H;
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            rcu_periph_clock_enable(RCU_GPIOD);
            
			/* 配置 IIC_SCL --> PD12 引脚为开漏输出 */ 
			gpio_init(GPIOD, GPIO_MODE_OUT_OD, GPIO_OSPEED_2MHZ, GPIO_PIN_12);
			/* 配置 IIC_SDA --> PD13 引脚为开漏输出 */ 
			gpio_init(GPIOD, GPIO_MODE_OUT_OD, GPIO_OSPEED_2MHZ, GPIO_PIN_13);
            
            /* 拉高通信线 */
            I2C4_SCL_H;
            I2C4_SDA_H;
            break;
        #endif
        
        default:
            break;
        
    }
    
}


void I2cStart(E_I2C_TYPE type)
{
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            I2C1_SDA_OUT;/* SDA设置为输出 */
            I2C1_SCL_H;
            I2C1_SDA_H;
            DelayUs(4);
            I2C1_SDA_L; /* 起始信号：SDA由高变低，SCL为高 */
            DelayUs(4);
            I2C1_SCL_L; /* 拉低SCL，准备发送或接收数据 */
		
			GLOBLE_START = 1;
		
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SDA_OUT;/* SDA设置为输出 */
            I2C2_SCL_H;
            I2C2_SDA_H;
            DelayUs(4);
            I2C2_SDA_L; /* 起始信号：SDA由高变低，SCL为高 */
            DelayUs(4);
            I2C2_SCL_L; /* 拉低SCL，准备发送或接收数据 */
		
			I2C2_SDA_IN;//ADD!!!!!!!!!!!
		
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SDA_OUT;/* SDA设置为输出 */
            I2C3_SCL_H;
            I2C3_SDA_H;
            DelayUs(4);
            I2C3_SDA_L; /* 起始信号：SDA由高变低，SCL为高 */
            DelayUs(4);
            I2C3_SCL_L; /* 拉低SCL，准备发送或接收数据 */
		
			I2C3_SDA_IN;//ADD!!!!!!!!!!!
		
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SDA_OUT;/* SDA设置为输出 */
            I2C4_SCL_H;
            I2C4_SDA_H;
            DelayUs(4);
            I2C4_SDA_L; /* 起始信号：SDA由高变低，SCL为高 */
            DelayUs(4);
            I2C4_SCL_L; /* 拉低SCL，准备发送或接收数据 */
		
			I2C4_SDA_IN;//ADD!!!!!!!!!!!
		
            break;
        #endif
        
        default:
            break;
        
    }
    
}


void I2cStop(E_I2C_TYPE type)
{
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            I2C1_SDA_OUT;/* SDA设置为输出 */
            I2C1_SDA_L;
			I2C1_SCL_H;        
            DelayUs(4);
            I2C1_SDA_H;  /* 结束信号：SDA由低变高，SCL为高 */
            DelayUs(4);
            I2C1_SCL_H;  /* 拉高SCL，不接收数据 */
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SDA_OUT;/* SDA设置为输出 */
            I2C2_SDA_L;
			I2C2_SCL_H;        
            DelayUs(4);
            I2C2_SDA_H;  /* 结束信号：SDA由低变高，SCL为高 */
            DelayUs(4);
            I2C2_SCL_H;  /* 拉高SCL，不接收数据 */
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SDA_OUT;/* SDA设置为输出 */
            I2C3_SDA_L;
            I2C3_SCL_H;
            DelayUs(4);
            I2C3_SDA_H;  /* 结束信号：SDA由低变高，SCL为高 */
            DelayUs(4);
            I2C3_SCL_H;  /* 拉高SCL，不接收数据 */
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SDA_OUT;/* SDA设置为输出 */
            I2C4_SDA_L;
			I2C4_SCL_H;        
            DelayUs(4);
            I2C4_SDA_H;  /* 结束信号：SDA由低变高，SCL为高 */
            DelayUs(4);
            I2C4_SCL_H;  /* 拉高SCL，不接收数据 */
            break;
        #endif
        
        default:
            break;
        
    }
}


INT8U I2cWaitAck(E_I2C_TYPE type)
{
    INT8U err_time = 0;
    
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            I2C1_SDA_IN;/* SDA设置为输入 */
            I2C1_SDA_H;
            DelayUs(1);
            I2C1_SCL_H;
            DelayUs(1);
            while(I2C1_READ)
            {
                err_time++;
                if(err_time > 250)
                {
                    I2cStop(I2C_TYPE_1);
                    return 1;
                }
            }
            I2C1_SCL_L;/* 拉低时钟线 */
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SDA_IN;/* SDA设置为输入 */
            I2C2_SDA_H;
            DelayUs(1);
            I2C2_SCL_H;
            DelayUs(1);
            while(I2C2_READ)
            {
                err_time++;
                if(err_time > 250)
                {
                    I2cStop(I2C_TYPE_2);
                    return 1;
                }
            }
            I2C2_SCL_L;/* 拉低时钟线 */
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SDA_IN;/* SDA设置为输入 */
            I2C3_SDA_H;
            DelayUs(1);
            I2C3_SCL_H;
            DelayUs(1);
            while(I2C3_READ)
            {
                err_time++;
                if(err_time > 250)
                {
                    I2cStop(I2C_TYPE_3);
                    return 1;
                }
            }
            I2C3_SCL_L;/* 拉低时钟线 */
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SDA_IN;/* SDA设置为输入 */
            I2C4_SDA_H;
            DelayUs(1);
            I2C4_SCL_H;
            DelayUs(1);
            while(I2C4_READ)
            {
                err_time++;
                if(err_time > 250)
                {
                    I2cStop(I2C_TYPE_4);
                    return 1;
                }
            }
            I2C4_SCL_L;/* 拉低时钟线 */
            break;
        #endif
        
        default:
            break;
        
    }
    
    return 0;
    
}

static void I2cAck(E_I2C_TYPE type)
{
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            I2C1_SCL_L;
            I2C1_SDA_OUT;/* SDA设置为输出 */
            I2C1_SDA_L;
            DelayUs(2);
            I2C1_SCL_H;
            DelayUs(2);
            I2C1_SCL_L;
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SCL_L;
            I2C2_SDA_OUT;/* SDA设置为输出 */
            I2C2_SDA_L;
            DelayUs(2);
            I2C2_SCL_H;
            DelayUs(2);
            I2C2_SCL_L;
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SCL_L;
            I2C3_SDA_OUT;/* SDA设置为输出 */
            I2C3_SDA_L;
            DelayUs(2);
            I2C3_SCL_H;
            DelayUs(2);
            I2C3_SCL_L;
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SCL_L;
            I2C4_SDA_OUT;/* SDA设置为输出 */
            I2C4_SDA_L;
            DelayUs(2);
            I2C4_SCL_H;
            DelayUs(2);
            I2C4_SCL_L;
            break;
        #endif
        
        default:
            break;
        
    }
}

static void I2cNotAck(E_I2C_TYPE type)
{
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            I2C1_SCL_L;
            I2C1_SDA_OUT;/* SDA设置为输出 */
            I2C1_SDA_H;
            DelayUs(2);
            I2C1_SCL_H;
            DelayUs(2);
            I2C1_SCL_L;
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SCL_L;
            I2C2_SDA_OUT;/* SDA设置为输出 */
            I2C2_SDA_H;
            DelayUs(2);
            I2C2_SCL_H;
            DelayUs(2);
            I2C2_SCL_L;
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SCL_L;
            I2C3_SDA_OUT;/* SDA设置为输出 */
            I2C3_SDA_H;
            DelayUs(2);
            I2C3_SCL_H;
            DelayUs(2);
            I2C3_SCL_L;
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SCL_L;
            I2C4_SDA_OUT;/* SDA设置为输出 */
            I2C4_SDA_H;
            DelayUs(2);
            I2C4_SCL_H;
            DelayUs(2);
            I2C4_SCL_L;
            break;
        #endif
        
        default:
            break;
        
    }
}


void I2cSendByte(E_I2C_TYPE type, INT8U txd)
{
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
//            I2C1_SDA_OUT;/* SDA设置为输出 */
		
		if(GLOBLE_START == 0)   //qiang  为了阻止start信号后产生尖刺
        {
           I2C1_SDA_OUT;/* SDA设置为输出 */
        }
        else
        {
         GLOBLE_START = 0;
        }
		
            I2C1_SCL_L;/* 拉低时钟开始数据传输 */
            for(INT8U i = 0; i < 8; i++)
            {
                if((txd & 0x80) >> 7)
                {
                    I2C1_SDA_H;
                }
                else
                {
                    I2C1_SDA_L;
                }
                
                txd <<= 1;
                DelayUs(2);
                I2C1_SCL_H;
                DelayUs(2);
                I2C1_SCL_L;
                DelayUs(2);
            }
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SDA_OUT;/* SDA设置为输出 */
            I2C2_SCL_L;/* 拉低时钟开始数据传输 */
            for(INT8U i = 0; i < 8; i++)
            {
                if((txd & 0x80) >> 7)
                {
                    I2C2_SDA_H;
                }
                else
                {
                    I2C2_SDA_L;
                }
                
                txd <<= 1;
                DelayUs(2);
                I2C2_SCL_H;
                DelayUs(2);
                I2C2_SCL_L;
                DelayUs(2);
            }
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SDA_OUT;/* SDA设置为输出 */
            I2C3_SCL_L;/* 拉低时钟开始数据传输 */
            for(INT8U i = 0; i < 8; i++)
            {
                if((txd & 0x80) >> 7)
                {
                    I2C3_SDA_H;
                }
                else
                {
                    I2C3_SDA_L;
                }
                
                txd <<= 1;
                DelayUs(2);
                I2C3_SCL_H;
                DelayUs(2);
                I2C3_SCL_L;
                DelayUs(2);
            }
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SDA_OUT;/* SDA设置为输出 */
            I2C4_SCL_L;/* 拉低时钟开始数据传输 */
            for(INT8U i = 0; i < 8; i++)
            {
                if((txd & 0x80) >> 7)
                {
                    I2C4_SDA_H;
                }
                else
                {
                    I2C4_SDA_L;
                }
                
                txd <<= 1;
                DelayUs(2);
                I2C4_SCL_H;
                DelayUs(2);
                I2C4_SCL_L;
                DelayUs(2);
            }
            break;
        #endif
        
        default:
            break;
        
    }
}


INT8U I2cReadByte(E_I2C_TYPE type, INT8U ack)
{
    INT8U receive = 0;
    
    switch(type)
    {
        #if defined(I2C1_ENABLE)
        case I2C_TYPE_1:
            I2C1_SDA_IN;/* SDA设置为输入 */
            for(INT8U i = 0; i < 8; i++)
            {
                I2C1_SCL_L; 
                DelayUs(2);
                I2C1_SCL_H;		//拉高时钟线-读数据
                receive <<= 1;
                if(I2C1_READ)
                {
                    receive++;
                }
                DelayUs(1);
            }
            
            if(!ack)
            {
                I2cNotAck(I2C_TYPE_1);/* 发送NotACK */
            }
            else
            {
                I2cAck(I2C_TYPE_1); /* 发送ACK */
            }
            break;
        #endif
        
        #if defined(I2C2_ENABLE)
        case I2C_TYPE_2:
            I2C2_SDA_IN;/* SDA设置为输入 */
            for(INT8U i = 0; i < 8; i++)
            {
                I2C2_SCL_L; 
                DelayUs(2);
                I2C2_SCL_H;
                receive <<= 1;
                if(I2C2_READ)
                {
                    receive++;
                }
                DelayUs(1);
            }
            
            if(!ack)
            {
                I2cNotAck(I2C_TYPE_2);/* 发送NotACK */
            }
            else
            {
                I2cAck(I2C_TYPE_2); /* 发送ACK */
            }
            break;
        #endif
        
        #if defined(I2C3_ENABLE)
        case I2C_TYPE_3:
            I2C3_SDA_IN;/* SDA设置为输入 */
            for(INT8U i = 0; i < 8; i++)
            {
                I2C3_SCL_L; 
                DelayUs(2);
                I2C3_SCL_H;
                receive <<= 1;
                if(I2C3_READ)
                {
                    receive++;
                }
                DelayUs(1);
            }
            
            if(!ack)
            {
                I2cNotAck(I2C_TYPE_3);/* 发送NotACK */
            }
            else
            {
                I2cAck(I2C_TYPE_3); /* 发送ACK */
            }
            break;
        #endif
        
        #if defined(I2C4_ENABLE)
        case I2C_TYPE_4:
            I2C4_SDA_IN;/* SDA设置为输入 */
            for(INT8U i = 0; i < 8; i++)
            {
                I2C4_SCL_L; 
                DelayUs(2);
                I2C4_SCL_H;
                receive <<= 1;
                if(I2C4_READ)
                {
                    receive++;
                }
                DelayUs(1);
            }
            
            if(!ack)
            {
                I2cNotAck(I2C_TYPE_4);/* 发送NotACK */
            }
            else
            {
                I2cAck(I2C_TYPE_4); /* 发送ACK */
            }
            break;
        #endif
        
        default:
            break;
        
    }
    
    return receive;
    
}
#endif
吴彦祖分会郑州分祖
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iic 控制引脚连接nca9555
03-21
iic 控制引脚连接nca9555
pca9555驱动 linux内核
04-01
linux内核pca9555驱动适用于android系统
NCA9555/PCA9555代码 通用总线IO扩展器芯片驱动
LH_SMD的博客
11-16 9780
芯片引脚及描述： 驱动代码： nca9555.h /* * nca9555.h * * Created on: 2021年11月11日 * Author: lhsmd */ #ifndef USER_APP_NCA9555_H_ #define USER_APP_NCA9555_H_ #include "em_gpio.h" /***************************************************IIC 驱动部门***************
使用模拟I2C读取NCA9555
qq_29408105的博客
11-21 327
I2C（集成电路总线），由Philips公司（2006年迁移到NXP）在1980年代初开发的一种简单、双线双向的同步串行总线，它利用一根时钟线和一根数据线在连接总线的两个器件之间进行信息的传递，为设备之间数据交换提供了一种简单高效的方法。每个连接到总线上的器件都有唯一的地址，任何器件既可以作为主机也可以作为从机，但同一时刻只允许有一个主机。I²C最重要的功能包括：只需要两条总线；没有严格的波特率要求，例如使用RS232，主设备生成总线时钟；
扩展 IO pca95555 linux驱动 及使用
lnwechag的博客
01-15 2878
pca9555 linux驱动使用
在龙芯uefi固件中添加nca9555的驱动代码
07-31 448
uefi 485 nca9555
IIC扩展IO NCA9555代码
Chen_1994的博客
07-18 2686
IIC扩展IO NCA9555代码
32单片机矩阵键盘-同列组合键不能识别故障-已解决
嵌入式 arm 单片机 入门 视频 培训
02-09 1645
矩阵键盘，组合键识别
i2c io拓展驱动代码
raoxu1154492168的博客
03-15 370
flags = I2C_M_RD, //标志，I2C_M_RD表示主机向主机读数据。.buf = data, //读取的数据存放的地址。.len = len, //要读取的数据的长度。\param[in] dev_addr：I2C设备地址。\param[in] dev_addr：I2C设备地址。.buf = ®_addr, //要写的数据的地址。.addr = dev_addr, //设备地址。.addr = dev_addr, //设备地址。
PCA9555芯片资料
11-12
PCA9555芯片资料，PCA9555用于IO口扩展，3.3V，可接5V
nca.rar_NCA_matlab nca
07-14
神经网络的分类算法，举例：矿井突水水源判别
ACO-Odev.rar_NCA
09-23
yapay kar&#305 nca kolonisi &#246 rnek uygulamallllll
PCA9555详细学习
TheOneZn的博客
01-27 1万+
2022.01.27 控制寄存器和命令寄存器，及英文理解 一般8位作为地址，其中前四位时固定的，中间三位为地址配置，最后一位是读写位，即读是1，写是0 当地址位，正确应答之后，主机会发送一个控制字节，控制字节将会存在PCA9555的控制寄存器中，其中三个字节，将会定义操作以及内部的寄存器，控制寄存器能被读以及写，控制字节只有写的时候才发送 command其实就相当于相应的控制寄存器地址，比如00就是访问input port0的寄存器 0和1寄存器地址，仅仅反应了输入到pin的逻辑电
S4.2.4.5 Lane Polarity Inversion
那么菜的博客
11-04 1067
原文摘录：PCIe 协议规定，必须支持该特性。该特性的目标也是为了简化 PCB 的布线。每个 lane 都包含一组发送（Tx）和接收（Rx），而 Tx 和 Rx 分别包含两根差分信号线（D+ 和 D-）。Polarity Inversion 的作用就是把某个设备的 D+ 变成 D-，D- 变成 D+。开启 Polarity Inversion 之后的效果如下图所示： 为了实现D+和D-正负极检测，接收逻辑Rx需要查看接收到的TS1或TS2中的Symbol 6到15：如果在TS1中接收到的是D21.5而不是D
PCA9555的使用个人总结
热门推荐
Osean_li的博客
08-22 1万+
1.德州仪器PCA9555-简化PCB布线，对处理器有限的IO口进行补充。 2.带中断，不带重启 3.24 引脚的CMOS器件，提供I2C/SMBus16位通用并行（GPIO）的扩展   4.地址：总共1字节（八位），前四位固定，（A0，A1，A2自定，最后一位，0为写，1为读。
【Proteus仿真】【Arduino单片机】寻迹避障蓝牙遥控小车
最新发布
Hello_Muyi的博客
06-24 508
本项目使用Proteus8仿真Arduino单片机控制器，使LCD1602液晶，L298电机，直流电机，HC05/06蓝牙模块，HCSR04超声波，红外寻迹模块等。主要功能：系统运行后，LCD1602显示小车运行状态、模式、检测距离；当小车在蓝牙模式，可通过蓝牙发送命令控制小车前进、后退、左转、右转、模式、LED开关；当小车在寻迹模式，通过左右红外传感器感应寻迹，前进时LED亮，否则灭；当小车在避障模式，通过超声波检测距离，当距离小于避障值，右转，否则前进；
OpenHarmony角落里的知识：WPA_Supplicant连接方式
m0_64422261的博客
06-21 1161
wpa_ctrl_get_fd() : 获取同WPAS的连接中， client端的fd， 获取的fd可以用于select， epoll等， 但是不能直接用于收发消息， 必须使用wpa_ctrl_request()和wpa_ctrl_recv（）wpa_ctrl_attach() : 使用wpa_ctrl_open()建立的连接， WPAS默认不会向这些连接的client端发送event， 必须显示调用wpa_ctrl_attach()，才能接收到消息。使用wpa_cli可以实现wifi的具体功能。
DMA学习笔记（天空星stmf4开发板）
weixin_62292999的博客
06-22 1077
中断法传输数据：将数据传输的指令，写在中断响应函数里面，当需要传输数据，触发中断，如果传输大量数据的时候，会出现一个问题，单片机中断，是一瞬间的事情，在响应中断的时候，CPU会只执行中断响应函数，while（）循环里面的函数就不行执行，这就会造成，轮询法传输数据：在main()函数的while()循环里面，执行检测相关标志位，的语句判断是否符合条件，满足条件进行传输数据，如果没有上rtos操作系统，又传输大量数据，这个时候，也会出现 响应延迟，因为mcu 在没有操作系统的情况下，
nca9555数据手册
01-28
NCA9555是一款由ON Semiconductor公司生产的I2C总线控制器。这款芯片具有16个通用输入/输出引脚，可以广泛用于数字电路的控制和通信。NCA9555可以通过I2C总线连接到主控制器，使其能够与其他设备进行通信并控制其状态。 NCA9555数据手册是关于该芯片的详细技术文档，包含了关于其功能、引脚定义、时序图、寄存器描述、特性参数等方面的信息。数据手册提供了对该芯片的全面了解和应用指南，使工程师能够更好地使用它进行硬件设计和编程。 数据手册中包含了NCA9555的引脚图和引脚功能描述，这有助于工程师正确地连接芯片，以及了解每个引脚的作用。时序图显示了各个操作的时序要求，帮助工程师进行正确的时序设计，以确保芯片正常工作。 此外，数据手册还包含了NCA9555的寄存器描述，详细说明了各个寄存器的功能和配置方法，通过对这些寄存器的编程，可以实现对芯片功能的灵活控制。特性参数表列出了芯片的电气特性和性能指标，包括供电电压范围、工作温度范围、IO口电流能力等，这些参数对于设计和测试过程中的性能评估非常重要。 总之，NCA9555数据手册是理解和应用该芯片的重要参考文献。通过仔细阅读和研究数据手册，工程师可以更好地了解NCA9555的特性和功能，并能够更加有效地将其应用于电路设计和系统集成中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值