EK-TM4C123G 串口UART0-UART7串口小练阻塞方式

#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/fpu.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/systick.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif





//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

void

ConfigureUART(void)

{

    //

    // Enable the GPIO Peripheral used by the UART.

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);



    //

    // Enable UART0

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);



    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PA0_U0RX);

    ROM_GPIOPinConfigure(GPIO_PA1_U0TX);

    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);









    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

    UARTConfigSetExpClk(UART0_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

    UARTEnable(UART0_BASE);

}



//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{

    //

    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART();





    //

    // Loop forever.

    //

    while(1)

    {

        UARTCharPut(UART0_BASE,0xAA);

    }

}

#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/fpu.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/systick.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif



//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

void

ConfigureUART(void)

{

    //

    // Enable the GPIO Peripheral used by the UART.

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);



    //

    // Enable UART0

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);



    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PA0_U0RX);

    ROM_GPIOPinConfigure(GPIO_PA1_U0TX);

    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);



    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);



    //

    // Initialize the UART for console I/O.

    //

    UARTStdioConfig(0, 115200, 16000000);

}



//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{



    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART();



    UARTprintf("Hello this is TM4C123H6PM USART0!\n");

    UARTprintf("USART0 by stdio.h!\n");

    // Loop forever.

    //

    while(1)

    {

    }

}

//*****************************************************************************

//

// bitband.c - Bit-band manipulation example.

//

// Copyright (c) 2012-2017 Texas Instruments Incorporated.  All rights reserved.

// Software License Agreement

//

// Texas Instruments (TI) is supplying this software for use solely and

// exclusively on TI's microcontroller products. The software is owned by

// TI and/or its suppliers, and is protected under applicable copyright

// laws. You may not combine this software with "viral" open-source

// software in order to form a larger program.

//

// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.

// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT

// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY

// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

// DAMAGES, FOR ANY REASON WHATSOEVER.

//

// This is part of revision 2.1.4.178 of the EK-TM4C123GXL Firmware Package.

//

//*****************************************************************************



#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/fpu.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/systick.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif





//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

void

ConfigureUART(void)

{

    // Enable GPIOC

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOB)));

    //

    // Enable UART1

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART1)));



    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PB0_U1RX);

    ROM_GPIOPinConfigure(GPIO_PB1_U1TX);

    ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);









    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART1_BASE, UART_CLOCK_PIOSC);

    UARTConfigSetExpClk(UART1_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

    UARTEnable(UART1_BASE);

}



//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{



    //

    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART();





    //

    // Loop forever.

    //

    while(1)

    {

        UARTCharPut(UART1_BASE,0xAA);

    }

}

//*****************************************************************************

//

// bitband.c - Bit-band manipulation example.

//

// Copyright (c) 2012-2017 Texas Instruments Incorporated.  All rights reserved.

// Software License Agreement

//

// Texas Instruments (TI) is supplying this software for use solely and

// exclusively on TI's microcontroller products. The software is owned by

// TI and/or its suppliers, and is protected under applicable copyright

// laws. You may not combine this software with "viral" open-source

// software in order to form a larger program.

//

// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.

// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT

// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY

// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

// DAMAGES, FOR ANY REASON WHATSOEVER.

//

// This is part of revision 2.1.4.178 of the EK-TM4C123GXL Firmware Package.

//

//*****************************************************************************



#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/fpu.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/systick.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif





//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

void

ConfigureUART(void)

{

    // Enable GPIOC

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOC)));

    //

    // Enable UART1

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART1)));



    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PC4_U1RX);

    ROM_GPIOPinConfigure(GPIO_PC5_U1TX);

    ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);









    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART1_BASE, UART_CLOCK_PIOSC);

    UARTConfigSetExpClk(UART1_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

    UARTEnable(UART1_BASE);

}



//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{



    //

    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART();





    //

    // Loop forever.

    //

    while(1)

    {

        UARTCharPut(UART1_BASE,0xAA);

    }

}

//*****************************************************************************

//

// bitband.c - Bit-band manipulation example.

//

// Copyright (c) 2012-2017 Texas Instruments Incorporated.  All rights reserved.

// Software License Agreement

//

