SDK测试-串口-FIFO

最新推荐文章于 2024-04-09 09:39:01 发布
最新推荐文章于 2024-04-09 09:39:01 发布
阅读量368 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/101696510
版权

完成明白3个FIFO

#include "gsmuart.h"
#include "gkbaseusart.h"
#include "gunit.h"
#include "gbaselist.h"
#include "GAppCmd.h"

void *puart=NULL;

//++++++++++++使用串口框架+++++++++++//
typedef struct
{
	volatile uint8_t  start;
    volatile uint32_t count;
    volatile uint8_t  idle;
}timeflagtype;

timeflagtype tflg;


#define RECEIVE_MAX 2048
typedef struct
{
    uint16_t len;
    char rxBuff[RECEIVE_MAX];
}lbDataType;

lbDataType udata;
//++++++++++++使用串口框架+++++++++++//
void mode_clear(void)
{
    memset(&udata,0,sizeof(lbDataType));
	memset(&tflg,0,sizeof(timeflagtype)); 
}
void usart_timer_isr(void)
{
	if( tflg.start)
	{
		if( tflg.count++ > 3 )
		{
            memset(&tflg,0,sizeof(timeflagtype));  
            tflg.idle =1;
		}
	}
}

void smuart_rxbyte(uint8_t data)
{
   //printf("data=%c\r\n",data);
    tflg.start=1;
    tflg.count=0;
    udata.rxBuff[udata.len++%RECEIVE_MAX]=data;
}

uint8_t *rxbuf;

void puart_init(void)
{
  rxbuf = malloc(100);
  printf("rxbuf add = %p\r\n",rxbuf);
  if( (puart = GK_usart_read_obj(1))==NULL)SHOWME;		
  GK_usart_init(puart,1,rxbuf,NULL);
}

void puart_reinit(void)
{	
    free(rxbuf);//也可以直接用 lbDataType udata;里面的 rxBuff[RECEIVE_MAX];


    GK_usart_init(puart,1,NULL,smuart_rxbyte);
    static node_oncetime_type T;
    timer.creat(&T, 1 , 1 ,usart_timer_isr );
}


void smuart_init(void)
{
	puart_init();
}


uint8_t smuart_TXRX_L1(uint8_t *TX , uint16_t TXlen , uint8_t *RX,uint16_t *RXlen )
{

	if(GK_usart_TXRX(puart, TX ,TXlen ,RX,RXlen))
	{
	    printf("TX:");printf("%s\r\n",TX);
	    printf("RX:");printf("%s\r\n",RX);
		return 1;
	}
	else
		return 0;
}


uint8_t smuart_TXRX_L2(uint8_t *TX , uint16_t TXlen , uint8_t *MUSTRX)
{
	char cnt=100;
	uint8_t RX[100]={0};
	uint16_t RXlen=0;
	while(--cnt !=0 )
	{
        HAL_Delay(100);
        memset(RX,0,100);
		if(smuart_TXRX_L1(TX ,TXlen ,RX,&RXlen))
		{
			if(strstr((char *)RX,(char *)MUSTRX))
			return 1;
		}
	}
		return 0;
}

#include "GAppCmd.h"
void smuart_test(void)
{
	static uint8_t  flag=0;
	smuart_init();
    registerCmds();
    //commer.ShowSelf();

    gizwitsInit();//L1级别
    FIFO_Init_L2();//L2级别
    FIFO_Init_pRbsend();
	while(1)
	{
		if(flag == 0)
		{
			if( smuart_TXRX_L2((uint8_t *)"hello",6,(uint8_t *)"world"))
			{
				flag = 1;
			}

		}

		if(flag==1)
		{
             puart_reinit();
             mode_clear();
			 flag = 2;
		}

		if(flag==2)
		{
			if(tflg.idle)
            {

                printf("\r\n+\r\n");
                G_printHEX(udata.rxBuff,udata.len);
                printf("\r\n+\r\n");

                
#if 0 //OLD 

    tslProtocolPutData((uint8_t *)udata.rxBuff,udata.len);

#else //NEW PUT  try:0101

    ProtocolMessage_t message;
    message.fd = 0;
    memcpy(message.data, (uint8_t *)udata.rxBuff,udata.len);
    message.len = 1;
    tslProtocolPutMessage(&message);
#endif
        
                mode_clear();
            }
		}
	 HAL_Delay(200);	
	}
}

