Gnuradio结合hackrf 通过FSK调制实现文本文件的发送与接收

迷南。 2022-07-16 09:12 888阅读 0赞

**Gnuradio结合hackrf 通过FSK调制实现文本文件的发送与接收**

** **

**一、实现目标**

1、将我们要发送的文件封装成帧；

2、通过FSK调制与解调实现文件的传输；

3、将接受到的文件进行非实时的采样处理还原我们发送的文本文件；

**二、实现过程**

1、将我们要发送的文本文件封装成帧

（1）首先我们要选择文本文件，例如send.txt我们在文件中输入我们要发送的字符串，在本次实验中我输入的是“Hello World！Xiaoming”，输入完后保存文件并退出。

![Center][]

（2）     利用自己编写的[Python][]程序data\_send.py将我们的要发送的文本文件send.txt封装成简单的数据帧

data\_send.py的截图

![Center 1][]

![Center 2][]

![Center 3][]

**①首先在帧头写入同步序列**

代码部分：

serial =\[1,0,1,1,0,1,0,0\]

serial=serial\*2

for i inserial:

f.write(chr(i))

通过代码可以看出，将\[1,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0\]作为我们的同步序列（为了后面的帧同步），将同步序列以字节的形式写入code.txt文件中**。**

**②接着写入数据的大小长度（以字节为单位）**

代码部分：

str1 =intTo2Str(length,8)

for i in range(8):

temp = str1\[i\]

temp = int(temp)

f.write(chr(temp))

计算我们要发送文本文件的大小，此处我用一个字节表示文本的字节数，即在本次试验中我们最多能够发送256字节（稍稍改变代码，可实现更多字节的传输），本次实验的为20字节，并以追加的方式写入code.txt文件中。

**③写入数据**

源代码：

for i in range(length):

str1 = intTo2Str(ord(send\[i\]),8)

for i in range(8):

temp = str1\[i\]

temp = int(temp)

f.write(chr(temp))

通过循环，我们将要发送的字符串，依次转换为字节，并追加写入code.txt文件中。

**④写入结束标志**

源代码：

serial =\[1,1,1,1,1,1,1,1\]

for i inserial:

f.write(chr(i))

f.close()

我们通过数据长度就可以确定数据的长度，所以结束标志并不是为了判断数据段的结束。我们知道我们的帧会被循环的发送出去，而我们的结束标志则是为了避免产生相同的同步序列。

⑤运行data\_read.py，我们打开code.txt，因为我们发现会出现乱码，就说明我们基本正确。我们写入code.txt是0或1的字节，用数字的方式写入文件。

![Center 4][]

2、将我们要发送的文本通过hackrf发送出去

（1）发送端的grc流程图

![Center 5][]

![Center 6][]

** **

**流程图介绍：**

①通过File source模块读取我们的code.txt中以保存的数据，因为我们的0,1是以字节的方式存入，所以File source模块数据类型参数选择Byte，还有记住选择code.txt的文件路径。我们可以从Vector wave看出读取出来的是0,1序列。

②Char to Float模块将字节数据类型转变为Float，方便后面的数据操作，例如乘除。

③接着我们把0,1变为-0.5和0.5，接着在乘以2，即-1,1，接着在每个数字后年插入0,达到的效果是从\[0,1,,,\]序列变为\[-1,0,1,0,,,,,\]等。然后通过Repeat进行插值，即从\[-1,0,,,\]变为\[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,,,,,\],通过这一系列的变化，达到的效果就是把读取出来的\[0,1\]序列用双极性方波，即从vector wave 变为Bipolar wav。（选择双极性方波的原因是方便的抽样判决）。

④通过，通过FractionalInterpolator 模块，稍稍改变原有的波形的形状，使原来的波形更容易加载到载波上。

⑤将稍稍变化后的方波通过WBFM Transmit模块完成调制。当我们的将调制后的波形放大看，发现调制后的波形，不怎么的好，于是我们就可以利用Rational Resampler模块进行插入重采样，可以使原来的波形变得更好（更光滑）。（详细的效果参考实验1的效果图）。

⑥然后通过HackRf发送出去，这里的我们用的100M，如果效果不好，可以自己设置。

![Center 7][]

**发送端效果图**

**（2）接收端的grc流程图**

** ![Center 8][]**

**流程图介绍：**

①通过osmocom Sink模块接收我们发送的的信息，其Freqency参数同发送端一样，同为100M，还有我们还以根据需要设置RF Gain，IF Gain，BBGain的值，来调节我们接收到波形的幅度的大小，本次实现依次设置的是12,10,10。

