串口模型-思考明明白白-完成char进入到串口中断

于 2019-09-05 17:41:44 发布
阅读量189 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/100563152
版权 
#include "gkbaseusart.h"
#include "gunit.h"
#include "esp8266.h"
#include "gtimer.h"
//这个没有啥意义 因为没有stop 天生就启动了
static char timerid;

//用于TIME的标识 和USART呼应
typedef struct
{
	volatile uint8_t start;
    volatile uint32_t count;
    volatile uint8_t idle;
}timeflagtype;

timeflagtype tflg;

//用于USART的接收
#define RECEIVE_MAX 200
typedef struct
{
    uint16_t len;
    char rxBuff[RECEIVE_MAX];
}lbDataType;

lbDataType udata;

 
//一共3个脚 TX+RX//RST PA4
#define ESPRST_GPIO_Port GPIOA
#define ESPRST_Pin       GPIO_PIN_4
#define	ESPRST1          HAL_GPIO_WritePin(ESPRST_GPIO_Port, ESPRST_Pin, GPIO_PIN_SET);
#define	ESPRST0          HAL_GPIO_WritePin(ESPRST_GPIO_Port, ESPRST_Pin, GPIO_PIN_RESET);

void post_data_stream_to_onenet(void);

static GK_USARTBASE_TYPE *puart=NULL;

static uint8_t rxbuf[2048];

   

void ESP8266RX(uint8_t ch)
{
    tflg.start=1;
    tflg.count=0;
    udata.rxBuff[udata.len++%RECEIVE_MAX]=ch;
}
static void U2_init(void)
{
  if( (puart = GK_usart_read_obj(2))==NULL)SHOWME;		
  GK_usart_init(puart,2,rxbuf,ESP8266RX);
}

void esp12s_resert( void )
{
	ESPRST0;
	HAL_Delay(10);
	ESPRST1;
	HAL_Delay(100);
    SHOWME
}
void usart_timer_isr(void)
{
	if( tflg.start)
	{
		if( tflg.count++ >= 5 )
		{
            memset(&tflg,0,sizeof(timeflagtype));
            //printf("USART & TIME 就是割韭菜 一旦USART有RX就会tflg.count清0 一旦停止RX tflg.count会在TIME长大 然后被割韭菜");    
            tflg.idle =1;
		}
	}
}
void esp8266_init(void)
{
	static time_type T;
	U2_init();
    memset(&tflg,0,sizeof(timeflagtype));
    timerid = timer.creat(&T, 10,1 , usart_timer_isr);
	esp12s_resert(); 
}


typedef struct _AtType_
{
    uint8_t Cnt;
    char   * At;
    char   * Chk;
}_AtType;

const _AtType AtBank []={
{0,"AT\r\n",                            "OK"},//握手--
{0,"ATE0\r\n",                          "OK"},//关闭回显--
{0,"AT+GMR\r\n",                        "version"},//
{0,"AT+CWMODE_CUR=1\r\n",               "OK"},//
{0,"AT+CWDHCP_DEF=1,1\r\n",             "OK"},//
{0,"AT+CWAUTOCONN=1\r\n",               "OK"},//
{0,"AT+CWJAP_DEF=\"TERMINUS\",\"WXtsl66117066\"\r\n",  "WIFI DISCONNECT"},// 
{0,"AT+CIPSTATUS\r\n",                 "STATUS:2"},//
{0,"AT+CIFSR\r\n",                     "OK"},//
{0,"AT+CIPMUX=1\r\n",                  "OK"},//设置多连接模式

{0,"AT+CIPDOMAIN=\"ibinhub.com\"\r\n", "CIPDOMAIN"},//DNS解析
{0,"AT+CIPSTART=0,\"TCP\",\"183.230.40.33\",80\r\n",  "OK"},//ONENET
{0,"AT+CIPSTART=1,\"TCP\",\"120.24.96.192\",80\r\n",  "OK"},//W5500 OTA平台
};



void WIFI_TX(uint8_t *TX , uint16_t TXlen  )
{
    puf->tx(puart, TX, TXlen);
}
//基础手法
uint8_t WIFI_TXRX_L1(uint8_t *TX , uint16_t TXlen , uint8_t *RX,uint16_t *RXlen )
{
	uint8_t Cnt = 100,ack=0;

    memset(&udata,0,sizeof(lbDataType));
	memset(&tflg,0,sizeof(timeflagtype));

    WIFI_TX(TX,TXlen);

	while(Cnt--)
	{	
		if(tflg.idle)
		{
			ack=1;
			break;
		}
		HAL_Delay(10);	
	}
    if(ack==0)
	return 0; 
   		
	*RXlen=udata.len;
	memcpy(RX,udata.rxBuff,udata.len);

    memset(&udata,0,sizeof(lbDataType));
	memset(&tflg,0,sizeof(timeflagtype));

    printf("TX[%s]RX[%s]\r\n",TX,RX);
	return 1;  
}


