单步调试串口输出正常，全速运行就只能输出17个字符，是...

l4568527193

1. #include "inc/hw_ints.h"
   
2. #include "inc/hw_memmap.h"
   
3. #include "inc/hw_types.h"
   
4. 
   
5. #include "driverlib/gpio.h"
   
6. #include "driverlib/interrupt.h"
   
7. #include "driverlib/sysctl.h"
   
8. #include "driverlib/timer.h"
   
9. #include "driverlib/uart.h"
   
10. 
    
11. unsigned char str_receive[10];
    
12. unsigned char pr=0,flag_valid_data=0,flag_complete_data=0;
    
13. void
    
14. UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
    
15. {
    
16.     //
    
17.     // Loop while there are more characters to send.
    
18.     //
    
19.     while(ulCount--)
    
20.     {       
    
21.         //
    
22.         // Write the next character to the UART.
    
23.         //
    
24.         UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);
    
25.     }
    
26. }
    
27. 
    
28. void
    
29. UARTIntHandler(void)
    
30. {
    
31. 
    
32.     unsigned long ulStatus;
    
33.        
    
34.     //
    
35.     // Get the interrrupt status.
    
36.     //
    
37.     ulStatus = UARTIntStatus(UART0_BASE, true);
    
38. 
    
39.     //
    
40.     // Clear the asserted interrupts.
    
41.     //
    
42.     UARTIntClear(UART0_BASE, ulStatus);
    
43. 
    
44.     //
    
45.     // Loop while there are characters in the receive FIFO.
    
46.     //
    
47.         str_receive[pr]=UARTCharGetNonBlocking(UART0_BASE);
    
48.         if((str_receive[pr]==0xcf)&&(flag_valid_data==0))
    
49.         {
    
50.                 flag_valid_data=1;
    
51.         }
    
52.         if(flag_valid_data)
    
53.         {
    
54.                 if(str_receive[pr]==0xfc)
    
55.                 {
    
56.                         pr=0;flag_complete_data=1;flag_valid_data=0;
    
57.                 }
    
58.                 else pr++;
    
59.         }
    
60.         else pr=0;
    
61.         if(flag_complete_data==1)
    
62.         {
    
63.                 UARTSend(str_receive,3);
    
64.                 flag_complete_data=0;
    
65.         }
    
66. /*        if(str_receive[0]=='a')
    
67.         {
    
68.                 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);       
    
69.         }
    
70.         else if(str_receive[0]=='b')
    
71.         {
    
72.                 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
    
73.         }  */
    
74. }                                         
    
75. void
    
76. Timer0IntHandler(void)
    
77. {
    
78.         TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
    
79.         IntMasterDisable();
    
80.         UARTSend((unsigned char *)"This is Time interrup!\n",sizeof("This is Time interrup!\n"));
    
81.         IntMasterEnable();
    
82. }
    
83.                                 
    
84. int                                           
    
85. main(void)
    
86. {
    
87.     //
    
88.     // Set the clocking to run directly from the crystal.
    
89.     //
    
90.     SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
    
91.                    SYSCTL_XTAL_8MHZ);
    
92. 
    
93.     //
    
94.     // Enable the peripherals used by this example.
    
95.     //
    
96.     SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
    
97.     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    
98.         SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    
99.     //
    
100.     // Enable processor interrupts.
     
101.     //
     
102.    
     
103.         GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
     
104.         GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
     
105.     //
     
106.     // Set GPIO A0 and A1 as UART pins.
     
107.     //
     
108.         GPIOPinConfigure(GPIO_PA0_U0RX);
     
109.         GPIOPinConfigure(GPIO_PA1_U0TX);
     
110.     GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
     
111. 
     
112.     //
     
113.     // Configure the UART for 115,200, 8-N-1 operation.
     
114.     //
     
115.     UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
     
116.                         (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
     
117.                          UART_CONFIG_PAR_NONE));
     
118. 
     
119.     //
     
120.     // Enable the UART interrupt.
     
121.     //
     
122.     IntEnable(INT_UART0);
     
123.     UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
     
124. 
     
125. 
     
126.         SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
     
127.         TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER);
     
128.         TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet());
     
129.         IntEnable(INT_TIMER0A);
     
130.         TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
     
131.         TimerEnable(TIMER0_BASE, TIMER_A);
     
132.         IntMasterEnable();
     
133.     //
     
134.     // Prompt for text to be entered.
     
135.     //
     
136.     UARTSend((unsigned char *)"It is start!\n", sizeof("It is start!\n"));
     
137.     //
     
138.     // Loop forever echoing data through the UART.
     
139.     //
     
140.     while(1)
     
141.     {                  
     
142.     }
     
143. }
     

复制代码

l4568527193

串口助手上显示的是
It is start!
This is Time inte

wye11083

从现象分析，必然是MCU没做延时处理。

l4568527193

wye11083 发表于 2013-8-31 17:50
从现象分析，必然是MCU没做延时处理。

在哪个地方加延时

wye11083

目测在这里面UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
{
    //
    // Loop while there are more characters to send.
    //
    while(ulCount--)
    {        
        //
        // Write the next character to the UART.
        //
        UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);
    }
}加个标志判断。

mitchell

NonBlocking...
buffer溢出了呗

l4568527193

wye11083 发表于 2013-8-31 18:14
目测在这里面UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
{
    //

什么标志位，什么用途的？

ulCount不就是发送的数据个数么？如果没有了就为0