// Texas Instruments (TI) is supplying this software for use solely and

// exclusively on TI's microcontroller products. The software is owned by

// TI and/or its suppliers, and is protected under applicable copyright

// laws. You may not combine this software with "viral" open-source

// software in order to form a larger program.

//

// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.

// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT

// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY

// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

// DAMAGES, FOR ANY REASON WHATSOEVER.

//

// This is part of revision 2.1.4.178 of the EK-TM4C123GXL Firmware Package.

//

//*****************************************************************************



#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_gpio.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/fpu.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/systick.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif





//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

void

ConfigureUART(void)

{

    // Enable GPIOC

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOD)));

    //

    // Enable UART1

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART2)));



        //ulock PD7

    HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;

    HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0xFF;

    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PD6_U2RX);

    ROM_GPIOPinConfigure(GPIO_PD7_U2TX);

    ROM_GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);









    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART2_BASE, UART_CLOCK_PIOSC);

    UARTConfigSetExpClk(UART2_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

    UARTEnable(UART2_BASE);

}



//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{



    //

    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART();





    //

    // Loop forever.

    //

    while(1)

    {

        UARTCharPut(UART2_BASE,0xAA);

    }

}

//*****************************************************************************

//

// bitband.c - Bit-band manipulation example.

//

// Copyright (c) 2012-2017 Texas Instruments Incorporated.  All rights reserved.

// Software License Agreement

// 

// Texas Instruments (TI) is supplying this software for use solely and

// exclusively on TI's microcontroller products. The software is owned by

// TI and/or its suppliers, and is protected under applicable copyright

// laws. You may not combine this software with "viral" open-source

// software in order to form a larger program.

// 

// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.

// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT

// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY

// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

// DAMAGES, FOR ANY REASON WHATSOEVER.

// 

// This is part of revision 2.1.4.178 of the EK-TM4C123GXL Firmware Package.

//

//*****************************************************************************



#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "inc/hw_gpio.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif



//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

void

ConfigureUART2(void)

{



    // Enable GPIOC

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOD)));

    //

    // Enable UART1

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART2)));



        //ulock PD7

    HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;

    HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0xFF;

    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PD6_U2RX);

    ROM_GPIOPinConfigure(GPIO_PD7_U2TX);

    ROM_GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);



    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART2_BASE, UART_CLOCK_PIOSC);



    //

    // Initialize the UART for console I/O.

    //

    UARTStdioConfig(2, 115200, 16000000);

}

//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{



    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART2();



    UARTprintf("Hello this is TM4C123H6PM USART2!\n");

    UARTprintf("USART2 by stdio.h!\n");

    // Loop forever.

    //

    while(1)

    {

    }

}

//*****************************************************************************

//

// bitband.c - Bit-band manipulation example.

//

// Copyright (c) 2012-2017 Texas Instruments Incorporated.  All rights reserved.

// Software License Agreement

//

// Texas Instruments (TI) is supplying this software for use solely and

// exclusively on TI's microcontroller products. The software is owned by

// TI and/or its suppliers, and is protected under applicable copyright

// laws. You may not combine this software with "viral" open-source

// software in order to form a larger program.

//

// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.

// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT

// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY

// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

// DAMAGES, FOR ANY REASON WHATSOEVER.

//

// This is part of revision 2.1.4.178 of the EK-TM4C123GXL Firmware Package.

//

//*****************************************************************************



#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/debug.h"

#include "driverlib/gpio.h"

#include "driverlib/fpu.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/systick.h"

#include "driverlib/rom.h"

#include "driverlib/uart.h"

#include "utils/uartstdio.h"



//*****************************************************************************

//

//! \addtogroup example_list

//! <h1>Bit-Banding (bitband)</h1>

//!

//! This example application demonstrates the use of the bit-banding

//! capabilities of the Cortex-M4F microprocessor.  All of SRAM and all of the

//! peripherals reside within bit-band regions, meaning that bit-banding

//! operations can be applied to any of them.  In this example, a variable in

//! SRAM is set to a particular value one bit at a time using bit-banding

//! operations (it would be more efficient to do a single non-bit-banded write;

//! this simply demonstrates the operation of bit-banding).

//

//*****************************************************************************





