modem协议作简要研究2

最新推荐文章于 2023-06-03 19:30:00 发布
最新推荐文章于 2023-06-03 19:30:00 发布
阅读量336 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/89156614
版权 
#ifndef _XMODEM_H_
#define _XMODEM_H_

#include <stdint.h>

int xmodemReceive(unsigned char *dest, int destsz)  ;
#endif

#include "main.h"
#include "gkbaseusart.h"
#include "xmodem.h"
#include <string.h>

#define SOH 0x01  
#define STX 0x02  
#define EOT 0x04  
#define ACK 0x06  
#define NAK 0x15  
#define CANX 0x18  
#define CTRLZ 0x1A  
#define DLY_1S 1000  
#define MAXRETRANS 25  
  
static int last_error = 0;  


//完成输出  
//类似printf搬运过来串口1的函数
//最一个准备工作 把接受区清空
void out_buff(unsigned char *buff, int size)  
{  
   GK_usart_clear(&GKU1);
	 HAL_UART_Transmit(&huart1 , buff, size , 0xffff);
}  
   
  
//发送出去以后 我们在收到的数据
//这个函数风格是 我TX以后 过一会儿 就去接受缓存区拿数据 有的话 就是成功
//拿到受到的数据buff 返回数据的长度
int in_buff(unsigned char *buff, int time_out)  
{
    int qSize = 0;  
    int readSize = 0;       
    last_error = 0;  

	
	  HAL_Delay(time_out);  
 
      
    if(GKU1.rx_len)  
    {  
        qSize = GKU1.rx_len;   
        if(qSize > 0)  
        {  
					readSize = GKU1.rx_len;  
					memcpy(buff,GKU1.rxBuf,GKU1.rx_len);
        }  
    }  
      
    if(readSize == 0)  
        last_error = 1;  
  
    return (readSize);  
}
//完成数据CRC计算
int calcrc(const unsigned char *ptr, int count)  
{  
    int crc;  
    char i;  
  
    crc = 0;  
    while (--count >= 0)  
    {  
        crc = crc ^ (int) *ptr++ << 8;  
        i = 8;  
        do  
        {  
            if (crc & 0x8000)  
                crc = crc << 1 ^ 0x1021;  
            else  
                crc = crc << 1;  
        } while (--i);  
    }  
  
    return (crc);  
}  
//完成数据和本地比较 1一样 0不同
int check(int crc, const unsigned char *buf, int sz)  
{    
    if(crc)  
    {  
        unsigned short crc = calcrc(buf, sz);  
        unsigned short tcrc = (buf[sz]<<8)+buf[sz+1];  
  
        if (crc == tcrc)  
            return 1;  
    }  
    else  
    {  
        int i = 0;  
        unsigned char cks = 0;  
          
        for(i = 0; i < sz; i ++)  
        {  
            cks += buf[i];   
        }  
          
        if (cks == buf[sz])  
            return 1;  
    }  
  
    return 0;   
  
}  

//接受函数
int xmodemReceive(unsigned char *dest, int destsz)  
{    
    unsigned char xbuff[140];  
    int bufsz = 0;  
    int crc = 0;  
    unsigned char trychar = 'C';  
    unsigned char packetno = 1;  
    int c = 0;  
    int len = 0;  
    int retry = 0;  
    int retrans = MAXRETRANS;  
    int recvSize = 0;  
  
    for(;;)   
    {  
        for(retry = 0; retry < 16; retry ++)  
        {  
            if(trychar)  
            {  
                xbuff[0] = trychar;  
                out_buff(xbuff, 1);  //发送'C'出去 作为接受者 先发送C 去启动
            }  
              
            recvSize = in_buff(xbuff, (DLY_1S)<<1); //相当于TXRX 这里收到的数据 去分析 
            c = xbuff[0];  
              
            if (last_error == 0)   
            {  
                switch(c)  
                {  
                    case SOH:  
                        bufsz = 128;  
                        goto start_recv;  
                    case STX:  
													{  
															xbuff[0] = CANX;  
															out_buff(xbuff, 1);  
													}  
													return -1;  
                    case EOT:   
														{  
																xbuff[0] = ACK;  
																out_buff(xbuff, 1);  
														}  
														return len;  
                    case CANX:  
  
                        in_buff(xbuff, DLY_1S);  
                        c = xbuff[0];  
                        if(c == CANX)  
                        {  
                            {  
                                xbuff[0] = ACK;  
                                out_buff(xbuff, 1);  
                            }  
                            return -1;  
                        }  
                        break;  
                    default:  
                        break;  
                }  
            }  
        }  
  
        if (trychar == 'C')  
        {  
            trychar = NAK;  
            continue;  
        }  
  
        {  
            xbuff[0] = CANX;  
            out_buff(xbuff, 1);  
            out_buff(xbuff, 1);  
            out_buff(xbuff, 1);  
        }  
  
        return -2;  
  
start_recv:  
        if(trychar == 'C')  
            crc = 1;  
  
        trychar = 0;  
  
        if(recvSize != (bufsz + (crc ? 1 : 0) + 4))  
            goto reject;  
          
        if(xbuff[1] == (unsigned char)(~xbuff[2]) &&   
            (xbuff[1] == packetno || xbuff[1] == (unsigned char)packetno - 1) &&   
            check(crc, &xbuff[3], bufsz))  
        {  
            if(xbuff[1] == packetno)  
            {  
                int count = destsz - len;  
                  
                if (count > bufsz)  
                    count = bufsz;  
  
                if (count > 0)  
                {  
                    memcpy(&dest[len], &xbuff[3], count);  
                    len += count;  
                }  
  
                packetno ++;  
  
                retrans = MAXRETRANS+1;  
            }  
  
            if(-- retrans <= 0)  
            {  
                {  
                    xbuff[0] = CANX;  
                    out_buff(xbuff, 1);  
                    out_buff(xbuff, 1);  
                    out_buff(xbuff, 1);  
                }  
                return -3;  
            }  
  
            {  
                    xbuff[0] = ACK;  
                    out_buff(xbuff, 1);  
            }  
              
            continue;  
        }  
  
reject:    
        {  
                xbuff[0] = NAK;  
                out_buff(xbuff, 1);  
        }  
  
    }  
}  
  
