lm3s-uart0.c

基于Cortex-M3的全自动焊接机

#include  <hw_memmap.h>
#include  <hw_types.h>
#include  <hw_ints.h>
#include  <hw_sysctl.h>
#include  <hw_gpio.h>
#include  <hw_uart.h>
#include  <interrupt.h>
#include  <sysctl.h>
#include  <gpio.h>
#include  <uart.h>
#include  <ctype.h>
#include  "LM3S-UART0.H"
#include  "define.h"
#include  "UartInit.h"


#include "stdlib.h"

/*

  通信双方约定数据头的好处是，能够通过第一个字节
  不是零，来判断执行后续动作
*/
unsigned char Sifu_Drv_Meg = 0x00;
unsigned char Sifu_Run_Spd = 0x00;
unsigned int  Sifu_Run_Dis = 0x0000;
unsigned char Sifu_Baojing_Meg = 0x00;
unsigned char Sifu_Dir = 0;
unsigned char Sifu_Drv = 0;
unsigned char Sifu_Res = 0;


unsigned char rec_data_flag = 0;   //串口收到数据，可以进行数据处理标志位
unsigned char data_reach;
unsigned  char  rec_master_Buf[RX_MAX];                             

unsigned  char  send_master_Buf[TX_MAX];

void enable_uart_servo_interrupt(void)
{
    UARTIntEnable(UART0_BASE , UART_INT_RX | UART_INT_RT);               
    
    IntEnable(INT_UART0);                               /*  使能UART0总中断             */
}

void disable_uart_servo_interrupt(void)
{
    UARTIntDisable(UART0_BASE , UART_INT_RX | UART_INT_RT);               
    
    IntDisable(INT_UART0);                             
}

//  UART0中断服务函数不使能发送中断

void  UART0_ISR(void)
{
    
    static unsigned char Rx_index = 0;
   
    unsigned long  ulStatus;
    
    
    ulStatus  =  UARTIntStatus(UART0_BASE , true); //  读取中断状态
    UARTIntClear(UART0_BASE ,ulStatus);  //清除接收中断和接收超时中断 

    for (;;) {
        if ( !UARTCharsAvail(UART0_BASE) ) {            /*  如果接收FIFO里没有字符      */
            break;
        }
        
        if(ulStatus==UART_INT_RT)//如果是超时中断   ,收到数据不作处理
        {
            for(Rx_index=0;Rx_index<RX_MAX;Rx_index++)
            {
                rec_master_Buf[Rx_index] =  UARTCharGetNonBlocking(UART0_BASE);
            }
            clear_rec_buf();
            Rx_index=0;
            break;
        }
        else if(ulStatus==UART_INT_RX)
        {
            while(UARTCharsAvail(UART0_BASE)) //判断FIFO里面还有数据没有
            {
                rec_master_Buf[Rx_index++] =  UARTCharGetNonBlocking(UART0_BASE);  //读取FIFO里的字符            */      
            }
            Rx_index = 0;
            data_reach = 1 ;
            rec_data_flag = 1;
            /*
              数据处理，原则是下次数据来到之前,及时处理之后清零
              千万不能够在下次数据来之前，该次数据被覆盖而又未
              来得及处理
            */
            disable_uart_servo_interrupt();
            break;  
        }
    }
}


void Rec_Data_Del(void)
{
    unsigned int total_num = 0x00;
    unsigned char i;
    char aa[]={"What "};
    char bb[]={"A "};
    char cc[]={"Fucking "};
    char dd[]={"Day \n"};
    for(i = 1;i<RX_MAX-1;i++)
    {
        total_num = (total_num+rec_master_Buf[i])%255;
    }
    if((rec_data_flag != 0)&&(rec_master_Buf[0]==0xa1)&&(rec_master_Buf[RX_MAX-1]==total_num))
    {
        rec_data_flag = 0;
        Sifu_Drv_Meg = rec_master_Buf[9];
        Sifu_Run_Spd = rec_master_Buf[10];
        Sifu_Run_Dis = (rec_master_Buf[11]<<8) | rec_master_Buf[12];
        
        Sifu_Baojing_Meg = (Sifu_Drv_Meg>>3) & 0x07;
        Sifu_Res = (Sifu_Drv_Meg>>2) & 0x01;
        Sifu_Drv = (Sifu_Drv_Meg>>1) & 0x01;
        Sifu_Dir = Sifu_Drv_Meg & 0x01;
    }
    
    if(Sifu_Dir==0x01)
      UART1_Puts(aa);
    if(Sifu_Drv==0x01)
     UART1_Puts(bb);
    if(Sifu_Run_Spd==0x93)
      UART1_Puts(cc);
    if(Sifu_Run_Dis==0x4567)
      UART1_Puts(dd);
}

void clear_rec_buf(void)
{
    unsigned char i;
    for(i=0;i<RX_MAX;i++)
    {
        rec_master_Buf[i] = 0;
    }
}


void fill_send_slaveBuf(unsigned char Sifu_Dir_Back,unsigned char Sifu_Drv_Back,unsigned char Sifu_Baojing_Back,
                        unsigned char Sifu_Spd_Back,unsigned int Sifu_Dis_Back)
{
        unsigned char i;
        unsigned char SendNumSum = 0x00;
        send_master_Buf[0] = 0xa1;
        for(i=1;i<9;i++)
        {
            send_master_Buf[i] = 0x00;
        }
        send_master_Buf[9] = (Sifu_Baojing_Back<<3) | (Sifu_Drv_Back<<1) | Sifu_Dir_Back;
        send_master_Buf[10] = Sifu_Spd_Back;
        send_master_Buf[11] = (Sifu_Dis_Back>>8) & 0xFF;
        send_master_Buf[12] = Sifu_Dis_Back & 0xFF;
        
        for(i=1;i<TX_MAX-1;i++)
        {
            SendNumSum = (SendNumSum+send_master_Buf[i])%255;
        } 
        send_master_Buf[13] = SendNumSum;
}

void uart0FIFOFill(void)
{
    unsigned char c;
    static unsigned char TxIndex = 0;
    //要不要做保护临界区处理呢
    for (;;)
    {
      
          c = send_master_Buf[TxIndex];
    
          if (TxIndex == TX_MAX)                                //  若填充完毕
          {
              TxIndex = 0;
              break;
          }
    
          if (UARTSpaceAvail(UART0_BASE))                     //  若发送FIFO里有可用空间
          {
              UARTCharPutNB(UART0_BASE, c); 
              TxIndex++;
          }
          else                                                //  若没有空间则跳出，不必等待
          {
              break;
          }
     
    }
    
}