Skip to content

Instantly share code, notes, and snippets.

@Judiths

Judiths/main.c

Created July 25, 2014 11:13
Show Gist options
  • Save Judiths/817f80dafe1056b04084 to your computer and use it in GitHub Desktop.
Save Judiths/817f80dafe1056b04084 to your computer and use it in GitHub Desktop.
Download ZIP
Serial debugging for TM4C123gh6pm
Raw
main.c
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "driverlib/uart.h"
#include "driverlib/gpio.h"
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_gpio.h"
#include "driverlib/interrupt.h"
#include "LCDDriver.h"
char Character[6] = {0};//定义 Character 为全局变量
void UART0_Int_Handler(void)
{
//中断标志的读取、处理和清除
unsigned long ulStatus;
IntMasterDisable();//使能全局中断
ulStatus = UARTIntStatus(UART0_BASE, true);
UARTIntClear(UART0_BASE, ulStatus);
//根据中断标志处理相关事件
if(ulStatus & UART_INT_RX)
{
int k,i;
for(k = 0; k < 6; k++)
{
Character[k] = UARTCharGet(UART0_BASE);
}
LCD_Draw_String(Character, ENUM_LINE_EIGHT, 3, LCD_DRAW_NORMAL);
for(i = 12;i < 18;i++)
{
LCD_Draw_Char_8x8('#', ENUM_LINE_EIGHT, i, LCD_DRAW_NORMAL);
}
}
IntMasterEnable();//使能全局中断
}
void Int_GPIO_C_Handler(void)
{
IntMasterDisable();//使能全局中断
// 读取中断状态
unsigned long ulStatus;
ulStatus = GPIOIntStatus(GPIO_PORTC_BASE, true);
// 清除中断状态
GPIOIntClear(GPIO_PORTC_BASE, ulStatus);
// 如果KEY的中断状态有效
if (ulStatus & GPIO_PIN_7) //PC7 s1
{
// 延时约10ms，消除按键抖动
SysCtlDelay(20 * (SysCtlClockGet() / 3000));
// 等待KEY抬起
while (GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_7) == 0x00);
// 延时约10ms，消除松键抖动
SysCtlDelay(20 * (SysCtlClockGet() / 3000));
int j;
for(j=3;j<21;j++)
{
LCD_Draw_Char_8x8('-', ENUM_LINE_EIGHT, j, LCD_DRAW_NORMAL);
}
}
IntMasterEnable();//使能全局中断
}
//按键 PD6 中断处理
void Int_GPIO_D_Handler(void)
{
IntMasterDisable();//使能全局中断
unsigned char newchar = '$';
unsigned long ulStatus;
// 读取中断状态
ulStatus = GPIOIntStatus(GPIO_PORTD_BASE, true);
// 清除中断状态
GPIOIntClear(GPIO_PORTD_BASE, ulStatus);
// 如果KEY的中断状态有效
if (ulStatus & GPIO_PIN_6) //PD6 s2
{
// 延时约10ms，消除按键抖动
SysCtlDelay(20 * (SysCtlClockGet() / 3000));
// 等待KEY抬起
while (GPIOPinRead(GPIO_PORTD_BASE, GPIO_PIN_6) == 0x00);
// 延时约10ms，消除松键抖动
SysCtlDelay(20 * (SysCtlClockGet() / 3000));
//发送新字符
UARTCharPut(UART0_BASE, newchar);
}
IntMasterEnable();//使能全局中断
if(ulStatus & GPIO_PIN_7) //PD7 s3
{
// 延时约10ms，消除按键抖动
SysCtlDelay(20 * (SysCtlClockGet() / 3000));
// 等待KEY抬起
while (GPIOPinRead(GPIO_PORTD_BASE, GPIO_PIN_7) == 0x00);
// 延时约10ms，消除松键抖动
SysCtlDelay(20 * (SysCtlClockGet() / 3000));
//显示一个字符*
UARTCharPut(UART0_BASE, '*');
//改变波特率
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE);
}
IntMasterEnable();//使能全局中断
}
//初始化LCD
void Init_LCD(void)
{
LCD_Enable();
LCD_Init();
LCD_ScreenClr();
}
//初始化 UART 模块
void Init_UART(void)
{
//初始化和配置 UART 模块,PA0/PA1
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600, UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE);
//UART 中断配置
UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX7_8, UART_FIFO_RX1_8);
UARTIntRegister(UART0_BASE, UART0_Int_Handler);
UARTIntEnable(UART0_BASE, UART_INT_RX);
//使UART传输数据使能
UARTIntEnable(UART0_BASE, UART_INT_TX);
}
//初始化按键 PC7和PD6
void Init_Key(void) //同时初始化PC7和PD7|PD7
{
//PC|PD按键解锁等等
HWREG(GPIO_PORTC_BASE | GPIO_PORTD_BASE + GPIO_O_LOCK) |= GPIO_LOCK_KEY;
HWREG(GPIO_PORTC_BASE | GPIO_PORTD_BASE + GPIO_O_CR) |= (1<<7);
HWREG(GPIO_PORTC_BASE | GPIO_PORTD_BASE + GPIO_O_DEN) &=(~(1<<7));
HWREG(GPIO_PORTC_BASE | GPIO_PORTD_BASE + GPIO_O_PDR) &= (~(1<<7));
HWREG(GPIO_PORTC_BASE | GPIO_PORTD_BASE + GPIO_O_PUR) &= (~(1<<7));
HWREG(GPIO_PORTC_BASE | GPIO_PORTD_BASE + GPIO_O_AFSEL) &=(~(1<<7));
//PC7 和PD6|PD7按键配置
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC | SYSCTL_PERIPH_GPIOD);
GPIODirModeSet(GPIO_PORTC_BASE , GPIO_PIN_7, GPIO_DIR_MODE_IN);
GPIOPadConfigSet(GPIO_PORTC_BASE , GPIO_PIN_7, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
GPIODirModeSet( GPIO_PORTD_BASE, GPIO_PIN_6|GPIO_PIN_7, GPIO_DIR_MODE_IN);
GPIOPadConfigSet( GPIO_PORTD_BASE, GPIO_PIN_6|GPIO_PIN_7, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
//PC7和PD6|PD7中断配置
GPIOIntTypeSet(GPIO_PORTC_BASE , GPIO_PIN_7, GPIO_LOW_LEVEL);
GPIOIntTypeSet( GPIO_PORTD_BASE, GPIO_PIN_6|GPIO_PIN_7, GPIO_LOW_LEVEL);
GPIOIntRegister(GPIO_PORTC_BASE, Int_GPIO_C_Handler);
GPIOIntRegister(GPIO_PORTD_BASE, Int_GPIO_D_Handler);
GPIOIntEnable(GPIO_PORTC_BASE , GPIO_PIN_7);
GPIOIntClear( GPIO_PORTC_BASE, GPIO_PIN_7);
GPIOIntEnable( GPIO_PORTD_BASE, GPIO_PIN_6|GPIO_PIN_7);
GPIOIntClear( GPIO_PORTD_BASE, GPIO_PIN_6|GPIO_PIN_7);
IntEnable(INT_UART0_TM4C123);
IntMasterEnable();//使能全局中断
}
int main(void)
{
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
Init_LCD();//初始化 LCD
Init_UART();//初始化 UART
Init_Key();//初始化按键 PC7和PD6|PD7
//屏幕上固定显示通信参数
LCD_Draw_String("UART0_Test... ", ENUM_LINE_ONE, 0, LCD_DRAW_NORMAL);
LCD_Draw_String("BaudRate: 9600", ENUM_LINE_THREE, 0, LCD_DRAW_NORMAL); //波特率
LCD_Draw_String("BaudRate*: 115200", ENUM_LINE_FOUR, 0, LCD_DRAW_NORMAL); //波特率
LCD_Draw_String("WordLength: 8", ENUM_LINE_FIVE, 0, LCD_DRAW_NORMAL);
LCD_Draw_String("Parity: None", ENUM_LINE_SIX, 0, LCD_DRAW_NORMAL);
LCD_Draw_String("Stop: 1", ENUM_LINE_SEVEN, 0, LCD_DRAW_NORMAL);
LCD_Draw_String("Re: ", ENUM_LINE_EIGHT, 0, LCD_DRAW_NORMAL);
while(1)
{
SysCtlDelay(SysCtlClockGet() / 12);
}
}
Raw
tm4c123gh6pm_startup_ccs.c
//*****************************************************************************
//
// Startup code for use with TI's Code Composer Studio.
//
// Copyright (c) 2011-2013 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// 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.
//
//*****************************************************************************
#include <stdint.h>
//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
void UART0_Int_Handler(void);
void Int_GPIO_C_Handler(void);
void Int_GPIO_D_Handler(void);
//*****************************************************************************
//
// External declaration for the reset handler that is to be called when the
// processor is started
//
//*****************************************************************************
extern void _c_int00(void);
//*****************************************************************************
//
// Linker variable that marks the top of the stack.
//
//*****************************************************************************
extern uint32_t __STACK_TOP;
//*****************************************************************************
//
// External declarations for the interrupt handlers used by the application.
//
//*****************************************************************************
// To be added by user
//*****************************************************************************
//
// The vector table. Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000 or at the start of
// the program if located at a start address other than 0.
//
//*****************************************************************************
#pragma DATA_SECTION(g_pfnVectors, ".intvecs")
void (* const g_pfnVectors[])(void) =
{
(void (*)(void))((uint32_t)&__STACK_TOP),
// The initial stack pointer
ResetISR, // The reset handler
NmiSR, // The NMI handler
FaultISR, // The hard fault handler
IntDefaultHandler, // The MPU fault handler
IntDefaultHandler, // The bus fault handler
IntDefaultHandler, // The usage fault handler
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // SVCall handler
IntDefaultHandler, // Debug monitor handler
0, // Reserved
IntDefaultHandler, // The PendSV handler
IntDefaultHandler, // The SysTick handler
IntDefaultHandler, // GPIO Port A
IntDefaultHandler, // GPIO Port B
Int_GPIO_C_Handler, // GPIO Port C
Int_GPIO_D_Handler, // GPIO Port D
IntDefaultHandler, // GPIO Port E
UART0_Int_Handler, // UART0 Rx and Tx
IntDefaultHandler, // UART1 Rx and Tx
IntDefaultHandler, // SSI0 Rx and Tx
IntDefaultHandler, // I2C0 Master and Slave
IntDefaultHandler, // PWM Fault
IntDefaultHandler, // PWM Generator 0
IntDefaultHandler, // PWM Generator 1
IntDefaultHandler, // PWM Generator 2
IntDefaultHandler, // Quadrature Encoder 0
IntDefaultHandler, // ADC Sequence 0
IntDefaultHandler, // ADC Sequence 1
IntDefaultHandler, // ADC Sequence 2
IntDefaultHandler, // ADC Sequence 3
IntDefaultHandler, // Watchdog timer
IntDefaultHandler, // Timer 0 subtimer A
IntDefaultHandler, // Timer 0 subtimer B
IntDefaultHandler, // Timer 1 subtimer A
IntDefaultHandler, // Timer 1 subtimer B
IntDefaultHandler, // Timer 2 subtimer A
IntDefaultHandler, // Timer 2 subtimer B
IntDefaultHandler, // Analog Comparator 0
IntDefaultHandler, // Analog Comparator 1
IntDefaultHandler, // Analog Comparator 2
IntDefaultHandler, // System Control (PLL, OSC, BO)
IntDefaultHandler, // FLASH Control
IntDefaultHandler, // GPIO Port F
IntDefaultHandler, // GPIO Port G
IntDefaultHandler, // GPIO Port H
IntDefaultHandler, // UART2 Rx and Tx
IntDefaultHandler, // SSI1 Rx and Tx
IntDefaultHandler, // Timer 3 subtimer A
IntDefaultHandler, // Timer 3 subtimer B
IntDefaultHandler, // I2C1 Master and Slave
IntDefaultHandler, // Quadrature Encoder 1
IntDefaultHandler, // CAN0
IntDefaultHandler, // CAN1
IntDefaultHandler, // CAN2
0, // Reserved
IntDefaultHandler, // Hibernate
IntDefaultHandler, // USB0
IntDefaultHandler, // PWM Generator 3
IntDefaultHandler, // uDMA Software Transfer
IntDefaultHandler, // uDMA Error
IntDefaultHandler, // ADC1 Sequence 0
IntDefaultHandler, // ADC1 Sequence 1
IntDefaultHandler, // ADC1 Sequence 2
IntDefaultHandler, // ADC1 Sequence 3
0, // Reserved
0, // Reserved
IntDefaultHandler, // GPIO Port J
IntDefaultHandler, // GPIO Port K
IntDefaultHandler, // GPIO Port L
IntDefaultHandler, // SSI2 Rx and Tx
IntDefaultHandler, // SSI3 Rx and Tx
IntDefaultHandler, // UART3 Rx and Tx
IntDefaultHandler, // UART4 Rx and Tx
IntDefaultHandler, // UART5 Rx and Tx
IntDefaultHandler, // UART6 Rx and Tx
IntDefaultHandler, // UART7 Rx and Tx
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // I2C2 Master and Slave
IntDefaultHandler, // I2C3 Master and Slave
IntDefaultHandler, // Timer 4 subtimer A
IntDefaultHandler, // Timer 4 subtimer B
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // Timer 5 subtimer A
IntDefaultHandler, // Timer 5 subtimer B
IntDefaultHandler, // Wide Timer 0 subtimer A
IntDefaultHandler, // Wide Timer 0 subtimer B
IntDefaultHandler, // Wide Timer 1 subtimer A
IntDefaultHandler, // Wide Timer 1 subtimer B
IntDefaultHandler, // Wide Timer 2 subtimer A
IntDefaultHandler, // Wide Timer 2 subtimer B
IntDefaultHandler, // Wide Timer 3 subtimer A
IntDefaultHandler, // Wide Timer 3 subtimer B
IntDefaultHandler, // Wide Timer 4 subtimer A
IntDefaultHandler, // Wide Timer 4 subtimer B
IntDefaultHandler, // Wide Timer 5 subtimer A
IntDefaultHandler, // Wide Timer 5 subtimer B
IntDefaultHandler, // FPU
0, // Reserved
0, // Reserved
IntDefaultHandler, // I2C4 Master and Slave
IntDefaultHandler, // I2C5 Master and Slave
IntDefaultHandler, // GPIO Port M
IntDefaultHandler, // GPIO Port N
IntDefaultHandler, // Quadrature Encoder 2
0, // Reserved
0, // Reserved
IntDefaultHandler, // GPIO Port P (Summary or P0)
IntDefaultHandler, // GPIO Port P1
IntDefaultHandler, // GPIO Port P2
IntDefaultHandler, // GPIO Port P3
IntDefaultHandler, // GPIO Port P4
IntDefaultHandler, // GPIO Port P5
IntDefaultHandler, // GPIO Port P6
IntDefaultHandler, // GPIO Port P7
IntDefaultHandler, // GPIO Port Q (Summary or Q0)
IntDefaultHandler, // GPIO Port Q1
IntDefaultHandler, // GPIO Port Q2
IntDefaultHandler, // GPIO Port Q3
IntDefaultHandler, // GPIO Port Q4
IntDefaultHandler, // GPIO Port Q5
IntDefaultHandler, // GPIO Port Q6
IntDefaultHandler, // GPIO Port Q7
IntDefaultHandler, // GPIO Port R
IntDefaultHandler, // GPIO Port S
IntDefaultHandler, // PWM 1 Generator 0
IntDefaultHandler, // PWM 1 Generator 1
IntDefaultHandler, // PWM 1 Generator 2
IntDefaultHandler, // PWM 1 Generator 3
IntDefaultHandler // PWM 1 Fault
};
//*****************************************************************************
//
// This is the code that gets called when the processor first starts execution
// following a reset event. Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called. Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void
ResetISR(void)
{
//
// Jump to the CCS C initialization routine. This will enable the
// floating-point unit as well, so that does not need to be done here.
//
__asm(" .global _c_int00\n"
" b.w _c_int00");
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiSR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
FaultISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
IntDefaultHandler(void)
{
//
// Go into an infinite loop.
//
while(1)
{
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment