0104_APP/src/agm_board/uart_agm.c

#include "uart_agm.h"
#include "delay.h"
#include "app/public.h"
#include "app/air780e.h"

uint32_t uart_delay[UART_MAX];

//根据波特率计算延时时间
void uart_baud_delay(uint8_t uartid, uint32_t baud)
{
    uint32_t delay,temp;
    if(uartid >= UART_MAX)
        return;
    temp = 1000000/baud;
    delay = temp*10 + temp*1;
    uart_delay[uartid] = delay;
    // printf("uart%d,delay:%u\n",uartid,uart_delay[uartid]);
}

void uart_0_debug_init(void)
{
    GPIO_AF_ENABLE(GPIO_AF_PIN(UART, LOGGER_UART, UARTRXD));
    GPIO_AF_ENABLE(GPIO_AF_PIN(UART, LOGGER_UART, UARTTXD));
    SYS_EnableAPBClock(APB_MASK_UART0);
    UART_Init(UART0, 115200, UART_LCR_DATABITS_8, UART_LCR_STOPBITS_1, UART_LCR_PARITY_NONE, UART_LCR_FIFO_1);

    UART_EnableInt(UART0, UART_INT_RX);
    UART_SetRxIntFifoLevel(UART0, UART_INT_FIFO_HALF);
    INT_EnableIRQ(UART0_IRQn, UART_PRIORITY);
}

void data_dump(const char *name, uint8_t *data, uint16_t length)
{
    int index = 0;

    printf("%s Data Info: \r\n    ", name);

    for (index = 0; index < length; index++)
    {
        if ((index % 4 == 0) && index)
        {
            if ((index % 16 == 0) && index)
            {
                printf("\r\n    ");
            }
            else
            {
                printf(" ");
            }
        }
        printf("%02x ", *(data + index));
    }
    printf("\r\n");
}

uint8_t uartDeal[1024] = {0};
uart_rcv_info g_u4ginfo;
uint8_t _tempstr[512],netrcvdata[512];
void UART1_isr(void)
{
    char val;
    volatile static uint16_t dalen = 0;
    volatile static uint8_t flag = 0;
    char *str = NULL, *str1 = NULL,*str2 = NULL;
    char *msg = NULL;
    int slen;
    volatile uint32_t net_rcv_len;
    if (UART_IsRawIntActive(UART1, UART_INT_RX))
    {
        UART_ClearInt(UART1, UART_INT_RX);
        UART_ReceiveCh(UART1, &val, 0);
        g_u4ginfo.rcvBuf[g_u4ginfo.tail] = val;
        if(val == '+'){
            dalen = 0;
        }
        if(dalen > 1023) dalen = 0;
        uartDeal[dalen++] = val;
        if((dalen>6) && (WORK_UPDATE != g_devMsg.workMode)){
             if(strncmp((char*)uartDeal,"+MSUB:",6)==0){ //
                if(uartDeal[dalen-2] =='\r' && uartDeal[dalen-1]=='\n'){
                    flag = 1;
                }
            }
        }
        if((flag == 1) ) {
            str = strstr(uartDeal,"+MSUB:");
            if(str) {
                str1 = strstr(uartDeal,"byte");
                str2 = strstr(str1,"\r\n");
                if(str1 && str2 ){//&&( ucnt-datalen>=(len+2))
                    memset(_tempstr, 0, sizeof(_tempstr));
                    slen = net_data_copy(str1+5,(uint8_t *)_tempstr);
                    net_rcv_len = net_rcvdata_ch((char *)_tempstr,netrcvdata,slen);
                    fifo_write(&g_4Grxfifo,netrcvdata,net_rcv_len);
                    //data_dump("NET RECB", netrcvdata, net_rcv_len);
                    memset(str,0xFF,str2-str1);
                    g_u4ginfo.tail = 0;
                    g_u4ginfo.head = 0;
                }
            }
            dalen = 0;
            flag = 0;
        }
        g_u4ginfo.tail = (g_u4ginfo.tail+1)%UART_RCV_PROCBUF_LEN;
        if(g_u4ginfo.head == g_u4ginfo.tail){ // 前面的已经覆盖
            g_u4ginfo.head = (g_u4ginfo.head+1)%UART_RCV_PROCBUF_LEN;
        }
        timeout_setValue(&g_u4ginfo.ttUart, UART_RCV_TIMEOUT);
        timeout_start(&g_u4ginfo.ttUart);
    }
}

/*--------------------------------------------------------------------------------
 *  串口fifo 的初始化函数
 *  uartid: 串口号 rcv: 信息接收函数
 *--------------------------------------------------------------------------------*/
int uart_rs232_fifo_init(void)
{
    g_u4ginfo.head = 0;
    g_u4ginfo.tail = 0;
    g_u4ginfo.readpos = 0;
    memset(g_u4ginfo.rcvBuf,0,UART_RCV_PROCBUF_LEN);

    return 0;
}
void uart1_4g_init(uint32_t baud)
{
    GPIO_AF_ENABLE(GPIO_AF_PIN(UART, 1, UARTRXD));
    GPIO_AF_ENABLE(GPIO_AF_PIN(UART, 1, UARTTXD));
    SYS_EnableAPBClock(APB_MASK_UART1);

    UART_Init(UART1, baud, UART_LCR_DATABITS_8, UART_LCR_STOPBITS_1, UART_LCR_PARITY_NONE, UART_LCR_FIFO_1);

    UART_EnableInt(UART1, UART_INT_RX);
    //UART_SetRxIntFifoLevel(UART1, UART_INT_FIFO_HALF); //
    INT_EnableIRQ(UART1_IRQn, UART_PRIORITY);
    uart_baud_delay(1,baud);
    uart_rs232_fifo_init();
}

