LPC1768 Dev kit 开发板 + 7、PCA9551输入和输出测试

TLLED · 发表于 2019-3-7 08:27:27

测试下PCA9551按键输入和LED输出测试。

一、硬件电路

二、手册部分

2.1、手册文件

PCA9551.pdf (162.24 KB, 下载次数: 0)

2019-3-7 08:02 上传

点击文件名下载附件
2.2、相关的寄存器，这次测试用到的寄存器就是红框里面的

三、程序部分

3.1、PCA9551程序

//PCA9551.C
#include "pca9551.h"
#include "i2c.h"
volatile uint32_t I2CMasterState = I2C_IDLE;
volatile uint32_t I2CSlaveState = I2C_IDLE;
volatile uint32_t I2CCmd;
volatile uint32_t I2CMode;
volatile uint8_t I2CMasterBuffer[BUFSIZE];
volatile uint8_t I2CSlaveBuffer[BUFSIZE];
volatile uint32_t I2CCount = 0;
volatile uint32_t I2CReadLength;
volatile uint32_t I2CWriteLength;
volatile uint32_t RdIndex = 0;
volatile uint32_t WrIndex = 0;
/*****************************************************************************
** Function name: I2CStart
**
** Descriptions: Create I2C start condition, a timeout
** value is set if the I2C never gets started,
** and timed out. It's a fatal error.
**
** parameters: None
** Returned value: true or false, return false if timed out
**
*****************************************************************************/
uint32_t I2CStart( void )
{
uint32_t timeout = 0;
uint32_t retVal = FALSE;
/*--- Issue a start condition ---*/
LPC_I2C0 -> I2CONSET = I2C_STA; //置位开始标志位
/*--- Wait until START transmitted ---*/
while( 1 )
{
if ( I2CMasterState == I2C_STARTED )
{
retVal = TRUE;
break;
}
if ( timeout >= MAX_TIMEOUT )
{
retVal = FALSE;
break;
}
timeout++;
}
return( retVal );
}
/*****************************************************************************
** Function name: I2CStop
**
** Descriptions: Set the I2C stop condition, if the routine
** never exit, it's a fatal bus error.
**
** parameters: None
** Returned value: true or never return
**
*****************************************************************************/
uint32_t I2CStop( void )
{
LPC_I2C0 -> I2CONSET = I2C_STO; //置位停止标志位
LPC_I2C0 -> I2CONCLR = I2C_SI; //清零中断标志位
/*--- Wait for STOP detected ---*/
while( LPC_I2C0 -> I2CONSET & I2C_STO );
//
return TRUE;
}
void init_pca9551 (void)
{
/* Configure I2C */
LPC_SC->PCONP |= 0x00000080; /* Enable clock for I2C0 */
LPC_PINCON->PINSEL1 |= 0x01400000;
LPC_I2C0->I2CONCLR = I2C_AA | I2C_SI | I2C_STA | I2C_I2EN;
LPC_I2C0->I2SCLL = 0x80; /* Set I2C Clock speed */
LPC_I2C0->I2SCLH = 0x80;
LPC_I2C0->I2CONSET = I2C_I2EN;
NVIC_EnableIRQ(I2C0_IRQn); //使能I2C中断
//LPC_I2C0->I2CONSET = I2C_STO;
}
uint32_t I2CInit( uint32_t I2cMode )
{
LPC_SC -> PCONP |= 0x00000080;//|= (1 << 19);
LPC_PINCON->PINSEL1 |= 0x01400000;
LPC_I2C0->I2CONCLR = I2C_AA | I2C_SI | I2C_STA | I2C_I2EN;
LPC_I2C0->I2SCLL = 0x80; /* Set I2C Clock speed */
LPC_I2C0->I2SCLH = 0x80;
LPC_I2C0->I2CONSET = I2C_I2EN;
NVIC_EnableIRQ(I2C0_IRQn); //使能I2C中断
//PINCON -> PINSEL1 &= ~0x03C00000;
//PINCON -> PINSEL1 |= 0x01400000; /* set PIO0.27 and PIO0.28 to I2C0 SDA and SCK */
/* function to 01 on both SDA and SCK. */
/*--- Clear flags ---*/
//I2C0 -> I2CONCLR = I2CONCLR_AAC | I2CONCLR_SIC | I2CONCLR_STAC | I2CONCLR_I2ENC;
/*--- Reset registers ---*/
//I2C0 -> I2SCLL = I2SCLL_SCLL;
//I2C0 -> I2SCLH = I2SCLH_SCLH;
if ( I2cMode == I2CSLAVE )
{
LPC_I2C0 -> I2ADR0 = PCA9551_ADDRESS;
}
/* Install interrupt handler */
NVIC_EnableIRQ(I2C0_IRQn);
//I2C0 -> I2CONSET = I2CONSET_I2EN;
return( TRUE );
}
/*****************************************************************************
** Function name: I2CEngine
**
** Descriptions: The routine to complete a I2C transaction
** from start to stop. All the intermitten
** steps are handled in the interrupt handler.
** Before this routine is called, the read
** length, write length, I2C master buffer,
** and I2C command fields need to be filled.
** see i2cmst.c for more details.
**
** parameters: None
** Returned value: true or false, return false only if the
** start condition can never be generated and
** timed out.
**
*****************************************************************************/
uint32_t I2CEngine( void )
{
I2CMasterState = I2C_IDLE;
RdIndex = 0;
WrIndex = 0;
if ( I2CStart() != TRUE )
{
I2CStop();
return ( FALSE );
}
while ( 1 )
{
if ( I2CMasterState == DATA_NACK )
{
I2CStop();
break;
}
}
return ( TRUE );
}
//读PCA9551输入数据
uint8_t pca9551_readdat (void)
{
uint8_t i;
uint8_t rd;
for ( i = 0; i < BUFSIZE; i++ ) /* clear buffer */
{
I2CMasterBuffer[i] = 0;
}
I2CWriteLength = 1;
I2CReadLength = 1;
I2CMasterBuffer[0] = PCA9551_ADDRESS;
I2CMasterBuffer[1] = PCA9551_REG_INPUT;
I2CMasterBuffer[2] = PCA9551_ADDRESS | RD_BIT;
I2CCmd = PCA9551_READ;
I2CEngine();
rd=I2CMasterBuffer[3];
return rd;
}
//pca9551输出数据
void pca9551_senddat (INT32U rLedValue)
{
uint8_t i;
rLedValue = (rLedValue & 0x01)|((rLedValue<<1) & 0x04)|((rLedValue<<2) & 0x10)|((rLedValue<<3) & 0x40);
/* Configure temp register before reading */
for ( i = 0; i < BUFSIZE; i++ ) /* clear buffer */
{
I2CMasterBuffer[i] = 0;
}
I2CWriteLength = 3;
I2CReadLength = 0;
I2CMasterBuffer[0] = PCA9551_ADDRESS;
I2CMasterBuffer[1] = PCA9551_REG_LS1;
I2CMasterBuffer[2] = rLedValue;
i=I2CEngine();
}
/*
From device to device, the I2C communication protocol may vary,
in the example below, the protocol uses repeated start to read data from or
write to the device:
For master read: the sequence is: STA,Addr(W),offset,RE-STA,Addr(r),data...STO
for master write: the sequence is: STA,Addr(W),length,RE-STA,Addr(w),data...STO
Thus, in state 8, the address is always WRITE. in state 10, the address could
be READ or WRITE depending on the I2CCmd.
*/
/*****************************************************************************
** Function name: I2C0MasterHandler
**
** Descriptions: I2C0 interrupt handler, deal with master mode
** only.
**
** parameters: None
** Returned value: None
**
*****************************************************************************/
void I2C0_IRQHandler(void)
{
uint8_t StatValue;
/* this handler deals with master read and master write only */
StatValue = LPC_I2C0 -> I2STAT;
switch ( StatValue )
{
case 0x08: /* A Start condition is issued. */
LPC_I2C0 -> I2DAT = I2CMasterBuffer[0];
LPC_I2C0 -> I2CONCLR = (I2C_SI | I2C_STA);
I2CMasterState = I2C_STARTED;
break;
case 0x10: /* A repeated started is issued */
if ( I2CCmd == PCA9551_READ )
{
LPC_I2C0 -> I2DAT = I2CMasterBuffer[2];
}
LPC_I2C0 -> I2CONCLR = (I2C_SI | I2C_STA);
I2CMasterState = I2C_RESTARTED;
break;
case 0x18: /* Regardless, it's a ACK */
if ( I2CMasterState == I2C_STARTED )
{
LPC_I2C0 -> I2DAT = I2CMasterBuffer[1+WrIndex];
WrIndex++;
I2CMasterState = DATA_ACK;
}
LPC_I2C0 -> I2CONCLR = I2C_SI; //清除中断
break;
case 0x28: /* Data byte has been transmitted, regardless ACK or NACK */
case 0x30:
if ( WrIndex != I2CWriteLength )
{
LPC_I2C0 -> I2DAT = I2CMasterBuffer[1+WrIndex]; /* this should be the last one */
WrIndex++;
if ( WrIndex != I2CWriteLength )
{
I2CMasterState = DATA_ACK;
}
else
{
I2CMasterState = DATA_NACK;
if ( I2CReadLength != 0 )
{
LPC_I2C0 -> I2CONSET = I2C_STA; /* Set Repeated-start flag */
I2CMasterState = I2C_REPEATED_START;
}
}
}
else
{
if ( I2CReadLength != 0 )
{
LPC_I2C0 -> I2CONSET = I2C_STA; /* Set Repeated-start flag */
I2CMasterState = I2C_REPEATED_START;
}
else
{
I2CMasterState = DATA_NACK;
LPC_I2C0 -> I2CONSET = I2C_STO; /* Set Stop flag */
}
}
LPC_I2C0 -> I2CONCLR = I2C_SI;
break;
case 0x40: /* Master Receive, SLA_R has been sent */
LPC_I2C0 -> I2CONSET = I2C_AA; /* assert ACK after data is received */
LPC_I2C0 -> I2CONCLR = I2C_SI;
break;
case 0x50: /* Data byte has been received, regardless following ACK or NACK */
case 0x58: //数据接收
I2CMasterBuffer[3+RdIndex] = LPC_I2C0 -> I2DAT;
RdIndex++;
if ( RdIndex != I2CReadLength )
{
I2CMasterState = DATA_ACK;
}
else
{
RdIndex = 0;
I2CMasterState = DATA_NACK;
}
LPC_I2C0 -> I2CONSET = I2C_AA; /* assert ACK after data is received */
LPC_I2C0 -> I2CONCLR = I2C_SI;
break;
//
case 0x20: /* regardless, it's a NACK */
case 0x48:
LPC_I2C0 -> I2CONCLR = I2C_SI;
I2CMasterState = DATA_NACK;
break;
case 0x38: /* Arbitration lost, in this example, we don't
deal with multiple master situation */
default:
LPC_I2C0 -> I2CONCLR = I2C_SI;
break;
}
}
//pca9551.h
#ifndef __PCA9551_H__
#define __PCA9551_H__
#include "LPC17xx.h"
#include "DataTypes.h"
// PCA9551 Info
#define PCA9551_ADDRESS 0xC0
#define PCA9551_REG_INPUT 0 // INPUT register (ro)
#define PCA9551_REG_PSC0 1 // Frequency Prescaler 0 (rw)
#define PCA9551_REG_PWM0 2 // PWM 0 (rw)
#define PCA9551_REG_PSC1 3 // Frequency Prescaler 1 (rw)
#define PCA9551_REG_PWM1 4 // PWM 1 (rw)
#define PCA9551_REG_LS0 5 // LED0 - LED3 Select (rw)
#define PCA9551_REG_LS1 6 // LED4 - LED7 Select (rw)
#define PCA9551_REG_AI 0x10 // Auto-Increment
#define I2C_AA 0x00000004
#define I2C_SI 0x00000008
#define I2C_STO 0x00000010
#define I2C_STA 0x00000020
#define I2C_I2EN 0x00000040
#define BUFSIZE 0x20
#define MAX_TIMEOUT 0x00FFFFFF
#define I2CMASTER 0x01
#define I2CSLAVE 0x02
/* For more info, read Philips's LM95 datasheet */
#define PCA9551_READ 0x01
#define RD_BIT 0x01
extern volatile uint32_t I2CCmd;
extern volatile uint32_t I2CMode;
extern volatile uint8_t I2CMasterBuffer[BUFSIZE];
extern volatile uint8_t I2CSlaveBuffer[BUFSIZE];
extern volatile uint32_t I2CReadLength;
extern volatile uint32_t I2CWriteLength;
extern uint32_t I2CInit( uint32_t I2cMode );
extern uint32_t I2CEngine( void );
extern void init_pca9551 (void);
extern void pca9551_senddat (INT32U rLedValue);
extern uint8_t pca9551_readdat (void);
/******************************************************************************/
#endif // __I2C_H__

