精华内容
下载资源
问答
  • 北斗RDSS测试软件

    2018-05-30 16:44:00
    北斗RDSS测试软件,支持北斗定位、短报文服务、单次定位(短报文)、连续定位(短报文)
  • 1、北斗RDSS终端模拟器主要解决,在软件开发过程中没有北斗终端设备、没有北斗卡的问题; 2、解决北斗卡频度限制问题(模拟器绕开空中链路,可模拟无频度限制),从而提高上位机软件开发效率; 3、解决搭建设备环境...
  • 北斗RDSS 测试软件,遵循RDSS 2.1协议,可测试通信和定位。免费开放给大家使用,欢迎大家使用过评价下
  • 【北斗放牧终端】北斗RDSS放牧终端PD09技术规格书 .pdf
  • 一款可以用于户外通信的智能手持机,采用北斗RDSS短报文通信技术
  • 户外必备北斗数传终端北斗RDSS多卡通信终端PD09规格书
  • 【北斗车载终端】北斗RDSS车载终端PD05技术规格书.pdf
  • 北斗RDSS的短报文功能,特别适用于我国广袤崇山峻岭及荒凉孤岛等区域的电子传播,为突发事件的应急通讯提供支持.采用北斗通讯作为第二通信通道,根据其通信特点,结合核辐射数据的随机性特征,提出一种北斗应急通讯...
  • 用于桥梁监测、电力、水利等工程监测的北斗RDSS倾斜仪PQ01终端介绍规格书
  • 【北斗卫星收发单元】北斗RDSS卫星收发单元PD07规格书.pdf
  • 北斗RDSS系统新体制信号子载波间干扰问题研究
  • 北斗RDSS基带处理芯片的关键技术及应用前景.pdf
  • 基于北斗RDSS海洋工程监控系统的设计与实现,睢洁,王远飞,基于北斗卫星导航系统的海洋工程监控系统是通过北斗卫星通信链路建立起来的海洋工程船舶与陆地指挥中心一体化的系统,北斗卫星通
  • 北斗RDSS在海洋工程数据传输中的应用,何嗣隆,叶方舟,目前移动通信,无线技术等迅速发展并覆盖全球,但是海洋是这些通信技术的最大盲区;海洋、河口疏浚业务中工程船因为远离岸边,这
  • 基于北斗RDSS远程生命体征监测系统的设计_李政清.pdf
  • 基于北斗RDSS的野外科考位置服务原型系统设计与实现,叶方舟,王远飞,鉴于野外科考的性质和特点,科考队员经常会前往一些人迹罕至的荒芜地区,并不时发生意外事故,因此科学考察中的安全问题已经受到
  • 环境气象站基于北斗RDSS短报文物联网环境气象监测 项目概述 随着时代的进步发展,社会对自然可利用资源的开采,伴随而来的自然灾害对国家的经济、军事、政治、产业等的生产发展活动造成巨大的影响。利用气象...

    北斗RDSS卫星传输应用于自动农业气象站预报系统

    • 方案概述

    农业气象站是一种能自动地观测与储存气象观测数据的设备,其主要功能是实时监测风、温度、湿度、气压、草温等气象要素以及土壤含水量的数据变化。设施农业作为我国现代农业的重要组成部分,正异军突起,发展规模在迅速扩大,不仅是在数量上、而且在现代化建设及装备方面都取得了可靠的发展。

    利用北斗RDSS短报文实现全国范围内,无距离限制的数据传输,在无手机信号的地区实现数据监控,实时的采集和控制管理。以实现智能化识别、传感器数据采集、智能控制、北斗RDSS短报文、实时监控和管理。随时随地实时监测农业变化。

    • 方案特点

    全国无盲区:使用北斗RDSS和3G/4G网络融合技术,全国范围内无盲区传输;

    数据感知:实时监测气压、风向、风速、温度、土壤湿度、雨量等气象要素。

    数据上报:农业气象监测终端实时采集数据输出信号,进行数据上报。

    数据传输:监测数据通过3G/4G/北斗数传终端PD06传输至线上多端。

    数据应用:监测预警多端平台实时显示、存储各监测点数据,并及时分析、发布预警信息。预防灾害,进行提前部署。

    • 主要构成

    设备名称

    数量

    主要技术指标

    传感器

    按需求定制

    温度、湿度、风向各类气象参数

    北斗卡

    60-300秒频度,78字节/条

    通讯设备

    (输出方式)

    北斗PD06

    (无人区无信号区数据传输)

    3G、4G输出

    LORA输出等

    立杆

    立杆长3m或5米(可选);

    带避雷针

    蓄电池

    1块

    24AH/12V;

    65AH/12V;

    太阳能电池板

    1套

    30W/60W

    监控系统

    1台

    支持多端实时监控

    都可按用户需求定制

    • 方案架构

    农业气象站进行农业环境实时监测,通过北斗卫星RDSS短报文输出到服务器,运行状态监控、视频监控、站房状态监控、远程控制、远程操作等功能。根据客户需求不同进行定制。

    方案框架图

     

    • 功能参数

    技术参数

    测量范围

    分辨率

    精度

    单位

    温度

    -40-125

    0.1

    ±0.2

    °C

    湿度

    0-100

    0.1

    ±3

    %RH

    PM2.5

    0-999

    1

    ±3F.s

    ug/m3

    PM10

    0-999

    1

    ±3F.s

    ug/m3

    大气压力

    1-110

    0.01

    ±0.1

    Kpa

    风速

    0-60

    0.1

    ±0.3

    m/s

    风向

    16方向

    1方向

    --

    --

    噪声

    30-130

    0.1

    ±3F.s

    dB

    雨量

    0-30

    0.2

    ±2%

    mm/min

    土壤

    -45-115

    0.5

    ±3%

    °C

    蒸发量

    0-200mm

    1

    ±1%

    mm

    SO2

    0-20

    0.1

    ±3F.s

    PPm

    NO2

    0-20

    0.1

    ±3F.s

    PPm

    O3

    0-20

    0.1

    ±3F.s

    PPm

    co

    0-1000

    0.1

    ±3F.s

    PPm

    通讯系统

    RS485有线

    通讯距离0-2000m

    选配

    以太网接口

    自接接线

    GPRS

    通讯距离不限

    选配

    北斗数传PD06

    (北斗RDSS短报文)

    无距离限制

    (无人区无信号数据传输)

    标配

    • 输出方式

    北斗RDSS输出方式

    使用北斗卫星系统可在无人区无信号区无距离限制通过数传终端直接传输到服务器端,用户可直接连接磐钴智能的云平台或者客户自己的云平台服务器。可以通过PC端、网页端、移动端登录查看实时数据、历史数据等。

    4G主动上报

     

    使用无线直接传送到服务器端,可直接连接我司的云平台或者客户自己的云平台服务器。用户可以通过PC端、网页端、移动端登录查看实时数据、历史数据等。

    以太网输出方式

    使用RJ45以太网传输,可直接将数据传送到服务器端,连接我司云平台或者客户自己的云平台服务器,同时还可以接入局域网使用电脑或者组态软件查看数据。

    LORA输出方式

     

    LORA超远距离输出方式,使用LoRaWan通讯协议将数据传输到服务器端。用户可直接连接我司云平台或者客户自己的云平台服务器,可以通过PC端、网页端、移动端登录查看实时数据、历史数据等。

    不同需求可定制

    • 云平台系统

    • 磐钴智能可视化云平台管理,可设置预警值,远程查看传感器实时数据、历史数据等

    • 用户端支持WEB网页端、移动端、PC端、小程序实时监测

     

    通过北斗PD06无线模块实时传输给服务器端,具备系统运行状态监控、远程控制、远程操作等功能。随时随地实时数据监控。

    1. 应用案例

    用于农业环境的气象参数的监测,利用北斗数传终端PD06传输到服务器端,用户可使用PC端、移动端进行数据的实时监测。

    北斗PD06适用于任何区域任何环境(无人区无信号区全国范围内进行气象参数的传输。

    展开全文
  • 原标题:【科普】涨知识,带你认识北斗RDSS的定位方式众所周知我们的北斗卫星定位系统的特色是集成了RNSS与RDSS两种业务。所谓RNSS与RDSS集成概念,是在卫星导航系统的导航卫星及运控应用系统中同时集成RNSS和RDSS两...

    原标题:【科普】涨知识,带你认识北斗RDSS的定位方式

    众所周知我们的北斗卫星定位系统的特色是集成了RNSS与RDSS两种业务。所谓RNSS与RDSS集成概念,是在卫星导航系统的导航卫星及运控应用系统中同时集成RNSS和RDSS两种业务。系统既可为用户提供连续定位,测速能力(即所谓无源导航定位),又可进行无信息传输的高安全级别的位置报告。其导航与通信的集成可以互相嵌入,互为增强。

    那么,北斗系统的RDSS定位方式又有哪些呢?

    北斗用户机的无线电卫星测定业务(RDSS)定位方式包括单词定位、连续定位和紧急定位三种方式。

    单次定位

    适用于用户实时确定当前的位置点,用户手动申请一次定位,可以获得当前的坐标位置。两次单次定位间隔需大于等于本机服务频度所要求的最小间隔。

    连续定位

    适用于运动载体,用户机按用户设定的定位频度自动连续获得到过年前的坐标位置。用户设定的定位频度需小于等于本机的服务频度。

    紧急定位

    紧急定位不受服务频度限制。在执行紧急定位时,其他功能暂时关闭。执行紧急定位并在2倍于本用户服务最小服务间隔后,方可在此申请正常定位。紧急定位也称紧急呼叫,或称口令识别。

    RDSS为有源服务模式。用户需要响应服务波束并将观测数据回传到中心站进行处理。由于卫星和地面设备通讯链路带宽和容量有限,入站和出站的资源都是有限的,因此必须对频度加以限制,根据用户的需求及重要等级进行区分。对于低等级用户,其服务频度偏低,但当其遇到一些特殊紧急情况时,该服务频度无法满足满足实际需求,为此,北斗RDSS专门针对用户特殊紧急情况,设计了北斗RDSS紧急定位模式,这是北斗系统的重要特色。

    当用户启动紧急定位功能后,主控站对改定位申请按三类用户机的实时性处理,及时完成用户定位,并保存用户的最新紧急定位的位置信息。

    用户机第一次申请紧急定位不受用户机服务频度限制。紧急定位功能一经使用,自动关闭用户机的发射功能,经过延时后恢复发射功能。用户机的关闭延时为该用户机申请平度最大延迟的2倍。

    通过RDSS,地面中心能够直接知道导航用户的位置信息,便于位置信息的获取、汇集和统筹利用。

    而RNSS用户只有自己知道自己的位置,除非用户借助另外的通信系统才能把自己的位置发送出来。

    所以北斗RDSS比较适合需要集中指挥调度行业的应用。

    在汶川抗震救灾时,北斗发挥了生命线作用,救灾部队在震区通信完全中断的头几天里,充分利用北斗RDSS收集灾情,指挥救灾,在救灾最关键的黄金72小时里,成功救出和转移灾民近万人。

    在我国东海南海的主要渔场,几万条渔船都已经装上了北斗RDSS卫星设备,渔民不仅能实时得到最新的鱼讯买卖信息,最新的台风预警信息,还能实现危险上报、越界报警、自救互救,作用大大滴。

    此外,北斗还在智能交通、森林防火、农业精耕、电力监控、水文监测等诸多行业正在发挥着不可替代的作用。返回搜狐,查看更多

    责任编辑:

    展开全文
  • 基于北斗RDSS短报文通信卫星的位置追踪监控和应急通信系统技术解决方案由现场端和局端组成。现场端的北斗手持终端、北斗车载终端、北斗船载终端等,通过北斗卫星这条新的通信链路发送到局端的接收设备,实现与局端...

            我国地大物博,电力、水利、交通、减灾各领域都有大量信息传递,而在大部分偏远区域,手机信号很弱,甚至根本没有任何手机信号的地区,想把信息传出来就成为了一个难题。

            基于北斗RDSS短报文通信卫星的位置追踪监控和应急通信系统技术解决方案由现场端和局端组成。现场端的北斗手持终端、北斗车载终端、北斗船载终端等,通过北斗卫星这条新的通信链路发送到局端的接收设备,实现与局端之间的数据透传。局端收到北斗报文之后,通过北斗通信前置服务器的软件解析并将数据传送至用户的业务系统,实现用户的业务功能。

    基于北斗RDSS短报文通信卫星的位置追踪监控和应急通信系统架构

     

     

    现场端功能描述

    现场端支持手持、车载、船载等各类设备,适用于各种场景。

            现场端的终端有手持、船载、车载设备,都可以支持单机工作,单机工作模式下,设备开机即可不断进行位置上报到局端,局端接收到位置信息即可在GIS系统中显示。同时,手持,船载,车载设备都可以支持蓝牙或者wifi形式连接天地卫通APP,在APP中,用户可以的功能如下:

    • 自由发送卫星消息/手机短信
    • 快捷通道进入指挥中心通信
    • 报平安/SOS告警功能
    • 获取离线消息
    • 多种卫星地图自由切换
    • 位置直播随时分享
    • 启动位置自动上报/极限追踪功能
    • 指北针查看位置
    • 所在经纬度日出日落查询
    • 设备状态查看

     

            磐钴的北斗盒子终端,硬件带一键sos按钮,如遇紧急情况,用户可手动启动SOS,向后台求助,后台管理员可以通过web系统分析用户的轨迹以及当前点的状况;

     

    局端功能描述

     

           局端由北斗指挥机、北斗卫星收发单元、北斗多卡机,北斗通信前置服务器、组成,采用网络方式连接。

     

    局端系统结构

           局端的北斗指挥机用于接收所用,而对外发送短报文,则由北斗卫星收发单元或北斗多卡机完成,对于发送设备,用户可二选一,而接收设备,则必须使用北斗指挥机,局端要完成以下功能:

    1、北斗通信前置服务器需部署磐钴智能定制开发的北斗协议处理后台、数据逻辑集中处理后台、应用业务管理后台、本地核心数据库、北斗位置监控后台、应用APP后台;

    2、北斗通信前置服务器接收每个现场北斗终端上送的各项数据,并保存在北斗通信前置服务器的数据库中;

    3、在北斗通信前置服务器的程序上实现:模拟现场的北斗数传终端与主站保持TCP/IP实时连接。当用户业务系统进行数据请求时,从本地的北斗通信前置服务器的数据库中取最新的数据,上送给用户业务系统;

    4、当局端收到来自于现场端的北斗报文时,局端可用北斗卫星收发单元或北斗多卡机往北斗数传终端发送回执;

     

    北斗位置监控平台介绍

     

             用户在使用现场端的北斗设备时,产生大量的位置数据和报文数据,北斗位置监控平台将从数据库中读取这些数据,并通过GIS、图表等可视化的方式向用户展示,管理平台采用CIS架构实现业务人员对系统的管理,实现北斗指挥机和北斗多卡机、北斗卫星收发单元的实时管理与监控,能在页面监控到后台对通道的智能巡检情况,如出现故障报警状况,专业的维护人员可以对其进行操作维护;同时能对平台各种参数数据、用户数据、北斗终端数据、等待的数据进行设定与管理。

    通用展示平台采用B/S架构,实现领导或用户能够直观的看到北斗终端的地图位置信息、短报文历史记录信息、坐标历史记录信息、行程轨迹信息等,为用户提供通用的信息展示。

    磐钴的本地部署把多个后台部署到用户服务器,用户无需花几个月开发,目前系统是基础的短报文通信管理功能,如果用户有额外的增值应用服务需求,本司支持付费定制;

     

     

    系统技术特点

     

    1、产品简单易用、便于维护

    本方案施工技术人员通过进行简单培训后,即可独立完成的设备安装,调试工作。现场终端设备迁移或变更时无需更改系统配置,维护方便。

    2、不占用其它网络资源

    随着物联网信息化、自动化的程度越来越高,有限的IP资源在分配应用上显得捉襟见肘。在采用其它方式通信通道建设时,需要在用户应用现场、用户公司内部等场景添加大量的设备,势必占用大量的IP资源,同时采集数据需经过用户信息内网,需要增加用户信息内网的带宽。而北斗通信通道不占用用户内网IP,也不占用用户信息内网带宽。

    3、北斗通信通道免费、后期维护成本低

    北斗卫星系统目前对民用完全免费,暂无需像租赁手机公网那样每月支付月租费用,未来待国家规定收取服务费时,将按照“数百元/点·年”收取年服务费。

    在后期的运行维护中,如出现设备故障,只需对设备本身进行故障诊断,无需像其它通信链路一样,需要判断复杂的通路问题

    4、通信带宽

    下行带宽:无论是分钟卡还是秒卡,在数据接收频率上没有限制,可以在同时接收多个终端上送的多条报文。

    上行带宽:北斗卫星通信支持短报文传输功能,目前支持报文长度为38个汉字。

    展开全文
  • ================================================ ...===========================================...北斗系统除了能够进行定位导航授时(Positioning, Navigation, and Timing,PNT)外,还能够进行短报文通信。其特点

    ================================================
    博主github:https://github.com/MichaelBeechan
    博主CSDN:https://blog.csdn.net/u011344545

    ================================================
    在这里插入图片描述

    • 北斗系统除了能够进行定位导航授时(Positioning, Navigation, and Timing,PNT)外,还能够进行短报文通信。其特点是:由用户以外的中心控制系统,通过用户对卫星信号的询问、应答获得距离观测量,由中心控制系统计算用户的位置坐标,并将此信息传送给用户。
      在这里插入图片描述

    RDSS定义

    • 卫星无线电定位系统(radio determination satel-lite system)指由中心地球站发信号,通过卫星与移动目标(海上、陆地、空中移动体)之间的无线电波传播时间,可测定移动目标的坐标(位置)、运动速度和方向等参数,并向移动目标传送简短信息的系统,简称RDSS系统
    • 北斗RDSS系统是一个区域性的卫星定位系统,具备快速导航定位、双向短报文通信和定位授时三大功能。RDSS系统由空间段卫星系统、地面测量与控制系统(MCC)和用户系统三大部分组成。
      在这里插入图片描述

    空间段卫星系统

    在这里插入图片描述

    • 空间段卫星系统是由两颗或多颗GEO(吉星,地球静止轨道卫星)卫星组成。
      在这里插入图片描述

    地面测量与控制系统(MCC)在这里插入图片描述

    • 地面测量与控制系统包括一个测量与控制中心和一个标校系统(CS),其中标校系统由20~30个标校站组成。
    • 测量与控制中心即MCC由地面控制中心和地面数据处理中心组成。
    地面控制中心

    在这里插入图片描述

    地面数据处理中心

    在这里插入图片描述

    用户系统

    • RDSS用户设备可分为手持型、车载型、船载型、机载型、指挥型。。。。。。。
    • 单址用户机:普通用户机
    • 多址用户机:指挥机
      在这里插入图片描述
    北斗二代RD
    • 北斗二代短报文通信:可为用户机与用户机、用户机与地面中心站之间提供每次最多120个汉字即1680bit的短报文通信服务(北斗二代RD)。每个用户机都有唯一的ID号,并采用1户1密的加密方式,通信均需经过地面中心站转发。
     -1)短报文发送方首先将包含接收方ID号和通信内容的通信申请信号加密后通过卫星转发入站;
     -2)地面中心站接收到通信申请信号后,经脱密和再加密后加入持续广播的出站广播电文中,经卫星广播给用户;
     -3)接收方用户机接收出站信号,解调解密出站电文,完成一次通信。
     -  短报文通信的传输时延约0.5秒,通信的最高频度也是11次。
    

    RDSS信号体制

    • 包含出站和入站,如下图
      在这里插入图片描述
    • 出入站信号格式参考:《北斗卫星导航定位原理与方法》:P344-P345

    在这里插入图片描述

    RD双星定位原理

    双星定位原理
    • 以 2 颗在轨卫星的已知坐标为圆心,各以测定的卫星至用户终端的距离为半径,形成 2个球面,用户终端将位于这 2 个球面交线的圆弧上。地面中心站配有电子高程地图,提供一个以地心为球心、以球心至地球表面高度为半径的非均匀球面。用数学方法求解圆弧与地球表面的交点即可获得用户的位置。
    • 所以当用户机发送北斗短报文定位请求给卫星后,卫星将请求转发给地面中心站,中心站计算完成后,就将用户机的位置坐标发送给卫星,经卫星中转到用户机。
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    闵士权:双星定位原理

    在这里插入图片描述

    RD双星定位算法
    • 主要参考:《北斗卫星导航定位原理与方法》
      在这里插入图片描述
      在这里插入图片描述
    RD单向授时算法

    在这里插入图片描述
    在这里插入图片描述

    RD双向授时算法

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    参考:

    1、卫星导航定位工程:谭树森
    2、北斗卫星导航定位原理与方法:黄德文

    代码
    /*
    1、短报文通信过程:
    (1)短报文发送方首先将包含接收方ID号和通讯内容的通讯申请信号加密后通过卫星转发入站;
    (2)地面中心站接收到通讯申请信号后,经脱密和再加密后加入持续广播的出站广播电文中,经卫星广播给用户;
    (3)接收方用户机接收出站信号,解调解密出站电文,完成一次通讯。
    与定位功能相似,短报文通讯的传输时延约0.5秒,通讯的最高频度也是1秒1次。
    2、北斗短报文的通信技术原理
    指挥机端可通过串口获取发送至其的数据,并通过JAVA 等编码程序接收并处理数据,以实现各种应用。
    串口非同步传送,参数定义如下:
    (1)传输速率:19200bit/s(默认),可根据用户机具体情况设置其他速率;
    (2)1 bit 开始位;
    (3)8 bit 数据位;
    (4)1 bit 停止位;
    (5)无校验。
    
    */
    
    //参考
    /******************************************************************************************************
    1、北斗协议和GPS协议不一样,不是以"\r\n"为一条协议的结束.
    2、printf函数中的打印信息是const字符串常量,放在cpu内部flash,北斗模块printf打印过多,导致scanf("%s",payload);输入的内容被改写.
    3、协议发送时不要使用结构体表示发送内容,接收时可以使用结构体表示接收内容.
    4、调试协议时使用串口监视工具AccessPort进行串口协议抓包.
    5、Msp430F5438:RAM(16KB),内部flash(256KB + 256B),4个串口.
    6、注意北斗协议净荷封装的是RTU的协议,由于RTU协议也是以'$'符号位为协议的开始,因此需要进行转义,本程序以'M'替代净荷中的'$'.
    7、Created by xumin,2015-05-20,copyright is reserved.
    ******************************************************************************************************/
     
    #include "..\..\include\includes.h"
     
    #ifdef DEF_COMPILE_PROJECT_APP
     
    #ifdef BD_COMM_SUPPORT
     
    unsigned char bd_buf_bitmap = 0;
     
    //unsigned char dwxx_buf[todo];
    unsigned char txxx_buf[TXXX_MAX_SIZE];
    unsigned char icxx_buf[ICXX_FIRM_SIZE];
    unsigned char zjxx_buf[ZJXX_FIRM_SIZE];
    //unsigned char sjxx_buf[todo];
    //unsigned char bbxx_buf[todo];
    unsigned char fkxx_buf[FKXX_FIRM_SIZE];
     
    unsigned int rx_packet_len = 0;
    unsigned char bd_rx_char;
    unsigned int bd_buf_pointer = 0;
    unsigned char bd_shared_rx_buf[RX_BD_MAX_DATA_SIZE];
     
    unsigned char  g_src_user_addr[3];
    unsigned char  g_dst_user_addr[3];
    unsigned char g_transfer_format;
     
     
    void init_uart3_for_bd()
    {
    #if 1 //波特率115200配置
        P10SEL |= BIT4 + BIT5;
        
        UCA3CTL1 |= UCSWRST; //USCI状态机复位
        
        UCA3CTL1 |= UCSSEL_2;  //SMCLK 
        
        UCA3BR0 = 69; //115200
        UCA3BR1 = 0x00;
        UCA3MCTL = 0x06; //波特率微调
        
        UCA3CTL1 &= ~UCSWRST; //初始化USCI状态机
        
        UCA3IE |=  UCRXIE; //使能BD串口RX中断
       
    #else  //波特率9600配置
        P10SEL |= BIT4+BIT5;
     
        UCA3CTL1 |= UCSWRST;//USCI状态机复位
        
        UCA3CTL1 |= UCSSEL_1;//ACLK
                      
        UCA3BR0 = 0x03;//9600
        UCA3BR1 = 0x00; 
        UCA3MCTL = 0x06;//波特率微调
     
        UCA3CTL1 &= ~UCSWRST;//初始化USCI状态机
     
        UCA3IE |=  UCRXIE;  //使能BD串口RX中断
    #endif
    }
     
    /* 
        异或校验和算法 
     */
     static unsigned char xor_checksum (unsigned char *buf, unsigned int len)
    {
        unsigned int i;
        unsigned char checksum = 0;
     
        for (i = 0; i < len; ++i)
        {
            checksum ^= *(buf++);
        }
     
        return checksum;
    }
     
    void tx_uart3_char(unsigned char c)
    {
        while (!(UCA3IFG & UCTXIFG));
        
        UCA3TXBUF  = c;
    }
     
    void tx_uart3_string(unsigned char *str, unsigned int len)
    {
        unsigned int i;  
        
        for (i = 0 ; i < len; ++i)
        {
            tx_uart3_char(*(str + i));
        }
    }
     
    void create_txsq(unsigned char *src_user_addr, unsigned char *dst_user_addr, 
                                    unsigned char transfer_format, unsigned char *payload, 
                                    unsigned int payload_len, unsigned char *send_txsq_data)
    {    
        /* 1、通信申请指令初始化,不采用memcpy等库函数,提高指令执行效率,只有涉及到大量数据赋值拷贝时才考虑用库函数 */
        send_txsq_data[0] = '$';   
        send_txsq_data[1] = 'T';   
        send_txsq_data[2] = 'X';  
        send_txsq_data[3] = 'S';  
        send_txsq_data[4] = 'Q';  
     
        /* 2、包长度,先传高位,再传低位 */
        send_txsq_data[5] = (TXSQ_FIRM_SIZE +  payload_len) / 256;
        send_txsq_data[6] = (TXSQ_FIRM_SIZE +  payload_len) % 256;
     
        /* 3、源用户地址 */
        send_txsq_data[7] = *src_user_addr;
        send_txsq_data[8] = *(src_user_addr + 1);
        send_txsq_data[9] = *(src_user_addr + 2);
        
        /* 4.1、信息-信息类别 */
        if (transfer_format == 0) //汉字
        {
            send_txsq_data[10] = TXSQ_PAYLOAD_CHINESE;//0b01000100; 
        }
        else //代码/混发
        {
            send_txsq_data[10] = TXSQ_PAYLOAD_BCD;//0b01000110;
        }
     
        /* 4.2、信息-目的用户地址 */
        send_txsq_data[11] = *dst_user_addr;
        send_txsq_data[12] = *(dst_user_addr + 1);
        send_txsq_data[13] = *(dst_user_addr + 2);
     
        /* 4.3、信息-电文净荷长度-单位是bit */ 
         send_txsq_data[14] = (payload_len * 8) / 256;
         send_txsq_data[15]  = (payload_len * 8) % 256;  
     
        /* 4.4、信息-是否应答 */
         send_txsq_data[16]  = 0;
     
        /* 4.5、信息-电文内容 */
        memcpy(&send_txsq_data[17] , payload, payload_len);
     
        /* 5、校验和 */
        send_txsq_data[TXSQ_FIRM_SIZE + payload_len -1] = xor_checksum(send_txsq_data, (TXSQ_FIRM_SIZE +  payload_len -1));
        printf("\r\n    xor_checksum = 0x%x\r\n",  xor_checksum(send_txsq_data, (TXSQ_FIRM_SIZE +  payload_len -1)));
    }
     
    void send_dwsq()
    {
        //todo
    }
     
    /* 
        1、结构体不宜管理可变长度的数据协议,如通讯申请协议
        2、发送长度为6个字节("我爱你"),发送方式为中文,协议内容:
           txsq:24 54 58 53 51 00 18 02 ad f7 44 02 ad f7 00 30 00 ce d2 b0 ae c4 e3 63
           txxx:24 54 58 58 58 00 1a 02 ad f7 40 02 ad f7 00 00 00 30 ce d2 b0 ae c4 e3 00 67
     */
    void send_txsq(unsigned char cmd, unsigned char *src_user_addr, unsigned char *dst_user_addr, 
                                 unsigned char transfer_format, unsigned char *send_txsq_payload, unsigned int send_txsq_payload_len)
    {
        unsigned int i;
        unsigned char l_transfer_format;
        unsigned int payload_len;
        unsigned long src_user_addr_long;
        unsigned long dst_user_addr_long;
        unsigned char l_src_user_addr[3];
        unsigned char l_dst_user_addr[3];
        unsigned char payload[MAX_PAYLOAD_LEN];
        unsigned char send_txsq_data[TXSQ_FIRM_SIZE + MAX_PAYLOAD_LEN]; 
     
        if (cmd == 1)
        {
            UCA2IE &=  ~UCRXIE; 
     
            DebugPrintBd("\r\n    输入十六进制用户地址(如02adf7,02adfb):");
            scanf("%lx", &src_user_addr_long);  
     
            DebugPrintBd("\r\n    输入十六进制目的用户地址(如02adf7,02adfb):");
            scanf("%lx", &dst_user_addr_long);
     
            DebugPrintBd("\r\n    内容编码(0:汉字,1代码):");
            scanf("%d",&l_transfer_format);
     
    #if 1      
            DebugPrintBd("\r\n    发送内容:");
            scanf("%s", payload);
            payload_len = strlen((char const *)payload);
    #else
            DebugPrintBd("\r\n    输入发送内容长度:");
            scanf("%d", &payload_len);
            //payload_len = 78;
            for (i = 0; i < payload_len; ++i)
            {
                payload[i] = 0x5a;
            }
    #endif
     
            UCA2IE |=  UCRXIE; 
             
            l_src_user_addr[0] = src_user_addr_long / 65536;
            l_src_user_addr[1] = (src_user_addr_long % 65536) / 256;
            l_src_user_addr[2] = (src_user_addr_long % 65536) % 256;
            
            l_dst_user_addr[0] = dst_user_addr_long / 65536;
            l_dst_user_addr[1] = (dst_user_addr_long % 65536) / 256;
            l_dst_user_addr[2] = (dst_user_addr_long % 65536) % 256;       
     
            for (i = 0; i < 3; ++i)
            {
                g_src_user_addr[i] = l_src_user_addr[i];
                g_dst_user_addr[i] = l_src_user_addr[i];
            }
            
            g_transfer_format = l_transfer_format;      
      
            
            create_txsq(l_src_user_addr, l_dst_user_addr, l_transfer_format, payload, payload_len, send_txsq_data);
            tx_uart3_string(send_txsq_data, (TXSQ_FIRM_SIZE + payload_len));
        }
        else
        {
            create_txsq(src_user_addr, dst_user_addr, transfer_format, send_txsq_payload, send_txsq_payload_len, send_txsq_data);
            tx_uart3_string(send_txsq_data, (TXSQ_FIRM_SIZE + send_txsq_payload_len));
        }
        
    }
     
    void send_cksc()
    {
        //todo
    }
     
    /*  
        1、IC检测协议内容:
           icjc:24 49 43 4A 43 00 0C 00 00 00 00 2B 	
           icxx:24 49 43 58 58 00 16 02 AD F7 00 00 00 0B 06 00 3C 03 00 00 00 52 
     */
    void send_icjc()
    {
        unsigned char send_icjc_data[XTZJ_FIRM_SIZE];
        
        send_icjc_data[0] = '$';  
        send_icjc_data[1] = 'I';
        send_icjc_data[2] = 'C'; 
        send_icjc_data[3] = 'J';
        send_icjc_data[4] = 'C';
        
        send_icjc_data[5] = ICJC_FIRM_SIZE / 256;  //先传高位
        send_icjc_data[6] = ICJC_FIRM_SIZE % 256; //再传低位
        
        send_icjc_data[7] = 0x00;
        send_icjc_data[8] = 0x00;
        send_icjc_data[9] = 0x00;
     
        send_icjc_data[10] = 0x00;
     
        send_icjc_data[11] = xor_checksum(send_icjc_data, (XTZJ_FIRM_SIZE - 1)); 
     
        tx_uart3_string(send_icjc_data, XTZJ_FIRM_SIZE); 
    }
     
    /*  
        1、XTZJ协议内容:
           xtzj:24  58 54 5A 4A 00 0D 02 AD FB 00 00 61 	
           zjxx:24 5a 4a 58 58 00 15 02 AD FB 01 00 64 02 00 00 03 00 02 00 13 
     */
     
    void send_xtzj()
    {
        unsigned long user_addr;
        unsigned int frequency;
        unsigned char send_xtzj_data[XTZJ_FIRM_SIZE];
     
        UCA2IE &=  ~UCRXIE;    
     
        DebugPrintBd("\r\n    输入十六进制用户地址(如02adf7):");
        scanf("%lx", &user_addr);
     
        DebugPrintBd("\r\n    输入系统自检的频度:");
        scanf("%d", &frequency);
     
        UCA2IE |=  UCRXIE; 
     
        send_xtzj_data[0] = '$';
        send_xtzj_data[1] = 'X';
        send_xtzj_data[2] = 'T';
        send_xtzj_data[3] = 'Z';
        send_xtzj_data[4] = 'J';
     
        send_xtzj_data[5] = XTZJ_FIRM_SIZE / 256; //先传高位
        send_xtzj_data[6] = XTZJ_FIRM_SIZE % 256; //再传低位
     
        send_xtzj_data[7] = user_addr / 65536;
        send_xtzj_data[8] = (user_addr % 65536) / 256;
        send_xtzj_data[9] = (user_addr % 65536) % 256;
     
        send_xtzj_data[10] = frequency / 256;
        send_xtzj_data[11] = frequency % 256;
     
        send_xtzj_data[12] = xor_checksum(send_xtzj_data, XTZJ_FIRM_SIZE-1);
        
        tx_uart3_string(send_xtzj_data, XTZJ_FIRM_SIZE);
    }
     
    void send_sjsc()
    {
        //todo
    }
     
    void send_bbdq()
    {
        //todo
    }
     
    void parse_txxx(struct txxx_struct *txxx)
    {
        unsigned int i;
        unsigned int payload_len;
        unsigned char send_data[104];//用途有2
     
        /* 1、指令内容 */
        for (i = 0; i < 5; ++i)
        {
            (*txxx).instruction[i] = txxx_buf[i];
        }
     
        /* 2、接收包长 */
        (*txxx).packet_len = txxx_buf[5] * 256 + txxx_buf[6];
     
        /* 3、目的用户地址 */
        for (i = 0; i < 3; ++i)
        {
            (*txxx).user_addr[i] = txxx_buf[i + 7];
        }
     
        /* 4.1、信息-信息类别 */
        memcpy(&((*txxx).txxx_info.txxx_info_type), (txxx_buf + 10), 1);   
     
        /* 4.2、信息-发送方地址 */
        for (i = 0; i < 3; ++i)
        {
            (*txxx).txxx_info.src_user_addr[i] = txxx_buf[i + 11];
        }
        
        /* 4.3、信息-发送时间 */
        (*txxx).txxx_info.send_time.hour = txxx_buf[14];
        (*txxx).txxx_info.send_time.minute = txxx_buf[15];
            
        /* 4.4、信息-电文长度 */
        (*txxx).txxx_info.payload_len = txxx_buf[16] * 256 + txxx_buf[17];
        payload_len = (*txxx).txxx_info.payload_len / 8;
        
        /* 4.5、信息-电文内容 */
        memcpy((*txxx).txxx_info.payload, (txxx_buf + 18), payload_len);
     
        /* 4.6、信息-CRC */
        (*txxx).txxx_info.crc = txxx_buf[18 + payload_len];
     
        /* 5、校验和 */
        (*txxx).checksum = txxx_buf[18 + payload_len + 1];
     
        if ((txxx_buf[18] == 'z') && (txxx_buf[19] == 't')/* (txxx_buf[18] == 'z') && (txxx_buf[19] == 't') && (txxx_buf[20] == 'c') && (txxx_buf[20] == 'x') */)
        {
    #if 1
            create_send_data_1(send_data);
            send_txsq(0, &(*txxx).user_addr[0], &(*txxx).txxx_info.src_user_addr[0], g_transfer_format, send_data, (104-37));
    #else   
            for (i = 0; i < (104-37); ++i)
            {
                send_data[i] = 0x5a;
            }
        
            send_data[0] = 'M';
            send_data[1] = (104-37);
            send_txsq(0, &(*txxx).user_addr[0], &(*txxx).txxx_info.src_user_addr[0], g_transfer_format, send_data, (104-37));
    #endif      
           
        }else if ( (txxx_buf[18] == 'M') && (txxx_buf[19] == (104-37)) )
        {
            create_send_data_2(send_data, &txxx_buf[18], payload_len);
            SendData(104, 1, GSMNEW_ENUM_measureCurSend, send_data); 
        } 
    }
     
    void parse_icxx(struct icxx_struct *icxx)
    {
        unsigned int i;
     
        for (i = 0; i < 5; ++i)
        {
            (*icxx).instruction[i] = icxx_buf[i];
        }
     
        (*icxx).packet_len = icxx_buf[5] * 256 + icxx_buf[6];
     
        for (i = 0; i < 3; ++i)
        {
            (*icxx).user_addr[i] = icxx_buf[i + 7];
        }
     
        (*icxx).icxx_info.frame_id = icxx_buf[10];
     
        for (i = 0; i < 3; ++i)
        {
            (*icxx).icxx_info.broadcast_id[i] = icxx_buf[i + 11];
        }
     
        (*icxx).icxx_info.user_feature = icxx_buf[14];
     
        (*icxx).icxx_info.service_frequency = icxx_buf[15] * 256 + icxx_buf[16];
     
        (*icxx).icxx_info.comm_level = icxx_buf[17];
     
        (*icxx).icxx_info.encryption_flag = icxx_buf[18];
     
        (*icxx).icxx_info.user_num = icxx_buf[19] * 256 + icxx_buf[20];
     
        (*icxx).checksum = icxx_buf[21];
        
    }
     
    void parse_zjxx(struct zjxx_struct *zjxx)
    {
        unsigned int i;
     
        for (i = 0; i < 5; ++i)
        {
            (*zjxx).instruction[i] = zjxx_buf[i];
        }
     
        (*zjxx).packet_len = zjxx_buf[5] * 256 + zjxx_buf[6];
     
        for (i = 0; i < 3; ++i)
        {
            (*zjxx).user_addr[i] = zjxx_buf[i + 7];
        }
     
        (*zjxx).zjxx_info.ic_status = zjxx_buf[10];
     
        (*zjxx).zjxx_info.hw_status = zjxx_buf[11];
     
        (*zjxx).zjxx_info.battery_quantity = zjxx_buf[12];
     
        (*zjxx).zjxx_info.in_station_status = zjxx_buf[13];
     
        for (i = 0; i < 6; ++i)
        {
            (*zjxx).zjxx_info.power_status[i] = zjxx_buf[14 + i];
        }
     
        (*zjxx).checksum = zjxx_buf[20];
    }
     
    void parse_fkxx(struct fkxx_struct *fkxx)
    {
        unsigned int i;
     
        for (i = 0; i < 5; ++i)
        {
            (*fkxx).instruction[i] = fkxx_buf[i];
        }
     
        (*fkxx).packet_len = fkxx_buf[5] * 256 + fkxx_buf[6];
        
        for (i = 0; i < 3; ++i)
        {
            (*fkxx).user_addr[i] = fkxx_buf[i + 7];
        }
     
        (*fkxx).fkxx_info.fk_flag = fkxx_buf[10];
     
        for (i = 0; i < 4; ++i)
        {
            (*fkxx).fkxx_info.extra_info[i] = fkxx_buf[11 + i];
        }
     
        (*fkxx).checksum = fkxx_buf[15];
    }
     
    void print_txxx(struct txxx_struct *txxx)
    {
        unsigned int i;
        
        Tx_monitor_S("\r\n    ========= TXXX包-打印开始=========\r\n");
     
        DebugPrintBd("\r\n    TXXX包总长度:%d", (*txxx).packet_len);
        DebugPrintBd("\r\n    TXXX包用户地址:0x%02x%02x%02x", (*txxx).user_addr[0], (*txxx).user_addr[1], (*txxx).user_addr[2]);
        DebugPrintBd("\r\n    TXXX包信息内容-发送方地址:0x%02x%02x%02x", (*txxx).txxx_info.src_user_addr[0], (*txxx).txxx_info.src_user_addr[1], (*txxx).txxx_info.src_user_addr[2]);
        DebugPrintBd("\r\n    TXXX包信息内容-发送时间:%02d时%02d分",  (*txxx).txxx_info.send_time.hour,  (*txxx).txxx_info.send_time.minute);
        DebugPrintBd("\r\n    TXXX包信息内容-电文长度:%d字节", (*txxx).txxx_info.payload_len / 8);
        DebugPrintBd("\r\n    TXXX包信息内容-电文内容:");
        for (i = 0; i < ((*txxx).txxx_info.payload_len / 8); ++i)
        {
            DebugPrintBd("%02x ", (*txxx).txxx_info.payload[i]);
        }
        DebugPrintBd("\r\n    TXXX包信息内容-CRC:0x%02x", (*txxx).txxx_info.crc);
        DebugPrintBd("\r\n    TXXX包校验和:0x%02x", (*txxx).checksum);
        
        DebugPrintBd("\r\n    ========= TXXX包-打印结束=========\r\n");
    }
     
    void print_icxx(struct icxx_struct *icxx)
    {
        Tx_monitor_S("\r\n    ========= ICXX包-打印开始=========\r\n");
        
        DebugPrintBd("\r\n    ICXX包总长度:%d", (*icxx).packet_len);
        DebugPrintBd("\r\n    ICXX包用户地址:0x%02x%02x%02x", (*icxx).user_addr[0], (*icxx).user_addr[1], (*icxx).user_addr[2]);   
        DebugPrintBd("\r\n    ICXX信息内容-帧号:%d", (*icxx).icxx_info.frame_id);   
        DebugPrintBd("\r\n    ICXX信息内容-通播ID:0x%02x%02x%02x", (*icxx).icxx_info.broadcast_id[0], (*icxx).icxx_info.broadcast_id[1], (*icxx).icxx_info.broadcast_id[2]);
        DebugPrintBd("\r\n    ICXX信息内容-用户特征:%d", (*icxx).icxx_info.user_feature);      
        DebugPrintBd("\r\n    ICXX信息内容-服务频度:%d秒", (*icxx).icxx_info.service_frequency);   
        DebugPrintBd("\r\n    ICXX信息内容-通信级别:%d", (*icxx).icxx_info.comm_level);   
        DebugPrintBd("\r\n    ICXX信息内容-加密标志:%d", (*icxx).icxx_info.encryption_flag);   
        DebugPrintBd("\r\n    ICXX信息内容-用户数目:%d", (*icxx).icxx_info.user_num);   
        DebugPrintBd("\r\n    ICXX包校验和:0x%02x\r\n", (*icxx).checksum);
        
        DebugPrintBd("\r\n    ========= ICXX包-打印结束=========\r\n");
    }
     
    void print_zjxx(struct zjxx_struct *zjxx)
    {
        Tx_monitor_S("\r\n    ========= ZJXX包-打印开始=========\r\n");
        
        DebugPrintBd("\r\n    ZJXX包总长度:%d", (*zjxx).packet_len);
        DebugPrintBd("\r\n    ZJXX包用户地址:0x%02x%02x%02x", (*zjxx).user_addr[0], (*zjxx).user_addr[1], (*zjxx).user_addr[2]);   
        DebugPrintBd("\r\n    ZJXX信息内容-IC卡状态:0x%02x", (*zjxx).zjxx_info.ic_status);      
        DebugPrintBd("\r\n    ZJXX信息内容-硬件状态:0x%02x", (*zjxx).zjxx_info.hw_status);   
        DebugPrintBd("\r\n    ZJXX信息内容-电池电量:0x%02x", (*zjxx).zjxx_info.battery_quantity);   
        DebugPrintBd("\r\n    ZJXX信息内容-入站状态:0x%02x", (*zjxx).zjxx_info.in_station_status);      
        DebugPrintBd("\r\n    ZJXX信息内容-功率状态:%d-%d-%d-%d-%d-%d", (*zjxx).zjxx_info.power_status[0], (*zjxx).zjxx_info.power_status[1],
                              (*zjxx).zjxx_info.power_status[2], (*zjxx).zjxx_info.power_status[3],(*zjxx).zjxx_info.power_status[4], (*zjxx).zjxx_info.power_status[5]);
        DebugPrintBd("\r\n    ZJXX包校验和:0x%02x\r\n", (*zjxx).checksum);
        
        DebugPrintBd("\r\n    ========= ZJXX包-打印结束=========\r\n");
    }
     
    void print_fkxx(struct fkxx_struct *fkxx)
    {
        Tx_monitor_S("\r\n    ========= FKXX包-打印开始=========\r\n");
     
        DebugPrintBd("\r\n    FKXX包总长度:%d", (*fkxx).packet_len);
        DebugPrintBd("\r\n    FKXX包用户地址:0x%02x%02x%02x", (*fkxx).user_addr[0], (*fkxx).user_addr[1], (*fkxx).user_addr[2]);   
        DebugPrintBd("\r\n    FKXX信息内容-反馈标志:0x%02x", (*fkxx).fkxx_info.fk_flag);    
        DebugPrintBd("\r\n    FKXX信息内容-附加信息:0x%02x-0x%02x-0x%02x-0x%02x", (*fkxx).fkxx_info.extra_info[0], (*fkxx).fkxx_info.extra_info[1], (*fkxx).fkxx_info.extra_info[2], (*fkxx).fkxx_info.extra_info[3]);   
        DebugPrintBd("\r\n    FKXX包校验和:0x%02x\r\n", (*fkxx).checksum);
     
        DebugPrintBd("\r\n    ========= FKXX包-打印结束=========\r\n");
     }
     
    void read_bd_rx_info(void)
    {
        struct txxx_struct txxx;
        struct icxx_struct icxx;
        struct zjxx_struct zjxx;
        struct fkxx_struct fkxx;
     
        if (bd_buf_bitmap & FKXX_BUF) 
        {
            parse_fkxx(&fkxx);
            print_fkxx(&fkxx);
            bd_buf_bitmap &= ~FKXX_BUF;
        }
     
        if (bd_buf_bitmap & ICXX_BUF)
        {
            parse_icxx(&icxx);
            print_icxx(&icxx);
            bd_buf_bitmap &= ~ICXX_BUF;
        }
     
        if (bd_buf_bitmap & ZJXX_BUF)
        {
            parse_zjxx(&zjxx);
            print_zjxx(&zjxx);
            bd_buf_bitmap &= ~ZJXX_BUF;
        }   
     
        if (bd_buf_bitmap & TXXX_BUF)
        {
            parse_txxx(&txxx);
            print_txxx(&txxx);
            bd_buf_bitmap &= ~TXXX_BUF;
        } 
    }
     
    void copy_packet_from_shared_buf()
    {
        if ((bd_shared_rx_buf[1] == 'D') && (bd_shared_rx_buf[2] == 'W')) //收到定位信息$DWXX
           {
               bd_buf_bitmap |= DWXX_BUF;
               //memcpy(dwxx_buf, bd_shared_rx_buf, sizeof(dwxx_buf));
           }
           else if ((bd_shared_rx_buf[1] == 'T') && (bd_shared_rx_buf[2] == 'X')) //收到通信信息$TXXX
           {
               bd_buf_bitmap |= TXXX_BUF;
               memcpy(txxx_buf, bd_shared_rx_buf, sizeof(txxx_buf));
           }
           else if ((bd_shared_rx_buf[1] == 'I') && (bd_shared_rx_buf[2] == 'C')) //收到IC信息$ICXX
           {
               bd_buf_bitmap |= ICXX_BUF;
               memcpy(icxx_buf, bd_shared_rx_buf, sizeof(icxx_buf));
           }
           else if ((bd_shared_rx_buf[1] == 'Z') && (bd_shared_rx_buf[2] == 'J')) //收到自检信息$ZJXX
           {
               bd_buf_bitmap |= ZJXX_BUF;
               memcpy(zjxx_buf, bd_shared_rx_buf, sizeof(zjxx_buf));
           }
           else if ((bd_shared_rx_buf[1] == 'S') && (bd_shared_rx_buf[2] == 'J')) //收到时间信息$SJXX
           {
                bd_buf_bitmap |= SJXX_BUF;
               //memcpy(sjxx_buf, bd_shared_rx_buf, sizeof(sjxx_buf));
           }
           else if ((bd_shared_rx_buf[1] == 'B') && (bd_shared_rx_buf[2] == 'B')) //收到版本信息$BBXX
           {
                bd_buf_bitmap |= BBXX_BUF;
               //memcpy(bbxx_buf, bd_shared_rx_buf, sizeof(bbxx_buf));
           }
           else if ((bd_shared_rx_buf[1] == 'F') && (bd_shared_rx_buf[2] == 'K')) //收到反馈信息$FKXX
           {
               bd_buf_bitmap |= FKXX_BUF;
               memcpy(fkxx_buf, bd_shared_rx_buf, sizeof(fkxx_buf));
           }
    }
     
    #pragma vector=USCI_A3_VECTOR
    __interrupt void USCI_A3_ISR(void)
    {
        unsigned int iv_temp;
        
        _DINT();
         PUSHALL
         
         iv_temp = UCA3IV;
         iv_temp = iv_temp % 16;
         if ((iv_temp & 0x02) != 0)
         {      
            bd_rx_char = UCA3RXBUF;
     
            if (bd_rx_char == '$') //开始接收报文
            {
                bd_buf_pointer = 0;
            }
            
            bd_shared_rx_buf[bd_buf_pointer] = bd_rx_char;
     
            if (bd_buf_pointer == 6)//接收到报文中长度字段的第2个字节
            {
                rx_packet_len = bd_shared_rx_buf[5] * 256 + bd_shared_rx_buf[6];
            }
            else if (bd_buf_pointer == (rx_packet_len - 1)) //接收到报文最后一个字节
            {
                copy_packet_from_shared_buf();
            }
     
            if (bd_buf_pointer != (rx_packet_len - 1))
            {
                bd_buf_pointer = (bd_buf_pointer + 1) % RX_BD_MAX_DATA_SIZE; //指针自增
            }
            else
            {
                bd_buf_pointer = 0; //收到最后一个字节后
            }
         }
         
        POPALL
        _EINT();
    }
    #endif
     
    #endif
     
     
    #ifndef __APPBD_H__
    #define __APPBD_H__
     
    #define MAX_PAYLOAD_LEN 210 //即(1680/8)
     
    #define INSTRUCTION_SIZE 5
    #define PACKET_LEN_SIZE 2
    #define USER_ADDR_SIZE 3
    #define CHECKSUM_SIZE 1
     
    #define IPUC (INSTRUCTION_SIZE + PACKET_LEN_SIZE + USER_ADDR_SIZE + CHECKSUM_SIZE)
     
    #define TXSQ_INFO_FIRM_SIZE 7 //即(1 个信息类别 + 3 个用户地址 + 2个电文长度 + 1个应答字节) 
    #define TXSQ_FIRM_SIZE (IPUC + TXSQ_INFO_FIRM_SIZE)
     
    #define ICJC_INFO_FIRM_SIZE 1 //即帧号,占一个字节
    #define ICJC_FIRM_SIZE (IPUC + ICJC_INFO_FIRM_SIZE)
     
    #define XTZJ_INFO_FIRM_SIZE 2 //即自检频度,占二个字节
    #define XTZJ_FIRM_SIZE (IPUC + XTZJ_INFO_FIRM_SIZE)
     
    #define ICXX_INFO_FIRM_SIZE 11 //即(1个帧号+3个通播ID+1个用户特征+2个服务频度+1个通信等级+1个加密标志+2个下属用户总数)
    #define ICXX_FIRM_SIZE (IPUC + ICXX_INFO_FIRM_SIZE)
     
    #define TXXX_INFO_FIRM_SIZE 9 //即(1个信息类别+3个发信方地址+2个发信时间+2个电文长度+1个CRC标志
    #define TXXX_FIRM_SIZE (IPUC + TXXX_INFO_FIRM_SIZE)
    #define TXXX_MAX_SIZE (TXXX_FIRM_SIZE + MAX_PAYLOAD_LEN)//TXXX由固定长度和净长度构成
     
    #define FKXX_INFO_FIRM_SIZE 5//即(1个反馈标志+4个附加信息)
    #define FKXX_FIRM_SIZE (IPUC + FKXX_INFO_FIRM_SIZE)
     
    #define ZJXX_INFO_FRIM_SIZE 10 //即(1个IC卡状态+1个硬件状态+1个电池电量+1个入站状态+6个功率状态)
    #define ZJXX_FIRM_SIZE (IPUC + ZJXX_INFO_FRIM_SIZE)
     
    #define RX_BD_MAX_DATA_SIZE TXXX_MAX_SIZE 
     
    #define TXSQ_PAYLOAD_CHINESE 0x44
    #define TXSQ_PAYLOAD_BCD 0x46
     
    enum {
        DWXX_BUF = (1 << 0),
        TXXX_BUF = (1 << 1),
        ICXX_BUF = (1 << 2),
        ZJXX_BUF = (1 << 3),
        SJXX_BUF = (1 << 4),
        BBXX_BUF = (1 << 5),
        FKXX_BUF = (1 << 6),
    };
     
    /* =================== RTU到用户机 ============================ */
     
    /* 
        注意:因为发送协议中通信申请(txsq)协议有可变数据内容,使用结构体来表示时,因为要通过串口发送出去,
        无法控制长度,所以发送协议不宜采用结构体表示!
    struct peri_to_user_struct
    {
        struct dwsq_struct dwsq;
        struct txsq_struct txsq;
        struct cksc_struct cksc;
        struct icjc_struct icjc;
        struct xtzj_struct xtzj;
        struct sjsc_struct sjsc;
        struct bbdq_struct bbdq;
    };
    */
     
    /* =================== 用户机到RTU ============================*/
     
    /* 定位信息 */
    struct dwxx_struct
    {
        unsigned int todo;
    };
     
    /* 通信信息 */
    struct txxx_info_type_struct
    {
        unsigned char packet_comm:2;
        unsigned char transfer_format:1;
        unsigned char ack:1;
        unsigned char comm_way:1;
        unsigned char has_key:1;
        unsigned char rest:2;
    };
     
    struct send_time_struct
    {
        unsigned char hour;
        unsigned char minute;
    };
     
    struct txxx_info_struct
    {
        struct txxx_info_type_struct  txxx_info_type;
        unsigned char src_user_addr[3];
        struct send_time_struct send_time;
        unsigned int payload_len;
        unsigned char payload[MAX_PAYLOAD_LEN];
        unsigned char crc;  
    };
     
    struct txxx_struct 
    {
        unsigned char instruction[5];
        unsigned int packet_len; //解析结构体时以整形数据表示其长度
        unsigned char user_addr[3];
        struct txxx_info_struct txxx_info;
        unsigned char checksum;
    };
     
    struct icxx_info_struct
    {
        unsigned char frame_id;
        unsigned char broadcast_id[3];
        unsigned char user_feature;
        unsigned int service_frequency;
        unsigned char comm_level;
        unsigned char encryption_flag;
        unsigned int user_num;
    };
     
    /* IC信息 */
    struct icxx_struct
    {
        unsigned char instruction[5];
        unsigned int packet_len;
        unsigned char user_addr[3];
        struct icxx_info_struct icxx_info;
        unsigned char checksum;
    };
     
    struct zjxx_info_struct
    {
        unsigned char ic_status;
        unsigned char hw_status;
        unsigned char battery_quantity;
        unsigned char in_station_status;
        unsigned char power_status[6];
    };
     
    struct zjxx_struct
    {
        unsigned char instruction[5];
        unsigned int packet_len;
        unsigned char user_addr[3];
        struct zjxx_info_struct zjxx_info;
        unsigned char checksum;
    };
     
    struct sjxx_struct
    {
        unsigned int todo;
    };
     
    struct bbxx_struct
    {
        unsigned int todo;
    };
     
    struct fkxx_info_struct
    {
        unsigned char fk_flag;
        unsigned char extra_info[4];
    };
     
    struct fkxx_struct
    {
        unsigned char instruction[5];
        unsigned int packet_len;  
        unsigned char user_addr[3];
        struct fkxx_info_struct fkxx_info;
        unsigned char checksum;
    };
     
    /*
    struct user_to_peri_struct
    {
        struct dwxx_struct dwxx;
        struct txxx_struct txxx;
        struct icxx_struct icxx;
        struct zjxx_struct zjxx;
        struct sjxx_struct sjxx;
        struct bbxx_struct bbxx;
        struct fkxx_struct fkxx;
    };
    */
     
    extern void send_dwsq();
    extern void send_txsq(unsigned char cmd, unsigned char *src_user_addr, unsigned char *dst_user_addr, 
                                           unsigned char transfer_format, unsigned char *send_txsq_payload, unsigned int send_txsq_payload_len);
    extern void send_cksc();
    extern void send_icjc();
    extern void send_xtzj();
    extern void send_sjsc();
    extern void send_bbdq();
     
    extern void init_uart3_for_bd();
    extern void read_bd_rx_info(void);
     
    #endif
    
    https://ww2.mathworks.cn/matlabcentral/fileexchange/29639-protection-level-toolbox
    
    展开全文
  •   北斗物联网监测是通过传感器、北斗系统等信息感知设备,按约定的协议连接起来,利用北斗RDSS短报文实现无距离限制的数据传输,数据监控,实时的采集和控制管理。以实现智能化识别、传感器数据采集、智能控制、...
  •   通过北斗RDSS短报文、GPRS/CDMA公网进行通讯传输,具备我国自主建设,独立运营的北斗卫星定位系统的RDSS短报文双向通信能力的数据传输,确保海洋监测数据传输的安全、高效。   海洋观测浮标是自主研发的一款...
  • 其中,北斗系统的误码率低,传输稳定可靠,因此,在紧急情况下,使用北斗RDSS卫星通信功能构建通信系统,实现一对一或一对多的通信,促成信息及时发送,对于灾区信息传输的时效性具有现实意义。 北斗卫星导航...
  • 然而大部分牧井处于偏远无公网信号覆盖地方,解决无网络信号覆盖地方的牧井智能控制变得日益迫切,本项目在牧区有风能和太阳能发电装置的前提下,利用北斗短报文RSSS短报文通信技术,拟开发出一套性能可靠的远程智能...
  • 北斗RDSS既可以进行定位,也可以发送短报文信息,通过短报文进行通讯,在没有公网信号的地区也能及时将定位数据传输至企业服务器,对于在无人区弱信号地区能做到随时随地联系,保障数据传输工作的正常运转与人员的...
  • 龙源期刊网http://www.qikan.com.cn浅谈北斗二代RDSS与RNSS组合技术作者:陈德旭王成皇刘延鹏来源:《中国科技...”北斗二代“将RDSS和RNSS功能相结合,能够最大限度地利用北斗资源,不但可以进行双向信息联络,还能...
  • 原标题:北斗RNSS和RDSS北斗RNSS和RDSS1、RNSS与RDSS的集成概念服务于用户位置确定的卫星无线电业务有两种。一种是卫星无线电导航业务,英文全称RadioNavigation SatelliteSystem,缩写RNSS,由用户接收卫星无线电...
  • 北斗RDSS & RNSS & 短报文

    千次阅读 2020-09-11 22:11:32
    北斗系统从建立之初到现在已经历经了四代的变革, 即北斗1-4号(4号从今年开始正式运行), 自卫星导航系统出现之后, 目前所有的导航系统都是只能定位, 而最新的北斗四代可以发送短信息. 首先, 我们要了解一下, 卫星是...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 135
精华内容 54
关键字:

北斗rdss