#include "GAppCmd.h"
#include "gunit.h"

static void connect(int fd, uint8_t sn, uint16_t len, uint8_t *data);
static void clearCard(int fd, uint8_t sn, uint16_t len, uint8_t *data);


static node_command_type commands[] = {
    {"connect",   NULL, 0X0100, connect,NULL},
    {"clearCard", NULL, 0X0101, clearCard,NULL},
};

static void connect(int fd, uint8_t sn, uint16_t len, uint8_t *data) {SHOWME
}

static void clearCard(int fd, uint8_t sn, uint16_t len, uint8_t *data) {SHOWME
}

//注册技术 可以把上面自己搞的函数注册进去
void registerCmds(void) {
    commer.Register(&commands[0], sizeof(commands) / sizeof(commands[0]));
}
//使用案例
//node_command_type * cmdnode = commer.find(id);
//if(cmdnode !=NULL)
//cmdnode->fun();





#include "GringBuffer.h"

#define RB_MAX_LEN 200
rb_t pRb;       
static uint8_t rbBuf[RB_MAX_LEN];


void gizwitsInit(void)
{    
    pRb.rbCapacity = RB_MAX_LEN;
    pRb.rbBuff = rbBuf;
    if(0 == rbCreate(&pRb))
	{
		printf("rbCreate Success \n");
	}
	else
	{
		printf("rbCreate Faild \n");
	}


}

rb_t pRbL2;       
static uint8_t rbBufL2[RB_MAX_LEN];

void FIFO_Init_L2(void)
{    
    pRbL2.rbCapacity = RB_MAX_LEN;
    pRbL2.rbBuff = rbBufL2;
    if(0 == rbCreate(&pRbL2))
	{
		printf("pRbL2Create Success \n");
	}
	else
	{
		printf("pRbL2Create Faild \n");
	}

}

rb_t pRbsend;       
static uint8_t Rbsend[RB_MAX_LEN];

void FIFO_Init_pRbsend(void)
{    
    pRbsend.rbCapacity = RB_MAX_LEN;
    pRbsend.rbBuff = Rbsend;
    if(0 == rbCreate(&pRbsend))
	{
		printf("pRbsendCreate Success \n");
	}
	else
	{
		printf("pRbsendCreate Faild \n");
	}

}
/*
 * 将收到的数据放入环形队列  
 */
int32_t tslProtocolPutData(uint8_t *buf, int32_t len) {
    int32_t count = 0;
    
    if(NULL == buf) {
        return -1;
    }
    
    count = rbWrite(&pRb,  buf, len);
    
    return count;
}


/*
 * 将收到的数据放入环形队列
 */
    
int32_t tslProtocolPutMessage(ProtocolMessage_t *message) 
{
    int32_t count = 0;
    
    if(NULL == message) {
        return -1;
    }
    
    count = rbWrite(&pRb, (uint8_t *)message, sizeof(ProtocolMessage_t));
    
    return count;
}


#include "GAppCmd.h"

void showp(ProtocolMessage_t *p)
{
        printf("p->fd=%04X\r\n",p->fd);
        G_printHEX(&p->data,10);
        printf("p->len=%04X\r\n",p->len);

}
/*
 * 处理用户注册的命令
 * 需要单独在一个线程中运行
这里的用法是在串口中接收数据 也即是放入到FIFO 然后在任务中读FIFO拿出来解析
 */