复制代码

3.2、LED输出主程序

int main (void)
{
INT32U i,j;
INT16U cnt=0;
INT16U AdcValue, AdcPrintValue;
const INT8U LedValue[8] = { 0x01,0x03,0x07,0x0F,0x0E,0x0C,0x08,0x00 };
SystemInit();
init_sysytick();
init_beep();
init_led();
init_uart0(); //初始化串口0
if ( I2CInit( (uint32_t)I2CMASTER ) == FALSE ) /* initialize I2c */
{
while ( 1 ); /* Fatal error */
}
while(1)
{
cnt++;
if(cnt>7)
{
cnt=0;
}
pca9551_senddat(LedValue[cnt]);
Delay(500);
led_on();
Delay(500);
led_off();
}
}

复制代码

3.3、按键输入主程序

int main (void)
{
uint8_t rd=0;
uint8_t rd1=0;
INT32U i,j;
INT16U cnt=0;
INT16U AdcValue, AdcPrintValue;
const INT8U LedValue[8] = { 0x01,0x03,0x07,0x0F,0x0E,0x0C,0x08,0x00 };
SystemInit();
init_sysytick();
init_beep();
init_led();
init_uart0(); //初始化串口0
init_uart1(); //初始化串口1
if ( I2CInit( (uint32_t)I2CMASTER ) == FALSE ) /* initialize I2c */
{
while ( 1 ); /* Fatal error */
}
while(1)
{
rd=pca9551_readdat();
if((rd&0x0f)!=0x0f)
{
rd1=(~rd)&0x0f;
uart0_senddat(rd1);
}
}
}

复制代码

四、测试结果

4.1、LED输出结果

4.2、按键输入结果
按键数据通过串口输出

阅读全文

mzy2364 · 发表于 2019-3-7 08:32:31

按键输入也出来了厉害啊

stm1024 · 发表于 2019-3-7 11:23:38

软件模拟IIC协议~

TLLED · 发表于 2019-3-7 13:15:24

mzy2364 发表于 2019-3-7 08:32
按键输入也出来了厉害啊

可以读出来了，还有点小问题，继续学习，^_^

TLLED · 发表于 2019-3-7 13:15:54

stm1024 发表于 2019-3-7 11:23
软件模拟IIC协议~

不是模拟，是用LPC1768的I2C协议

stm1024 · 发表于 2019-3-8 08:00:51

TLLED 发表于 2019-3-7 13:15
不是模拟，是用LPC1768的I2C协议

确实是，看错了

[原创] LPC1768 Dev kit 开发板 + 7、PCA9551输入和输出测试

站长推荐 /4