Пример #1
0
/**
 * \brief Application entry point.
 *
 * Configures USART1 in spi master/slave mode and SPI in slave/master mode,start
 * a transmission between two peripherals.
 * \return Unused.
 */
extern int main( void )
{
    char c ;
    char data = 0x0 ;

    /* Disable watchdog */
    WDT_Disable( WDT ) ;

    /*  Configure pins */
    PIO_Configure( pins, PIO_LISTSIZE( pins ) ) ;

    /* Example information log */
    printf( "-- USART SPI Mode Example %s --\n\r", SOFTPACK_VERSION ) ;
    printf( "-- %s\n\r", BOARD_NAME ) ;
    printf( "-- Compiled: %s %s --\n\r", __DATE__, __TIME__ ) ;

    /* display main menu*/
    _DisplayMainmenu() ;

    /* configure USART1 in  Master and SPI in slave mode*/
    _ConfigureUsart( STATE_UM_SS ) ;
    _ConfigureSpi( STATE_UM_SS ) ;

    printf( "--  USART1 as MASTER,SPI as SLAVE.--\n\r" ) ;

    while ( 1 )
    {
        c = UART_GetChar() ;
        switch ( c )
        {
            case 'w':
            case 'W':
            if ( glob_state == STATE_UM_SS )
            {
                data = SPI->SPI_RDR;
                printf( "0x%x\n\r", data ) ;

                /* slave in */
                SPI_ReadBuffer( SPI, pRecvBufferSPI, BUFFER_SIZE ) ;
                SPI_EnableIt( SPI, SPI_IER_RXBUFF ) ;
                /* master out*/
                USART_WriteBuffer( BOARD_USART_BASE, Buffer, BUFFER_SIZE ) ;
                while ( !recvDone ) ;

                if ( recvDone )
                {
                    printf( "----USART1 MASTER WRITE----\n\r" ) ;

                    if ( strncmp( pRecvBufferSPI, Buffer, BUFFER_SIZE ) )
                    {
                        printf( " -F-: Failed!\n\r" ) ;
                    }
                    else
                    {
                       /* successfully received*/
                       _DumpInfo( pRecvBufferSPI, BUFFER_SIZE ) ;
                    }
                    printf( "----END of USART1 MASTER WRITE----\n\r" ) ;
                    memset( pRecvBufferSPI, 0, sizeof( pRecvBufferSPI ) ) ;
                    recvDone = false ;
                }
            }
            else
            {
                data = USART1->US_RHR ;
                printf( "US_RHR:0x%x\n\r", data ) ;

                /* slave in */
                USART_ReadBuffer( USART1, pRecvBufferUSART1, BUFFER_SIZE ) ;
                USART_EnableIt( USART1, US_IER_RXBUFF ) ;
                printf( "----SPI MASTER WRITE----\n\r" ) ;

                /* master out*/
                SPI_WriteBuffer( SPI, Buffer, BUFFER_SIZE ) ;
                while ( !recvDone ) ;
                if ( recvDone )
                {
                    if ( strncmp( pRecvBufferUSART1, Buffer, BUFFER_SIZE ) )
                    {
                       printf( " -F-: Failed!\n\r" ) ;
                    }
                    else
                    {
                       /* successfully received*/
                       _DumpInfo( pRecvBufferUSART1, BUFFER_SIZE ) ;
                    }

                    printf( "----END of SPI MASTER WRITE----\n\r" ) ;
                    memset( pRecvBufferUSART1, 0, sizeof( pRecvBufferUSART1 ) ) ;
                    recvDone = false ;
                }
            }
            break ;

            case 'r':
            case 'R':
            if ( glob_state == STATE_UM_SS )
            {
                data = USART1->US_RHR ;
                printf( "US_RHR:0x%x\n\r", data ) ;

                /* slave out */
                SPI_WriteBuffer( SPI, Buffer, BUFFER_SIZE ) ;

                /* master read */
                USART_ReadBuffer( USART1, pRecvBufferUSART1, BUFFER_SIZE ) ;
                USART_EnableIt( USART1, US_IER_RXBUFF ) ;

                /* start transmission */
                USART_WriteBuffer( BOARD_USART_BASE, Buffer1, BUFFER_SIZE ) ;
                printf( "----USART1 MASTER READ----\n\r" ) ;
                while ( !recvDone ) ;

                if ( recvDone )
                {
                    if ( strncmp( pRecvBufferUSART1, Buffer, BUFFER_SIZE ) )
                    {
                       printf( " -F-: Failed!\n\r" ) ;
                    }
                    else
                    {
                       /* successfully received*/
                       _DumpInfo( pRecvBufferUSART1, BUFFER_SIZE ) ;
                    }
                    printf( "----END of USART1 MASTER READ----\n\r" ) ;
                    memset( pRecvBufferUSART1, 0, sizeof( pRecvBufferUSART1 ) ) ;
                    recvDone = false ;
                }
            }
            else
            {
                data = SPI->SPI_RDR ;
                printf( "SPI_RDR:0x%x\n\r", data ) ;

                /* slave out */
                USART_WriteBuffer( USART1, Buffer, BUFFER_SIZE ) ;
                printf( "----SPI MASTER READ----\n\r" ) ;

                /* master read */
                SPI_ReadBuffer( SPI, pRecvBufferSPI, BUFFER_SIZE ) ;
                SPI_EnableIt( SPI, SPI_IER_RXBUFF ) ;

                /* start transmission */
                SPI_WriteBuffer( SPI, Buffer1, BUFFER_SIZE ) ;
                while ( !recvDone ) ;

                if ( recvDone )
                {
                    if ( strncmp( pRecvBufferSPI, Buffer, BUFFER_SIZE ) )
                    {
                        printf( " -F-: Failed!\n\r" ) ;
                    }
                    else
                    {
                       /* successfully received */
                       _DumpInfo( pRecvBufferSPI, BUFFER_SIZE ) ;
                    }
                    printf("----END of SPI MASTER READ----\n\r");
                    memset(pRecvBufferSPI,0,sizeof(pRecvBufferSPI));
                    recvDone = false;
                }

            }
            break ;

            case 's':
            case 'S':
                if ( glob_state == STATE_UM_SS )
                {
                    glob_state = STATE_US_SM ;
                    _ConfigureUsart( glob_state ) ;
                    _ConfigureSpi( glob_state ) ;

                    printf( "-- USART1 as SLAVE,SPI as MASTER\n\r" ) ;

                }
                else
                {
                    glob_state = STATE_UM_SS ;
                    _ConfigureUsart( glob_state ) ;
                    _ConfigureSpi( glob_state ) ;

                    printf( "-- USART1 as MASTER,SPI as SLAVE\n\r" ) ;
                }
            break ;

            case 'm':
            case 'M':
                _DisplayMainmenu() ;
            break ;

        }

    }
}
Пример #2
0
Файл: main.c Проект: gstroe/Arm
/**
 *  \brief usart_spi Application entry point.
 *
 *  \return Unused (ANSI-C compatibility).
 */