int8_t tslProtocolHandleCmd(void) {
    int32_t tempLength = 0;
    ProtocolMessage_t message;
    
    tempLength = rbRead(&pRb, (uint8_t *)&message, sizeof(ProtocolMessage_t));
    if (tempLength == sizeof(ProtocolMessage_t)) 
        {
                printf("\r\n");
                G_printHEX(&message,sizeof(ProtocolMessage_t));
                printf("\r\n");
                showp(&message);
                node_command_type *node =  commer.Find(message.fd);
                if(node !=NULL)
                    node->fun(0,0,0,NULL);
                return 0;
        } 
    else 
       {
            return -1;
        }
    }
    






/*
 * 通过TCP写入一定长度的数据
 * 此接口必须实现
把数据放到FIFO 它没有前面的做的好 前面是写一个结构体进去！比写数据进去好！
 */

//int32_t tslProtocolPutData(uint8_t *buf, int32_t len) {一抹一眼

uint32_t tslTcpWrite(int fd, uint8_t *data, uint32_t size) {
    int32_t count = 0;
    
    if(NULL == data) {
        return 0;
    }
    
    count = rbWrite(&pRbsend,  data, size); 
    
    return count;
}

/*
 * 处理用户注册的命令
 * 需要单独在一个线程中运行
这里的用法是在程序中任意位置调用tslTcpWrite 放入到FIFO 然后在任务中读FIFO拿出发送出去
 */
int8_t tslProtocolHandleSend(void) {
    int32_t tempLength = 0;
    uint8_t tempData[20];
    
    tempLength = rbRead(&pRbsend, (uint8_t *)&tempData, sizeof(tempData));
    if (tempLength >0)
        {
                printf("\r\n#tslProtocolHandleSend\r\n");
                G_printHEX(tempData,tempLength);
                printf("\r\n#tslProtocolHandleSend\r\n");
                //tcpWrite(tempData, tempLength);//模块发送出去 可以是BLE W5500等 
                return 0;
        }
     return 1;
}
/* 举例
static void sendDataTask(void *pvParameters) {
    int32_t tempLength = 0;
    uint8_t tempData[20];
    
    pvParameters = pvParameters;

    for (; ;) {
        osDelay(10);
        tempLength = rt_ringbuffer_get(&sendRingBuffer, (uint8_t *)&tempData, sizeof(tempData));
        if (tempLength > 0) {
           tcpWrite(tempData, tempLength);
        }
    }
}   */







typedef void (*DataHandleHook)(uint8_t len, uint8_t *data);
static DataHandleHook   reciveDataHandleHook = NULL;
/*
 * 设置数据处理钩子函数
 * 比如数据是加密的，协议栈传输的时候是不知道的，这时可以设置钩子函数解密数据
 */
void registerReciveDataHandleHook(DataHandleHook hook) {
    reciveDataHandleHook = hook;
}

#define MAX_DATA_LEN        20
typedef struct {
    uint8_t         head;      
    uint8_t         num;  
    uint8_t         rnum;     
    uint16_t        alen;        
} ProtocolHead_t;
typedef struct {
    ProtocolHead_t   head;
    uint8_t          data[MAX_DATA_LEN];
    uint16_t         crc;
    int              fd;
} ProtocolCommon_t;

static ProtocolCommon_t dataProtocol;
void show_ProtData(ProtocolCommon_t *pag)
{
    printf("\n****************************************** \r\n");
    printf("pag->head.head= [%02X]\r\n" , pag->head.head);
    printf("pag->head.num= [%02X]\r\n" , pag->head.num);
    printf("pag->head.rnum= [%02X]\r\n" , pag->head.rnum);
    printf("pag->head.alen= [%04X]\r\n" , pag->head.alen);
    G_printHEX(pag->data,pag->head.alen);
    printf("pag->crc= [%04X]\r\n" , pag->crc);
    printf("\n****************************************** \r\n");
}

//分析状态机
typedef enum {
    Protocol_head,
    Protocol_num,
    Protocol_rnum,
    Protocol_alen,
    Protocol_body,
    Protocol_crc,
} ProtocolStatus_t;

typedef struct {
    ProtocolStatus_t status;
    uint8_t          alen;
    uint8_t          rlen;
    uint8_t          cmdCount;
    uint16_t         check;
} StatusData_t;

