void LCD_GPIO_Init(void)
{
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOB);
xGPIODirModeSet( xGPIO_PORTA_BASE, xGPIO_PIN_8, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_12, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_13, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_14, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_15, xGPIO_DIR_MODE_OUT);
}
//*****************************************************************************
//
//! \brief Write data to CH376.
//!
//! \param mData data value
//!
//! \details Write data to CH376.
//!
//! \return None.
//
//*****************************************************************************
void xWriteCH376Data( unsigned char ucData )
{
xGPIODirModeSet( CH376_DATA_PORT, 0xFF, xGPIO_DIR_MODE_OUT );
CH376_A0_CLR;
CH376_PCS_CLR;
CH376_WR_CLR;
CH376_PARA_DATA_OUT( ucData );
CH376_WR_SET;
CH376_PCS_SET;
xGPIODirModeSet( CH376_DATA_PORT, 0xFF, xGPIO_DIR_MODE_IN );
}
//*****************************************************************************
//
//! \brief Initialize 93LC46A.
//!
//! \return None.
//
//*****************************************************************************
void eep_93LC46A_Init()
{
//
// Clock and GPIO Configure
//
xSysCtlClockSet(8000000, xSYSCTL_XTAL_8MHZ | xSYSCTL_OSC_MAIN);
xSysCtlPeripheralEnable(_93LC46A_PERIPH_PORT);
xGPIODirModeSet(_93LC46A_PIN_PORT, _93LC46A_PIN_SEL, GPIO_DIR_MODE_OUT);
xGPIODirModeSet(_93LC46A_PIN_PORT, _93LC46A_PIN_CLOCK, GPIO_DIR_MODE_OUT);
xGPIODirModeSet(_93LC46A_PIN_PORT, _93LC46A_PIN_DI, GPIO_DIR_MODE_IN);
xGPIODirModeSet(_93LC46A_PIN_PORT, _93LC46A_PIN_DO, GPIO_DIR_MODE_OUT);
xGPIOPinWrite(_93LC46A_PIN_PORT, _93LC46A_PIN_SEL, 0);
xGPIOPinWrite(_93LC46A_PIN_PORT, _93LC46A_PIN_CLOCK, 0);
xGPIOPinWrite(_93LC46A_PIN_PORT, _93LC46A_PIN_DO, 0);
//
// Enable Write
//
eep_93LC46A_Cmd(_93LC46A_WriteEnable);
}
void Blinky(void)
{
unsigned long i;
//
// Initionalize system clock.
//
xSysCtlClockSet(16000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_25MHZ);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
//
// Set GPIO port A pin 0 , 1 output mode.
//
xGPIODirModeSet( xGPIO_PORTA_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT );
xGPIODirModeSet( xGPIO_PORTA_BASE, xGPIO_PIN_1, xGPIO_DIR_MODE_OUT );
while (1)
{
//
// Delay some time.
//
for( i = 0; i < 0x1FFFF; i++ )
//
// Output high level.
//
xGPIOPinWrite( xGPIO_PORTA_BASE, xGPIO_PIN_0 | xGPIO_PIN_1, 1 );
for( i = 0; i < 0x1FFFF; i++ )
//
// Output low level.
//
xGPIOPinWrite( xGPIO_PORTA_BASE, xGPIO_PIN_0 | xGPIO_PIN_1, 0 );
}
}
void Blinky(void)
{
unsigned long uli;
//
// Initionalize system clock.
//
xSysCtlPeripheralClockSourceSet( 10000000, xSYSCTL_XTAL_6MHZ );
//
// Set GPIO port c pin 12, 13, 14, 15 output mode.
//
xGPIODirModeSet( xGPIO_PORTC_BASE, xGPIO_PIN_12, xGPIO_DIR_MODE_OUT );
xGPIODirModeSet( xGPIO_PORTC_BASE, xGPIO_PIN_13, xGPIO_DIR_MODE_OUT );
while (1)
{
//
// Delay some time.
//
for( uli = 0; uli < 0x1FFFF; uli++ )
//
// Output high level.
//
xGPIOPinWrite( xGPIO_PORTC_BASE, xGPIO_PIN_12 | xGPIO_PIN_13, 1 );
for( uli = 0; uli < 0x1FFFF; uli++ )
//
// Output low level.
//
xGPIOPinWrite( xGPIO_PORTC_BASE, xGPIO_PIN_12 | xGPIO_PIN_13, 0 );
}
}
//*****************************************************************************
//
//! \brief Initialize STMPE811 and I2C
//!
//! \param None
//!
//! This function initialize the mcu I2C as master and specified I2C port.the
//! master block will be set up to transfer data at 400 kbps.
//!
//! \return None.
//
//*****************************************************************************
void STMPE811Init(void)
{
//
// Enable GPIO Periph clock and Alternate Fuction I/O clock.
//
xSysCtlPeripheralEnable(STMPE811_I2C_GPIO);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//
// Enable the I2C which is connected with STMPE811
//
xSysCtlPeripheralEnable2(STMPE811_PIN_I2C_PORT);
//
// Set STMPE811_PIN_I2C_SCK as IICx.SCK
//
xSPinTypeI2C(STMPE811_I2C_SCK, STMPE811_PIN_I2C_SCK);
//
// Set STMPE811_PIN_I2C_SDA as I2Cx.SDA
//
xSPinTypeI2C(STMPE811_I2C_SDA, STMPE811_PIN_I2C_SDA);
//
// I2C enable
//
xI2CMasterEnable(STMPE811_PIN_I2C_PORT);
//
// Initializes the I2C Master block.
//
xI2CMasterInit(STMPE811_PIN_I2C_PORT, I2C_Speed);
//
// Set INT pin.
//
xGPIODirModeSet(STMPE811_INT_PORT, STMPE811_INT_GPIO, xGPIO_DIR_MODE_IN);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(STMPE811_INT_PORT, STMPE811_INT_GPIO, STMPE811IntCallback);
// Enable GPIO pin interrupt.
xGPIOPinIntEnable(STMPE811_INT_PORT, STMPE811_INT_GPIO, xGPIO_FALLING_EDGE);
xIntEnable(INT_GPIO);
// STNPE811 initializtion.
STMPE811InitConfig();
}
void TCN75Exp()
{
//
// Initalizes I2C.
//
TCN75Init(5000);
//
// config TCN75.
//
TCN75WakeUp();
TCN75Config(TCN75_MODE_CMP | TCN75_POLARITY_HIGH | TCN75_FAULTQUE_6);
TCN75LowLimitSet(fTemp);
TCN75UpLimitSet(fTemp);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIO);
xGPIODirModeSet(GPIO_PORTA_BASE, GPIO_PIN_12, GPIO_DIR_MODE_OUT);
TCN75IntConfig(test_Led);
xIntEnable(xINT_GPIOB);
xIntMasterEnable();
uli = 0;
while(!uli)
{
fTemp = TCN75TempReadFDC();
for(ulj = 0; ulj < 0xfff ;ulj++);
}
xIntDisable(xINT_GPIOB);
xIntMasterDisable();
//
// Disables I2C0, set TCN75 as shutdown mode.
//
TCN75DeInit();
}
//////////////////////////////////////////////////////////////////////////////
// Platform (STM32F103X) initialization for peripherals as GPIO, SPI, UARTs //
//////////////////////////////////////////////////////////////////////////////
void platform_init(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay((xSysCtlClockGet()/1000)*50); // wait 50ms
/**************************/
/* GPIO_A For SPI CS PIN */// It must be first to enable GPIO peripheral than other peripheral. (Otherwise, UART do not run in STM32F103X)
/**************************/
xSysCtlPeripheralEnable( xSYSCTL_PERIPH_GPIOA );
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
/************/
/* For UART */
/************/
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xSPinTypeUART(UART1TX,PA9);
xSPinTypeUART(UART1RX,PA10);
xUARTConfigSet(xUART1_BASE, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
xUARTEnable(xUART1_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
/***********/
/* For SPI */
/***********/
xSysCtlPeripheralReset(WIZCHIP_SPI_PERIPH);
xSysCtlPeripheralEnable(WIZCHIP_SPI_PERIPH);
xSPinTypeSPI(WIZCHIP_SPI_CLK, WIZCHIP_SPI_CLK_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_5, GPIO_TYPE_AFOUT_STD, GPIO_OUT_SPEED_50M);
xSPinTypeSPI(WIZCHIP_SPI_MOSI,WIZCHIP_SPI_MOSI_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_7, GPIO_TYPE_AFOUT_STD, GPIO_OUT_SPEED_50M);
xSPinTypeSPI(WIZCHIP_SPI_MISO,WIZCHIP_SPI_MISO_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_6, GPIO_TYPE_IN_FLOATING, GPIO_IN_SPEED_FIXED);
xSPIConfigSet(WIZCHIP_SPI_BASE, xSysCtlClockGet()/2, xSPI_MOTO_FORMAT_MODE_0 | xSPI_MODE_MASTER | xSPI_MSB_FIRST | xSPI_DATA_WIDTH8);
xSPISSSet(WIZCHIP_SPI_BASE, SPI_SS_SOFTWARE, xSPI_SS_NONE);
xSPIEnable(WIZCHIP_SPI_BASE);
printf("HCLK = %dMHz\r\n", (unsigned int)(xSysCtlClockGet()/1000000));
}
//*****************************************************************************
//
//! \brief MCU communication port initialize
//!
//! \param None
//!
//! \return None.
//
//*****************************************************************************
void CH376PortInit( void )
{
#ifdef CH376_INT_WIRE
xSysCtlPeripheralEnable2(CH376_INT_PORT);
xGPIOSPinDirModeSet(CH376_INT_PIN, xGPIO_DIR_MODE_IN); //pass
xGPIOSPinWrite(CH376_INT_PIN, 1);
#endif
#ifdef CH376_USE_HARDWARE_SPI
xSysCtlPeripheralEnable2(CH376_SPI_CS_PORT);
xGPIOSPinDirModeSet(CH376_SPI_CS_PIN, xGPIO_DIR_MODE_OUT);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_SCK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MOSI));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MISO));
xSysCtlPeripheralEnable2(CH376_SPI_PORT);
xSPinTypeSPI(CH376SPI_CLK, CH376_SCK);
xSPinTypeSPI(CH376SPI_MISO, CH376_MISO);
xSPinTypeSPI(CH376SPI_MOSI, CH376_MOSI);
xSPIConfigSet(CH376_SPI_PORT, CH376_CLK_FREQ, SPI_MODE_MASTER |
xSPI_MOTO_FORMAT_MODE_3 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST |
xSPI_DATA_WIDTH8);
// SPISSModeConfig(CH376_SPI_PORT, SPI_CR1_SSM);
// SPISSIConfig(CH376_SPI_PORT, SPI_CR1_SSI);
xSPISSSet( CH376_SPI_PORT, xSPI_SS_SOFTWARE, xSPI_SS0 );
SPIEnble(CH376_SPI_PORT);
CH376_SPI_CS_SET;
#endif //End of CH376_USE_HARDWARE_SPI define
#ifdef CH376_USE_SOFTWARE_SPI
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_SCK_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MISO_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MOSI_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_SPI_CS_PIN));
xGPIOSPinDirModeSet(CH376_SPI_CS_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_SCK_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_MOSI_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_MISO_PIN, xGPIO_DIR_MODE_IN);
CH376_SPI_CS_SET;
#endif //End of CH376_USE_SOFTWARE_SPI define
#ifdef CH376_USE_PARALLEL
xSysCtlPeripheralEnable2(CH376_WR_PORT);
xSysCtlPeripheralEnable2(CH376_RD_PORT);
xSysCtlPeripheralEnable2(CH376_A0_PORT);
xSysCtlPeripheralEnable2(CH376_PCS_PORT);
xSysCtlPeripheralEnable2(CH376_DATA_PORT);
xGPIOSPinDirModeSet(CH376_WR_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_RD_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_A0_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_PCS_PIN, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( CH376_DATA_PORT, 0xFF, xGPIO_DIR_MODE_IN );
CH376_PCS_SET;
CH376_WR_SET;
CH376_RD_SET;
CH376_A0_CLR;
#endif //End of CH376_USE_PARALLEL define
}
//*****************************************************************************
//
//! \brief xgpio001 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
static void xgpio001Execute(void)
{
unsigned long ulPin, ulPort;
unsigned long ulvalue, ulTemp;
int i, j;
//
// GPIOA PIN mode test
//
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTA_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioA, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTA_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioA, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTA_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioA, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTA_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioA, \" GPIODirModeSet or GPIODirModeGet()\" error");
//
// GPIOB pin mode test
//
xGPIODirModeSet(xGPIO_PORTB_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTB_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioB, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTB_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTB_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioB, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTB_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTB_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioB, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTB_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTB_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioB, \" GPIODirModeSet or GPIODirModeGet()\" error");
//
// GPIOC pin mode test
//
xGPIODirModeSet(xGPIO_PORTC_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTC_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTC_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTC_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTC_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTC_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTC_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTC_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
//
// GPIOD pin mode test
//
xGPIODirModeSet(xGPIO_PORTD_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTD_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTD_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTD_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTD_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTD_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTD_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTD_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
//
// GPIOE pin mode test
//
xGPIODirModeSet(xGPIO_PORTE_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTE_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTE_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTE_BASE, xGPIO_PIN_0) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTE_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_IN);
ulvalue = xGPIODirModeGet(xGPIO_PORTE_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_IN),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xGPIODirModeSet(xGPIO_PORTE_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
ulvalue = xGPIODirModeGet(xGPIO_PORTE_BASE, xGPIO_PIN_4) ;
TestAssert((ulvalue == xGPIO_DIR_MODE_OUT),
"xgpioC, \" GPIODirModeSet or GPIODirModeGet()\" error");
xIntDisable(xINT_GPIOA);
xIntDisable(xINT_GPIOB);
xIntDisable(xINT_GPIOC);
xIntDisable(xINT_GPIOD);
xIntDisable(xINT_GPIOE);
/*
//
// GPIOA int enable test
//
for(i = 0; i < 5; i++)
{
xGPIOPinIntEnable(xGPIO_PORTA_BASE, xGPIO_PIN_0, ulIntTypes[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0) & EXTI_CFGR0_SRCTYPE_M;
TestAssert(ulTemp == ulIntTypes[i],
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_ESSRO) & AFIO_ESSR0_EXTINPIN_M;
TestAssert(ulTemp == 0,
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_ICR) & 0x00000001;
TestAssert(ulTemp == 0x00000001,
"xgpio, \"xGPIOPinIntEnable \" error");
}
//
// GPIOB int enable test
//
for(i = 0; i < 5; i++)
{
xGPIOPinIntEnable(xGPIO_PORTB_BASE, xGPIO_PIN_9, ulIntTypes[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0 + 9*4) & EXTI_CFGR0_SRCTYPE_M;
TestAssert(ulTemp == ulIntTypes[i],
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_ESSR1) & (AFIO_ESSR0_EXTINPIN_M << 4);
TestAssert(ulTemp == (1 << 4),
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_ICR) & (0x00000001 << 9);
TestAssert(ulTemp == (0x00000001 << 9),
"xgpio, \"xGPIOPinIntEnable \" error");
}
//
// GPIOC int enable test
//
for(i = 0; i < 5; i++)
{
xGPIOPinIntEnable(xGPIO_PORTC_BASE, xGPIO_PIN_1, ulIntTypes[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0 + 4) & EXTI_CFGR0_SRCTYPE_M;
TestAssert(ulTemp == ulIntTypes[i],
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_ESSRO) & (AFIO_ESSR0_EXTINPIN_M << 4);
TestAssert(ulTemp == 2 << 4,
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_ICR) & 0x00000002;
TestAssert(ulTemp == 0x00000002,
"xgpio, \"xGPIOPinIntEnable \" error");
}
//
// GPIOD int enable test
//
for(i = 0; i < 5; i++)
{
xGPIOPinIntEnable(xGPIO_PORTD_BASE, xGPIO_PIN_9, ulIntTypes[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0 + 9*4) & EXTI_CFGR0_SRCTYPE_M;
TestAssert(ulTemp == ulIntTypes[i],
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_ESSR1) & (AFIO_ESSR0_EXTINPIN_M << 4);
TestAssert(ulTemp == (3 << 4),
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_ICR) & (0x00000001 << 9);
TestAssert(ulTemp == (0x00000001 << 9),
"xgpio, \"xGPIOPinIntEnable \" error");
}
//
// GPIOE int enable test
//
for(i = 0; i < 5; i++)
{
xGPIOPinIntEnable(xGPIO_PORTE_BASE, xGPIO_PIN_10, ulIntTypes[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0 + 10*4) & EXTI_CFGR0_SRCTYPE_M;
TestAssert(ulTemp == ulIntTypes[i],
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_ESSR1) & (AFIO_ESSR0_EXTINPIN_M << 8);
TestAssert(ulTemp == (4 << 8),
"xgpio, \"xGPIOPinIntEnable \" error");
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_ICR) & (0x00000001 << 10);
TestAssert(ulTemp == (0x00000001 << 10),
"xgpio, \"xGPIOPinIntEnable \" error");
}
*/
//
// Int Disable test
//
for(ulPin = 0; ulPin < 16; ulPin++)
{
xGPIOPinIntDisable(GPIO_AFIO_BASE, ulPackedPin[ulPin]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_ICR) & (0x00000001 << ulPin);
TestAssert(ulTemp == 0,
"xgpio, \"Interrupt disable test \" error");
}
//
// GPIOA out/in test
//
xGPIODirModeSet( xGPIO_PORTA_BASE, xGPIO_PIN_0, GPIO_DIR_MODE_OUT );
xGPIOPinWrite(xGPIO_PORTA_BASE, xGPIO_PIN_0, 1);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTA_BASE);
TestAssert(ulTemp == xGPIO_PIN_0,
"xgpio, \"Output pin value set \" error");
xGPIOPinWrite(xGPIO_PORTA_BASE, xGPIO_PIN_0, 0);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTA_BASE);
TestAssert(ulTemp == 0,
"xgpio, \"Output pin value set \" error");
//
// GPIOB out/in test
//
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_2, GPIO_DIR_MODE_OUT );
xGPIOPinWrite(xGPIO_PORTB_BASE, xGPIO_PIN_2, 1);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTB_BASE) & xGPIO_PIN_2;
TestAssert(ulTemp == xGPIO_PIN_2,
"xgpio, \"Output pin value set \" error");
xGPIOPinWrite(xGPIO_PORTB_BASE, xGPIO_PIN_2, 0);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTB_BASE) & xGPIO_PIN_2;
TestAssert(ulTemp == 0,
"xgpio, \"Output pin value set \" error");
GPIOPortWrite(xGPIO_PORTB_BASE, 0x00000004);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTB_BASE) & xGPIO_PIN_2;
TestAssert(ulTemp == 0x00000004,
"xgpio, \"Output port value set \" error");
GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_2, 0);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTB_BASE) & xGPIO_PIN_2;
TestAssert(ulTemp == 0,
"xgpio, \"Output port value set2 \" error");
//
// GPIOC out/in test
//
xGPIODirModeSet( xGPIO_PORTC_BASE, xGPIO_PIN_0, GPIO_DIR_MODE_OUT );
xGPIOPinWrite(xGPIO_PORTC_BASE, xGPIO_PIN_0, 1);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTC_BASE);
TestAssert(ulTemp == xGPIO_PIN_0,
"xgpio, \"Output pin value set \" error");
xGPIOPinWrite(xGPIO_PORTC_BASE, xGPIO_PIN_0, 0);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTC_BASE);
TestAssert(ulTemp == 0,
"xgpio, \"Output pin value set \" error");
//
// GPIOD out/in test
//
xGPIODirModeSet( xGPIO_PORTD_BASE, xGPIO_PIN_0, GPIO_DIR_MODE_OUT );
xGPIOPinWrite(xGPIO_PORTD_BASE, xGPIO_PIN_0, 1);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTD_BASE);
TestAssert(ulTemp == xGPIO_PIN_0,
"xgpio, \"Output pin value set \" error");
xGPIOPinWrite(xGPIO_PORTD_BASE, xGPIO_PIN_0, 0);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTD_BASE);
TestAssert(ulTemp == 0,
"xgpio, \"Output pin value set \" error");
//
// GPIOE out/in test
//
xGPIODirModeSet( xGPIO_PORTE_BASE, xGPIO_PIN_0, GPIO_DIR_MODE_OUT );
xGPIOPinWrite(xGPIO_PORTE_BASE, xGPIO_PIN_0, 1);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTE_BASE);
TestAssert(ulTemp == xGPIO_PIN_0,
"xgpio, \"Output pin value set \" error");
xGPIOPinWrite(xGPIO_PORTE_BASE, xGPIO_PIN_0, 0);
ulTemp = GPIOPinPortDoutGet(xGPIO_PORTE_BASE);
TestAssert(ulTemp == 0,
"xgpio, \"Output pin value set \" error");
//
// EXTI line De-bounce enable test
//
EXTILineDebounceEnable(xGPIO_PIN_0);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0) & EXTI_CFGR0_DBEN;
TestAssert(ulTemp == EXTI_CFGR0_DBEN,
"xgpio, \"De-bounce enable test \" error");
//
// EXTI line De-bounce disable test
//
EXTILineDebounceDisable(xGPIO_PIN_0);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_CFGR0) & EXTI_CFGR0_DBEN;
TestAssert(ulTemp == 0,
"xgpio, \"De-bounce disable test \" error");
//
// EXTI line De-bounce time set test
//
for(i = 0; i < 3; i++)
{
for(j = 0; j < 3; j++)
{
EXTIDebounceTimeSet(ulEXTILines[i], ulDeBounceTime[j]);
ulTemp = EXTIDebounceTimeGet(ulEXTILines[i]);
TestAssert(ulTemp == ulDeBounceTime[j],
"xgpio, \"De-bounce disable test \" error");
}
}
//
// EXTI Wake Up Int configure test
//
EXTIWakeUpIntConfigure(ulEXTIWakeUpInt[0]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_WAKUPCR) & EXTI_WAKUPCR_EVWUPIEN;
TestAssert(ulTemp == EXTI_WAKUPCR_EVWUPIEN,
"xgpio, \"EXTI Wake Up Int Enable \" error");
EXTIWakeUpIntConfigure(ulEXTIWakeUpInt[1]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_WAKUPCR) & EXTI_WAKUPCR_EVWUPIEN;
TestAssert(ulTemp == 0,
"xgpio, \"EXTI Wake Up Int Enable \" error");
//
// EXTI Wake up Configure test
//
for(i = 0; i < 3; i++)
{
EXTILineWakeUpConfigure(ulEXTILines[i], ulEXTIWakeUpLevel[0],
ulEXTIWakeUp[0]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_WAKUPPOLR) &
(1 << ulEXTILineShift[i]);
TestAssert(ulTemp == (1 << ulEXTILineShift[i]),
"xgpio, \"EXTI Wake Up Level \" error");
EXTILineWakeUpConfigure(ulEXTILines[i], ulEXTIWakeUpLevel[1],
ulEXTIWakeUp[0]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_WAKUPPOLR) &
(1 << ulEXTILines[i]);
TestAssert(ulTemp == 0,
"xgpio, \"EXTI Wake Up Level \" error");
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_WAKUPCR) &
(1 << ulEXTILineShift[i]);
TestAssert(ulTemp == (1 << ulEXTILineShift[i]),
"xgpio, \"EXTI Wake Up Enable \" error");
EXTILineWakeUpConfigure(ulEXTILines[i], ulEXTIWakeUpLevel[0],
ulEXTIWakeUp[1]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_WAKUPCR) &
(1 << ulEXTILineShift[i]);
TestAssert(ulTemp == 0,
"xgpio, \"EXTI Wake Up Disable \" error");
}
//
// GPIO Pad configure
//
GPIOPadConfigSet(GPIO_PORTA_BASE, xGPIO_PIN_3,
ulStrengthValue[0], ulOpenDrain[0] | ulPullResistor[0]);
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_DRVR) & xGPIO_PIN_3;
TestAssert(ulTemp ==0,
"xgpio, \"Current drain Configure\" error");
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_PUR) & xGPIO_PIN_3;
TestAssert(ulTemp == xGPIO_PIN_3,
"xgpio, \"Pull up resistor Enable \" error");
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_PDR) & xGPIO_PIN_3;
TestAssert(ulTemp == 0,
"xgpio, \"Pull up resistor Enable \" error");
ulTemp = xHWREG(ulPort + GPIO_ODR) & xGPIO_PIN_3;
TestAssert(ulTemp == xGPIO_PIN_3,
"xgpio, \"Open drain enable \" error");
GPIOPadConfigSet(GPIO_PORTA_BASE, xGPIO_PIN_3,
ulStrengthValue[1], ulOpenDrain[1] | ulPullResistor[1]);
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_DRVR) & xGPIO_PIN_3;
TestAssert(ulTemp == xGPIO_PIN_3,
"xgpio, \"Current drain Configure\" error");
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_PUR) & xGPIO_PIN_3;
TestAssert(ulTemp == 0,
"xgpio, \"Pull up resistor Enable \" error");
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_PDR) & xGPIO_PIN_3;
TestAssert(ulTemp == xGPIO_PIN_3,
"xgpio, \"Pull up resistor Enable \" error");
ulTemp = xHWREG(GPIO_PORTA_BASE + GPIO_ODR) & xGPIO_PIN_3;
TestAssert(ulTemp == 0,
"xgpio, \"Open drain disable \" error");
//
// Software Trigger test
//
for(i = 0; i < 3; i++)
{
EXTILineSoftwareTrigger(ulEXTILines[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_SSCR) & ulEXTILines[i];
TestAssert(ulTemp == ulEXTILines[i],
"xgpio, \"Software Trigger Set \" error");
}
//
// Software Trigger clear
//
for(i = 0; i < 3; i++)
{
EXTILineSoftwareClear(ulEXTILines[i]);
ulTemp = xHWREG(GPIO_EXTI_BASE + EXTI_SSCR) & ulEXTILines[i];
TestAssert(ulTemp == 0,
"xgpio, \"Software Trigger Clear \" error");
}
//
// Short pin to pin test
//
ulTemp = xGPIOSPinToPin(PA0);
TestAssert(ulTemp == ulPinValue[0],
"xgpio, \" Short pin to pin test \" error");
ulTemp = xGPIOSPinToPin(PA1);
TestAssert(ulTemp == ulPinValue[1],
"xgpio, \" Short pin to pin test \" error");
ulTemp = xGPIOSPinToPin(PA2);
TestAssert(ulTemp == ulPinValue[2],
"xgpio, \" Short pin to pin test \" error");
//
// Short pin write test
//
xGPIOSPinWrite(PA0, 1);
ulTemp = GPIOSPinRead(PA0) & GPIO_PIN_0;
TestAssert(ulTemp == GPIO_PIN_0,
"xgpio, \"Short pin write test \" error");
//
// Ture pin to ADC function
//
xSPinTypeADC(ADC0, PA0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 0);
TestAssert((ulTemp == (1 << 0 )),
"xgpio, \"Turn pin to ADC AIN0 \" error");
xSPinTypeADC(ADC1, PA1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 2);
TestAssert((ulTemp == (1 << 2 )),
"xgpio, \"Turn pin to ADC AIN1 \" error");
xSPinTypeADC(ADC2, PA2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 4);
TestAssert((ulTemp == (1 << 4 )),
"xgpio, \"Turn pin to ADC AIN2 \" error");
xSPinTypeADC(ADC3, PA3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 6);
TestAssert((ulTemp == (1 << 6 )),
"xgpio, \"Turn pin to ADC AIN3 \" error");
xSPinTypeADC(ADC4, PA4);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 8);
TestAssert((ulTemp == (1 << 8 )),
"xgpio, \"Turn pin to ADC AIN4 \" error");
xSPinTypeADC(ADC5, PA5);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 10);
TestAssert((ulTemp == (1 << 10 )),
"xgpio, \"Turn pin to ADC AIN5 \" error");
xSPinTypeADC(ADC6, PA6);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 12);
TestAssert((ulTemp == (1 << 12 )),
"xgpio, \"Turn pin to ADC AIN6 \" error");
xSPinTypeADC(ADC7, PA7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 14);
TestAssert((ulTemp == (1 << 14 )),
"xgpio, \"Turn pin to ADC AIN7 \" error");
//
// Ture pin to I2C0 function
//
xSPinTypeI2C(I2C0SDA, PC5);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 10);
TestAssert((ulTemp == (2 << 10)),
"xgpio, \"Turn pin to I2C SDA \" error");
xSPinTypeI2C(I2C0SDA, PC12);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 24);
TestAssert((ulTemp == (1 << 24)),
"xgpio, \"Turn pin to I2C SDA \" error");
xSPinTypeI2C(I2C0SDA, PD13);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 26);
TestAssert((ulTemp == (2 << 26)),
"xgpio, \"Turn pin to I2C SDA \" error");
xSPinTypeI2C(I2C0SCK, PC4);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 8);
TestAssert((ulTemp == (2 << 8 )),
"xgpio, \"Turn pin to I2C SCK \" error");
xSPinTypeI2C(I2C0SCK, PC11);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 22);
TestAssert((ulTemp == (1 << 22 )),
"xgpio, \"Turn pin to I2C SCK \" error");
xSPinTypeI2C(I2C0SCK, PD12);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 24);
TestAssert((ulTemp == (2 << 24 )),
"xgpio, \"Turn pin to I2C SCK \" error");
//
// Ture pin to I2C1 function
//
xSPinTypeADC(I2C1SDA, PB7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 14);
TestAssert((ulTemp == (2 << 14 )),
"xgpio, \"Turn pin to I2C1 SDA \" error");
xSPinTypeADC(I2C1SDA, PC1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 2);
TestAssert((ulTemp == (3 << 2 )),
"xgpio, \"Turn pin to I2C1 SDA \" error");
xSPinTypeADC(I2C1SDA, PC7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 14);
TestAssert((ulTemp == (1 << 14 )),
"xgpio, \"Turn pin to I2C1 SDA \" error");
xSPinTypeADC(I2C1SDA, PE10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 20);
TestAssert((ulTemp == (3 << 20 )),
"xgpio, \"Turn pin to I2C1 SDA \" error");
xSPinTypeI2C(I2C1SCK, PC0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 0);
TestAssert((ulTemp == (3 << 0 )),
"xgpio, \"Turn pin to I2C1 SCK \" error");
xSPinTypeI2C(I2C1SCK, PC6);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 12);
TestAssert((ulTemp == (1 << 12 )),
"xgpio, \"Turn pin to I2C1 SCK \" error");
xSPinTypeI2C(I2C1SCK, PE9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 20);
TestAssert((ulTemp == (3 << 20 )),
"xgpio, \"Turn pin to I2C1 SCK \" error");
/*
//
// Turn pin to pwm mode
//
xSPinTypePWM(PWM0, PC2);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP2;
ulTemp1 = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_ALT2;
TestAssert((ulTemp == 0) && (ulTemp1 == GCR_GPCMFP_ALT2),
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM1, PC3);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP3;
ulTemp1 = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_ALT3;
TestAssert((ulTemp == 0) && (ulTemp1 == GCR_GPCMFP_ALT3),
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM2, PC4);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP4;
ulTemp1 = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_ALT4;
TestAssert((ulTemp == 0) && (ulTemp1 == GCR_GPCMFP_ALT4),
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM3, PC5);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP5;
ulTemp1 = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_ALT5;
TestAssert((ulTemp == 0) && (ulTemp1 == GCR_GPCMFP_ALT5),
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM4, PC6);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP6;
ulTemp1 = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_ALT6;
TestAssert((ulTemp == 0) && (ulTemp1 == GCR_GPCMFP_ALT6),
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM5, PA4);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP5;
ulTemp1 = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_ALT5;
TestAssert((ulTemp == 0) && (ulTemp1 == GCR_GPCMFP_ALT5),
"xgpio, \"Turn pin to PWM function \" error");
*/
//
// Turn pin to spi function test
//
xSPinTypeSPI(SPI0CLK, PB1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 2);
TestAssert((ulTemp == (3 << 2)),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CLK, PD1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 2);
TestAssert((ulTemp == (2 << 2)),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CLK, PD9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 18);
TestAssert((ulTemp == (1 << 18)),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MOSI, PB2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 4);
TestAssert((ulTemp == (3 << 4 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MOSI, PD2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 4);
TestAssert((ulTemp == (2 << 4 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MOSI, PD10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 20);
TestAssert((ulTemp == (1 << 20 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MISO, PB3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 6);
TestAssert((ulTemp == (3 << 6 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MISO, PD3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 6);
TestAssert((ulTemp == (2 << 6 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MISO, PD11);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 22);
TestAssert((ulTemp == (1 << 22 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CS, PB0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 0);
TestAssert((ulTemp == (3 << 0 )),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CS, PD0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 0);
TestAssert((ulTemp == (2 << 0)),
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CS, PD8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 16);
TestAssert((ulTemp == (1 << 16)),
"xgpio, \"Turn pin to SPI function \" error");
//
// Turn pin to timer function test
//
xSPinTypeTimer(TIMCCP0, PA0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 0);
TestAssert((ulTemp == (3 << 0)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP0, PB0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 0);
TestAssert((ulTemp == (1 << 0)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP0, PD0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 0);
TestAssert((ulTemp == (1 << 0)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP0, PE5);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 10);
TestAssert((ulTemp == (2 << 10)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP1, PA1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 2);
TestAssert((ulTemp == (3 << 2)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP1, PB1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 2);
TestAssert((ulTemp == (1 << 2)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP1, PD1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 2);
TestAssert((ulTemp == (1 << 2)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP1, PE6);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 12);
TestAssert((ulTemp == (2 << 12)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP2, PA2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 4);
TestAssert((ulTemp == (3 << 4)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP2, PB2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 4);
TestAssert((ulTemp == (1 << 4)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP2, PD2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 4);
TestAssert((ulTemp == (1 << 4)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP2, PE7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 14);
TestAssert((ulTemp == (2 << 14)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP3, PA3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 6);
TestAssert((ulTemp == (3 << 6)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP3, PB3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 6);
TestAssert((ulTemp == (1 << 6)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP3, PD3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 6);
TestAssert((ulTemp == (1 << 6)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP3, PE8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 16);
TestAssert((ulTemp == (2 << 16)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP4, PA12);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 24);
TestAssert((ulTemp == (1 << 24)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP4, PC0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 0);
TestAssert((ulTemp == (2 << 0)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP4, PD8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 16);
TestAssert((ulTemp == (3 << 16)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP5, PA13);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 26);
TestAssert((ulTemp == (1 << 26)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP5, PC1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 2);
TestAssert((ulTemp == (2 << 2)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP5, PD9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 18);
TestAssert((ulTemp == (3 << 18)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP6, PA14);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 28);
TestAssert((ulTemp == (1 << 28)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP6, PC2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 4);
TestAssert((ulTemp == (2 << 4)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP6, PD10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 20);
TestAssert((ulTemp == (3 << 20)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP7, PA15);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 30);
TestAssert((ulTemp == (1 << 30)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP7, PC3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 6);
TestAssert((ulTemp == (2 << 6)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP7, PD11);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 22);
TestAssert((ulTemp == (3 << 22)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(T0EX, PC15);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 30);
TestAssert((ulTemp == (2 << 30)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(T0EX, PD13);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 26);
TestAssert((ulTemp == (3 << 26)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(T0EX, PE9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 18);
TestAssert((ulTemp == (2 << 18)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(T1EX, PD12);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 24);
TestAssert((ulTemp == (3 << 24)),
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(T1EX, PE10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 20);
TestAssert((ulTemp == (2 << 20)),
"xgpio, \"Turn pin to TIMER function \" error");
//
// Turn pin to uart function test
//
xSPinTypeUART(UART0RX, PA3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 6);
TestAssert((ulTemp == (2 << 6)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RX, PA11);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 22);
TestAssert((ulTemp == (2 << 22)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RX, PB13);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 26);
TestAssert((ulTemp == (1 << 26)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RX, PC10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 20);
TestAssert((ulTemp == (3 << 20)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0TX, PA2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 4);
TestAssert((ulTemp == (2 << 4)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0TX, PA10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 20);
TestAssert((ulTemp == (2 << 20)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0TX, PB10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 20);
TestAssert((ulTemp == (1 << 20)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0TX, PC8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 16);
TestAssert((ulTemp == (3 << 16)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RTS, PA8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 16);
TestAssert((ulTemp == (2 << 16)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RTS, PB8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 16);
TestAssert((ulTemp == (1 << 16)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RTS, PC11);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 22);
TestAssert((ulTemp == (3 << 22)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0CTS, PA9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 18);
TestAssert((ulTemp == (2 << 18)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0CTS, PB9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 18);
TestAssert((ulTemp == (1 << 18)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0CTS, PC12);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 24);
TestAssert((ulTemp == (3 << 24)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0DCD, PC3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 6);
TestAssert((ulTemp == (3 << 6)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0DCD, PD2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 4);
TestAssert((ulTemp == (3 << 4)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0DSR, PC15);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 30);
TestAssert((ulTemp == (3 << 30)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0DTR, PB7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 14);
TestAssert((ulTemp == (3 << 14)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0DTR, PD0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 0);
TestAssert((ulTemp == (3 << 0)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RI, PC2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 4);
TestAssert((ulTemp == (3 << 4)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RI, PD1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPDCFGR) & (3 << 2);
TestAssert((ulTemp == (3 << 2)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RX, PA7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 14);
TestAssert((ulTemp == (2 << 14)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RX, PB3);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 6);
TestAssert((ulTemp == (2 << 6)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RX, PC5);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 10);
TestAssert((ulTemp == (1 << 10)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1TX, PA6);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 12);
TestAssert((ulTemp == (2 << 12)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1TX, PB2);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 4);
TestAssert((ulTemp == (2 << 4)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1TX, PC4);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 8);
TestAssert((ulTemp == (1 << 8)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RTS, PA4);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 8);
TestAssert((ulTemp == (2 << 8)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RTS, PB0);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 0);
TestAssert((ulTemp == (2 << 0)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RTS, PB15);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 30);
TestAssert((ulTemp == (1 << 30)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RTS, PC13);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 26);
TestAssert((ulTemp == (3 << 26)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1CTS, PA5);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPACFGR) & (3 << 10);
TestAssert((ulTemp == (2 << 10)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1CTS, PB1);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 2);
TestAssert((ulTemp == (2 << 2)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1CTS, PB14);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPBCFGR) & (3 << 28);
TestAssert((ulTemp == (1 << 28)),
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1CTS, PC14);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPCCFGR) & (3 << 28);
TestAssert((ulTemp == (3 << 28)),
"xgpio, \"Turn pin to UART function \" error");
//
// Turn the pin to ACMP function
//
xSPinTypeACMP(CMP0P, PE6);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 12);
TestAssert((ulTemp == (1 << 12)),
"xgpio, \"Turn pin to ACMP function \" error");
xSPinTypeACMP(CMP0N, PE5);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 10);
TestAssert((ulTemp == (1 << 10)),
"xgpio, \"Turn pin to ACMP function \" error");
xSPinTypeACMP(CMP0O, PE7);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 14);
TestAssert((ulTemp == (1 << 14)),
"xgpio, \"Turn pin to ACMP function \" error");
xSPinTypeACMP(CMP1P, PE9);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 18);
TestAssert((ulTemp == (1 << 18)),
"xgpio, \"Turn pin to ACMP function \" error");
xSPinTypeACMP(CMP1N, PE8);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 16);
TestAssert((ulTemp == (1 << 16)),
"xgpio, \"Turn pin to ACMP function \" error");
xSPinTypeACMP(CMP1O, PE10);
ulTemp = xHWREG(GPIO_AFIO_BASE + AFIO_GPECFGR) & (3 << 20);
TestAssert((ulTemp == (1 << 20)),
"xgpio, \"Turn pin to ACMP function \" error");
}
void Blinky(void)
{
volatile int i = 0;
//
// Initionalize system clock.
//
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
//
// Configure LED and USB Disc Port
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOB);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xGPIOPinConfigure(PB4(APP), PB4);
//
// Configure UART Pin
// PA9-->TX PA10-->RX
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSPinTypeUART(UART1TX, PA9);
xSPinTypeUART(UART1RX, PA10);
//xSPinTypeUART(UART2TX, PA2);
//xSPinTypeUART(UART2RX, PA3);
//
// Configure UART1 115200 8-N-1
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xUARTConfigSet(USART1_BASE, 115200, xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE);
xUARTEnable(USART1_BASE, xUART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX);
PrintStr("Embedded Pi Board Test Begin\r\n");
PrintStr("1:LED Test, Now LED will Light\r\n");
//
// Configure LED Port
//
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_13, xGPIO_DIR_MODE_OUT );
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 1 );
xSysCtlDelay(MAX_TICK*10);
PrintStr("2: USB Disc Test, Now you computer will find a new device\r\n");
PrintStr("And LED is Blinking\r\n");
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT );
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_4 , 0 );
//
// Shane LED to indicate that USB Disc is PROCESSING
//
for(i = 0; i < 10; i++)
{
//
// Turn on LED
//
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 1 );
xSysCtlDelay(MAX_TICK);
//
// Turn off LED
//
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 0 );
xSysCtlDelay(MAX_TICK);
}
PrintStr("Now, USB Disc test is over and led will be turned off\r\n");
//
// Turn off LED, USB Disc is over
//
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_4 , 1 );
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 0 );
//Configure PB4 to Jtag Mode
AFIO_DEBUG_REG &= 0x00FFFFFF;
//
// Test Low Speed External crystal
//
PrintStr("3: Low Speed External crystal test begin\r\n");
PrintStr("If you can't see OK later, then test is failure\r\n");
xSysCtlPeripheralEnable(SYSCTL_PERIPH_PWR | SYSCTL_PERIPH_BKP);
SysCtlBackupAccessEnable();
SysCtlLSEConfig(SYSCTL_LSE_OSC_EN);
PrintStr("OK\r\n");
PrintStr("Running");
while(1)
{
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 1 );
PrintStr(".");
xSysCtlDelay(10*MAX_TICK);
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 0 );
PrintStr(".");
xSysCtlDelay(10*MAX_TICK);
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 1 );
PrintStr(".");
xSysCtlDelay(10*MAX_TICK);
xGPIOPinWrite( xGPIO_PORTB_BASE, xGPIO_PIN_13 , 0 );
PrintStr(".");
xSysCtlDelay(10*MAX_TICK);
PrintStr("\b\b\b\b \b\b\b\b");
}
}
//*****************************************************************************
//
//! \brief xgpio002 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
static void xgpio002Execute(void)
{
//
// Set PA.10 as mode in
//
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_10, xGPIO_DIR_MODE_IN);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(xGPIO_PORTA_BASE, xGPIO_PIN_10, user_Callback0);
//
// Enable GPIO pin interrupt.
//
xGPIOPinIntEnable(xGPIO_PORTA_BASE, xGPIO_PIN_10, xGPIO_FALLING_EDGE);
xIntEnable(xINT_GPIOA);
TestAssertQBreak("a", "gpio interrupt test fail", 0xffffffff);
//---------------------------------------------------------------------
//
// Set PB.10 as mode in
//
xGPIODirModeSet(xGPIO_PORTB_BASE, xGPIO_PIN_10, xGPIO_DIR_MODE_IN);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(xGPIO_PORTB_BASE, xGPIO_PIN_10, user_Callback1);
//
// Enable GPIO pin interrupt.
//
xGPIOPinIntEnable(xGPIO_PORTB_BASE, xGPIO_PIN_10, xGPIO_BOTH_EDGES);
xIntEnable(xINT_GPIOB);
TestAssertQBreak("a", "gpio interrupt test fail", 0xffffffff);
//---------------------------------------------------------------------
//
// Set PC.0 mode in.
//
xGPIODirModeSet(xGPIO_PORTC_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_IN);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(xGPIO_PORTC_BASE, xGPIO_PIN_0, user_Callback2);
//
// Enable GPIO pin interrupt.
//
xGPIOPinIntEnable(xGPIO_PORTC_BASE, xGPIO_PIN_0, xGPIO_BOTH_EDGES);
xIntEnable(xINT_GPIOC);
TestAssertQBreak("a", "gpio interrupt test fail", 0xffffffff);
//---------------------------------------------------------------------
//
// Set PD.0 mode in.
//
xGPIODirModeSet(xGPIO_PORTD_BASE, xGPIO_PIN_10, xGPIO_DIR_MODE_IN);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(xGPIO_PORTD_BASE, xGPIO_PIN_10, user_Callback3);
//
// Enable GPIO pin interrupt.
//
xGPIOPinIntEnable(xGPIO_PORTD_BASE, xGPIO_PIN_10, xGPIO_FALLING_EDGE);
xIntEnable(xINT_GPIOD);
TestAssertQBreak("a", "gpio interrupt test fail", 0xffffffff);
}
//*****************************************************************************
//
//! \brief xgpio001 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
static void xgpio001Execute(void)
{
unsigned long ulPin, ulPort;
unsigned long ulvalue, ulTemp, ulTemp1;
int i, j;
//
// GPIO mode set and get.
//
for(ulPort = 0; ulPort < 5; ulPort++)
{
for(ulPin = 0; ulPin < 16; ulPin++)
{
for(i = 0; i < 5; i++)
{
if(ulPort != 1 && ulPort != 3)
{
xGPIODirModeSet(ulGPIO[ulPort], ulPackedPin[ulPin], ulPinMode[i]);
ulvalue = xGPIODirModeGet(ulGPIO[ulPort], ulPackedPin[ulPin]);
TestAssert((ulvalue == ulPinMode[i]),
"xgpio, \" GPIODirModeSet or GPIODirModeGet()\" error");
}
}
}
}
xIntDisable(xINT_GPIOA);
xIntDisable(xINT_GPIOB);
xIntDisable(xINT_GPIOC);
xIntDisable(xINT_GPIOD);
xIntDisable(xINT_GPIOE);
//
// Interrupt enable.
//
for(ulPort = 0; ulPort < 5; ulPort++)
{
for(ulPin = 0; ulPin < 16; ulPin++)
{
for(i = 0; i < 6; i++)
{
xGPIOPinIntEnable(ulGPIO[ulPort], ulPackedPin[ulPin], ulIntType[i]);
if(ulIntType[i] & 0x10)
{
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_IMD) & ulPackedPin[ulPin];
TestAssert(ulTemp == ulPackedPin[ulPin],
"xgpio, \"Level INT type enable \" error");
}
else
{
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_IMD) & ulPackedPin[ulPin];
TestAssert(ulTemp == 0,
"xgpio, \"Edge INT type enable \" error");
}
if(ulIntType[i] & 2)
{
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_IEN) & (ulPackedPin[ulPin] << 16);
TestAssert(ulTemp == (ulPackedPin[ulPin] << 16),
"xgpio, \"Rising or high level Int \" error");
}
if(ulIntType[i] & 1)
{
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_IEN) & ulPackedPin[ulPin];
TestAssert(ulTemp == ulPackedPin[ulPin],
"xgpio, \"Falling or low level Int \" error");
}
}
}
}
//
// Interrupt disable test
//
for(ulPort = 0; ulPort < 5; ulPort++)
{
for(ulPin = 0; ulPin < 16; ulPin++)
{
xGPIOPinIntDisable(ulGPIO[ulPort], ulPackedPin[ulPin]);
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_IEN) & (ulPackedPin[ulPin] << 16);
ulTemp1 = xHWREG(ulGPIO[ulPort] + GPIO_IEN) & ulPackedPin[ulPin];
ulTemp |= ulTemp1;
TestAssert(ulTemp == 0,
"xgpio, \"Interrupt disable test \" error");
}
}
//
// Pin Out/in value test
//
for(ulPort = 0; ulPort < 5; ulPort++)
{
//
// Output pin value set
//
for(ulPin = 0; ulPin < 16; ulPin++)
{
xGPIODirModeSet( ulGPIO[ulPort], ulPackedPin[ulPin], GPIO_DIR_MODE_OUT );
xGPIOPinWrite(ulGPIO[ulPort], ulPackedPin[ulPin], 1);
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_DOUT) & ulPackedPin[ulPin];
TestAssert(ulTemp == ulPackedPin[ulPin],
"xgpio, \"Output pin value set \" error");
}
}
//
// De-bounce enable/disable test
//
for(ulPort = 0; ulPort < 5; ulPort++)
{
//
// De-bounce enable test
//
for(ulPin = 0; ulPin < 16; ulPin++)
{
GPIOPinDebounceEnable(ulGPIO[ulPort], ulPackedPin[ulPin]);
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_DBEN) & ulPackedPin[ulPin];
TestAssert(ulTemp == ulPackedPin[ulPin],
"xgpio, \"De-bounce enable test \" error");
}
//
// De-bounce disable test
//
for(ulPin = 0; ulPin < 16; ulPin++)
{
GPIOPinDebounceDisable(ulGPIO[ulPort], ulPackedPin[ulPin]);
ulTemp = xHWREG(ulGPIO[ulPort] + GPIO_DBEN) & ulPackedPin[ulPin];
TestAssert(ulTemp == 0,
"xgpio, \"De-bounce Disable test \" error");
}
}
//
// Mask set/get test
//
for(ulPort = 0; ulPort < 5; ulPort++)
{
for(ulPin = 0; ulPin < 16; ulPin++)
{
GPIOPinMaskSet(ulGPIO[ulPort], ulPackedPin[ulPin]);
ulTemp = GPIOPortMaskGet(ulGPIO[ulPort]) & ulPackedPin[ulPin];
TestAssert(ulTemp == ulPackedPin[ulPin],
"xgpio, \" Mask set/get test \" error");
}
}
//
// De-bounce time set and get test
//
for(i = 0; i < 2; i++)
{
for(j = 0; j < 3; j++)
{
GPIODebounceTimeSet(ulDelay[i], ulDelayCycle[j]);
ulTemp = xHWREG(GPIO_DBNCECON) & 0x10;
if(i == 0)
{
TestAssert(ulTemp == 0,
"xgpio, \" De-bounce source set \" error");
}
else
{
TestAssert(ulTemp == 0x10,
"xgpio, \" De-bounce source set \" error");
}
ulTemp1 = GPIODebounceTimeGet();
TestAssert(ulTemp1 == ulDelayCycle[j],
"xgpio, \" De-bounce cycle test \" error");
}
}
//
// Pin to peripheral ID test
//
ulTemp = xGPIOSPinToPeripheralId(PA0);
TestAssert(ulTemp == ulPeripheralID[0],
"xgpio, \" Pin to peripheral ID test \" error");
//
// Short pin to pin test
//
ulTemp = xGPIOSPinToPin(PA0);
TestAssert(ulTemp == ulPinValue[0],
"xgpio, \" Short pin to pin test \" error");
ulTemp = xGPIOSPinToPin(PB8);
TestAssert(ulTemp == ulPinValue[1],
"xgpio, \" Short pin to pin test \" error");
ulTemp = xGPIOSPinToPin(PE15);
TestAssert(ulTemp == ulPinValue[2],
"xgpio, \" Short pin to pin test \" error");
//
// Short pin dir mode set test
//
for(i = 0; i < 5; i++)
{
xGPIOSPinDirModeSet(PA0, ulPinMode[i]);
ulTemp = xGPIODirModeGet(xGPIO_PORTA_BASE, GPIO_PIN_0);
TestAssert(ulTemp == ulPinMode[i],
"xgpio, \" Short pin dir mode set test \" error");
}
//
// Short pin interrupt enable
//
for(i = 0; i < 6; i++)
{
xGPIOSPinIntEnable(PA0, ulIntType[i]);
if(ulIntType[i] & 0x10)
{
ulTemp = xHWREG(xGPIO_PORTA_BASE + GPIO_IMD) & GPIO_PIN_0;
TestAssert(ulTemp == GPIO_PIN_0,
"xgpio, \"ShortPin INT type enable \" error");
}
else
{
ulTemp = xHWREG(xGPIO_PORTA_BASE + GPIO_IMD) & GPIO_PIN_0;
TestAssert(ulTemp == 0,
"xgpio, \"ShortPin INT type enable \" error");
}
if(ulIntType[i] & 2)
{
ulTemp = xHWREG(xGPIO_PORTA_BASE + GPIO_IEN) & (GPIO_PIN_0 << 16);
TestAssert(ulTemp == (GPIO_PIN_0 << 16),
"xgpio, \"ShortPin INT type enable \" error");
}
if(ulIntType[i] & 1)
{
ulTemp = xHWREG(xGPIO_PORTA_BASE + GPIO_IEN) & GPIO_PIN_0;
TestAssert(ulTemp == GPIO_PIN_0,
"xgpio, \"ShortPin INT type enable \" error");
}
}
//
// Short pin interrupt disable
//
xGPIOSPinIntDisable(PA0);
ulTemp = xHWREG(xGPIO_PORTA_BASE + GPIO_IEN) & (GPIO_PIN_0 << 16);
ulTemp1 = xHWREG(xGPIO_PORTA_BASE + GPIO_IEN) & GPIO_PIN_0;
ulTemp |= ulTemp1;
TestAssert(ulTemp == 0,
"xgpio, \"Short pin interrupt disable \" error");
//
// Short pin write test
//
xGPIOSPinWrite(PA0, 1);
ulTemp = xHWREG(xGPIO_PORTA_BASE + GPIO_DOUT) & GPIO_PIN_0;
TestAssert(ulTemp == GPIO_PIN_0,
"xgpio, \"Short pin write test \" error");
//
// Turn pin to gpio mode test
//
xGPIOSPinTypeGPIOInput(PA0);
ulTemp = xHWREG(GCR_GPAMFP) & GPIO_PIN_0;
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to gpio mode test \" error");
//
// Turn pin to ADC input function
//
xSPinTypeADC(ADC0, PA0);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP0;
TestAssert(ulTemp == GCR_GPAMFP_MFP0,
"xgpio, \"Turn pin to ADC0 input \" error");
xSPinTypeADC(ADC1, PA1);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP1;
TestAssert(ulTemp == GCR_GPAMFP_MFP1,
"xgpio, \"Turn pin to ADC1 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_4);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC1 input \" error");
xSPinTypeADC(ADC2, PA2);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP2;
TestAssert(ulTemp == GCR_GPAMFP_MFP2,
"xgpio, \"Turn pin to ADC2 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_3);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC2 input \" error");
xSPinTypeADC(ADC3, PA3);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP3;
TestAssert(ulTemp == GCR_GPAMFP_MFP3,
"xgpio, \"Turn pin to ADC3 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_2);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC3 input \" error");
xSPinTypeADC(ADC4, PA4);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP4;
TestAssert(ulTemp == GCR_GPAMFP_MFP4,
"xgpio, \"Turn pin to ADC4 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_1);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC4 input \" error");
xSPinTypeADC(ADC5, PA5);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP5;
TestAssert(ulTemp == GCR_GPAMFP_MFP5,
"xgpio, \"Turn pin to ADC5 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_0);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC5 input \" error");
xSPinTypeADC(ADC6, PA6);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP6;
TestAssert(ulTemp == GCR_GPAMFP_MFP6,
"xgpio, \"Turn pin to ADC6 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC6 input \" error");
xSPinTypeADC(ADC7, PA7);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP7;
TestAssert(ulTemp == GCR_GPAMFP_MFP7,
"xgpio, \"Turn pin to ADC7 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC7 input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & GCR_ALTMFP_PA7_S21;
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to ADC7 input \" error");
//
// Ture pin to I2C function
//
xSPinTypeI2C(I2C0SCK, PA9);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP9;
TestAssert(ulTemp == GCR_GPAMFP_MFP9,
"xgpio, \"Turn pin to I2C input \" error");
xSPinTypeI2C(I2C0SDA, PA8);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP8;
TestAssert(ulTemp == GCR_GPAMFP_MFP8,
"xgpio, \"Turn pin to I2C input \" error");
xSPinTypeI2C(I2C1SCK, PA11);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP11;
TestAssert(ulTemp == GCR_GPAMFP_MFP11,
"xgpio, \"Turn pin to I2C input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to I2C input \" error");
xSPinTypeI2C(I2C1SDA, PA10);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP10;
TestAssert(ulTemp == GCR_GPAMFP_MFP10,
"xgpio, \"Turn pin to I2C input \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to I2C input \" error");
//
// Turn pin to CAN function
//
xSPinTypeCAN(CAN0RX, PD6);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP6;
TestAssert(ulTemp == GCR_GPDMFP_MFP6,
"xgpio, \"Turn pin to CAN function \" error");
xSPinTypeCAN(CAN0TX, PD7);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP7;
TestAssert(ulTemp == GCR_GPDMFP_MFP7,
"xgpio, \"Turn pin to CAN function \" error");
//
// Turn pin to I2S function
//
xSPinTypeI2S(I2S0RXMCLK, PA15);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP15;
TestAssert(ulTemp == GCR_GPAMFP_MFP15,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & GCR_ALTMFP_PA15_I2SMCLK;
TestAssert(ulTemp == GCR_ALTMFP_PA15_I2SMCLK,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0RXSCK, PC1);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP1;
TestAssert(ulTemp == GCR_GPCMFP_MFP1,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC1_I2SBCLK);
TestAssert(ulTemp == GCR_ALTMFP_PC1_I2SBCLK,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0RXSD, PC2);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP2;
TestAssert(ulTemp == GCR_GPCMFP_MFP2,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC2_I2SDI);
TestAssert(ulTemp == GCR_ALTMFP_PC2_I2SDI,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0RXWS, PC0);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP0;
TestAssert(ulTemp == GCR_GPCMFP_MFP0,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC0_I2SLRCLK);
TestAssert(ulTemp == GCR_ALTMFP_PC0_I2SLRCLK,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0TXMCLK, PA15);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP15;
TestAssert(ulTemp == GCR_GPAMFP_MFP15,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & GCR_ALTMFP_PA15_I2SMCLK;
TestAssert(ulTemp == GCR_ALTMFP_PA15_I2SMCLK,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0TXSCK, PC1);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP1;
TestAssert(ulTemp == GCR_GPCMFP_MFP1,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC1_I2SBCLK);
TestAssert(ulTemp == GCR_ALTMFP_PC1_I2SBCLK,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0TXSD, PC3);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP3;
TestAssert(ulTemp == GCR_GPCMFP_MFP3,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC3_I2SDO);
TestAssert(ulTemp == GCR_ALTMFP_PC3_I2SDO,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeI2S(I2S0TXWS, PC0);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP0;
TestAssert(ulTemp == GCR_GPCMFP_MFP0,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC0_I2SLRCLK);
TestAssert(ulTemp == GCR_ALTMFP_PC0_I2SLRCLK,
"xgpio, \"Turn pin to I2S function \" error");
//
// Turn pin to pwm mode
//
xSPinTypePWM(PWM0, PA12);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP12;
TestAssert(ulTemp == GCR_GPAMFP_MFP12,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_5);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to PWM input \" error");
xSPinTypePWM(PWM1, PA13);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP13;
TestAssert(ulTemp == GCR_GPAMFP_MFP13,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_6);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to PWM input \" error");
xSPinTypePWM(PWM2, PA14);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP14;
TestAssert(ulTemp == GCR_GPAMFP_MFP14,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_HB_EN_7);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to PWM input \" error");
xSPinTypePWM(PWM3, PA15);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP15;
TestAssert(ulTemp == GCR_GPAMFP_MFP15,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & GCR_ALTMFP_PA15_I2SMCLK;
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM4, PB11);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP11;
TestAssert(ulTemp == GCR_GPBMFP_MFP11,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB11_PWM4);
TestAssert(ulTemp == GCR_ALTMFP_PB11_PWM4,
"xgpio, \"Turn pin to PWM input \" error");
xSPinTypePWM(PWM5, PE5);
ulTemp = xHWREG(GCR_GPEMFP) & GCR_GPEMFP_MFP5;
TestAssert(ulTemp == GCR_GPEMFP_MFP5,
"xgpio, \"Turn pin to I2S function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PE5_T1EX);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to PWM input \" error");
xSPinTypePWM(PWM6, PE0);
ulTemp = xHWREG(GCR_GPEMFP) & GCR_GPEMFP_MFP0;
TestAssert(ulTemp == GCR_GPEMFP_MFP0,
"xgpio, \"Turn pin to PWM function \" error");
xSPinTypePWM(PWM7, PE1);
ulTemp = xHWREG(GCR_GPEMFP) & GCR_GPEMFP_MFP1;
TestAssert(ulTemp == GCR_GPEMFP_MFP1,
"xgpio, \"Turn pin to PWM function \" error");
//
// Turn pin to spi function test
//
xSPinTypeSPI(SPI0CLK, PC1);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP1;
TestAssert(ulTemp == GCR_GPCMFP_MFP1,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC1_I2SBCLK);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MOSI, PC5);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP5;
TestAssert(ulTemp == GCR_GPCMFP_MFP5,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MOSI, PC3);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP3;
TestAssert(ulTemp == GCR_GPCMFP_MFP3,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0MISO, PC2);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP2;
TestAssert(ulTemp == GCR_GPCMFP_MFP2,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC2_I2SDI);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to I2S function \" error");
xSPinTypeSPI(SPI0MISO, PC4);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP4;
TestAssert(ulTemp == GCR_GPCMFP_MFP4,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CS, PC0);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP0;
TestAssert(ulTemp == GCR_GPCMFP_MFP0,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PC0_I2SLRCLK);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CS, PB10);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP10;
TestAssert(ulTemp == GCR_GPBMFP_MFP10,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB10_S01);
TestAssert(ulTemp == GCR_ALTMFP_PB10_S01,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI0CS, PC0);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP0;
TestAssert(ulTemp == GCR_GPCMFP_MFP0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI1MOSI, PC13);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP13;
TestAssert(ulTemp == GCR_GPCMFP_MFP13,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI1MOSI, PC11);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP11;
TestAssert(ulTemp == GCR_GPCMFP_MFP11,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI1MISO, PC12);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP12;
TestAssert(ulTemp == GCR_GPCMFP_MFP12,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI1MISO, PC10);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP10;
TestAssert(ulTemp == GCR_GPCMFP_MFP10,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI1CS, PB9);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP9;
TestAssert(ulTemp == GCR_GPBMFP_MFP9,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB9_S11);
TestAssert(ulTemp == GCR_ALTMFP_PB9_S11,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI1CS, PC8);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP8;
TestAssert(ulTemp == GCR_GPCMFP_MFP8,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2CLK, PD1);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP1;
TestAssert(ulTemp == GCR_GPDMFP_MFP1,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2MOSI, PD3);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP3;
TestAssert(ulTemp == GCR_GPDMFP_MFP3,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2MOSI, PD5);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP5;
TestAssert(ulTemp == GCR_GPDMFP_MFP5,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2MISO, PD4);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP4;
TestAssert(ulTemp == GCR_GPDMFP_MFP4,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2MISO, PD2);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP2;
TestAssert(ulTemp == GCR_GPDMFP_MFP2,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2CS, PA7);
ulTemp = xHWREG(GCR_GPAMFP) & GCR_GPAMFP_MFP7;
TestAssert(ulTemp == GCR_GPAMFP_MFP7,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PA7_S21);
TestAssert(ulTemp == GCR_ALTMFP_PA7_S21,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI2CS, PD0);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP0;
TestAssert(ulTemp == GCR_GPDMFP_MFP0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3CLK, PD9);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP9;
TestAssert(ulTemp == GCR_GPDMFP_MFP9,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3MOSI, PD11);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP11;
TestAssert(ulTemp == GCR_GPDMFP_MFP11,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3MOSI, PD13);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP13;
TestAssert(ulTemp == GCR_GPDMFP_MFP13,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3MISO, PD10);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP10;
TestAssert(ulTemp == GCR_GPDMFP_MFP10,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3MISO, PD12);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP12;
TestAssert(ulTemp == GCR_GPDMFP_MFP12,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3CS, PB14);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP14;
TestAssert(ulTemp == GCR_GPBMFP_MFP14,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB14_S31);
TestAssert(ulTemp == GCR_ALTMFP_PB14_S31,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeSPI(SPI3CS, PD8);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP8;
TestAssert(ulTemp == GCR_GPDMFP_MFP8,
"xgpio, \"Turn pin to SPI function \" error");
//
// Turn pin to timer function test
//
xSPinTypeTimer(TIMCCP0, PB8);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP8;
TestAssert(ulTemp == GCR_GPBMFP_MFP8,
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP1, PB9);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP9;
TestAssert(ulTemp == GCR_GPBMFP_MFP9,
"xgpio, \"Turn pin to TIMER function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB9_S11);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP2, PB10);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP10;
TestAssert(ulTemp == GCR_GPBMFP_MFP10,
"xgpio, \"Turn pin to TIMER function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB10_S01);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to TIMER function \" error");
xSPinTypeTimer(TIMCCP3, PB11);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP11;
TestAssert(ulTemp == GCR_GPBMFP_MFP11,
"xgpio, \"Turn pin to TIMER function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB11_PWM4);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to TIMER function \" error");
//
// Turn pin to uart function test
//
xSPinTypeUART(UART0RX, PB0);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP0;
TestAssert(ulTemp == GCR_GPBMFP_MFP0,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0TX, PB1);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP1;
TestAssert(ulTemp == GCR_GPBMFP_MFP1,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0RTS, PB2);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP2;
TestAssert(ulTemp == GCR_GPBMFP_MFP2,
"xgpio, \"Turn pin to UART function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_nWRL_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to UART function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB2_T2EX);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART0CTS, PB3);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP3;
TestAssert(ulTemp == GCR_GPBMFP_MFP3,
"xgpio, \"Turn pin to UART function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN | GCR_ALTMFP_EBI_nWRH_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to UART function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_PB3_T3EX);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RTS, PB6);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP6;
TestAssert(ulTemp == GCR_GPBMFP_MFP6,
"xgpio, \"Turn pin to UART function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1RX, PB4);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP4;
TestAssert(ulTemp == GCR_GPBMFP_MFP4,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART1TX, PB5);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP5;
TestAssert(ulTemp == GCR_GPBMFP_MFP5,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART2RX, PD14);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP14;
TestAssert(ulTemp == GCR_GPDMFP_MFP14,
"xgpio, \"Turn pin to UART function \" error");
xSPinTypeUART(UART2TX, PD15);
ulTemp = xHWREG(GCR_GPDMFP) & GCR_GPDMFP_MFP15;
TestAssert(ulTemp == GCR_GPDMFP_MFP15,
"xgpio, \"Turn pin to UART function \" error");
//
// Turn pin to ACMP function test
//
xSPinTypeACMP(CMP0P, PC6);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP6;
TestAssert(ulTemp == GCR_GPCMFP_MFP6,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeACMP(CMP0N, PC7);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP7;
TestAssert(ulTemp == GCR_GPCMFP_MFP7,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeACMP(CMP0O, PB12);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP12;
TestAssert(ulTemp == GCR_GPBMFP_MFP12,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeACMP(CMP1P, PC14);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP14;
TestAssert(ulTemp == GCR_GPCMFP_MFP14,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeACMP(CMP1N, PC15);
ulTemp = xHWREG(GCR_GPCMFP) & GCR_GPCMFP_MFP15;
TestAssert(ulTemp == GCR_GPCMFP_MFP15,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
xSPinTypeACMP(CMP1O, PB13);
ulTemp = xHWREG(GCR_GPBMFP) & GCR_GPBMFP_MFP13;
TestAssert(ulTemp == GCR_GPBMFP_MFP13,
"xgpio, \"Turn pin to SPI function \" error");
ulTemp = xHWREG(GCR_ALTMFP) & (GCR_ALTMFP_EBI_EN);
TestAssert(ulTemp == 0,
"xgpio, \"Turn pin to SPI function \" error");
}