extern int main(void)
{
	uint8_t ucKey, i;

	/* Disable watchdog */
	WDT_Disable(WDT);

	SCB_EnableICache();
	SCB_EnableDCache();

	/* Configure systick for 1 ms. */
	TimeTick_Configure();

	/* Output example information */
	printf("-- USART SPI Example %s --\n\r", SOFTPACK_VERSION);
	printf("-- %s\n\r", BOARD_NAME);
	printf("-- Compiled: %s %s  With %s--\n\r", __DATE__, __TIME__, COMPILER_NAME);

	/* Display menu */
	_DisplayMainmenu();

	while (1) {
		ucKey = DBG_GetChar();
		switch (ucKey) {
			/*usart as spi master*/
		case 'm':
		case 'M':
			/* Configure pins*/
			PIO_Configure(pins1, PIO_LISTSIZE(pins1));
			/* Configure USART as SPI master */
			_ConfigureUsartAsSpiMaster();

			/* Configure SPi slave */
			_ConfigureSpiSlave();
			printf("-I- Configure USART as spi master ...\n\r");
			SPI_EnableIt(SPI, SPI_IER_RDRF);
			SPI_Enable(SPI);

			USART_EnableIt(USART, UART_IER_RXRDY);

			for (i = 0; (pTxBuffer1[i]!='\0' && pTxBuffer2[i]!='\0'); i++) {
				while ((SPI->SPI_SR & SPI_SR_TXEMPTY) == 0);
				SPI->SPI_TDR = ((uint16_t)pTxBuffer2[i]) | SPI_PCS( 0 );
				USART_Write( USART, pTxBuffer1[i], 0);
			}
			break;

			/*usart as spi slave*/
		case 's':
		case 'S':
			printf("-I- Configure USART as spi slave...\n\r");
			/* Configure pins*/
			PIO_Configure(pins2, PIO_LISTSIZE(pins2));
			/* Configure USART as SPI slave */
			_ConfigureUsartAsSpiSlave();
			/* Configure SPI master */
			_ConfigureSpiMaster();
			USART_EnableIt(USART, UART_IER_RXRDY);
			SPI_EnableIt(SPI, SPI_IER_RDRF);
			SPI_Enable(SPI);
			for (i = 0; (pTxBuffer1[i]!='\0' && pTxBuffer2[i]!='\0'); i++) {
				USART_Write(USART, (uint16_t)pTxBuffer2[i], 0);
				SPI_Write( SPI, 1, (uint16_t)pTxBuffer1[i]);
			}
			break;

		case 'h':
		case 'H':
			_DisplayMainmenu();
			break;
		}
	}
}