uart485Info_t g_uart485;
uart_com_rcv_info g_uComInfo[3];
uint8_t usart485TX_Buffer[USART3_TX_SIZE];
void read_485_data(void)
{
    static uint8_t tempbuf[256];
    uint8_t strlen = 0;
    static uint16_t len = 0;
    //len = 0;


    if(timeout_isOut(&g_uComInfo[0].ttUart)&& g_uComInfo[0].ttUart.endMode==3){
        timeout_stop(&g_uComInfo[0].ttUart);
        //printf("head = %d, tail=%d\n",g_uComInfo[0].head,g_uComInfo[0].tail);
        while(g_uComInfo[0].head != g_uComInfo[0].tail){
            tempbuf[len++] = g_uComInfo[0].rcvBuf[g_uComInfo[0].head];
            g_uComInfo[0].head = (g_uComInfo[0].head+1)%UART_COM_RCVBUF_LEN;
        }
        if(strstr(tempbuf,"AT+PTMOD=ON\r\n") && (g_devMsg.workMode != WORK_UPDATE)){
            //fifo_write(&g_rxfifo,tempbuf,len);// 数据加入到fifo中
            printf("jum to pt\n");
            len = 0;
            memset(tempbuf,0,256);
            run_app();

        }
        if(len >= 12)
        {
            //printf("head = %d, tail=%d\n",g_uComInfo[0].head,g_uComInfo[0].tail);
            //data_dump("收到 ~~~~~~~~: ",tempbuf,len);
            strlen = (tempbuf[11]<<8)| tempbuf[10];
            if(len >= (strlen+12)) {
                fifo_write(&g_rxfifo,tempbuf,len);// 数据加入到fifo中
                len = 0;
                memset(tempbuf,0,256);
            }
            if(len >= 256) len = 0;
        }

    }


}
void UART2_isr(void)
{
    char data;
    uart_com_rcv_info *uinfo;

    uinfo = &g_uComInfo[0];
    if (UART_IsRawIntActive(UART2, UART_INT_RX))
    {
        UART_ReceiveCh(UART2, &data, 0);
        uinfo->rcvBuf[uinfo->tail] = data;
        uinfo->tail = (uinfo->tail + 1)%UART_COM_RCVBUF_LEN;
        timeout_setValue(&uinfo->ttUart,UART_RCV_TIMEOUT);
        timeout_start(&uinfo->ttUart);
        UART_ClearInt(UART2, UART_INT_RX);
    }
}

void uart2_485_init(uint32_t baud)
{
    GPIO_AF_ENABLE(GPIO_AF_PIN(UART, 2, UARTRXD));
    GPIO_AF_ENABLE(GPIO_AF_PIN(UART, 2, UARTTXD));
    SYS_EnableAPBClock(APB_MASK_UART2);
    UART_Init(UART2, baud, UART_LCR_DATABITS_8, UART_LCR_STOPBITS_1, UART_LCR_PARITY_NONE, UART_LCR_FIFO_1);

    UART_EnableInt(UART2, UART_INT_RX);
    UART_SetRxIntFifoLevel(UART2, UART_INT_FIFO_HALF);
    INT_EnableIRQ(UART2_IRQn, UART_PRIORITY);

    // 485 CTL
    SYS_EnableAPBClock(APB_MASK_GPIO1);
    GPIO_SetOutput(GPIO1, GPIO_BIT2);
    RS485_RX();

    g_uComInfo[0].head = 0;
    g_uComInfo[0].tail = 0;

    uart_baud_delay(2,baud);
}



// 串口发送函数
UART_TypeDef *uart_choice(uint8_t uartid)
{
    UART_TypeDef *USARTx;
    switch (uartid)
    {
    case UART0_ID:
        USARTx = UART0;
        break;
    case UART1_ID:
        USARTx = UART1;
        break;
    case UART2_ID:
        USARTx = UART2;
        break;
    case UART3_ID:
        USARTx = UART3;
        break;
    case UART4_ID:
        USARTx = UART4;
        break;
    default:
        break;
    }
    return USARTx;
}
/*******************************************************************************
 *uart1_msg_send 发送报文处理
 *Input:
 *	buf		--需要发送的数据指针
 *	buflen	--发送的数据长度
 *Output:
 *	None
 *Return:
 *	OK/ERROR，表示执行成功和失败
 */
ReturnCodeTypedef UART_Send_t(uint8_t uartid, UART_TypeDef *uart, const unsigned char *p, unsigned int num)
{
    for (unsigned int i = 0; i < num; ++i)
    {
        // UART_SendCh(uart,*p);
        // p++;
        // delay_us(90);
        while (UART_IsTxFifoFull(uart))
            ;

        uart->DR = *p++;

        delay_us(uart_delay[uartid]);
    }
    return RET_OK;
}
int uart_msg_send(uint8_t uartid, const char *buf, uint32_t buflen)
{
    uint32_t t = 0;
    UART_TypeDef *USARTx;

    if (uartid >= UART_MAX)
        return -1;
    if (uartid == UART2_ID)
        RS485_TX();
    USARTx = uart_choice(uartid);
    UART_Send_t(uartid, USARTx, buf, buflen);
    // UART_Send(USARTx, buf, buflen);
    if (uartid == UART2_ID)
    {
        // delay_us(60);
        RS485_RX();
    }
    return 0;
}