matlab syms

>>syms x
>>syms y
>> y=diff(0.25*3^x*exp(-3.56*x*(1-x)))


y =
(3^x*exp((89*x*(x - 1))/25)*((178*x)/25 - 89/25))/4 + (3^x*exp((89*x*(x - 1))/25)*log(3))/4


>> solve('-(178*x)/25 + 89/25-log(3)=0','x')

ans = 1/2 - (25*log(3))/178


>> x=1/2 - (25*log(3))/178

x = 0.3457



***OR***

>> solve('y=0','y','x')

% if x has only one solution, the value can be seen from the "Workspace"
% However, if it has more than one solution, i still do not know how to look into % the construction of syms......

backup: interview summary

谷歌笔试：
1.
n支队伍比赛，分别编号为0，1，2。。。。n-1，已知它们之间的实力对比关系，存储在一个二维数组w[n][n] 中，w[i][j]
的值代表编号为i，j的队伍中更强的一支 所以w[i][j]=i 或者j，现在给出它们的出场顺序，并存储在数组order[n]中，
比如order[n] = {4,3,5,8,1......}，那么第一轮比赛就是 4对3， 5对8。。。。。。
胜者晋级，败者淘汰，同一轮淘汰的所有队伍排名不再细分，即可以随便排，
下一轮由上一轮的胜者按照顺序，再依次两两比，比如可能是4对5,直至出现第一名
编程实现，给出二维数组w，一维数组order 和 用于输出比赛名次的数组result[n]，求出result

2.题目说的比较花哨，根据我的理解，本质上就是有n个长为m+1的字符串，如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接，问这n个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误

百度面试：

3.
用天平（只能比较，不能称重）从一堆小球中找出其中唯一一个较轻的，使用x次天平 最多可以从y个小球中找出较轻的那个，求y与x的关系式
4.有一个很大很大的输入流，大到没有存储器可以将其存储下来，而且只输入一次，如何从这个输入流中随机取得m个记录
5.大量的URL字符串，如何从中去除重复的，优化时间空间复杂度

网易有道笔试：
6. 求一个二叉树中任意两个节点间的最大距离，两个节点的距离的定义是
这两个节点间边的个数，比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度
7.求一个有向连通图的割点，割点的定义是，如果除去此节点和与其相关的边，有向图不再连通，描述算法

discussion can be found @:
http://topic.csdn.net/u/20100930/13/9f10c56c-9545-488e-9b53-edffc9b6761d.html

==========

GOOGLE今天晚上的笔试题，刚参加回来.

第一题比较简单，检测同一个平面上的两个矩形是否重合

第二题是，给定一个随机函数，对一个数组进行随机排列，保证所有可能的排列出现的概率相等，也就是n!分之一

第三题就是约瑟夫问题的最优解法~Knuth具体数学上有，不过我忘记了，自己没推导出来，就写了个模拟

discussion can be found @:
http://topic.csdn.net/u/20101018/23/75b6dc53-610f-401e-b8ae-5aebee5cabe8.html

==========

雅虎：
1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。

2.一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值
比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1;
{3,6}{2,4,3} m=2
{3,3}{2,4}{6} m=3 所以m的最大值为3

搜狐：

3.四对括号可以有多少种匹配排列方式？比如两对括号可以有两种：（）（）和（（））

创新工场：

4.求一个数组的最长递减子序列 比如{9，4，3，2，5，4，3，2}的最长递减子序列为{9，5，4，3，2}

微软：
5.一个数组是由一个递减数列左移若干位形成的，比如{4，3，2，1，6，5}是由{6，5，4，3，2，1}左移两位形成的，在这种数组中查找某一个数。

discussion can be found @:
http://topic.csdn.net/u/20101021/14/7fdbcd52-3ee6-42ce-b48e-8fb56c4418da.html

==========

雅虎：
1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。

2.一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值
比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1;
{3,6}{2,4,3} m=2
{3,3}{2,4}{6} m=3 所以m的最大值为3

搜狐：

3.四对括号可以有多少种匹配排列方式？比如两对括号可以有两种：（）（）和（（））

创新工场：

4.求一个数组的最长递减子序列 比如{9，4，3，2，5，4，3，2}的最长递减子序列为{9，5，4，3，2}

微软：
5.一个数组是由一个递减数列左移若干位形成的，比如{4，3，2，1，6，5}是由{6，5，4，3，2，1}左移两位形成的，在这种数组中查找某一个数。

discussion can be found @:
http://topic.csdn.net/u/20101021/14/7fdbcd52-3ee6-42ce-b48e-8fb56c4418da.html

sth. about usrp in gnuradio

On Thu, Jul 21, 2005 at 05:48:33PM +0530, Arora_Amit wrote:
> Hi all,
>
> We are working on USRP. Please can any let us know what the
> factors or on what basis the audio_decimation, if_freq, usrp_decim.

These values are choosen so that the sample rates through the
processing path "make sense".  The USRP can sample and decimate at
particular rates.  The audio sink/source can sample at particular
rates.  We generally pick ratios such that they are related by simple
integer factors and that the signals of interest have appropriate
bandwidth at various points in the signal processing chain.

The API for using and controlling the usrp is documented in
usrp/host/lib/usrp_basic.h and usrp_standard.h

> It will be help if we can get what the following mention programs does:

> 1.    usrp_fft_simple.py

Does the same thing as usrp_fft only with less gui cruft.
(Plots Fast Fourier Transform of samples received from USRP.)

> 2.    benchmark_usb.py

An unreliable program to detemine maximum bandwidth of USB

>From the comment at the top of the file:

  Benchmark the USB/USRP throughput.  Finds the maximum full-duplex speed
  the USRP/USB combination can sustain without errors.

> 3.    usrp_oscope.py

Digital oscilloscope that uses a USRP as the source of samples.

> 4.    dbs_debug.py

Program to assist in debugging the DBS_RX daughterboard.

The DBS_RX daughterboard is a receive-only daughterboard that covers
800 MHz to 2400 MHz.

> 5.    nbfm_ptt_quick_and_dirty.py

Removed from CVS.  See nbfm_ptt.py  Narrow Band FM "Push to Talk" (wakie-talkie)

> 6.     usrp_rx_cfile.py

Read samples from the USRP and write to file formatted as binary
single-precision complex values.

> 7.    dbs_fft.py

Removed from CVS.

> 8.    nbfm_rcv.py

Narrow Band FM receiver.


If you haven't already, I suggest that you spend some time with:

  http://www.gnu.org/software/gnuradio/doc/exploring-gnuradio.html
  http://www.gnu.org/software/gnuradio/doc/howto-write-a-block.html


Also, there are online docs for the C++ guts:

  http://www.gnu.org/software/gnuradio/doc/index.html

matlab log

log: Natural logarithm
Syntax: Y = log(X)
Description:
The log function operates element-wise on arrays. Its domain includes
complex and negative numbers, which may lead to unexpected results if
used unintentionally.
Y = log(X) returns the natural logarithm of the elements of X. For
complex or negative , where , the complex logarithm is returned.
log(z) = log(abs(z)) + i*atan2(y,x)
Examples
The statement abs(log(-1)) is a clever way to generate .
ans =
3.1416

CS Conference Rankings: System Technology area

Rank 1:

SIGCOMM: ACM Conf on Comm Architectures, Protocols & Apps
INFOCOM: Annual Joint Conf IEEE Comp & Comm Soc
SPAA: Symp on Parallel Algms and Architecture
PODC: ACM Symp on Principles of Distributed Computing
PPoPP: Principles and Practice of Parallel Programming
RTSS: Real Time Systems Symp
SOSP: ACM SIGOPS Symp on OS Principles
SOSDI: Usenix Symp on OS Design and Implementation
CCS: ACM Conf on Comp and Communications Security
IEEE Symposium on Security and Privacy
MOBICOM: ACM Intl Conf on Mobile Computing and Networking
USENIX Conf on Internet Tech and Sys
ICNP: Intl Conf on Network Protocols
PACT: Intl Conf on Parallel Arch and Compil Tech
RTAS: IEEE Real-Time and Embedded Technology and Applications Symposium
ICDCS: IEEE Intl Conf on Distributed Comp Systems

Rank 2:

CC: Compiler Construction
IPDPS: Intl Parallel and Dist Processing Symp
IC3N: Intl Conf on Comp Comm and Networks
ICPP: Intl Conf on Parallel Processing
SRDS: Symp on Reliable Distributed Systems
MPPOI: Massively Par Proc Using Opt Interconns
ASAP: Intl Conf on Apps for Specific Array Processors
Euro-Par: European Conf. on Parallel Computing
Fast Software Encryption
Usenix Security Symposium
European Symposium on Research in Computer Security
WCW: Web Caching Workshop
LCN: IEEE Annual Conference on Local Computer Networks
IPCCC: IEEE Intl Phoenix Conf on Comp & Communications
CCC: Cluster Computing Conference
ICC: Intl Conf on Comm
WCNC: IEEE Wireless Communications and Networking Conference
CSFW: IEEE Computer Security Foundations Workshop

Rank 3:

MPCS: Intl. Conf. on Massively Parallel Computing Systems
GLOBECOM: Global Comm
ICCC: Intl Conf on Comp Communication
NOMS: IEEE Network Operations and Management Symp
CONPAR: Intl Conf on Vector and Parallel Processing
VAPP: Vector and Parallel Processing
ICPADS: Intl Conf. on Parallel and Distributed Systems
Public Key Cryptosystems
Annual Workshop on Selected Areas in Cryptography
Australasia Conference on Information Security and Privacy
Int. Conf on Inofrm and Comm. Security
Financial Cryptography
Workshop on Information Hiding
Smart Card Research and Advanced Application Conference
ICON: Intl Conf on Networks
NCC: Nat Conf Comm
IN: IEEE Intell Network Workshop
Softcomm: Conf on Software in Tcomms and Comp Networks
INET: Internet Society Conf
Workshop on Security and Privacy in E-commerce

Un-ranked:

PARCO: Parallel Computing
SE: Intl Conf on Systems Engineering (**)
PDSECA: workshop on Parallel and Distributed Scientific and
Engineering Computing with Applications
CACS: Computer Audit, Control and Security Conference
SREIS: Symposium on Requirements Engineering for Information Security
SAFECOMP: International Conference on Computer Safety, Reliability and Security
IREJVM: Workshop on Intermediate Representation Engineering for the
Java Virtual Machine
EC: ACM Conference on Electronic Commerce
EWSPT: European Workshop on Software Process Technology
HotOS: Workshop on Hot Topics in Operating Systems
HPTS: High Performance Transaction Systems
Hybrid Systems
ICEIS: International Conference on Enterprise Information Systems
IOPADS: I/O in Parallel and Distributed Systems
IRREGULAR: Workshop on Parallel Algorithms for Irregularly Structured Problems
KiVS: Kommunikation in Verteilten Systemen
LCR: Languages, Compilers, and Run-Time Systems for Scalable Computers
MCS: Multiple Classifier Systems
MSS: Symposium on Mass Storage Systems
NGITS: Next Generation Information Technologies and Systems
OOIS: Object Oriented Information Systems
SCM: System Configuration Management
Security Protocols Workshop
SIGOPS European Workshop
SPDP: Symposium on Parallel and Distributed Processing
TreDS: Trends in Distributed Systems
USENIX Technical Conference
VISUAL: Visual Information and Information Systems
FoDS: Foundations of Distributed Systems: Design and Verification of
Protocols conference
RV: Post-CAV Workshop on Runtime Verification
ICAIS: International ICSC-NAISO Congress on Autonomous Intelligent Systems
ITiCSE: Conference on Integrating Technology into Computer Science Education
CSCS: CyberSystems and Computer Science Conference
AUIC: Australasian User Interface Conference
ITI: Meeting of Researchers in Computer Science, Information Systems
Research & Statistics
European Conference on Parallel Processing
RODLICS: Wses International Conference on Robotics, Distance Learning
& Intelligent Communication Systems
International Conference On Multimedia, Internet & Video Technologies
PaCT: Parallel Computing Technologies workshop
PPAM: International Conference on Parallel Processing and Applied Mathematics
International Conference On Information Networks, Systems And Technologies
AmiRE: Conference on Autonomous Minirobots for Research and Edutainment
DSN: The International Conference on Dependable Systems and Networks
IHW: Information Hiding Workshop
GTVMT: International Workshop on Graph Transformation and Visual
Modeling Techniques

basic python math calculation in gnuradio

/gnuradio3.2.2/gr-wxgui/src/python/common.py

####################
# Shared Functions
#####################
import numpy
import math

"""
# Python is a general purpose programming language.
It is interpreted and dynamically typed and is very
suited for interactive work and quick prototyping,
while being powerful enough to write large applications in.
# NumPy is a Python extension module, written mostly in C,
that defines the numerical array and matrix types
and basic operations on them.
"""

def get_exp(num):
"""
Get the exponent of the number in base 10.
@param num the floating point number
@return the exponent as an integer
"""
if num == 0: return 0
return int(math.floor(math.log10(abs(num))))

def get_clean_num(num):
"""
Get the closest clean number match to num with bases 1, 2, 5.
@param num the number
@return the closest number
"""
if num == 0: return 0
sign = num > 0 and 1 or -1
exp = get_exp(num)
nums = numpy.array((1, 2, 5, 10))*(10**exp)
return sign*nums[numpy.argmin(numpy.abs(nums - abs(num)))]
#numpy.argmin: Return the indices of the minimum values along an axis.

def get_clean_incr(num):
"""
Get the next higher clean number with bases 1, 2, 5.
@param num the number
@return the next higher number
"""
num = get_clean_num(num)
exp = get_exp(num)
coeff = int(round(num/10**exp))
return {
-5: -2,
-2: -1,
-1: -.5,
1: 2,
2: 5,
5: 10,
}[coeff]*(10**exp)

def get_clean_decr(num):
"""
Get the next lower clean number with bases 1, 2, 5.
@param num the number
@return the next lower number
"""
num = get_clean_num(num)
exp = get_exp(num)
coeff = int(round(num/10**exp))
return {
-5: -10,
-2: -5,
-1: -2,
1: .5,
2: 1,
5: 2,
}[coeff]*(10**exp)

def get_min_max(samples):
"""
Get the minimum and maximum bounds for an array of samples.
@param samples the array of real values
@return a tuple of min, max
"""
scale_factor = 3
mean = numpy.average(samples)
rms = numpy.max([scale_factor*((numpy.sum((samples-mean)**2)/len(samples))**.5),
.1])
min = mean - rms
max = mean + rms
return min, max

(ZT) unix vs. windows

我看UNIX与Windows的本质区别

文化，我首先想到的是文化。Unix和Windows从诞生之初的文化差异本质上划分了两者的界限。直观看来，一个装逼文化，一个傻逼文化。

Unix诞生在贝尔实验室的MULTICS项目之后。据说当时这个项目设计得十分复杂，功能设计也几乎是上天入地无所不能。虽说当时贝尔实验室是很牛，可以牛到不用装逼也能露逼一下的地步。但历史告诉我们这种项目最后绝对会死得很惨。当然，项目最终结果还是没有违背历史规律。当时一位MULTICS参与者Ken Thompson事后痛定思痛，准备重新自己开发一个多任务操作系统，摒弃了MULTICS过于复杂的系统设计，力求新系统的简洁紧凑。传闻时值Ken Thompson老婆带上孩子回娘家过日子去了，一时间Ken Thompson晚上无以为乐，只好天天以堆码为业。不到一个月，Ken Thompson用汇编把这套操作系统编写出来了，这就是后来流芳百世的UNIX。当然，当时的Ken Thompson根本没有意会到他这个业余时间的作品会改变整个计算机发展史。因此这个操作系统设计用户群只针对他预想的计算机科学家、黑客，再不济怎么也得算上个计算机科学技术本科生。Unix只面对政府、研究机构、大学等专业性很强的机构，简洁、高效、安全是Unix的文化哲学。同时结合到当时的硬件条件限制，也不难理解UNIX诞生之初就根深蒂固的文化：

1、计算机庞大的占地面积、高额的购买维护费用使得普通用户根本无力支撑起一台计算机的各种资源消耗，当时更多的是计算机专家在通过终端在控制整个计算机运作逻辑。没有GUI、没有多媒体，字符界面，这对于这批靠计算机完成科学任务的黑客来说已经完全够用了。

2、同时遵循简洁统一的输入输出接口，相比于GUI的事件驱动模型来说，更适合使用脚本将各种程序粘合起来，完成复杂多样的计算任务。

有人说起过UNIX正巧在当年GUI史前诞生，时运不济，所以只出了个字符怪胎，要是再踌躇几年，等到GUI日臻成熟，那诞生出的UNIX恐怕就是如今Windows的翻版了。对此我还是不太认可，UNIX的存在是计算机荒洪时代遗留的文化，即使现在丰富多彩的GUI也照样没有改变UNIX的基础设计恐怕就是一个极好的证据。目前大多数的服务器依然保持着当年UNIX诞生之初的风貌，依然CLI、依然Shell，因为我们需要把更多的资源让给使用服务器的客户，人类对计算机性能的榨取永远是贪婪的。这让我想起了几年前Windows渐入佳境PC，游戏刚大行其道，桌面游戏编写还不是那么方便时候，有人预言等几年之后，按照摩尔定律，编写星际争霸之类的游戏便不需要多牛逼的算法，甚至能用写脚本语言都能完成。这几年算是大致差不多算过来了吧，星际是有牛人用JavaScript完成了，不过现时最牛逼的游戏(如魔兽世界)还是会用很牛逼的算法，还是需要使用C/C++，还是需要精通图形学，还是需要熟悉图形硬件。所以不管硬件如何发展，UNIX文化中的简洁高效这些准则还是依然存在，因为我们会把最佳的性能留给我们服务器的客户，然后可以把敲打字符，玩弄指法的时间留给自己，在老板面前装逼一下。

Windows(以及其前任DOS)诞生在公司，公司不像学院，不会像UNIX一样如果能装逼就尽量装逼一下，公司直接面对客户，产品唯一使命就是取悦用户，只能把用户伺候好了，公司才能维系发展。所以Windows诞生之初就一直肩负比尔"让每一个家庭都有一台电脑"的使命，不装逼，不玩酷，一切功能照顾用户，就是用户是傻逼你也得当亲爹一样伺候。故而Windows一直就假定使用它的用户你就是一个傻逼，哪怕是删除文件这个小问题上，Windows也会想小娘们儿一样谨谨慎慎战战兢兢地一再向人确认"确实要删除****吗？""确实要删除只读文件****吗?"。当然，最终能够让大妈大叔阿公阿婆阿猫阿狗都能使用上计算机的Windows绝对占领了终端用户桌面，比尔也因此一夜暴富，摇身一变成为世界首富&慈善家。不得不承认，如果没有Windows，"让每一个家庭都有一台电脑"的崇高理想恐怕又得推迟几年才能够得以实现了。自然，微软技术是肯定不差的，而不是像一些Linux小菜鸟口中所言"微软技术很烂"，相反微软技术是很牛的，牛到曾经豪言可以立马灭掉Google，试看如今还有谁可以发出这样傻逼的豪言。但是微软牛，不代表Windows就可以干过MULTICS，上天入地翻江倒海无所不能。Windows 在安全性、性能以及开源项目上与UNIX相比确实还是有一定差距，但这并不妨碍windows成为桌面第一大操作系统。