//send_buff_size == 140  
int xmodemTransmit(unsigned char *src, int srcsz)  
{  
    unsigned char xbuff[140];  
    int bufsz = 0;  
    int crc = -1;  
    unsigned char packetno = 1;  
    int i = 0;  
    int c = 0;  
    int len = 0;  
    int retry = 0;  
  
    for(;;)  
    {  
        for( retry = 0; retry < 16; ++retry)  
        {  
            in_buff(xbuff, (DLY_1S)<<1);  
            c = xbuff[0];  
              
            if(last_error == 0)  
            {  
                switch(c)  
                {  
                    case 'C':  
                        crc = 1;  
                        goto start_trans;  
                    case NAK:  
                        crc = 0;  
                        goto start_trans;  
                    case CANX:  
                        in_buff(xbuff, DLY_1S);  
                        c = xbuff[0];  
                        if(c == CANX)   
                        {  
                            {  
                                    xbuff[0] = ACK;  
                                    out_buff(xbuff, 1);  
                            }  
                            return -1;  
                        }  
                        break;  
                    default:  
                        break;  
                }  
            }  
        }  
  
        {  
            xbuff[0] = CANX;  
            out_buff(xbuff, 1);  
            out_buff(xbuff, 1);  
            out_buff(xbuff, 1);  
        }  
  
        return -2;  
  
        for(;;)  
        {  
start_trans:    
            xbuff[0] = SOH;  
            bufsz = 128;  
            xbuff[1] = packetno;  
            xbuff[2] = ~packetno;  
              
            c = srcsz - len;  
            if(c > bufsz)  
                c = bufsz;  
  
            if(c >= 0)  
            {  
                memset(&xbuff[3], 0, bufsz);  
  
                if (c == 0)  
                {  
                    xbuff[3] = CTRLZ;  
                }  
                else  
                {  
                    memcpy(&xbuff[3], &src[len], c);  
                      
                    if (c < bufsz)  
                        xbuff[3 + c] = CTRLZ;  
                }  
                  
                if(crc)  
                {  
                    unsigned short ccrc = calcrc(&xbuff[3], bufsz);  
                      
                    xbuff[bufsz + 3] = (ccrc>>8) & 0xFF;  
                    xbuff[bufsz + 4] = ccrc & 0xFF;   
                }  
                else  
                {  
                    unsigned char ccks = 0;  
                      
                    for(i = 3; i < bufsz + 3; i ++)  
                    {  
                        ccks += xbuff[i];  
                    }  
                      
                    xbuff[bufsz + 3] = ccks;  
                }  
                  
                for(retry = 0; retry < MAXRETRANS; retry ++)  
                {  
                    out_buff(xbuff, bufsz + 4 + (crc ? 1 : 0));  
  
                    in_buff(xbuff, DLY_1S);  
                    c = xbuff[0];  
                      
                    if(last_error == 0)  
                    {  
                        switch(c)  
                        {  
                            case ACK:  
                                packetno ++;  
                                len += bufsz;  
                                goto start_trans;  
                            case CANX:  
                                in_buff(xbuff, DLY_1S);  
                                c = xbuff[0];  
                                if(c == CANX)  
                                {  
                                    {  
                                        xbuff[0] = ACK;  
                                        out_buff(xbuff, 1);  
                                    }  
                                      
                                    return -1;  
                                }  
                                break;  
                            case NAK:  
                                break;  
                            default:  
                                break;  
                        }  
                    }  
                }  
                {  
                    xbuff[0] = CANX;  
                    out_buff(xbuff, 1);  
                    out_buff(xbuff, 1);  
                    out_buff(xbuff, 1);  
                }  
  
                return -4;  
            }  
            else  
            {  
                for(retry = 0; retry < 10; retry ++)  
                {  
                    {  
                        xbuff[0] = EOT;  
                        out_buff(xbuff, 1);  
                    }  
                      
                    in_buff(xbuff, (DLY_1S)<<1);  
                    c = xbuff[0];  
  
                    if(c == ACK)  
                        break;  
                }  
              
                return ((c == ACK) ? len : -5);  
            }  
        }  
    }  
}