②首先还是通过波形进行RationalResampler模块进行抽取重采样，主要是与发送的端的Rational Resampler模块想对应，是发送信息和接受的信息的速率一样。

③接着我们通过一个低通滤波器模块Low PassFilter滤除高频部分，是波形变得平坦，有利于后面的抽样判决。

④接着我们就通过Float To Int 模块实现将数据进行量化，大于0.5取1，介于-0.5到0.5之间取0，小于-0.5取-1。(注意此处我们接收到的信号幅度在-1~1左右)

⑤ 接着我们将数据保存到文件中去，这里自己设置文件的保存路径，此次试验我们保存的文件的文件名是receive.txt。

** ![Center 9][]**

**接收端效果图**

**（3）     将保存的文件转化为我们能操作的数据类型**

使用的命令是：

gr\_plot\_int2  -B20000  /home/…./receive.txt

此处gr\_plot\_int2是一个编写python文件，由于代码太多，这里不再节后，详细的代码看后面的附录。

化后我们保存到kk.txt这个文件中，打开文件我们可以看出，全是1,0，-1组成的序列。

![Center 10][]

**（4）     从kk.txt文件中解码出我们发送的文件信息。**

**源代码如下：**

![Center 11][]

![Center 12][]

![Center 13][]

**①首先读取出文件，稍作处理，将数据加载到数组中去。**

**代码部分：**

str\_arry =\[\]

data\_arry =\[\]

line =f.readline()

sign = line

line =line.split(', ')

printstr(line)

for str1 inline:

str\_arry.append(str1)

while   sign!='':

line = f.readline()

sign = line

line = line.split(', ')

for str1 in line:

str\_arry.append(str1)

f.close()

str\_arry =str\_arry\[1:-2\]

data\_arry =str\_arry

n =len(str\_arry)

for i inrange(n):

if data\_arry\[i\] == '1':

data\_arry\[i\] = 1

if data\_arry\[i\] == '0':

data\_arry\[i\] = 0

if data\_arry\[i\] == '-1':

data\_arry\[i\] = -1

过代码可以看出，我们是将0,1，-1一个字符串数组，变为数字形式的数字数组，这样可供我们后面进一步的分析处理。

**②接着就是抽样判决**

**代码部分：**

data = \[\]

data.append(data\_arry\[0\])

for i in range(1,n):

ifdata\_arry\[i\] != data\[-1\]:

data.append(data\_arry\[i\])

data = data\[20:-1\]

此处我们通过判断数据跳变来确定采样时刻，这就是就是利用双极性方波特点，在每个周期内电平会跳变。

**③确定同步序列**

代码部分：

serialnumber= \[1,0,-1,0,1,0,1,0,-1,0,1,0,-1,0,-1,0\]

serialnumber= serialnumber\*2

m =len(serialnumber)

index = 0

for i inrange(n-m):

sign = 0

for j in range(m):

if data\[i+j\] != serialnumber\[j\]:

sign = 1

if sign == 0:

index = i+32

break

print'i='+str(index)

data =data\[index:-1\]

print'ss'+str(len(data))

new\_data =\[\]

for i inrange(len(data)):

if i%2==0:

new\_data.append(data\[i\])

for i inrange(len(new\_data)):

if new\_data\[i\] == -1:

new\_data\[i\] = 0

通过同发送端的同步序列对比，找到接收文件中的同步序列，即确定帧的开始地方。

**④获取数据包的长度**

**代码部分：**

sizeofdata = ''

for i in range(8):

sizeofdata = sizeofdata+str(new\_data\[i\])

sizeofdata =int(sizeofdata,2)

print str(sizeofdata)

new\_data =new\_data\[8:-1\]

上面确定好同步序列，知道帧的起始接着8位数据就是我们发送的字符串的长度，从而确定后面数据包的长度。

⑤**获取数据包并还原为字符串**

**代码部分：**

rec\_string = ''

for i in range(sizeofdata):

index= i\*8

temp=''

fori in range(8):

temp= temp+str(new\_data\[index+i\])

rec\_string= rec\_string+chr(int(temp,2))

print 'receive:'+rec\_string

f = open(r'/home/cyp/myfile/decode.txt','wb')

f.write(rec\_string)

上面确定数据包的长度长度，我们直接读取指定长度的数据部分，并还原为字符串形式，保存到decode.txt文件中。

**⑥使用命令**

** ** 在终端中运行：./data\_read.py

将解码获取的字符串信息保存到decode.txt文件中。通过对比发现同发送的文件字符串一样，证明我们正确的实现文本文件的传输。

**总结**