//TXRX 携带返回比较
uint8_t WIFI_TXRX_L2(void *tx , uint16_t length , uint16_t timeout , uint8_t repert , void *checkData)
{
    uint8_t *TX = (uint8_t *)tx;
    char *CHK   = (char *)checkData;
	char RX[200]={0};
	uint16_t RXLEN=0;

    while (1)
    {
      if(CHK==NULL)
      {
         printf("ONLY TX [%s]\r\n",TX);
         WIFI_TX(TX,length);
         return 1;
      }
 
	  memset(RX,0,sizeof(RX));
      memset(rxbuf,0,sizeof(rxbuf));
      if( WIFI_TXRX_L1(TX , length ,(uint8_t*)RX , &RXLEN) )
      {

            if( strstr (RX , CHK) != NULL)
            {
              return 1;
            }
            HAL_Delay(timeout);      
      }

      if(repert != 0xFF)
      {
        if( --repert == 0 )return 0;
      }

    }

}


#define	fun_chk( fun,id)	\
  do{\
    if( (fun) )\
      { printf("Function i=%d OK\r\n",id);\
        id++;}\
    else {\
						printf("Function i=%d Failed \r\n",id);\
						{\
                         \
						}\
					}\
  }while(0)
	
char Wifi_Init(void)
{
	uint16_t TXlen=0,i=0;
	char *TX = NULL;
	char *RXCHK = NULL;
	uint8_t rst=0;
	for(i=0;i<sizeof(AtBank)/sizeof(*AtBank);)
	{
				 TX    = AtBank[i].At;
				 TXlen = strlen(TX);
				 RXCHK = AtBank[i].Chk;
				 rst = WIFI_TXRX_L2(TX , TXlen ,500,10, RXCHK);
				 fun_chk(rst,i);

	}
	printf("\r\n\r\n\r\n%s\r\n\r\n\r\n",__FUNCTION__);
	return 0;
}




void esp8266test(void)
{
	static uint8_t  flag=0;

	esp8266_init();
			
	if(flag == 0)
	{
		if(Wifi_Init()==0)//这里都是TXRX 此后的话TX出去 没有RX了
        {
            flag = 1;
        }
	}

 

也就是我有了全新的基础串口模型！

#include "gkbaseusart.h"
#include "string.h"
#include "stdio.h"
#include "gunit.h"
GK_USARTBASE_TYPE GKU2;
GK_USARTBASE_TYPE GKU3;
GK_USARTBASEFUNCTION_TYPE GKUF,*puf;
//使用说明：
//1
//GK_UART_RxIdleCallback(&GKU3);需要在IT中
//#include "usart.h"
//#include "gkbaseusart.h"
//2
//使用比如BM77
//void U3_init(void)
//{
//  if( (puart = GK_usart_read_obj(3))==NULL)SHOWME;		
//  GK_usart_init(puart,3,rxbuf);
//}



uint8_t GK_usart_init(GK_USARTBASE_TYPE *myuart,uint8_t usartid,uint8_t * buf,rxIsrCb rxf)
{
	switch(usartid)//绑定关系
	{
        case 2:myuart->huart=&huart2;break;
		case 3:myuart->huart=&huart3;break;
		default :return 0;	
	}
	myuart->rxBuf=buf;
    myuart->rxf=rxf;
	HAL_UART_Receive_IT(myuart->huart, &myuart->one, 1);//开启中断接收 1个1个的接收// 对应 下文
	__HAL_UART_ENABLE_IT(myuart->huart,UART_IT_IDLE);//开启空闲中断
	__HAL_UART_CLEAR_IDLEFLAG(myuart->huart);
	return 1;
}


void GK_usart_clear(GK_USARTBASE_TYPE *myuart)
{
	memset(&myuart->rx_len,0,sizeof(GK_USARTBASE_TYPE)-offsetof(GK_USARTBASE_TYPE,rx_len));
}


//需要自己放在IT
void GK_UART_RxIdleCallback(GK_USARTBASE_TYPE *myuart)
{
	if(__HAL_UART_GET_FLAG(myuart->huart,UART_FLAG_IDLE))
	{
		__HAL_UART_CLEAR_IDLEFLAG(myuart->huart);
        if(flag==0)
		myuart->received2idle=1;
        else
        {
            printf("#######COM1####\r\n");
            if(myuart->rx_len >1024)
            myuart->received2idle=1;
        }
	}
}

//不需要管理 它会自动调用 本来有WEAK
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) //这里扩展一下！！！！
{ 
	if(huart->Instance == USART3) 
	{ 
		GKU3.rxBuf[GKU3.rx_len++]=GKU3.one;   //类似标准外设库函数// 对应 上文
		HAL_UART_Receive_IT(huart, &GKU3.one, 1) ; 
	} 
	else if(huart->Instance == USART2) 
	{ 
		//GKU2.rxBuf[GKU2.rx_len++%2048]=GKU2.one; 
        GKU2.rxf(GKU2.one); 
		HAL_UART_Receive_IT(huart, &GKU2.one, 1) ; 
	}

}