此时写一文件

启动发送

在运行代码即可

STM32收到了数据到buf而且不够的全部是0X1A

GKoSon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
modem协议 免费-综合文档
05-25
MODEML208 VCC C223 0.1U J203 1 2 CON2 PHONE TIP PHONE RING VCC C204 J201 1 2 3 4 CON4 LINE TIP LINE RING PHONE TIP PHONE RING VCC C201 0.1U C202 0.1U C203 10U/16V VD3.3 U201 8 51 13 14 15 16 17 18 19 ...
Y-modem协议文档
08-14
Y-Modem协议是X-Modem的改进协议，它最用于调制解调器之间的文件传输的协议，具有快速，稳定传输的优点。它的传输速度比X-Modem快，这是由于它可以一次传输1024字节的信息块，同时它还支持传输多个文件，也就是常说...
MODEM 开发-SIM
liudong200618的博客
06-03 171
鉴权开始时，网络产生一个128比特的随机数RAND，经无线电控制信道传送到移动台， SIM卡依据卡中的密钥Ki和算法A3,对接收到的RAND计算出应答信号SRES，并将结果发回网络端。而网络端在鉴权中心查明该用户的密钥Ki，用同样的RAND和算法A3算出SRES,并与收到的SRES进行比较，如一致，鉴权通过。SIM卡本身是通过PIN码来保护的，PIN是一个4～8位的个人密码，只有当用户输入正确的PIN码时，SIM卡才能被启用，移动终端才能对SIM卡进行存取，也只有PIN认证通过后，用户才能上网通话。
常见的MODEM通讯协议
　　　　　KISSMonX
05-29 5901
常见的MODEM通讯协议体系可以分为传输协议、纠错协议、压缩协议及传真协议、语音协议等几大类。 　　1、传输协议 　　Bell 103 贝尔的 300bps 标准，相当于 V.21。由于与 ITU 标准不兼容，已被淘汰。 　　Bell 212 贝尔的 1200bps 标准，相当于 V.22。由于与 ITU 标准不兼容，已被淘汰。 　　V.21 ITU 传输协议，最高速率 3
手机 modem开发（19）---LTE注网总体流程
keyanting_2018的博客
03-12 1988
https://blog.csdn.net/zhangbijun1230/article/details/80639073 LTE注网总体流程 注网流程 1. 开机驻留 UE开机后在SIM卡初始化还未完成前，会先尝试获取限制服务。获取限制服务后可以支持拨打紧急电话 2. 初始化SIM卡 从AP侧可以看到SIM卡READ的状态。从modem侧，过滤NAS消息，当SIM卡初始化完成后...
modem协议作简要研究
GKoSon的博客
04-09 1262
1、什么是Xmodem协议 Xmodem协议是串口通信中广泛使用到的异步文件传输协议。 以128字节块的形式传输数据，并且每个块都使用一个校验过程来进行错误检测。 在校验过程中如果接收方关于一个块的检验和与它在发送方的检验相同时， 接收方就向发送方发送一个确认字节<ACK>。如果有错则发送一个字节<NAK>要求重发。 以保证传输过程中的正确性，但是由于需要对每个块都要进行...
手机Modem协议开发快速上手.docx
09-22
介绍手机modem协议开发主要信令流程，高通/MTK modem协议相关技术，项目实战快速上手。
modem协议术语总结
06-07
modem协议术语总结
xmodemxieyi.rar_DOS_XMODEM协议_dos XMODEM_modem_modem协议
09-14
XMODEM协议 c语言实现,大家可以参考参考
Modem开发
jerry7582597的专栏
01-22 1023
手机在弱场环境下出网的问题分析建议 提出几点debug的建议： 1 排查是否RF硬件问题 测试那台问题手机的RF接收性能，尤其是在出问题的地点(弱场)的频段上。 例如测试地点是在某一个中国联通WCDMA网络的弱场中，若使用在IMT2100频段上， 对这个频段上高中低三个频率点上测试RF的接收灵敏度，把测试出来的结果 同相同软硬件版本的手机（例如同一版DVT的机型，相同的软件版本）做对比。 2 排查...
modem协议学习入门
weixin_44331944的博客
11-04 1731
协议学习大纲 Phone Phone状态监听 语音业务 拨号流程 来电去电处理流程 Call状态变化处理流程 Phone相关进程及通信 Phone进程启动流程 服务状态 服务状态上报流程 信号强度上报流程 CellLocation通知流程 飞行模式开关流程 Android运营商名称显示 (FW中的更新) plmn和spn显示规则 网络模式 手动搜网 补充业务 呼叫转移 CFI通知流程 呼叫等待 固定拨号 LTE信令 Volte SIM卡 SIM锁卡相关 SIM卡单双卡切换,热插拔.不识卡问题 IccF
手机主叫的信道流程与Modem Log简单分析
sjz4860402的专栏
11-03 4665
一. 通讯设备之间任何实际应用信息的传送总是伴随着一些控制信息的传递,它们按照既定的通讯协议工作,将应用信息安全、可靠、高效地传送到目的地。这些信息在计算机网络中叫做协议控制信息,而在电信网中叫做信令(Signal)。
[LTE] LTE基本架构
热门推荐
轻舞飞扬
12-07 7万+
这篇文章主要介绍LTE的最基础的架构，包括LTE网络的构成，每一个网络实体的作用以及LTE网络协议栈，最后还包括对一个LTE数据流的模型的说明。LTE网络参考模型
手机MODEM 开发（29）--- VoLTE协议
zhangbijun1230的专栏
07-27 2451
二 VoLTE协议栈   从无线角度来看：VoLTE需要建立的承载 要实现语音或视频业务需要UE同时建立三个数据承载外，还需要UE建立RRC链接信令承载：SRB1和SRB2。   VoLTE用户注册：   VoLTE用户在体验高质量通话之前，必须先进行VoLTE的注册流程，从无线角度来看，注册分为两个步骤：   (1)LTE无线的无线注册: 由于VoLTE实质上对于无线来...
SIM卡基础知识
柔情峡谷的博客
06-24 2万+
SIM卡的基础知识
手机modem开发（1）---MTK modem开发
zhangbijun1230的专栏
04-13 6054
  手机软件分2部分, AP部分和BP部分, AP部分就是基于Linux的这一套, BP部分就是modem部分. modem部分主要负责打电话,数据链接等这些工作.AP需要打电话或者数据上网,就会跟BP进行通信.一般是通过串口. SIM卡的管理之类也是由BP部分来做.我们编译一套完整的软件, 首先要由射频组给出射频文件,然后在modem代码里面进行配置, 配置完之后编译出 modem 部分的二进制...