通过这次实本文件的发送与接收，我们对hackrf和gnuradio有了一个更深的理解，同时让我们切实体会到帧结构，同步序列，调制与解调的原理，让我们学到的理论知识在实践中得以验证。

**展望：**通过对代码进一步的修改，帧结构的进一步完善，就可以实现图片，甚至视频的传送。

附录：

gr\_plot\_int2文件的源代码如下：

\#!/usr/bin/envpython

\#This file is part of GNU Radio

\#GNU Radio is free software; you can redistribute it and/or modify

\#it under the terms of the GNU General Public License as published by

\#the Free Software Foundation; either version 3, or (at your option)

\#any later version.

\#GNU Radio is distributed in the hope that it will be useful,

\#but WITHOUT ANY WARRANTY; without even the implied warranty of

\#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

\#GNU General Public License for more details.

\#You should have received a copy of the GNU General Public License

\#along with GNU Radio; see the file COPYING. If not, write to

\#the Free Software Foundation, Inc., 51 Franklin Street,

\#Boston, MA 02110-1301, USA.

"""

Utilityto help plotting data from files.

"""

try:

import scipy

exceptImportError:

print "Please install SciPy to runthis script (http://www.scipy.org/)"

raise SystemExit, 1

try:

from pylab import \*

exceptImportError:

print "Please install Matplotlib torun this script (http://matplotlib.sourceforge[.NET][]/)"

raise SystemExit, 1

fromoptparse import OptionParser

classplot\_data:

def \_\_init\_\_(self, datatype, filenames,options):

self.hfile = list()

self.legend\_text = list()

for f in filenames:

self.hfile.append(open(f,"r"))

self.legend\_text.append(f)

self.block\_length = options.block

self.start = options.start

self.sample\_rate = options.sample\_rate

self.datatype = datatype

self.sizeof\_data =datatype().nbytes    \# number of bytesper sample in file

self.axis\_font\_size = 16

self.label\_font\_size = 18

self.title\_font\_size = 20

self.text\_size = 22

\# Setup PLOT

self.fig = figure(1, figsize=(16, 9),facecolor='w')

rcParams\['xtick.labelsize'\] =self.axis\_font\_size

rcParams\['ytick.labelsize'\] =self.axis\_font\_size

self.text\_file\_pos = figtext(0.10,0.88, "File Position: ", weight="heavy",size=self.text\_size)

self.text\_block    = figtext(0.40, 0.88, ("Block Size:%d" % self.block\_length),

weight="heavy", size=self.text\_size)

self.text\_sr       = figtext(0.60, 0.88, ("SampleRate: %.2f" % self.sample\_rate),

weight="heavy", size=self.text\_size)

self.make\_plots()

self.button\_left\_axes =self.fig.add\_axes(\[0.45, 0.01, 0.05, 0.05\], frameon=True)

self.button\_left =Button(self.button\_left\_axes, "<")

self.button\_left\_callback =self.button\_left.on\_clicked(self.button\_left\_click)

self.button\_right\_axes =self.fig.add\_axes(\[0.50, 0.01, 0.05, 0.05\], frameon=True)

self.button\_right =Button(self.button\_right\_axes, ">")

self.button\_right\_callback =self.button\_right.on\_clicked(self.button\_right\_click)

self.xlim = self.sp\_f.get\_xlim()

print 'start!'

self.manager = get\_current\_fig\_manager()

connect('key\_press\_event', self.click)

show()

def get\_data(self, hfile):

