精华内容
下载资源
问答
  • 单片机接收数据帧帧头帧尾校验数据解析C语言,采用VS2010编译器书写,已经通过验证,单片机里面也十分实用。双向链表方法。
  • 以太网帧帧头(协议标识): IPv4 0x0800 IPX 0x8137 ARP 0x0806 Pause Control 0x8808 IPv6 0x86DD 其他通信协议常见的帧头帧尾: 帧头: 0x55AA 0xEB90 0x2222 0xAAAA 帧尾: 0x0D 0x0D0A ...

    以太网帧帧头(协议标识):
    IPv4 0x0800
    IPX 0x8137
    ARP 0x0806
    Pause Control 0x8808
    IPv6 0x86DD

    其他通信协议常见的帧头帧尾:
    帧头:
    0x55AA
    0xEB90
    0x2222
    0xAAAA

    帧尾:
    0x0D
    0x0D0A

    展开全文
  • 串口帧头帧尾判断.vi

    2020-04-23 16:14:35
    数据帧格式为:帧头1、帧头2、数据1高、数据1低、数据2高、数据2低、数据3高、数据3低、数据4高、数据4低、帧尾1、帧尾2数据接收类似于堆栈的入栈操作,最新收到的数据始终在数组的第0个元素中,当收到一帧数据后,...
  • 串口有帧头帧尾的解码

    千次阅读 2018-11-13 00:53:20
    串口有帧头帧尾的解码 #include <stdio.h> #include <string.h> #define MAX_SIZE 1024 int bw_getFrame(unsigned char *buf, int len) { int i = 0; ...

    AT指令编解码-有帧头帧尾的编解码

    参考:https://www.cnblogs.com/chucklu/p/6428615.html
    c实现转义:https://www.jianshu.com/p/2221ab0c0dce

    #include <stdio.h>
    #include <string.h>
    
    #define MAX_SIZE 1024
    
    
    int bw_getFrame(unsigned char *buf, int len)
    {
        int     i = 0;    
        int     ret;
        
        unsigned char head[5] = {0x0d, 0x0a, '+', 'r','='};   /*头帧标志符号*/
        unsigned char tail[2] = {0x0d, 0x0a};   /*尾帧标志符号*/
        int           len_head = 5;
        int           len_tail = 2;
        unsigned char *pData   = NULL;
        int           iData    = 0;
        unsigned char *pDataEnd= NULL;
        int           bHasHead = 0;
        unsigned char Payload[MAX_SIZE]= {0};
        int           lenPayload       = 0;
        unsigned char tmp[MAX_SIZE]    = {0};
        int           lentmp           = 0;
        
        
        
        print_dbg("[i, len] = [%d, %d]\n", i, len);
        if(len <= len_head + len_tail){
            memcpy(tmp, buf, len);
            lentmp += len;
            
            /* TODO: read time out */
            unsigned char more[6] = {'=',  0x33, 0x34, 0x35  ,0x0d, 0x0a};
            ret = 6;
            if(ret <= 0){
                return -1;
            }
            memcpy(&tmp[lentmp], more, ret);
            lentmp += ret;
            print_buf(tmp, lentmp);
            bw_getFrame(tmp, lentmp);
            return 0;
        }
       
        while(i < len){
            if(!bHasHead){
                ret = memcmp(head, &buf[i], len_head);
                if(ret == 0){
                    i        += len_head;
                    pData    = &buf[i];
                    iData    = i;
                    bHasHead = 1;
                    continue;
                }else{
                    
                    goto next;
                }
            }else{
                ret = memcmp(tail, &buf[i], len_tail);
                if(ret == 0){
                    pDataEnd = &buf[i];
                    /* complete a frame */
                    //print_dbg("[i] = [%d]\n", i);
                    print_buf(pData, (pDataEnd-pData));
                    i        += len_tail;
                    if(i+1 < len){
                        print_dbg("has more\n");
                        /* reset var*/
                        bw_getFrame(&buf[i], len-i);
                        return 0;
                    }
                }else{
                    Payload[lenPayload++] = buf[i];
                    goto next;
                }
            }
    next:
            i++;
        }
        
        
        return 0;
    }
    
    int main()
    {      
        /*输入一个带头帧和尾帧的字符串*/
        //char str[MAX_SIZE];
        //printf("Please input str");
        //scanf("%s",str);
        unsigned char buf[100] =  {0x0d, 0x0a, '+', 'r'};
        unsigned char buf0[100] = {0x0d, 0x0a, '+', 'r', '='};
        unsigned char buf1[100] = {0x0d, 0x0a, '+', 'r','=',  0x33, 0x34, 0x35  ,0x0d, 0x0a};
        unsigned char buf2[100] = {0x0d, 0x0a, '+', 'r','=',  0x33, 0x34, 0x35  ,0x0d, 0x0a, 0x0d, 0x0a, '+', 'r','=',  0x77, 0x77,0x77  ,0x0d, 0x0a};
        unsigned char buf3[100] = {0x0d, 0x0a, '+', 'r','=',  0x33, 0x34, 0x35  ,0x0d, 0x0a, 
                                   0x0d, 0x0a, '+', 'r','=',  0x77, 0x77, 0x77  ,0x0d, 0x0a,   
                                   0x0d, 0x0a, '+', 'r','=',  0x00, 0x00, 0x00  ,0x0d, 0x0a,   
                                   0x0d, 0x0a, '+', 'r','=',  0x88, 0x88, 0x88  ,0x0d, 0x0a};
        
        
    
    //     bw_getFrame(buf, 4);
        bw_getFrame(buf0, 5);
    //     bw_getFrame(buf3, 20);
        //bw_getFrame(buf2, 20);
        return 0;
    }
    
    
    
    展开全文
  • 队列容量等于一数据的大小,每来一个数据就将数据往队列里面加,当完整接收到一数据时此时队列中的全部数据也就是一完整的数据,因此只需要判断队列是否是数据校验,队列是否是数据校验就可以得知当前...
  • 以下是解决问题的代码,并且有了详细注释,希望对你有所帮助。 欢迎在评论区一起讨论 ... 4 char *find(char *str,char *flag) //此函数形参分别接受被寻找字符串的首地址和帧头帧尾字符串首地址 ...

    以下是解决问题的代码,并且有了详细注释,希望对你有所帮助。
    欢迎在评论区一起讨论

    
      1 #include<stdio.h>
      2 #include<string.h>
      3 #include<stdlib.h>
      4 char *find(char *str,char *flag) //此函数形参分别接受被寻找字符串的首地址和帧头或帧尾字符串首地址
      5 {
      6     int s = strlen(str);//得出被寻找字符串的总长度
      7     int h = strlen(flag);//得出帧头或帧尾字符串的长度
      8     int i;
      9     for(i = 0; i < strlen(str); i++)//这里可以稍微优化一下'i < strlen(str) - strlen(flag) + 1'不过无伤大雅。。。
     10     {
     11         if(strncmp(str + i,flag,strlen(flag)) == 0)//调用了strncmp函数,其中后两个实参传入的是帧头或帧尾首地址和其长度,至于'str+i'就是寻找功能了,str是字符串首地址,每次加一直到找到相同字符串(结合strncmp函数的作用)
     12         {
     13             return str + i;//返回值就是帧在字符串中的地址
     14         }
     15     }
     16 }
     17 int main()
     18 {
     19     char *str;//字符串
     20     str = (char *)malloc(sizeof(char) * 128);//申请了128字节空间,malloc返回了空间首地址,并被str接收了,下同;
     21     char *head;//帧头
     22     head = (char *)malloc(sizeof(char) * 8);
     23     char *tail;//帧尾
     24     tail = (char *)malloc(sizeof(char) * 8);
     25     printf("请输入一串字符串(最大128位),帧头(最大8位),帧尾(最大8位)\n");
     26     scanf("%s%s%s",str,head,tail);
     27     char *h = find(str,head);//先找帧头
     28     if(NULL == h)//如果没找可以提示用户,下同
     29     {
     30         printf("没有找到帧头!\n");
     31     }
     32     char *t = find(str,tail);//再找帧尾
     33     if(NULL == t)
     34     {
     35         printf("没有找到帧尾!\n");
     36     }
     37 //  *(t + strlen(tail)) = '\0';//如果要将帧头和帧尾以及其中的字符串都输出要这么写,自然下面一行的代码就需要被删除或注释掉
     38     *t = '\0';//如果只要两帧之间的字符串,只需将帧尾首地址所指字符赋值为‘\0’即可
     39     printf("找到的字符串如下:\n");
     40     printf("%s\n",h + strlen(head));//这里没有包含帧头,如果要包含就需要将‘strlen(head)’去掉
     41 }
    
    
    展开全文
  • 根据帧头帧尾去能够完成数据截取,老的思路是去掉没有用的数据把数据都一个一个移位 3. 功能测试 目前功能正常 */ package queue import ( "sync" ) type queue struct { head int foot int arr []byte ...
    /*
    	1.此类想做成数据缓冲区的功能能,能够接受网络包进行数据缓冲区,根据
    	2. 根据帧头帧尾去能够完成数据截取,老的思路是去掉没有用的数据把数据都一个一个移位
    	3. 功能测试  目前功能正常
    */
    
    package queue
    
    import (
    	"sync"
    )
    
    type queue struct {
    	head   int
    	foot   int
    	arr    []byte
    	mutexP *sync.Mutex
    
    	headArr      []byte
    	footArr      []byte
    	realDataChan chan []byte
    }
    
    //创建一个数据缓冲区
    func CreateQueue(len int, headBytes, footBytes []byte) queue {
    	qu := queue{
    		head:         0, //包含此下标值
    		foot:         0, // 不包含此下标值
    		mutexP:       &sync.Mutex{},
    		arr:          make([]byte, len+1),
    		realDataChan: make(chan []byte, 5),
    	}
    	qu.footArr = append(qu.footArr, footBytes...)
    	qu.headArr = append(qu.headArr, headBytes...)
    	return qu
    }
    
    //入队
    func (its *queue) enqueue(v byte) bool {
    
    	if (its.foot+1)%len(its.arr) == its.head {
    		return false
    	}
    	its.arr[its.foot] = v
    	its.foot = (its.foot + 1) % len(its.arr)
    	return true
    }
    
    //出队
    func (its *queue) dequeue() (val byte, bl bool) {
    	val = 0
    	bl = false
    	if its.foot == its.head {
    		return
    	}
    	val = its.arr[its.head]
    	its.head = (its.head + 1) % len(its.arr)
    	bl = true
    	return
    }
    
    //计算长度
    func (its *queue) Count() int {
    	dataLen := (its.foot + len(its.arr) - its.head) % len(its.arr)
    	return dataLen
    }
    
    //判断队列是否存储满了
    func (its *queue) IsFull() bool {
    	its.mutexP.Lock()
    	defer its.mutexP.Unlock()
    	return its.foot == its.head
    }
    
    //判断队列是否为空
    func (its *queue) IsEmpty() bool {
    	its.mutexP.Lock()
    	defer its.mutexP.Unlock()
    	return (its.foot+1)%len(its.arr) == its.head
    }
    
    //获取当前缓冲区全部信息
    func (its *queue) GetCurArrInfo() []byte {
    	its.mutexP.Lock()
    	defer its.mutexP.Unlock()
    	arrLen := len(its.arr)
    	lens := (its.foot + arrLen - its.head) % arrLen
    	splice := make([]byte, lens)
    	if lens == 0 {
    		return splice
    	}
    	//数组不为空则去添加数据
    	tempHead := its.head
    	for idx := 0; idx < lens; idx++ {
    		tempHead = (its.head + idx) % arrLen
    		splice[idx] = its.arr[tempHead]
    	}
    	return splice
    }
    
    //清空队列
    func (its *queue) Clear() {
    	its.mutexP.Lock()
    	defer its.mutexP.Unlock()
    	for idx := 0; idx < len(its.arr); idx++ {
    		its.arr[idx] = 0
    	}
    	its.head = 0
    	its.foot = 0
    }
    
    //获取队列容量
    func (its *queue) Capacity() int {
    	its.mutexP.Lock()
    	defer its.mutexP.Unlock()
    	return len(its.arr) - 1
    }
    
    //返回所有结果集的切片
    func (its *queue) GetResult() [][]byte {
    	var reault [][]byte
    
    	for {
    		if len(its.realDataChan) > 0 {
    			reault = append(reault, <-its.realDataChan)
    		} else {
    			break
    		}
    	}
    	return reault
    }
    
    //添加一个数据包到缓冲区 并且根据帧头帧尾截取数据  若果缓冲区满了或者结果chan满了则不能再次加入
    func (this *queue) AddBuf(buf []byte) bool {
    	if buf == nil || len(buf) == 0 {
    		return false
    	}
    	//1. 判断数据是否能够存下数据
    	this.mutexP.Lock()
    	defer this.mutexP.Unlock()
    	for idx := 1; idx <= len(buf); idx++ {
    		if (this.foot+1+idx)%len(this.arr) == this.foot {
    			return false
    		}
    	}
    	// 1.1 程序结果缓冲区 是否已经满了
    	if len(this.realDataChan) == cap(this.realDataChan) {
    		return false
    	}
    
    	//2.存入数据
    	for _, v := range buf {
    		this.enqueue(v)
    	}
    
    	//3. 判断数据是否符合要求
    	for {
    		headNu := this.findHeadOrFoot(1)
    		count := this.Count()
    		if headNu == -1 {
    			//1. 此时没有找到指定头数据
    			arrLength := len(this.headArr)
    			if count >= arrLength {
    				for dquI := 0; dquI < count-arrLength; dquI++ {
    					this.dequeue()
    				}
    			}
    			break
    		} else {
    			//2. 此种情况找到了有效头位置
    			if count > len(this.headArr)+len(this.footArr) {
    				//2.1 开始找帧尾数据 前去除帧头无效数据
    				var deletNu = (headNu + len(this.arr) - this.head) % len(this.arr)
    				for i := 0; i < deletNu; i++ {
    					this.dequeue()
    				}
    				footNu := this.findHeadOrFoot(2)
    				if footNu != -1 {
    					//2.2 此种情况找到了帧尾
    					entity := make([]byte, (footNu+len(this.footArr)+len(this.arr)-this.head)%len(this.arr))
    					var tempByte byte
    					var tempDequBl bool
    					for inx := 0; inx < cap(entity); inx++ {
    						tempByte, tempDequBl = this.dequeue()
    
    						if tempDequBl {
    							entity[inx] = tempByte
    						}
    					}
    					this.realDataChan <- entity
    
    				} else {
    					break
    				}
    			}
    		}
    	}
    	return true
    }
    
    // 查找帧头和帧尾  1头 2尾
    // 如果返回-1 则表示无效
    func (its *queue) findHeadOrFoot(headOrfoot byte) int {
    	headNu := -1
    	if !(headOrfoot == 1 || headOrfoot == 2) {
    		return headNu
    	}
    	arrLen := len(its.arr)
    	lens := (its.foot + arrLen - its.head) % arrLen
    	if lens == 0 {
    		return headNu
    	}
    	//1. 开始遍历切片缓冲区
    	tempHead := its.head //为了查找数据用的
    	var (
    		corDataLen int
    		corDataBuf []byte
    	)
    	if headOrfoot == 1 {
    		corDataLen = len(its.headArr)
    		corDataBuf = its.headArr
    	} else if headOrfoot == 2 {
    		corDataLen = len(its.footArr)
    		corDataBuf = its.footArr
    	}
    	var headJ int = 0
    	for idx := 0; idx < lens; idx++ {
    		tempHead = (its.head + idx) % arrLen
    		//2. 开始对比帧数据
    		for headJ = 0; headJ < corDataLen; headJ++ {
    			if its.arr[(tempHead+headJ)%arrLen] != corDataBuf[headJ] {
    				break
    			}
    		}
    		if corDataLen == headJ {
    			headNu = tempHead
    			//3. 找到第一个符合要求返回 开始位置
    			break
    		}
    	}
    	return headNu
    }
    
    

    也可以用其他语言实现此功能,在处理数据需要拼数据包 感觉更好用一些, 但是在add函数中感觉 功能却有点混乱

    展开全文
  • 在下位机通讯中,经常使用带帧头帧尾的协议。此时需要将采集上来的数据进行识别处理。 代码示例 string factMessage = &amp;quot;Extension methods have all the capabilities of regular static methods.&...
  • 帧头帧尾代码

    2020-06-15 15:13:44
    #include #include char head_tail(char str,char result){ int i = 0;... printf(“头帧:head\n”); printf(“帧:tail\n”); head_tail(str,result); printf(“取出的中间字符串=%s\n”,result); return 0; }
  • 帧头 帧尾问题

    千次阅读 2016-11-17 22:07:53
    char *head_count(char *str, char *head)//找出帧头前面的字符串 { char *temp; int size_head = strlen(head); int count1 = 0; int head_flag = 0; if(str == NULL || head == NUL
  • i++) //打印帧头帧尾之间的字符串(包括帧头帧尾)  {  printf("%c",str[i]);  }  printf("\n");  return 0; } /*以下是定义一个函数,函数输入是两个数组,一个整型数*/ int substr(char str[n],char s[n],...
  • 一、MAC帧头定义/数据帧定义,头14个字节,4个字节/typedef struct _MAC_FRAME_HEADER{char m_cDstMacAddress[6]; //目的mac地址char m_cSrcMacAddress[6]; //源mac地址short m_cType; //上一层协议类型,如0x0800...
  • 之前想找串口分析的程序一直不知道怎么实现的,现在自己折腾出来分享大家,串口屏也花了好几天看资料,给刚开始使用的方便。里面 还有ADC转换在线写入串口屏数据以及掉电存储功能以及stm32内外时钟切换配置注释,...
  • 因此只需要判断队列是否是数据校验,队列是否是数据校验就可以得知当前是否已经接收到了一完整的数据,然后在将数据从队列中取出即可。原理图如下: 每来一个数据就往队列里面加: 当接收到一完整数据时...
  • 1. 简介 图像修复是对图像中缺失的区域进行填补。相比较传统的修复算法,深度学习借助大量的数据... 论文对视频的缺失区域进行填补,需要解决的问题有2个:1)对单图片进行修复;2)保证修复视频的连续性。同一视...
  • 现在我想在每960bytes数据前帧头,比如4个字节的AA : AA AA AA AA,然后再帧尾也加4个字节的AA. 那么数据帧结构就是 AA AA AA AA .......(160bytes data).......AA AA AA AA 请问大家怎么实现啊?
  • 来自公众号:新世界杂货铺阅读建议这是HTTP2.0系列的第二篇,所以笔者推荐阅读顺序如下:Go中的HTTP请求之——HTTP1.1请求流程分析Go发起HTTP2.0请求流程分析(前篇)本篇主要分为三个部分:数据,流控制...数据HT...
  • (单选题) A、将这个数据只从G0/0/2端口转发出去 B、将这个数据泛洪出去 C、SWA将数据丢弃 D、将这个数据只从G0/0/3端口转发出去 参考答案:B 解析: 当交换机收到未知单播,会采用泛洪的方式转发,也就是从...
  • 阅读建议这是HTTP2.0系列的第二篇,所以笔者推荐阅读顺序如下:Go中的HTTP请求之——HTTP1.1请求流程分析Go发起HTTP2.0请求流程分析(前篇)本篇主要分为三个部分:数据,流控制器以及通过分析源码逐步了解流控制。...
  • 1.帧头帧尾校验和是自己定的么?这算是一个协议么? 2.我看到有的协议有帧头没有帧尾但是有校验和,帧尾是可以有可以没有么? 3.帧尾就是校验和么?帧尾和校验和有一个就可以吗? 4.帧头跟帧尾都必须有吗还是帧头...
  • #include #include #define MAX_SIZE 1024 void head2tail(char *str,char *head,char *tail) { int m = 0; int n = 0; int k = 0; int low; int high; int len;...int taille
  • 在算法方面,U7A系列电视,增加了SR增强算法,智能运动测,在高解析动作或者快速切换动作上,能够实现“AI插”,动态补偿画质。使得视频连贯度和清晰度有所提升。屏幕支持HDR解码,独创了体育模式,在体育球赛...
  • 我用串口调试助手发送ASCII码数据,报文格式是 STX 0 F ETX L这些控制字符帧头帧尾STX,ETX应该怎么输入?
  • 头帧尾

    千次阅读 2018-05-31 12:55:59
    printf("头帧:head\n"); //输出部分的头帧 printf("帧:tail\n"); //输出部分的帧 head_tail(str,result); //调用子函数 printf("取出的中间字符串 = %s\n",result);//取字符   return 0;...
  • 1. 输入一个字符串,同时输入帧头帧尾(可以是多个字符),将该字符串中合法的帧识别出来. 提示:帧头帧尾分别是head和tail 字符串”asdheadhauboisoktail”中headhauboisoktail是合法帧 #include #include ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 632
精华内容 252
关键字:

帧头帧尾