UNIX的黑客们，眼见着曾经引以为豪的计算机技术壁垒瞬间被Windows GUI冲击到荡然无存了，心中肯定是有落差的。不过这段技术演变技术普及已经成为了历史发展趋势。一个少数人才能驾驭的技术，哪怕就是敲一个ls这样简单的命令，你也可以把它吹破牛皮，扯虎皮拉大旗捧为艺术珍品，搞得善男甚广善女甚众。一旦技术被迫普及后，曾经视作的艺术瞬间就被廉价的工业化大生产所替代，现在满大街的廉价代码工就是计算机程序设计工业化后的结果。前段时间众人大骂Java程序员把自己的价位又拉低了。殊不知，拉低自己价位的非Java也，乃工业化大生产趋势。今不出Java，明儿准会出来个Bava，Cava，照样把你收拾成码农。时至如今，UNIX黑客们还在装逼，用CLI命令行跑出花花绿绿的文字，时不时感叹下曾经的软件英雄时代一去不复返，时不时像祥林嫂一般唠叨"当年哥可是写汇编的，没想到如今沦落到如此地步，人心不古，世风日下啊~"，时不时还顾影自怜，想装逼下，可惜时光不再。

妈逼的给老子回去写代码！这个月还想不想领工资了！？


结语：

不管是UNIX的装逼文化，还是Windows的傻逼文化，最终在计算机产业工业化的历史滚滚长流中归于平庸，归于廉价。曾经的那批牛逼的、不牛逼的、风骚的、不风骚的UNIX文化精英们，如今早已是廉颇老矣，尚可喝粥。曾经被意淫为"计算机科学与艺术"如今也早已沦落为"软件码工"。软件英雄时代早已不再，编码也成为三百六十行中的一行，一种用以谋生的手段，一种混饭吃的活路。关键问题早已不在程序，不在编码：

编程只是一个工具，关键在于你拿这个工具来实现别人的事业，还是自己的事业。

some commands for matlab

matrix functions

 INV    Matrix inverse.
    INV(X) is the inverse of the square matrix X.
    A warning message is printed if X is badly scaled or
    nearly singular.

 .' Transpose.
    X.' is the non-conjugate transpose.
    B = TRANSPOSE(A) is called for the syntax A.' when A is an object.

 SQUEEZE Remove singleton dimensions.
    B = SQUEEZE(A) returns an array B with the same elements as
    A but with all the singleton dimensions removed.  A singleton
    is a dimension such that size(A,dim)==1.  2-D arrays are
    unaffected by squeeze so that row vectors remain rows.
    For example,   squeeze(rand(2,1,3))    is 2-by-3.

Especially, for a 3-dimension matrix, for the command "matri = original_matrix(1,:,:)", the resulting matrix matri is still a 3-D matrix whose 1st dimension is just 1.

==========

for plotting, this example will explain the most frequently used commands:

x = -pi:.1:pi;
y = sin(x);
plot(x,y);
set(gca,'XTick',-pi:pi/2:pi);
set(gca,'XTickLabel',{'-pi','-pi/2','0','pi/2','pi'});
xlabel('-\pi \leq \Theta \leq \pi');
ylabel('sin(\Theta)');
title('Plot of sin(\Theta)');
AXIS([XMIN XMAX YMIN YMAX])
XLIM([XMIN XMAX])
YLIM([YMIN YMAX])

Some usrp_spectrum_sense.py code Explanation

Hi Everybody,

and Merry Christmas

I received many emails requesting some explanation for usrp_spectrum_sense.py gnuradio example program. The following link contains the code with some explanation and one bug fix (in self.max_center_freq equation):

http://rapidshare.com/files/177960860/usrp_spectrum_sense.py





usrp_spectrum_sense.py Explanation :
=======================================================================================

Introduction:
-------------

1) This program can be used as a basic code for implementing wideband spectrum analyzer.
2) As we know, the USRP cannot examine more than 8 MHz of RF spectrum due to USB bus limitations.
3) So, to scan across a wide RF spectrum band (bigger than 8 MHz) we have to tune USRP RF front end in suitable steps so that we can examine a lot of spectrum, although not all at the same instant.
4) The usrp_spectrum_sense shows the way how it can be done.It steps across the spectrum and make the RF measurements. This application can
sense a large bandwidth, but not in real time, and it can do the frequency sweep over the required frequency range,



Theory:
-------

1) To use N points complex FFT X(W) analysis, we have to get N time samples x(t) which are sampled at Fs.
2) These N time samples must be time windowed using a known window function to reduce spectral leakage.
3) Performing N points complex FFT analysis.
4) The output of the complex FFT will represent the frequency spectrum contents as follows:

a) The first value of the FFT output (bin 0 == X[0]) is the passband center frequency.
b) The first half of the FFT (X[1] to X[N/2-1] contains the positive baseband frequencies,which corresponds to the passband spectrum from the center frequency out to the maximum passband frequency (from center frequency to +Fs/2).
c) The second half of the FFT (X[N/2] to X[N-1]) contains the negative baseband frequencies,which correspond to the lowest passband frequency up to the passband center frequency (from -Fs/2 to center frequency).


Example
-------

Let us assume that we have 1024 (I and Q) samples gathered using a tuner centered at 20MHz. And let us assume that the sampling frequency was 8MHz.
Doing 1024 points complex FFT means:

1) FFT Frequency resolution is : 8MHz / 1024 = 7812.5 KHz
2) The output of the FFT X[0] represents the spectrum at 20MHz.
3) The output of the FFT X[1] to X[511] represents the frequencies from 20.0078125 MHz to 23.9921875 MHz (about 4MHz above center frequency).
4) The output of the FFT X[512] to X[1023] represents the frequencies from 16.0078125 MHz to 19.9921875 MHz (about 4MHz bellow center frequency).




RF Frequency Sweeping
---------------------

1) Let us suppose that we want to scan RF spectrum band from 10MHz to 52 MHz.
2) Let us remember that USRP can analyze 8MHz of frequency at a time.
3) So theoretically we have to step our RF center frequency as follows:

First step is 14MHz (it will cover frequency band from 10MHz to 18MHz),
Second step is 22MHz (it will cover frequency band from 18MHz to 26MHz),
Third step is 30MHz (it will cover frequency band from 26MHz to 34MHz),
Fourth step is 38MHz (it will cover frequency band from 34MHz to 42MHz),
Fifth step is 46MHz (it will cover frequency band from 42MHz to 50MHz),
and finally the Sixth step is 54MHz (it will cover frequency band from 50MHz to 58MHz). Remember that we want the frequencies up to 52MHz only, so we have to discard some FFT points from the Sixth analysis.


4) Paralytically we have to use FFT overlapping to reduce the non linearity response of the Digital Down Converter (the DDC frequency response is not Flat from -Fs/2 to + Fs/2) and to fill the frequency holes that will be present at the FFT analysis edges (10MHz, 18MHz, 26MHz, 34MHz, 42MHz, 50 MHz).

So if we choose to use an overlap of 25%, this means that our step size will be 6MHz (8MHz*(1-.25)), thus practically we have to step our RF center frequency as follows:

First step is 13MHz (it will cover frequency band from 9MHz to 17MHz),
Second step is 19MHz (it will cover frequency band from 15MHz to 23MHz),
Third step is 25MHz (it will cover frequency band from 21MHz to 29MHz),
Fourth step is 31MHz (it will cover frequency band from 27MHz to 35MHz),
Fifth step is 37MHz (it will cover frequency band from 33MHz to 41MHz),
Sixth step is 43MHz (it will cover frequency band from 39MHz to 47MHz),
and Finally the Seventh step is 49MHz (it will cover frequency band from 45MHz to 53MHz),





Changing RF center Frequency
----------------------------

1) To change USRP RF center frequency we have to send a tunning command to the USRP every time we complete the analysis of the current frequency chunk.
2) Before gnuradio revision [10165], all USRP RF daughterboards tunning were done using Python functions and classes. After that revision, tunning the USRP daughterboards from withen C++ code is possible.
3) In usrp_spectrum_sense.py, the DSP C++ written code is allowed to transparently invoke Python code USRP tune function. This tunning control is done in gr_bin_statistics_f sink function.




Tunning Delay Problem:
---------------------

When we command the usrp RF daughterboard to change its center frequency, we have to wait until (right) ADC samples arrive to our FFT engine and we have to insure that it belongs to the wanted center frequency. This represents a problem since there are many delays along the digitization path (RF synthesizer settling time, and pipeline propagation delay [FPGA FIFO filling time, USB transferring time...etc]). To overcome this problem we have to use enough tune delay time in order to  be sure that the samples entering our FFT block are belong to the requested center frequency. This is done simply by dropping the incoming received samples over a specified tunning delay time.



usrp_spectrum_sense Implementation
----------------------------------