self.text\_file\_pos.set\_text("FilePosition: %d" % (hfile.tell()//self.sizeof\_data))

try:

f = scipy.fromfile(hfile,dtype=self.datatype, count=self.block\_length)

except MemoryError:

print "End of File"

else:

self.f = scipy.array(f)

self.time =scipy.array(\[i\*(1/self.sample\_rate) for i in range(len(self.f))\])

fhh2 = open(r'/home/cyp/myfile/kk.txt', 'w')

print str(len(self.f))

data = \[\]

for j in range(len(self.f)):

data.append((self.f\[j\]))

fhh2.write(str(data))

fhh2.close()

def make\_plots(self):

self.sp\_f = self.fig.add\_subplot(2,1,1,position=\[0.075, 0.2, 0.875, 0.6\])

self.sp\_f.set\_title(("Amplitude"),fontsize=self.title\_font\_size, fontweight="bold")

self.sp\_f.set\_xlabel("Time(s)", fontsize=self.label\_font\_size, fontweight="bold")

self.sp\_f.set\_ylabel("Amplitude(V)", fontsize=self.label\_font\_size, fontweight="bold")

self.plot\_f = list()

maxval = -1e12

minval = 1e12

for hf in self.hfile:

\# if specified on the command-line,set file pointer

hf.seek(self.sizeof\_data\*self.start, 1)

self.get\_data(hf)

\# Subplot for real and imaginaryparts of signal

self.plot\_f += plot(self.time, self.f,'o-')

maxval = max(maxval, self.f.max())

minval = min(minval, self.f.min())

self.sp\_f.set\_ylim(\[1.5\*minval,1.5\*maxval\])

self.leg =self.sp\_f.legend(self.plot\_f, self.legend\_text)

draw()

def update\_plots(self):

maxval = -1e12

minval = 1e12

for hf,p inzip(self.hfile,self.plot\_f):

self.get\_data(hf)

p.set\_data(\[self.time, self.f\])

maxval = max(maxval, self.f.max())

minval = min(minval, self.f.min())

self.sp\_f.set\_ylim(\[1.5\*minval,1.5\*maxval\])

draw()

def click(self, event):

forward\_valid\_keys = \[" ","down", "right"\]

backward\_valid\_keys = \["up","left"\]

if(find(event.key,forward\_valid\_keys)):

self.step\_forward()

elif(find(event.key,backward\_valid\_keys)):

self.step\_backward()

def button\_left\_click(self, event):

self.step\_backward()

def button\_right\_click(self, event):

self.step\_forward()

def step\_forward(self):

self.update\_plots()

def step\_backward(self):

for hf in self.hfile:

\# Step back in file position

if(hf.tell() >=2\*self.sizeof\_data\*self.block\_length ):

hf.seek(-2\*self.sizeof\_data\*self.block\_length, 1)

else:

hf.seek(-hf.tell(),1)

self.update\_plots()

deffind(item\_in, list\_search):

try:

return list\_search.index(item\_in) != None

except ValueError:

return False

try:

import scipy

exceptImportError:

print "Please install SciPy to runthis script (http://www.scipy.org/)"

raise SystemExit, 1

fromoptparse import OptionParser

defmain():

usage="%prog: \[options\] input\_filenames"

description = "Takes a GNU Radiointeger binary file and displays the samples versus time. You can set the blocksize to specify how many points to read in at a time and the start position inthe file. By default, the system assumes a sample rate of 1, so in time, eachsample is plotted versus the sample number. To set a true time axis, set thesample rate (-R or --sample-rate) to the sample rate used when capturing thesamples."

parser =OptionParser(conflict\_handler="resolve", usage=usage,description=description)

parser.add\_option("-B","--block", type="int", default=1000,

help="Specify theblock size \[default=%default\]")

parser.add\_option("-s","--start", type="int", default=0,

help="Specify where to start in the file\[default=%default\]")

parser.add\_option("-R","--sample-rate", type="float", default=1.0,

help="Set thesampler rate of the data \[default=%default\]")

(options, args) = parser.parse\_args ()

if len(args) < 1:

parser.print\_help()

raise SystemExit, 1

filenames = args

datatype=scipy.int32

dc = plot\_data(datatype, filenames,options)

if\_\_name\_\_ == "\_\_main\_\_":

try:

main()

except KeyboardInterrupt:

pass

** **

顶

踩

[Center]: /images/20220716/5ef9cb818451492a9e4fc7049466d69d.png
[Python]: http://lib.csdn.net/base/python
[Center 1]: /images/20220716/7ecfc6ba3ed34a4a9a401f13ed59f73d.png
[Center 2]: /images/20220716/dcb5271a814f409d829f04a6ba50e5a7.png
[Center 3]: /images/20220716/8f8e8733680f4ce8a22f8db84690a303.png
[Center 4]: /images/20220716/87f2e0c9a3b748829c974827fcc53956.png
[Center 5]: /images/20220716/f61f204fea454442bcbd8f5d6cf4c6f0.png
[Center 6]: /images/20220716/be317abb128a43eaa08bdb044bfc7fc7.png
[Center 7]: /images/20220716/86b540a7bc2943628d6275ce83c7215d.png
[Center 8]: /images/20220716/db5e027745de46159396db4ba26bf5d9.png
[Center 9]: /images/20220716/2404034c33a4445c9ed48c653e45a6b1.png
[Center 10]: /images/20220716/bd90eb6fed6d4362b4bdc295c77beda4.png
[Center 11]: /images/20220716/1c8c51e682f14c8b9a988287cc39dc9d.png
[Center 12]: /images/20220716/4622657bdf304200830b861e147cd25e.png
[Center 13]: /images/20220716/b92f1e21a55c460a95b448cafee72c6a.png
[.NET]: http://lib.csdn.net/base/dotnet