static StatusData_t     statusMachineData;

/*
 * 复位状态机 仅仅针对POS设置
 */
void resetStateMachine(void) {
    statusMachineData.status = Protocol_head;
}

/*
 * 复位状态机中间变量 其他成员清0
 */
void resetStateMachineData(void) {
    statusMachineData.alen = 0;
    statusMachineData.rlen = 0;
    statusMachineData.cmdCount = 0;
    statusMachineData.check = 0;
}
/*
* 协议分析
*/
int8_t protocolAnalyze(int fd, ProtocolCommon_t *protocol, uint8_t element) 
{
	uint16_t crc16 = 0;
	uint8_t finish = 0;
	switch(statusMachineData.status)
	{
		case Protocol_head:
		{
			if (element == 0XAA) 
			{
				statusMachineData.status = Protocol_num;
				protocol->head.head = 0XAA;
			}
			else 
			{
				resetStateMachine();
				resetStateMachineData();
			}
		} break;
		case Protocol_num:
		{
			protocol->head.num = element;
			statusMachineData.status = Protocol_rnum;
		}  break;
		case Protocol_rnum :
		{
			protocol->head.rnum = element;
			statusMachineData.status = Protocol_alen;
		}  break;
		case Protocol_alen:
		{
			if (statusMachineData.cmdCount == 0) 
			{
				protocol->head.alen = element << 8;
				statusMachineData.cmdCount = 1;
			} 
			else if (statusMachineData.cmdCount == 1) 
			{
				protocol->head.alen |= element;
				statusMachineData.cmdCount = 0;
				statusMachineData.alen = protocol->head.alen;
				statusMachineData.status = Protocol_body;
			}
		} break;
		case Protocol_body:
		{
			protocol->data[statusMachineData.rlen++] = element;
			if (statusMachineData.rlen >= statusMachineData.alen) 
			{
				statusMachineData.status = Protocol_crc;
			}
		}  break;
		case Protocol_crc:
		{
			if (statusMachineData.cmdCount == 0)
			{
				protocol->crc = element << 8;
				statusMachineData.cmdCount = 1;
			} 
			else if (statusMachineData.cmdCount == 1) 
			{
				protocol->crc |= element;
				statusMachineData.cmdCount = 0;
				finish =1;
			}
		} break;
		default :    NEVERSHOW  break;
	}
	if(finish)
		if (crc16 == protocol->crc) 
		{   
            show_ProtData(protocol);
			protocol->fd = fd;
			resetStateMachine();
			resetStateMachineData();
			return 0;
		}
    
	return -1;
}

//L1---L2的传递 L1读出来写到L2
int8_t tslProtocolLoop(void) {
    int32_t tempLength = 0;
    ProtocolMessage_t message;
    int8_t ret = 0;
    
    tempLength = rbRead(&pRb, (uint8_t *)&message, sizeof(ProtocolMessage_t));
    if (tempLength == sizeof(ProtocolMessage_t)) {
        for (int i = 0; i < message.len; i++) {
            ret = protocolAnalyze(message.fd, &dataProtocol, message.data[i]);
            if (ret == 0)
            {
                if (reciveDataHandleHook) 
                    {
                        reciveDataHandleHook(dataProtocol.head.alen, dataProtocol.data);
                    }
               rbWrite(&pRbL2, (uint8_t *)&dataProtocol, sizeof(ProtocolCommon_t));
            }
        }
    }
    
    return 0;
}

/*L2的读出
 * 处理用户注册的命令
 * 需要单独在一个线程中运行
这里的用法是在串口中接收数据 也即是放入到FIFO 然后在任务中读FIFO拿出来解析
 */