手机MODEM 开发（31）--- VoLTE基本流程和信令解析
zhangbijun1230的专栏
07-29 9796
四 VoLTE基本流程和信令解析   4.1 VoLTE呼叫业务流程 上述A和B均是IDLE模式，互相进行拨打的方式是实际应用场景中最常见的一种方式了，具体流程如下。   1.用户A和B在注册成功后，无业务触发，MME发起上下文释放，将A和B均置为IDLE模式。   2. UE A呼叫UE B，此时A发现其为IDLE模式，则需要先建立信令连接。首先缓存需要发送的数据，向e...
modem mmit
最新发布
01-09
根据提供的引用内容，我了解到"modem mmit"是指在ICCV19 MMIT竞赛中获得第一名的所有模型。这些模型包括了最新最全的通用视频分类主流方法的实现，其中包括2D方法（TSN、TSM、TIN）和3D方法（SlowFast、ResNet-3D、R(2+1)D）。这些模型在多个数据集上取得了SOTA的性能。 此外，引用中提到了一个名为时序交错网络（Temporal Interlace Network，TIN）的模块，它是一种简单而强大的模块，用于解决视频分类问题。TIN通过交错过去到未来以及未来到过去的空间特征来融合时-空信息，而不是学习时间特征。TIN使用可微分的子模块来计算交错时的特征在时序维度上的偏移量，并根据偏移量重新排列特征，使每组特征在时间维度上位移不同的距离。这种特征位移操作取代了传统的3D卷积，从而降低了网络的参数量和计算量，使网络整体变得轻量化。研究者还从理论上证明了可学习的时序交错模块本质上等同于受约束的时序卷积网络。 总结起来，"modem mmit"是指在ICCV19 MMIT竞赛中获得第一名的所有模型，其中包括了最新最全的通用视频分类主流方法的实现，以及一个名为时序交错网络（TIN）的轻量化模块用于视频分类任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值