uint8_t GK_usart_TXRX(GK_USARTBASE_TYPE  *myuart, void *Tx ,uint16_t TXlen ,uint8_t *RX,uint16_t *RXlen)
{
	uint8_t Cnt = 100,ack=0;
	uint8_t *TX =(uint8_t*)Tx;
//准备工作：
	GK_usart_clear(myuart);

//发送：
	HAL_UART_Transmit(myuart->huart, TX, TXlen, 0xFFFF);
//等待返回：
	while(Cnt--)
	{	
		if(myuart->received2idle)
		{
			ack=1;
			break;
		}
		HAL_Delay(10);//尝试次数 10次   这里面其实需要喂狗 每次这样的情形都有喂狗		
	}
//处理返回：
    if(ack==0)
	return 0; 
   		
	*RXlen=myuart->rx_len;
	memcpy(RX,myuart->rxBuf,myuart->rx_len);
	
//收尾工作：有必要的 比如以后不再TXRX了 只是单纯的RX
	GK_usart_clear(myuart);
	return 1;    
}



//通过ID获得全部结构体 以小博大
GK_USARTBASE_TYPE * GK_usart_read_obj( uint8_t usartid)
{
	switch(usartid)
	{
		case 2:return &GKU2;//WIFI
		case 3:return &GKU3;//BLE
		default :return NULL;	
	}
}


void TX(GK_USARTBASE_TYPE *myuart,uint8_t *TX , uint16_t TXlen)
{
    HAL_UART_Transmit(myuart->huart, TX, TXlen, 0xFFFF);
}

uint16_t RX(GK_USARTBASE_TYPE *myuart,uint8_t *RX , uint16_t *RXlen,uint16_t timeout)
{
    while(1)
    {
        if(myuart->received2idle)
        {
            *RXlen = myuart->rx_len;
            memcpy(RX,myuart->rxBuf,*RXlen);
            printf("--*RXlen %d--\r\n",*RXlen );
            break;
        }
        timeout--;
        if(timeout == 0||timeout == 0XFF)break;
        HAL_Delay(10);
    }
    
    if(timeout == 0)
        return 0;
    else
    {
        GK_usart_clear(myuart);
        return *RXlen;
    }
}
void GKF_USART_INIT(void)
{
    puf = &GKUF;

    puf->clear = GK_usart_clear;
    puf->read = GK_usart_read_obj;
    puf->tx   = TX;
    puf->txrx = GK_usart_TXRX;
    puf->rx =   RX;
}

#ifndef __GKBASEUSART_H_
#define __GKBASEUSART_H_

#include "usart.h" 

typedef void (*rxIsrCb)	(uint8_t);

typedef struct
{
	UART_HandleTypeDef *huart; //来自HAL的模块
    rxIsrCb  rxf;
	uint8_t  *rxBuf;//放置数据的-不是数组了这样灵活点儿
	uint16_t rx_len;
	uint8_t  one;//当前过来的HEX
	uint8_t  received2idle;//1空闲中断到了
}GK_USARTBASE_TYPE ;	 

typedef struct
{
   void                  (*clear)(GK_USARTBASE_TYPE *myuart);
   GK_USARTBASE_TYPE*    (*read) (uint8_t id);
   void                  (*tx)   (GK_USARTBASE_TYPE *myuart,uint8_t *TX , uint16_t TXlen);
   uint8_t               (*txrx) (GK_USARTBASE_TYPE *myuart, void *Tx ,uint16_t TXlen ,uint8_t *RX,uint16_t *RXlen);
   uint16_t              (*rx)   (GK_USARTBASE_TYPE *myuart,uint8_t *RX , uint16_t *RXlen,uint16_t timeout);

}GK_USARTBASEFUNCTION_TYPE ;	 


extern GK_USARTBASE_TYPE GKU3;
extern GK_USARTBASE_TYPE GKU2;
extern GK_USARTBASEFUNCTION_TYPE *puf;

extern uint8_t GK_usart_init(GK_USARTBASE_TYPE *myuart,uint8_t usartid,uint8_t* buf,rxIsrCb rxf);
extern uint8_t GK_usart_TXRX(GK_USARTBASE_TYPE  *myuart, void *Tx ,uint16_t TXlen ,uint8_t *RX,uint16_t *RXlen);
extern void GK_usart_clear(GK_USARTBASE_TYPE *myuart);//收发前后
extern void GK_UART_RxIdleCallback(GK_USARTBASE_TYPE *huart);//IT中！
extern GK_USARTBASE_TYPE * GK_usart_read_obj( uint8_t usartid);
extern void GKF_USART_INIT(void);
#endif

 

GKoSon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值