int8_t tslProtocolHandle(void) 
{
    int32_t tempLength = 0;
    ProtocolCommon_t dataProtocol;
    
    tempLength = rbRead(&pRbL2, (uint8_t *)&dataProtocol, sizeof(ProtocolCommon_t));
    if (tempLength == sizeof(ProtocolCommon_t)) 
        {
                printf("\r\n");
                G_printHEX(&dataProtocol,sizeof(ProtocolCommon_t));
                printf("\r\n");
                show_ProtData(&dataProtocol);
                node_command_type *node =  commer.Find(dataProtocol.data[0]<<8 |dataProtocol.data[1] );
                if(node !=NULL)
                    node->fun(0,0,0,NULL);

                tslTcpWrite(0,"123456",6);
                return 0;
        } 
    else 
       {
            return -1;
        }
    }


    
#include "GAppCmd.h"
char timerid=0;
void timerpaly(void)
{   
    static int cnt=0;
    ++cnt;
   // printf("\r\ncnt=%d\r\n",cnt);

  //  tslProtocolHandleCmd();
tslProtocolHandleSend();
tslProtocolLoop();
tslProtocolHandle();
}

 

GKoSon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
纯SDK开发的串口调试工具
05-12
使用纯Win32 SDK开发的串口调试工具. 这是源代码。
自定义axi-lite ip，修改，可以访问32bit地址，配套SDK测试用例
08-01
例如，如果项目中不需要串口或FIFO，可以将其从IP核中移除，节省资源并优化性能。 在实际应用中，这种自定义的AXI-Lite IP核可以用于配置和控制各种硬件模块，如PLLs、存储控制器或数字信号处理器。通过SDK测试用例...
SDK 串口使用
shx_2613的博客
03-18 616
串口初始化需要初始化 // 串口部分 XuartPs 1.cfg(id)\ gic 中断管理 初始化 2.波特率 3.fifoThreshold fifo阈值 4.Timeout 超时中断长度 4*波特率周期 5.使能中断类型 超时中断、阈值中断等 //中断部分 XScugic 1.lookup cfg 获取地址和实例初始化 2. setpropertiy设置中断优先级、触发方式等 3.connect 连接中断处理函数及传递参数 4.Enable 使能对应中断 uart_id 5
Telink 825x SDK--printf串口打印
hjj801006的专栏
05-15 777
telink BLE SDK 串口printf实现
对串口通信的初次尝试
qq_52171727的博客
10-17 432
这个是使用Java开发的一个工具，所以要先安装JRE环境。1.下载完安装包后，点击安装，如下（若不想使用默认路径，记得在左下方勾选“更改目标文件夹”）。选择安装2.修改安装路径， 点击下一步。注:（安装路径的文件夹是空文件夹）3.然后等待完整完成关闭即可。
ZYNQ-Vitis（SDK）裸机开发之（一）串口收发使用：PS串口+PL串口、多个串口使用方法
最新发布
qq_38584212的博客
04-09 2936
一些注意事项：PS和PL串口同时使用时，PL串口配置的中断优先级不能小于等于0xA0（即数值不能大于等于0xA0），目前代码中配置的PL串口中断优先级为0x98，如果数值大于等于0xA0时，单独使用PL串口收发没有问题，一旦使用了一次PS串口的收发，PL串口收发功能就失效了，具体原因我也不太清楚，还没深究，大家知道的话可以评论区说下~实例化PS、PL串口结构体对象，并新建数组，存放实例化后的对象指针，方便后续使用操作，这样后面的串口初始化配置等操作，只需要传入对应串口号即可操作响应的串口结构体；
串口 - 杨奉武 - 博客园1
08-04
【串口 - 杨奉武 - 博客园1】这篇博客主要涵盖了ESP8266模块在SDK开发中的串口应用，以及一系列基于ESP8266的外设和网络开发教程。串口作为通用异步收发传输器（UART），在嵌入式系统中扮演着重要的角色，用于设备间...
nRF52840开发指南-上册.pdf.docx
02-24
- **安装串口驱动**: 安装适用于nRF52840的串口驱动程序。 - **安装MDK5.23**: 下载并安装最新版本的Keil MDK-ARM。 - **安装pack**: 安装支持nRF52840的Keil pack文件。 - **安装JLINK驱动**: 安装J-Link驱动程序，...
uart fifo的fpga程序
04-30
UART（通用异步收发传输器）是一种广泛用于设备间串行通信的接口，它在嵌入式系统、微控制器以及FPGA设计中扮演着重要角色。UART利用FIFO（先进先出）缓冲区来提高数据传输的效率和稳定性。在FPGA实现UART FIFO时，...
C8051F系列单片机串口通讯程序 - 副本.zip_C8051F 串口_C8051F020串口通信_单片机_单片机串口
07-15
在C8051F系列单片机的串口编程中，通常会使用Silicon Labs提供的C8051F单片机软件开发套件（C8051F SDK），它包含库函数和示例代码，简化了开发过程。例如，`UART_Init()`函数用于初始化串口，`UART_Transmit()`和`...
sdk 如何从串口发数据到网口_ESP8266之SDK开发教程-第二讲
weixin_39635314的博客
12-04 179
第二讲.开始使用按键点亮你的"第一个LED"作者：电子快递哥日期：于2020年3月18日有态度，有温度，欢迎关注电子快递哥，转载请注明出处，关注电子快递哥，一起学习后续教程，关注+转发，私信免费索取源码2.1，打开乐鑫的SDK技术文档https://www.espressif.com/zh-hans/support/download/documents，2.2，我们搜索下管脚GPIO的相关设置：2...
typedef void(*Func)(void)的理解
xuechanba的博客
06-29 650
引用链接: https://blog.csdn.net/Fantanstical/article/details/85223600. typedef void(*Func)(void)的理解 typedef 和 #define 很类似。区别是：typedef 是在编译过程中被解析的，而 #define 是在编译之前的预处理时被破解的； #define 只是对所定义的别名的简单替换，而 typedef 则要灵活的多。总的来说 typedef 可以做到 #define 能做到的所有事情，而且可以做得更好。
typedef void(*T)(void *)的含义
qq_38635597的博客
10-17 7145
对于typedef void(*T)(void *)，我们进行一层层的剖析 首先写成 void(*T)() 可以看出 T是一个指针，是一个指向返回值为void ，参数为空的类型的函数指针 在加上(void *)  为 void(*T)(void *)  就变成了一个指向 返回值为void，参数为void *类型的指针 在加上上typedef ，加上后，T就不再是一个函数指针了，它代表着一种类...
SDK分析
GKoSon的博客
10-08 635
需要3个FIFO TX rt_ringbuffer_init(&sendRingBuffer, sendBuffer, sizeof(sendBuffer));---发送数据出去TCP RX rt_ringbuffer_init(&rxRingBuffer, rxBuffer, sizeof(rxBuffer));--串口收到数据 rt_ringbuffer_init(&m...
C语言中typedef void(*F)(类型)解读
weixin_43772611的博客
04-12 7427
文章目录一、typedef void(*T)(void *)1. void(*T)()2. void(*T)(void *)3. typedef void(*T)(void *)二、typedef void(*T)(非void *指针)1.void(*task_func)()2. void(*task_func)(uint8_t tb_flag, uint8_t *const power_mode)3. typedef void(*task_func)(uint8_t tb_flag, uint8_t
API实现串口通讯
热门推荐
09-09 1万+
第一节  实现串口通讯的函数及串口编程简介   API函数不仅提供了打开和读写通讯端口的操作方法，还提供了名目繁多的函数以支持对串行通讯的各种操作。常用函数及作用下： 函数名                    作用 CreateFile
串口Fifo设置
weixin_30553065的博客
12-06 363
UART 寄存器组中的0x2 在写入时和读取时的bit意义是不一样的 写入时可以控制串口是不是用Fifo模式。 //set to fifo mode. Otherwise source level debugging will not work //0x2 is Fifo control register when writting // bit0: Fifo enable...
S2-LP的大数据量FIFO管控机制详解
S2-LP是一种智能硬件平台，它在设计中特别考虑了FIFO（First-In-First-Out，先进先出）机制，这对于处理数据传输至关重要。S2-LP具有两个独立的数据FIFO，一个用于数据发送（TXFIFO），另一个用于数据接收（RXFIFO）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值