1) The engine of the usrp_spectrum_sense depends mainly on bin_statistics sink function.

2) bin_statistics function combines statistics gathering with a state machine for controlling the USRP RF tuning (frequency sweeping). It determines max values (keeps track of the maximum power in each FFT bin) of vectors (with length vlen) over a time period determined by dwell_delay (after converting it to a number of FFT vectors). This operation is performed after discarding tune_delay samples.

3) After processing N = dwell_delay samples, bin_statistics composes a message and inserts it in a message queue.

4) Each message from bin_statistics consists of a vector of max values, prefixed by the center frequency corresponding to the associated samples,
i.e., it is the center frequency value of the delivered input samples to bin_statistics.




Choosing Tune and Dwell delay times
----------------------------------

1) We have to play with the --tune-delay and --dwell-delay command line options to determine appropriate timming values. The most important one is the tune delay time.

2) The choose of tune-delay should include time for the front end PLL to settle, plus time for the new samples to propagate through the pipeline.  The default value is 1ms, which is probably in the ballpark on the RFX** boards.  The TV RX board is much slower.  The tuner data sheets says it could take 100ms to settle.

3) The tune delay timing parameter passed to bin_statistics is calculated in FFT frames which depends on USRP rate and FFT length as in :

tune_delay_passed_to_bin_statistics = int(round(required_tune_delay_in_sec*usrp_rate/fft_size))

if this calculated value is less than "1", then we should make it at least "1" FFT frame.

For example:

If the :

required_tune_delay_in_sec = 10e-3
and usrp_rate = 8000000 (decimation =8)
and FFT size is 1024


Then :

tune_delay_passed_to_bin_stats = 78   (FFT Frames)

This means we have to skip 78 incoming vectors (FFT frames) before we actually use the acquired samples in our spectrum statistics.

4) Beside tunning time depends on the hardware (RF synthesizer speed),one should remember that the time needed to collect 1024 samples
with decimation rate=8 (minimum USRP decimation) is 128 usec, while the time needed to collect 1024 samples with decimation rate=256 (maximum USRP decimation) is 4.096 msec. This means that the tune delay in the case of decimation rate =256 should be larger than that used for decimation = 8.

5) A working tune delay value (which gives accurate results) can be known by experiments (for given decimation rate and FFT length).




Interrupting Output Spectrum
-----------------------------

The actual mapping from the levels at the daughterboard antenna input port to the output analysis values depends on a lot of factors including the used daughterboard RF gain and decimation specific gain in the digital down converter. You'll need to calibrate the system if you need something that maps to dBm.Currently, the output of usrp_spectrum_sense is the magnitude squared of the FFT output.  That is, for each FFT bin[i], the output is Y[i] = re[X[i]]*re[X[i]] + im[X[i]]*im[X[i]]. If you want power, take the square root of the output.

========================================================================================


Best Regards,


Firas

advance info. about usrp trans.

new examples for the 802.11b trans. (here)

======================

btw, there is an excellent discussion about how to run the code.

(1)

Hi

I am trying to establish communication between USRP2 and USRP1. I am using RFX2400 daughterboard. I am using Ubuntu 8.10. I am using the svn version of GNU Radio. I dont know the revision number. I am not able to receive anything on USRP2 when USRP1 is transmitting and vice versa. The python codes for USRP2 work perfectly fine. I guess there is some problem with the ADC and DAC incompatibility (interpolation and decimation) between USRP2 and USRP1. I am attaching all the necessary files that I am using currently. I would appreciate if someone can look at these files and help me to sort out the problem.  

benchmark_tx.py

#!/usr/bin/env python
#
# Copyright 2005, 2006, 2007 Free Software Foundation, Inc.
# 
# 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.
# 

from gnuradio import gr, gru, modulation_utils
from gnuradio import usrp2
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option
from optparse import OptionParser

import random
import time
import struct
import sys

# from current dir
from transmit_path_usrp2 import transmit_path
import fusb_options

#import os 
#print os.getpid()
#raw_input('Attach and press enter')

class my_top_block(gr.top_block):
    def __init__(self, modulator, options):
        gr.top_block.__init__(self)
        self.txpath = transmit_path(modulator, options)
        self.connect(self.txpath)

#
/////////////////////////////////////////////////////////////////////////////
#                                   main
#
/////////////////////////////////////////////////////////////////////////////

def main():

    def send_pkt(payload='', eof=False):
        return tb.txpath.send_pkt(payload, eof)

    def rx_callback(ok, payload):
        print "ok = %r, payload = '%s'" % (ok, payload)

    mods = modulation_utils.type_1_mods()

    parser = OptionParser(option_class=eng_option,
conflict_handler="resolve")
    expert_grp = parser.add_option_group("Expert")

    parser.add_option("-m", "--modulation", type="choice",
choices=mods.keys(),
                      default='gmsk',
                      help="Select modulation from: %s [default=%%default]"
                            % (', '.join(mods.keys()),))

    parser.add_option("-s", "--size", type="eng_float", default=1500,
                      help="set packet size [default=%default]")
    parser.add_option("-M", "--megabytes", type="eng_float", default=1.0,
                      help="set megabytes to transmit [default=%default]")
    parser.add_option("","--discontinuous", action="store_true",
default=False,
                      help="enable discontinous transmission (bursts of 5
packets)")
    parser.add_option("","--from-file", default=None,
                      help="use file for packet contents")

    transmit_path.add_options(parser, expert_grp)

    for mod in mods.values():
        mod.add_options(expert_grp)

    fusb_options.add_options(expert_grp)
    (options, args) = parser.parse_args ()

    if len(args) != 0:
        parser.print_help()
        sys.exit(1)

    if options.tx_freq is None:
        sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
        parser.print_help(sys.stderr)
        sys.exit(1)

    if options.from_file is not None:
        source_file = open(options.from_file, 'r')

    # build the graph
    tb = my_top_block(mods[options.modulation], options)

    r = gr.enable_realtime_scheduling()
    if r != gr.RT_OK:
        print "Warning: failed to enable realtime scheduling"

    tb.start()                       # start flow graph
        
    # generate and send packets
    nbytes = int(1e6 * options.megabytes)
    n = 0
    pktno = 0
    pkt_size = int(options.size)

    while n < nbytes:
        if options.from_file is None:
            data = (pkt_size - 2) * chr(pktno & 0xff) 
        else:
            data = source_file.read(pkt_size - 2)
            if data == '':
                break;

        payload = struct.pack('!H', pktno & 0xffff) + data
        send_pkt(payload)
        n += len(payload)
        sys.stderr.write('.')
        if options.discontinuous and pktno % 5 == 4:
            time.sleep(1)
        pktno += 1
        
    send_pkt(eof=True)

    tb.wait()                       # wait for it to finish

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        pass


transmit_path_usrp2.py

#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
# 
# 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.
# 

from gnuradio import gr, gru, blks2
from gnuradio import usrp2
from gnuradio import eng_notation

import copy
import sys

# from current dir
from pick_bitrate import pick_tx_bitrate

#
/////////////////////////////////////////////////////////////////////////////
#                              transmit path
#
/////////////////////////////////////////////////////////////////////////////

class transmit_path(gr.hier_block2): 
    def __init__(self, modulator_class, options):
        '''
        See below for what options should hold
        '''
        gr.hier_block2.__init__(self, "transmit_path",
                                gr.io_signature(0, 0, 0), # Input signature
                                gr.io_signature(0, 0, 0)) # Output signature

        options = copy.copy(options)    # make a copy so we can
destructively modify

        self._interface          = options.interface           # the USRP
board attached
        self._mac_addr           = options.mac_addr
        self._verbose            = options.verbose
        self._tx_freq            = options.tx_freq         # tranmitter's
center frequency
        self._tx_amplitude       = options.tx_amplitude    # digital
amplitude sent to USRP
        #self._tx_subdev_spec     = options.tx_subdev_spec  # daughterboard
to use
        self._bitrate            = options.bitrate         # desired bit
rate
        self._interp             = options.interp          # interpolating rate 
for
the USRP (prelim) 
        self._samples_per_symbol = options.samples_per_symbol  # desired
samples/baud 
        #self._fusb_block_size    = options.fusb_block_size # usb info for USRP
        #self._fusb_nblocks       = options.fusb_nblocks    # usb info for
USRP
        self._use_whitener_offset = options.use_whitener_offset # increment
start of whitener XOR data
        
        self._modulator_class = modulator_class         # the