//*****************************************************************************

//

// The value that is to be modified via bit-banding.

//

//*****************************************************************************

static volatile uint32_t g_ui32Value;



//*****************************************************************************

//

// The error routine that is called if the driver library encounters an error.

//

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, uint32_t ui32Line)

{

    while(1)

    {

        //

        // Hang on runtime error.

        //

    }

}

#endif





//*****************************************************************************

//

// Configure the UART and its pins.  This must be called before UARTprintf().

//

//*****************************************************************************

//void

//ConfigureUART3(void)

//{

//    // Enable GPIOC

//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);

//    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOC)));

//    //

//    // Enable UART1

//    //

//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);

//    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART3)));

//

//

//    //

//    // Configure GPIO Pins for UART mode.

//    //

//    ROM_GPIOPinConfigure(GPIO_PC6_U3RX);

//    ROM_GPIOPinConfigure(GPIO_PC7_U3TX);

//    ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7);

//

//

//

//

//    //

//    // Use the internal 16MHz oscillator as the UART clock source.

//    //

//    UARTClockSourceSet(UART3_BASE, UART_CLOCK_PIOSC);

//    UARTConfigSetExpClk(UART3_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

//    UARTEnable(UART3_BASE);

//}





//void

//ConfigureUART4(void)

//{

//    // Enable GPIOC

//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);

//    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOC)));

//    //

//    // Enable UART1

//    //

//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);

//    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART4)));

//

//

//    //

//    // Configure GPIO Pins for UART mode.

//    //

//    ROM_GPIOPinConfigure(GPIO_PC4_U4RX);

//    ROM_GPIOPinConfigure(GPIO_PC5_U4TX);

//    ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);

//

//

//

//

//    //

//    // Use the internal 16MHz oscillator as the UART clock source.

//    //

//    UARTClockSourceSet(UART4_BASE, UART_CLOCK_PIOSC);

//    UARTConfigSetExpClk(UART4_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

//    UARTEnable(UART4_BASE);

//}



//void

//ConfigureUART5(void)

//{

//    // Enable GPIOC

//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);

//    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOE)));

//    //

//    // Enable UART1

//    //

//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART5);

//    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART5)));

//

//

//    //

//    // Configure GPIO Pins for UART mode.

//    //

//    ROM_GPIOPinConfigure(GPIO_PE4_U5RX);

//    ROM_GPIOPinConfigure(GPIO_PE5_U5TX);

//    ROM_GPIOPinTypeUART(GPIO_PORTE_BASE, GPIO_PIN_4 | GPIO_PIN_5);

//

//

//

//

//    //

//    // Use the internal 16MHz oscillator as the UART clock source.

//    //

//    UARTClockSourceSet(UART5_BASE, UART_CLOCK_PIOSC);

//    UARTConfigSetExpClk(UART5_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

//    UARTEnable(UART5_BASE);

//}



void

ConfigureUART7(void)

{

    // Enable GPIOC

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOE)));

    //

    // Enable UART1

    //

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);

    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART7)));





    //

    // Configure GPIO Pins for UART mode.

    //

    ROM_GPIOPinConfigure(GPIO_PE0_U7RX);

    ROM_GPIOPinConfigure(GPIO_PE1_U7TX);

    ROM_GPIOPinTypeUART(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1);









    //

    // Use the internal 16MHz oscillator as the UART clock source.

    //

    UARTClockSourceSet(UART7_BASE, UART_CLOCK_PIOSC);

    UARTConfigSetExpClk(UART7_BASE,16000000,115200,UART_CONFIG_PAR_NONE|UART_CONFIG_STOP_ONE|UART_CONFIG_WLEN_8);

    UARTEnable(UART7_BASE);

}

//*****************************************************************************

//

// This example demonstrates the use of bit-banding to set individual bits

// within a word of SRAM.

//

//*****************************************************************************

int

main(void)

{



    //

    // Set the clocking to run directly from the crystal.

    //

    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

                       SYSCTL_XTAL_16MHZ);



    //

    // Initialize the UART interface.

    //

    ConfigureUART7();





    //

    // Loop forever.

    //

    while(1)

    {

        UARTCharPut(UART7_BASE,0xAA);

    }

}