modulator_class we are using
    
        if self._tx_freq is None:
            sys.stderr.write("-f FREQ or --freq FREQ or --tx-freq FREQ must
be specified\n")
            raise SystemExit

        # Set up USRP sink; also adjusts interp, samples_per_symbol, and
bitrate
        self._setup_usrp_sink()  

        # copy the final answers back into options for use by modulator
        options.samples_per_symbol = self._samples_per_symbol
        options.bitrate = self._bitrate
        options.interp = self._interp

        # Get mod_kwargs
        mod_kwargs =
self._modulator_class.extract_kwargs_from_options(options)

        # Set center frequency of USRP
        ok = self.set_freq(self._tx_freq)
        if not ok:
            print "Failed to set Tx frequency to %s" %
(eng_notation.num_to_str(self._tx_freq),)
            raise ValueError
    
        # transmitter
        self.packet_transmitter = \
            blks2.mod_pkts(self._modulator_class(**mod_kwargs),
                           access_code=None,
                           msgq_limit=4,
                           pad_for_usrp=True,
                           use_whitener_offset=options.use_whitener_offset)


        # Set the USRP for maximum transmit gain
        # (Note that on the RFX cards this is a nop.)
        self.set_gain(self.u.gain_range()[1])

        self.amp = gr.multiply_const_cc(1)
        self.set_tx_amplitude(self._tx_amplitude)

        # enable Auto Transmit/Receive switching
        #fiske_removed self.set_auto_tr(True)

        # Display some information about the setup
        if self._verbose:
            self._print_verbage()

        # Create and setup transmit path flow graph
        self.connect(self.packet_transmitter, self.amp, self.u)

    def _setup_usrp_sink(self):
        """
        Creates a USRP sink, determines the settings for best bitrate,
        and attaches to the transmitter's subdevice.
        """
        #self.u = usrp2.source_32fc(options.interface, options.mac_addr)
        #self.u = usrp2.sink_32fc (options._interface, options._mac_addr)
        self.u = usrp2.sink_32fc("eth0","00:50:C2:85:31:5A")  #fiske hard coded 
        dac_rate = self.u.dac_rate();

        # derive values of bitrate, samples_per_symbol, and interp from
desired info
        (self._bitrate, self._samples_per_symbol, self._interp) = \
            pick_tx_bitrate(self._bitrate,
self._modulator_class.bits_per_symbol(),
                            self._samples_per_symbol, self._interp,
dac_rate)
        
        #fiske_removed self.u.set_interp_rate(self._interp)

        # determine the daughterboard subdevice we're using
        #if self._tx_subdev_spec is None:
        #    self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
        #self.u.set_mux(usrp.determine_tx_mux_value(self.u,
self._tx_subdev_spec))
        #self.subdev = usrp.selected_subdev(self.u, self._tx_subdev_spec)


    def set_freq(self, target_freq):
        """
        Set the center frequency we're interested in.

        @param target_freq: frequency in Hz
        @rypte: bool

        Tuning is a two step process.  First we ask the front-end to
        tune as close to the desired frequency as it can.  Then we use
        the result of that operation and our target_frequency to
        determine the value for the digital up converter.
        """
        r = self.u.set_center_freq(target_freq)
        if r:
            return True

        return False
        
    def set_gain(self, gain):
        """
        Sets the analog gain in the USRP
        """
        self.gain = gain
        self.u.set_gain(gain)

    def set_tx_amplitude(self, ampl):
        """
        Sets the transmit amplitude sent to the USRP
        @param: ampl 0 <= ampl < 32768.  Try 8000
        """
        self._tx_amplitude = max(0.0, min(ampl, 32767.0))
        self.amp.set_k(self._tx_amplitude)
        
    def set_auto_tr(self, enable):
        """
        Turns on auto transmit/receive of USRP daughterboard (if exits; else
ignored)
        """
        return self.u.set_auto_tr(enable)
        
    def send_pkt(self, payload='', eof=False):
        """
        Calls the transmitter method to send a packet
        """
        return self.packet_transmitter.send_pkt(payload, eof)
        
    def bitrate(self):
        return self._bitrate

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def interp(self):
        return self._interp

    def add_options(normal, expert):
        """
        Adds transmitter-specific options to the Options Parser
        """
        add_freq_option(normal)
        if not normal.has_option('--bitrate'):
            normal.add_option("-r", "--bitrate", type="eng_float",
default=None,
                              help="specify bitrate.  samples-per-symbol and
interp/decim will be derived.")
        normal.add_option("-e", "--interface", type="string",
default="eth0",
                          help="select Ethernet interface, default is eth0")
        normal.add_option("-m", "--mac-addr", type="string", default="",
                          help="select USRP by MAC address, default is
auto-select")
        #normal.add_option("-T", "--tx-subdev-spec", type="subdev",
default=None,
        #                  help="select USRP Tx side A or B")
        normal.add_option("", "--tx-amplitude", type="eng_float",
default=12000, metavar="AMPL",
                          help="set transmitter digital amplitude: 0 <= AMPL
< 32768 [default=%default]")
        normal.add_option("-v", "--verbose", action="store_true",
default=False)

        expert.add_option("-S", "--samples-per-symbol", type="int",
default=None,
                          help="set samples/symbol [default=%default]")
        expert.add_option("", "--tx-freq", type="eng_float", default=None,
                          help="set transmit frequency to FREQ
[default=%default]", metavar="FREQ")
        expert.add_option("-i", "--interp", type="intx", default=None,
                          help="set fpga interpolation rate to INTERP
[default=%default]")
        expert.add_option("", "--log", action="store_true", default=False,
                          help="Log all parts of flow graph to file
(CAUTION: lots of data)")
        expert.add_option("","--use-whitener-offset", action="store_true",
default=False,
                          help="make sequential packets use different
whitening")

    # Make a static method to call before instantiation
    add_options = staticmethod(add_options)

    def _print_verbage(self):
        """
        Prints information about the transmit path
        """
        print "Using TX d'board %s"    % (self.u.daughterboard_id(),)
        print "Tx amplitude     %s"    % (self._tx_amplitude)
        print "modulation:      %s"    % (self._modulator_class.__name__)
        print "bitrate:         %sb/s" %
(eng_notation.num_to_str(self._bitrate))
        print "samples/symbol:  %3d"   % (self._samples_per_symbol)
        print "interp:          %3d"   % (self._interp)
        print "Tx Frequency:    %s"    %
(eng_notation.num_to_str(self._tx_freq))
        

def add_freq_option(parser):
    """
    Hackery that has the -f / --freq option set both tx_freq and rx_freq
    """
    def freq_callback(option, opt_str, value, parser):
        parser.values.rx_freq = value
        parser.values.tx_freq = value

    if not parser.has_option('--freq'):
        parser.add_option('-f', '--freq', type="eng_float",
                          action="callback", callback=freq_callback,
                          help="set Tx and/or Rx frequency to FREQ
[default=%default]",
                          metavar="FREQ")

benchmark_rx.py

#!/usr/bin/env python
#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
# 
# 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.
# 

from gnuradio import gr, gru, modulation_utils
from gnuradio import usrp2
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option
from optparse import OptionParser

import random
import struct
import sys

# from current dir
from receive_path_usrp2 import receive_path
import fusb_options

#import os
#print os.getpid()
#raw_input('Attach and press enter: ')

class my_top_block(gr.top_block):
    def __init__(self, demodulator, rx_callback, options):
        gr.top_block.__init__(self)
        self.rxpath = receive_path(demodulator, rx_callback, options) 
        self.connect(self.rxpath)

#
/////////////////////////////////////////////////////////////////////////////
#                                   main
#
/////////////////////////////////////////////////////////////////////////////

global n_rcvd, n_right

def main():
    global n_rcvd, n_right

    n_rcvd = 0
    n_right = 0
    
    def rx_callback(ok, payload):
        global n_rcvd, n_right
        (pktno,) = struct.unpack('!H', payload[0:2])
        n_rcvd += 1
        if ok:
            n_right += 1

        print "ok = %5s  pktno = %4d  n_rcvd = %4d  n_right = %4d" % (
            ok, pktno, n_rcvd, n_right)


    demods = modulation_utils.type_1_demods()

    # Create Options Parser:
    parser = OptionParser (option_class=eng_option,
conflict_handler="resolve")
    expert_grp = parser.add_option_group("Expert")

    parser.add_option("-m", "--modulation", type="choice",
choices=demods.keys(), 
                      default='gmsk',
                      help="Select modulation from: %s [default=%%default]"
                            % (', '.join(demods.keys()),))

    receive_path.add_options(parser, expert_grp)

    for mod in demods.values():
        mod.add_options(expert_grp)

    fusb_options.add_options(expert_grp)
    (options, args) = parser.parse_args ()

    if len(args) != 0:
        parser.print_help(sys.stderr)
        sys.exit(1)

    if options.rx_freq is None:
        sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
        parser.print_help(sys.stderr)
        sys.exit(1)


    # build the graph
    tb = my_top_block(demods[options.modulation], rx_callback, options)

    r = gr.enable_realtime_scheduling()
    if r != gr.RT_OK:
        print "Warning: Failed to enable realtime scheduling."

    tb.start()        # start flow graph
    tb.wait()         # wait for it to finish

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        pass

receive_path_usrp2.py

#!/usr/bin/env python
#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
# 
# 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.
# 

from gnuradio import gr, gru, blks2
from gnuradio import usrp2
from gnuradio import eng_notation
import copy
import sys

# from current dir
from pick_bitrate import pick_rx_bitrate

#
/////////////////////////////////////////////////////////////////////////////
#                              receive path
#
/////////////////////////////////////////////////////////////////////////////

class receive_path(gr.hier_block2):
    def __init__(self, demod_class, rx_callback, options):

        gr.hier_block2.__init__(self, "receive_path",
                                gr.io_signature(0, 0, 0), # Input signature
                                gr.io_signature(0, 0, 0)) # Output signature

        options = copy.copy(options)    # make a copy so we can
destructively modify

        self._interface          = options.interface           # the USRP
board attached
        self._mac_addr           = options.mac_addr
        self._verbose            = options.verbose
        self._rx_freq            = options.rx_freq         # receiver's
center frequency
        self._rx_gain            = options.rx_gain         # receiver's gain
        #self._rx_subdev_spec     = options.rx_subdev_spec  # daughterboard
to use
        self._bitrate            = options.bitrate         # desired bit
rate 
        self._decim              = options.decim           # Decimating rate
for the USRP (prelim) 
        self._samples_per_symbol = options.samples_per_symbol  # desired
samples/symbol
        self._fusb_block_size    = options.fusb_block_size # usb info for USRP
        self._fusb_nblocks       = options.fusb_nblocks    # usb info for
USRP

        self._rx_callback   = rx_callback      # this callback is fired when
there's a packet available
        self._demod_class   = demod_class      # the demodulator_class we're
using

        if self._rx_freq is None:
            sys.stderr.write("-f FREQ or --freq FREQ or --rx-freq FREQ must
be specified\n")
            raise SystemExit

        # Set up USRP source; also adjusts decim, samples_per_symbol, and
bitrate
        self._setup_usrp_source()

        g = self.u.gain_range()
        if options.show_rx_gain_range:
            print "Rx Gain Range: minimum = %g, maximum = %g, step size =
%g" \
                  % (g[0], g[1], g[2])

        self.set_gain(options.rx_gain)

        self.set_auto_tr(True)                 # enable Auto
Transmit/Receive switching

        # Set RF frequency
        ok = self.set_freq(self._rx_freq)
        if not ok:
            print "Failed to set Rx frequency to %s" %
(eng_notation.num_to_str(self._rx_freq))
            raise ValueError, eng_notation.num_to_str(self._rx_freq)

        # copy the final answers back into options for use by demodulator
        options.samples_per_symbol = self._samples_per_symbol
        options.bitrate = self._bitrate
        options.decim = self._decim

        # Get demod_kwargs
        demod_kwargs =
self._demod_class.extract_kwargs_from_options(options)
        # Fix USRP2 -> USRP1 scaling
        self.scale = gr.multiply_const_cc(32768)
        # Design filter to get actual channel we want
        sw_decim = 1
        chan_coeffs = gr.firdes.low_pass (1.0,                  # gain
                                          sw_decim *
self._samples_per_symbol, # sampling rate
                                          1.0,                  # midpoint
of trans. band
                                          0.5,                  # width of
trans. band
                                          gr.firdes.WIN_HANN)   # filter
type 

        # Decimating channel filter
        # complex in and out, float taps
        self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)
        #self.chan_filt = gr.fir_filter_ccf(sw_decim, chan_coeffs)

        # receiver
        self.packet_receiver = \
            blks2.demod_pkts(self._demod_class(**demod_kwargs),
                             access_code=None,
                             callback=self._rx_callback,
                             threshold=-1)
    
        # Carrier Sensing Blocks
        alpha = 0.001
        thresh = 30   # in dB, will have to adjust

        if options.log_rx_power == True:
            self.probe = gr.probe_avg_mag_sqrd_cf(thresh,alpha)
            self.power_sink = gr.file_sink(gr.sizeof_float, "rxpower.dat")
            self.connect(self.chan_filt, self.probe, self.power_sink)
        else:
            self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
            self.connect(self.chan_filt, self.probe)

        # Display some information about the setup
        if self._verbose:
            self._print_verbage()
            
        self.connect(self.u, self.scale, self.chan_filt,
self.packet_receiver)

    def _setup_usrp_source(self):
        self.u = usrp2.source_32fc (self._interface, self._mac_addr)
        adc_rate = self.u.adc_rate()

        # derive values of bitrate, samples_per_symbol, and decim from
desired info
        (self._bitrate, self._samples_per_symbol, self._decim) = \ 
            pick_rx_bitrate(self._bitrate,
self._demod_class.bits_per_symbol(), \
                            self._samples_per_symbol, self._decim, adc_rate) 

        self.u.set_decim(self._decim)
        # determine the daughterboard subdevice we're using
        #if self._rx_subdev_spec is None:
        #    self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
        #self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec)

        #self.u.set_mux(usrp.determine_rx_mux_value(self.u,
self._rx_subdev_spec))

    def set_freq(self, target_freq):
        """
        Set the center frequency we're interested in.

        @param target_freq: frequency in Hz
        @rypte: bool

        Tuning is a two step process.  First we ask the front-end to
        tune as close to the desired frequency as it can.  Then we use
        the result of that operation and our target_frequency to
        determine the value for the digital up converter.
        """
        r = self.u.set_center_freq(target_freq)
        if r:
            return True

        return False

    def set_gain(self, gain):
        """
        Sets the analog gain in the USRP
        """
        if gain is None:
            r = self.u.gain_range()
            gain = (r[0] + r[1])/2               # set gain to midpoint
        self.gain = gain
        return self.u.set_gain(gain)

    def set_auto_tr(self, enable):
        #return self.u.set_auto_tr(enable)
        return
        
    def bitrate(self):
        return self._bitrate

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def decim(self):
        return self._decim

    def carrier_sensed(self):
        """
        Return True if we think carrier is present.
        """
        #return self.probe.level() > X
        return self.probe.unmuted()

    def carrier_threshold(self):
        """
        Return current setting in dB.
        """
        return self.probe.threshold()

    def set_carrier_threshold(self, threshold_in_db):
        """
        Set carrier threshold.

        @param threshold_in_db: set detection threshold
        @type threshold_in_db:  float (dB)
        """
        self.probe.set_threshold(threshold_in_db)
    
        
    def add_options(normal, expert):
        """
        Adds receiver-specific options to the Options Parser
        """
        add_freq_option(normal)
        if not normal.has_option("--bitrate"):
            normal.add_option("-r", "--bitrate", type="eng_float",
default=None,
                              help="specify bitrate.  samples-per-symbol and
interp/decim will be derived.")
        normal.add_option("-e", "--interface", type="string",
default="eth0",
                          help="select Ethernet interface, default is eth0")
        normal.add_option("-m", "--mac-addr", type="string", default="",
                          help="select USRP by MAC address, default is
auto-select")
        #normal.add_option("-R", "--rx-subdev-spec", type="subdev",
default=None,
        #                  help="select USRP Rx side A or B")
        normal.add_option("", "--rx-gain", type="eng_float", default=None,
metavar="GAIN",
                          help="set receiver gain in dB [default=midpoint]. 
See also --show-rx-gain-range")
        normal.add_option("", "--show-rx-gain-range", action="store_true",
default=False, 
                          help="print min and max Rx gain available on
selected daughterboard")
        normal.add_option("-v", "--verbose", action="store_true",
default=False)
        expert.add_option("-S", "--samples-per-symbol", type="int",
default=None,
                          help="set samples/symbol [default=%default]")
        expert.add_option("", "--rx-freq", type="eng_float", default=None,
                          help="set Rx frequency to FREQ
[default=%default]", metavar="FREQ")
        expert.add_option("-d", "--decim", type="intx", default=None,
                          help="set fpga decimation rate to DECIM
[default=%default]")
        expert.add_option("", "--log", action="store_true", default=False,
                          help="Log all parts of flow graph to files
(CAUTION: lots of data)")
        expert.add_option("", "--log-rx-power", action="store_true",
default=False,
                          help="Log receive signal power to file (CAUTION:
lots of data)")

    # Make a static method to call before instantiation
    add_options = staticmethod(add_options)


    def _print_verbage(self):
        """
        Prints information about the receive path
        """
        print "\nReceive Path:"
        print "Using RX d'board %s"    % (self.u.daughterboard_id(),)
        print "Rx gain:         %g"    % (self.gain,)
        print "modulation:      %s"    % (self._demod_class.__name__)
        print "bitrate:         %sb/s" %
(eng_notation.num_to_str(self._bitrate))
        print "samples/symbol:  %3d"   % (self._samples_per_symbol)
        print "decim:           %3d"   % (self._decim)
        print "Rx Frequency:    %s"    %
(eng_notation.num_to_str(self._rx_freq))
        # print "Rx Frequency:    %f"    % (self._rx_freq)

    def __del__(self):
        # Avoid weak reference error
        #del self.subdev
        return
            
def add_freq_option(parser):
    """
    Hackery that has the -f / --freq option set both tx_freq and rx_freq
    """
    def freq_callback(option, opt_str, value, parser):
        parser.values.rx_freq = value
        parser.values.tx_freq = value

    if not parser.has_option('--freq'):
        parser.add_option('-f', '--freq', type="eng_float",
                          action="callback", callback=freq_callback,
                          help="set Tx and/or Rx frequency to FREQ
[default=%default]",
                          metavar="FREQ")

pick_bitrate.py

#
# Copyright 2005,2006 Free Software Foundation, Inc.
# 
# 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.
# 

_default_bitrate = 500e3

_valid_samples_per_symbol = (2,3,4,5,6,7)

def _gen_tx_info(converter_rate):
    results = []
    for samples_per_symbol in _valid_samples_per_symbol:
        for interp in range(16, 512 + 1, 4):
            bitrate = converter_rate / interp / samples_per_symbol
            results.append((bitrate, samples_per_symbol, interp))
    results.sort()
    return results

def _gen_rx_info(converter_rate):
    results = []
    for samples_per_symbol in _valid_samples_per_symbol:
        for decim in range(8, 256 + 1, 2):
            bitrate = converter_rate / decim / samples_per_symbol
            results.append((bitrate, samples_per_symbol, decim))
    results.sort()
    return results
    
def _filter_info(info, samples_per_symbol, xrate):
    if samples_per_symbol is not None:
        info = [x for x in info if x[1] == samples_per_symbol]
    if xrate is not None:
        info = [x for x in info if x[2] == xrate]
    return info

def _pick_best(target_bitrate, bits_per_symbol, info):
    """
    @returns tuple (bitrate, samples_per_symbol, interp_rate_or_decim_rate)
    """
    if len(info) == 0:
        raise RuntimeError, "info is zero length!"

    if target_bitrate is None:     # return the fastest one
        return info[-1]
    
    # convert bit rate to symbol rate
    target_symbolrate = target_bitrate / bits_per_symbol
    
    # Find the closest matching symbol rate.
    # In the event of a tie, the one with the lowest samples_per_symbol
wins.
    # (We already sorted them, so the first one is the one we take)

    best = info[0]
    best_delta = abs(target_symbolrate - best[0])
    for x in info[1:]:
        delta = abs(target_symbolrate - x[0])
        if delta < best_delta:
            best_delta = delta
            best = x

    # convert symbol rate back to bit rate
    return ((best[0] * bits_per_symbol),) + best[1:]

def _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                  xrate, converter_rate, gen_info):
    """
    @returns tuple (bitrate, samples_per_symbol, interp_rate_or_decim_rate)
    """
    if not isinstance(bits_per_symbol, int) or bits_per_symbol < 1:
        raise ValueError, "bits_per_symbol must be an int >= 1"
    
    if samples_per_symbol is not None and xrate is not None:  # completely
determined
        return (float(converter_rate) / xrate / samples_per_symbol,
                samples_per_symbol, xrate)

    if bitrate is None and samples_per_symbol is None and xrate is None:
        bitrate = _default_bitrate

    # now we have a target bitrate and possibly an xrate or
    # samples_per_symbol constraint, but not both of them.

    return _pick_best(bitrate, bits_per_symbol,
                      _filter_info(gen_info(converter_rate),
samples_per_symbol, xrate))
    
#
---------------------------------------------------------------------------------------

def pick_tx_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                    interp_rate, converter_rate=128e6): 
    """
    Given the 4 input parameters, return at configuration that matches

    @param bitrate: desired bitrate or None
    @type bitrate: number or None
    @param bits_per_symbol: E.g., BPSK -> 1, QPSK -> 2, 8-PSK -> 3
    @type bits_per_symbol: integer >= 1
    @param samples_per_symbol: samples/baud (aka samples/symbol)
    @type samples_per_symbol: number or None
    @param interp_rate: USRP interpolation factor
    @type interp_rate: integer or None
    @param converter_rate: converter sample rate in Hz
    @type converter_rate: number

    @returns tuple (bitrate, samples_per_symbol, interp_rate)
    """
    return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                         interp_rate, converter_rate, _gen_tx_info)


def pick_rx_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                    decim_rate, converter_rate=64e6): 
    """
    Given the 4 input parameters, return at configuration that matches

    @param bitrate: desired bitrate or None
    @type bitrate: number or None
    @param bits_per_symbol: E.g., BPSK -> 1, QPSK -> 2, 8-PSK -> 3
    @type bits_per_symbol: integer >= 1
    @param samples_per_symbol: samples/baud (aka samples/symbol)
    @type samples_per_symbol: number or None
    @param decim_rate: USRP decimation factor
    @type decim_rate: integer or None
    @param converter_rate: converter sample rate in Hz
    @type converter_rate: number

    @returns tuple (bitrate, samples_per_symbol, decim_rate)
    """
    return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                         decim_rate, converter_rate, _gen_rx_info)

Thanks in advance for your cooperation.

(2)

Hi,

This is what I get when I run benchmark _tx.py and benchmark_rx.py
respectively on USRP2 with transmit_path_usrp2.py and receive_path_usrp2.py
respectively:

benchmark_tx.py:-

m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_tx.py -f 2400M -v
usrp2::ctor reset_db failed
usrp2::ctor set_rx_gain failed
usrp2::ctor set_tx_interp failed
usrp2::ctor set_rx_scale_iq failed
>>> gr_fir_fff: using SSE
bits per symbol = 1
Gaussian filter bt = 0.35
Using TX d'board 43
Tx amplitude     12000
modulation:      gmsk_mod
bitrate:         500kb/s
samples/symbol:    2
interp:          100
Tx Frequency:    2.4G
...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$
 

benchmark_rx.py:-

m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_rx.py -f 2400M -v
usrp2::ctor reset_db failed
>>> gr_fir_fff: using SSE
bits per symbol = 1
M&M clock recovery omega = 2.000000
M&M clock recovery gain mu = 0.175000
M&M clock recovery mu = 0.500000
M&M clock recovery omega rel. limit = 0.005000
frequency error = 0.000000

Receive Path:
Using RX d'board 39
Rx gain:         35
modulation:      gmsk_demod
bitrate:         500kb/s
samples/symbol:    2
decim:           100
Rx Frequency:    2.4G


Now the same thing for usrp1 but using transmit_path.py and receive_path.py
which is already provided in gnuradio:

benchmark_tx.py:-

m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_tx.py -f 2400M -v
>>> gr_fir_fff: using SSE
bits per symbol = 1
Gaussian filter bt = 0.35
Using TX d'board A: Flex 2400 Tx MIMO B
Tx amplitude     12000
modulation:      gmsk_mod
bitrate:         500kb/s
samples/symbol:    2
interp:          128
Tx Frequency:    2.4G
...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$
 

benchmark_rx.py:-

m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_rx.py -f 2400M -v
>>> gr_fir_fff: using SSE
bits per symbol = 1
M&M clock recovery omega = 2.000000
M&M clock recovery gain mu = 0.175000
M&M clock recovery mu = 0.500000
M&M clock recovery omega rel. limit = 0.005000
frequency error = 0.000000

Receive Path:
Using RX d'board A: Flex 2400 Rx MIMO B
Rx gain:         45
modulation:      gmsk_demod
bitrate:         500kb/s
samples/symbol:    2
decim:            64
Rx Frequency:    2.4G

I am using the same pick_bitrate.py file that is already provided in
gnuradio. As it can be seen that both usrp systems have the default bit rate
irrespective of whether it acts as receiver or transmitter. My concern is
with the interpolation and decimation. Do I need to make changes to the
pick_bitrate.py file for USRP2? If yes, then what kind of changes. I also
observed that even though USRP2 shows a bit rate of 500kbps, however I
believe that its transmitting too fast which does not allow USRP1 to receive
correctly.I would greatly appreciate any help in this matter.

Thanks in advance.

(3)

At a minimum, you will need to call pick_tx_bitrate and
pick_rx_bitrate providing proper rates for the ADC and DAC.  They
default to the values appropriate for the USRP1.  However, it looks
like you'll need a USRP2 version since they encode the acceptable
ranges for interpolation and decimation which are different between
the USRP1 and USRP2.

Eric

(4)

Hi,

I already tried to set the value of the converter_rate in pick_tx_bitrate
and Pick_rx_bitrate according to the ADC and DAC specifications of u...@. I
set it to 200e6 in pick_tx_bitrate and in pick_rx_bitrate. But even that did
not worked. I am confused with how to modify the pick_bitrate.py file for
usrp2. I am not able to determine the different parameters that I need to
provide for usrp2. If anyone has already worked on it then please help me to
modify the pick_bitrate file for usrp2. Also if any other changes are
required in other python files.

Thanks in advance.

Smith

(5)

The DAC rate is 100e6. The "bitrate" is the desired data rate of the over the air modulation. It should be MUCH less, like 100k to 1M or so.
There is absolutely nothing in any of the systems for which 200e6 is a correct choice.

Matt

Why dont you read the "readme" file first?!

it's fucking awful to find everything in readme file, while I spent nearly 10 hours wander around in the internet......

==========

/gnuradio3.2.2/gnuradio-examples/python/digital/README

Quick overview of what's here:

* benchmark_tx.py: generates packets of the size you
specify and sends them across the air using the USRP.  Known to work
well using the USRP with the RFX transceiver daughterboards.
You can specify the bitrate to use with the -r command line
parameter.  The default is 500k.  Some machines will do 1M or more.
You can select the modulation to use with the -m command
line argument.  The legal values for are gmsk, dbpsk and dqpsk.

* benchmark_rx.py: the receiver half of benchmark_tx.py.
Command line arguments are pretty much the same as rx.  Works well
with a USRP and RFX transceiver daughterboards.  Will also work
with TVRX daugherboard, but you'll need to fiddle with the gain.  See
below.  Prints a summary of each packet received and keeps a running
total of packets received, and how many of them were error free.
There are two levels of error reporting going on.  If the access code
(PN code) and header of a packet were properly detected, then you'll
get an output line.  If the CRC32 of the payload was correct you get
"ok = True", else "ok = False".  The "pktno" is extracted from the
received packet.  If there are skipped numbers, you're missing some
packets.  Be sure you've got a suitable antenna connected to the TX/RX
port on each board.  For the RFX-400, "70 cm" / 420 MHz antennas for ham
handi-talkies work great.  These are available at ham radio supplies,
etc.  The boards need to be at least 3m apart.  You can also try
experimenting with the rx gain (-g command line option).

Generally speaking, I start the rx first on one machine, and then fire
up the tx on the other machine.  The tx also supports a discontinous
transmission mode where it sends bursts of 5 packets and then waits 1
second.  This is useful for ensuring that all the receiver control
loops lock up fast enough.

* tunnel.py: This program provides a framework for building your own
MACs.  It creates a "TAP" interface in the kernel, typically gr0,
and sends and receives ethernet frames through it.  See
/usr/src/linux/Documentation/networking/tuntap.txt and/or Google for
"universal tun tap".  The Linux 2.6 kernel includes the tun module, you
don't have to build it.  You may have to "modprobe tun" if it's not
loaded by default.  If /dev/net/tun doesn't exist, try "modprobe tun".

To run this program you'll need to be root or running with the
appropriate capability to open the tun interface.  You'll need to fire
up two copies on different machines.  Once each is running you'll need
to ifconfig the gr0 interface to set the IP address.

This will allow two machines to talk, but anything beyond the two
machines depends on your networking setup.  Left as an exercise...

On machine A:

  $ su
  # ./tunnel.py --freq 423.0M --bitrate 500k
  # # in another window on A, also as root...
  # ifconfig gr0 192.168.200.1


On machine B:

  $ su
  # ./tunnel.py --freq 423.0M --bitrate 500k
  # # in another window on B, also as root...
  # ifconfig gr0 192.168.200.2

Now, on machine A you shold be able to ping machine B:

  $ ping 192.168.200.2

and you should see some output for each packet in the
tunnel.py window if you used the -v option.

Likewise, on machine B:

  $ ping 192.168.200.1

This now uses a carrier sense MAC, so you should be able to ssh
between the machines, web browse, etc.

* run_length.py: This program takes a single argument '-f FILE' and
outputs the number of runs of similar bits within the file. It is
useful as a diagnostic tool when experimenting with line coding or
whitening algorithms.

How to test USRP when you get it

prerequisites:
1. install Linux: need to select a OS here
2. install GNU Radio:    --http://gnuradio.org/trac/wiki
3. (optional) read the hardware documents:    --http://gnuradio.org/trac/wiki/USRP
        user guide/install guide:    --http://www.comsec.com/wiki?UsrpInstall
        All the datasheets can be downloaded here
4. (optional) read driver source code
        the source codes related to USRP:
            /usrp
                firmware: for 8051 in USB controller, mostly writen as .c and .a51
                FPGA: for FPGA, mostly writen as .v (it seems fpga only has SRAM inside, so it need to download software for fpga every time)
                host: for PC, mostly writen as .cc
            /gr-usrp
                driver for dauther board: mostly writen as .py and .cc
            /gnuradio-example/python/usrp
                example for single usrp board: all writen in .py
            /gnuradio-example/python/multi-usrp
                example for multi usrp boards: all writen in .py

begin to test:
1. How to power on and start test:
        step1. before plug in USB cable, open two terminal.
        step2. to see a real time display of all log messages: tail -f /var/log/messages (to check the usb driver is correctly installed)
    How to stop and power off:
        step1. stop the program.
        step2. disconnect USB connection and power off
2. test a script for usrp first without daughter board, which file I need to test?
--http://www.comsec.com/wiki?UsrpInstall
gnuradio\gnuradio-examples\python\usrp\usrp_siggen.py & usrp_fft.py

3. how to test the transmitter and receiver for daughter board?
The antenna should be connect by Tx/Rx SMA but NOT Rx2! there is a switch for Rx2 and the switch is off in default!
The Tx and Rx can NOT be connected directly by cable! need a attenuator about 40-50 dB!!
    1) /gnuradio-examples/python/usrp/usrp_siggen.py and usrp_fft.py to observe signal
    2) /gnuradio-examples/python/digital/benchmark_tx.py and benchmark_rx.py to test data transmission.
        The boards need to be at least 3m apart. --/home/james/gnuradio/gnuradio-examples/python/digital/README
    3) use tx_voice.py and rx_voice.py to test voice transmission.
    4) some also said to test /gnuradio-examples/python/usrp/usrp_nbfm_ptt.py to test full duplex voice call, but I can't make it works.

test voice:
1. gnuradio-examples\python\audio\dial_tone.py as tutorial
2. gnuradio-examples\python\audio\audio_copy.py
    gnuradio-examples\python\audio\audio_to_file.py
    gnuradio-examples\python\audio\audio_play.py
3. gnuradio-examples\python\digital_voice\encdec.py to test by one USRP
4. gnuradio-examples\python\digital\tx_voice.py
    gnuradio-examples\python\digital\rx_voice.py to test by two USRP

test data:
1. gnuradio-examples\python\digital\benchmark_tx.py
    gnuradio-examples\python\digital\benchmark_rx.py to test by two USRP

suggested by others:
1. http://www.nabble.com/High-packet-error-and-reception-problems-with-RFX-2400-t3522095.html
./benchmark_tx.py -f 2412M --bitrate 500k -v --tx-amplitude=30000
usrp_siggen.py and usrp_oscope.py
./benchmark_rx.py -f 2412M --bitrate 100k -v --rx-gain=75
--in digital folder

2. http://staff.washington.edu/jon/gr-osx/gr-osx-usrp.html#using
benchmark_usb.py Estimate throughput of USB
usrp_siggen.py Signal generator
usrp_oscope.py Oscilloscope (screenshot)
usrp_fft.py Spectrum analyzer (screenshot)

ways to keep from duplicating path variable in csh

#!/usr/bin/perl
#
# ^^ ensure this is pointing to the correct location.
#
# Title:    SLimPath
# Author:   David "Shoe Lace" Pyke 
#   :   Tim Nelson 
# Purpose: To create a slim version of my envirnoment path so as to eliminate
#       duplicate entries and ensure that the "." path was last.
# Date Created: April 1st 1999
# Revision History:
#   01/04/99: initial tests.. didn't wok verywell at all
#       : retreived path throught '$ENV' call
#   07/04/99: After an email from Tim Nelson  got it to
#         work.
#       : used 'push' to add to array
#       : used 'join' to create a delimited string from a list/array.
#   16/02/00: fixed cmd-line options to look/work better
#   25/02/00: made verbosity level-oriented
#
#
use Getopt::Std;
sub printlevel;

$initial_str = "";
$debug_mode = "";
$delim_chr = ":";
$opt_v = 1;

getopts("v:hd:l:e:s:");

OPTS: {
    $opt_h && do {
print "\n$0 [-v level] [-d level] [-l delim] ( -e varname | -s strname | -h )";
print "\nWhere:";
print "\n   -h  This help";
print "\n   -d  Debug level";
print "\n   -l  Delimiter (between path vars)";
print "\n   -e  Specify environment variable (NB: don't include \$ sign)";
print "\n   -s  String (ie. $0 -s \$PATH:/looser/bin/)";
print "\n   -v  Verbosity (0 = quiet, 1 = normal, 2 = verbose)";
print "\n";
        exit;
    };
    $opt_d && do {
        printlevel 1, "You selected debug level $opt_d\n";
        $debug_mode = $opt_d;
    };
    $opt_l && do {
        printlevel 1, "You are going to delimit the string with \"$opt_l\"\n";
        $delim_chr = $opt_l;
    };
    $opt_e && do {
        if($opt_s) { die "Cannot specify BOTH env var and string\n"; }
        printlevel 1, "Using Environment variable \"$opt_e\"\n";
        $initial_str = $ENV{$opt_e};
    };
    $opt_s && do {
        printlevel 1, "Using String \"$opt_s\"\n";
        $initial_str = $opt_s;
    };
}
if( ($#ARGV != 1) and !$opt_e and !$opt_s){
    die "Nothing to work with -- try $0 -h\n";
}

$what = shift @ARGV;
# Split path using the delimiter
@dirs = split(/$delim_chr/, $initial_str);

$dest;
@newpath = ();
LOOP: foreach (@dirs){
    # Ensure the directory exists and is a directory
    if(! -e ) { printlevel 1, "$_ does not exist\n"; next; }
    # If the directory is ., set $dot and go around again
    if($_ eq '.') { $dot = 1; next; }
#   if ($_ ne `realpath $_`){
#               printlevel 2, "$_ becomes ".`realpath $_`."\n";
#   }
    undef $dest;
    #$_=Stdlib::realpath($_,$dest);
    # Check for duplicates and dot path
    foreach $adir (@newpath) { if($_ eq $adir) { 
        printlevel 2, "Duplicate: $_\n";
        next LOOP; 
    }}

    push @newpath, $_;
}
# Join creates a string from a list/array delimited by the first expression
print join($delim_chr, @newpath) . ($dot ? $delim_chr.".\n" : "\n");

printlevel 1, "Thank you for using $0\n";
exit;
sub printlevel {
    my($level, $string) = @_;

    if($opt_v >= $level) {
        print STDERR $string;
    }
}

"C/C++ Development Tooling" plug in Eclipse

It is weird that the official website of CDT does not contain anything about how to integrate the CDT with an existing Eclipse, and so does its google search within the website. However, except the awkward "import project" method (at least, for me... I have tried several times on the username/password to ssh the remote server), the method mentioned here is much more straightforward. For more information, the Eclipse CDT wiki is a nice place to go.

The method is:

1. Download the master zip file and put it somewhere on your machine.
2. Fire up Eclipse (The Platform Run-time 3.6 is minimum recommended)
3. Help->Install New Software...
4. Add... in the master zip as an Archive site
5. Under CDT Main Features select the one you want. C/C++ Development Tools is the main one. The SDK adds in the schemas and source for building extensions to the CDT. The C/C++ Development Platform is the Tools without the GNU toolchain support.
6. You can install other neat things, including the Mylyn bridge, from the CDT Optional Features category.

ps.
the Pydev install web address is: http://pydev.org/updates/
The EPIC for perl can be downloaded from: http://e-p-i-c.sf.net/updates. And it also need the ActivePerl (http://www.activestate.com/Products/activeperl/) for windows os.