Brian's Tech Blog

PSoC bootloaders ZZ

2014-10-28T08:03:00.000-07:00

eewiki.net/display/microcontroller/PSoC+Bootloaders#PSoCBootloaders-HowBootloadersWork

Creating PSoC Bootloaders

Cypress makes it very simple to create bootloader programs. This section will walk through the process of creating a bootloader application in PSoC Creator 3.0 for PSoC 3, 4, and 5LP devices. PSoC Creator 3.0 can be downloaded for free here.

Open PSoC Creator 3.0.
Navigate to File -> New -> Project.
Select Empty PSoC 3, 4, 5LP Design - whichever device family you are using.
Type a descriptive name for your bootloader program in the "Name" field. I usually indicate which device family I'm using, which serial port I'm using, and the fact that it's a bootloader. i.e. PSoC4_UART_Bootloader
Browse to whatever directory you wish to save the project in.
Click the '+ Advanced' button.
Select your specific device.
Select "Bootloader" as the application type and click 'OK'.
PSoC Creator should bring up the schematic view. If not, double click "TopDesign.cysch" from the Project Explorer window.
From the Component Catalog, drag the desired communication port for your bootloader into your design. For example, if you would like a UART-based bootloader, click and drag the UART component into your design.
Double-click on your component after it has been added to the design to configure it. Name it whatever you would like and setup your desired communication settings. For a UART, you will need to verify the baud rate, number of data bits, parity type, number of stop bits, and flow control setting. You will also need to change the RX and TX buffer sizes to 64 bytes if using UART. If using I2C, you'll need to use an I2C Slave component. You'll need to verify the slave address and data rate. You can use any serial com you would like, or create your own custom serial com. However, that is out of the scope of this page. Apply any changes and click 'OK'.
From the Component Catalog, drag a Bootloader component into your design.
Double-click on the Bootloader to configure it. Name it whatever you'd like. Your com port should be available in the Communication Component drop-down. The Wait Time defines how long the bootloader will wait for the start signal from the Host before passing control to the application program. Multi-application bootloader is out of the scope of this page. Every other option can be set however you wish. I usually leave default settings. Apply any changes and click 'OK'.
Open the .cydwr file for your project from the Project Explorer window. Assign physical pins to your communication port. Save and close the .cydwr file.
Open the main.c file from the Project Explorer window. Nothing needs to be changed in main.c for the bootloader to function properly. You could light up an LED before starting the bootloader, if you wish, but for a simple bootloader program, main.c can be left alone.
Save and build the project. This will create bootloader .hex and .elf files and in the Debug folder of your project directory. These files are necessary for your Bootloadable application.
- For PSoC3 devices, they will be in your project directory under <project name>.cydsn -> DP8051 -> DP8051_Keil_9xx -> Debug.
- For PSoC4 devices, they will be in your project directory under <project name>.cydsn -> CortexM0 -> ARM_GCC_4xx -> Debug.
- For PSoC5 devices, they will be in your project directory under <project name>.cydsn -> CortexM3 -> ARM_GCC_4xx -> Debug.
Program the bootloader to your device like you would normally program a PSoC device using Debug -> Program from within your bootloader project. You can also use PSoC Programmer to program your device.

Congratulations! If you completed all of these steps, you just created and flashed a bootloader to your PSoC device! Give yourself a pat on the back...but not too hard. We don't need anybody getting hurt. We haven't even used our bootloader yet! Now we need to create a Bootloadable application.

Creating PSoC Bootloadable Applications

Cypress makes it very simple to create a bootloadable application from scratch. This section will walk through the process of creating a bootloadable application in PSoC Creator 3.0 for PSoC 3, 4, and 5LP devices.

Open PSoC Creator 3.0.
Navigate to File -> New -> Project.
Select Empty PSoC 3, 4, 5LP Design - whichever device family your are using.
Type a descriptive name for your bootloadable program in the "Name" field. I usually type my application name preceded by which device family I'm using, which serial port I'm using, and the fact that it's bootloadable. i.e. PSoC4_UART_Bootloadable_TempSensor.
Browse to whatever directory you wish to save the project in.
Click the '+ Advanced' button.
Select your specific device.
Select "Bootloadable" as the application type and click 'OK'.
PSoC Creator should bring up the schematic view. If not, double click "TopDesign.cysch" from the Project Explorer window.
Click and drag a Bootloadable component into your schematic from the Component Catalog. Double-click the Bootloadable to configure it. The General tab can be left alone. Under the Dependencies tab, you will need to map the project to the bootloader .hex and .elf files you previously created.
At this point you should develop your program exactly as you would any other PSoC application. Add any components you need for your design and develop firmware in main.c as you normally would.
Save and build your bootloadable program. Just like any normal PSoC project, building will create a program .hex file in the Debug folder of your project directory. However, for a bootloadable project, a .cyadc file will also be generated. This is the file needed by the Bootloader Host application that actually uploads the device firmware using your bootloader.
- For PSoC3 devices, the .cyacd file will be in your project directory under <project name>.cydsn -> DP8051 -> DP8051_Keil_9xx -> Debug.
- For PSoC4 devices, the .cyacd file will be in your project directory under <project name>.cydsn -> CortexM0 -> ARM_GCC_4xx -> Debug.
- For PSoC5 devices, the .cyacd file will be in your project directory under <project name>.cydsn -> CortexM3 -> ARM_GCC_4xx -> Debug.

Cheers! If you completed all of these steps, you just created a bootloadable application that can be uploaded to your device using the bootloader that you already programmed to memory. Now we need to upload the bootloadable program using Bootloader Host.

Using Bootloader Host

Bootloader Host is included by default in the PSoC Creator installation. You can use this application to upload PSoC bootloadable programs to a PSoC device containing the mapped bootloader program. This section will walk through the process of uploading a bootloadable application using Bootloader Host.

Bootloader Host supports numerous serial communication protocols. However, keep in mind, you will need to physically connect the target device to the PC somehow. In many cases, the only connectivity options on a PC are USB or RS232. You may need some sort of bridge device to actually connect your target to the PC.

USB / UART Bridges:

- TTL-232R-3V3: This is a USB to 3.3V TTL bridge cable from FTDI. If your bootloader uses UART, this can be used to connect the UART of your target to the USB port of a PC.
- CYUSBS232: This kit contains a USB to RS232 bridge device that can be used to connect your target to the USB port of a PC if your bootloader uses UART.

USB / I2C Bridges:

- CY8CKIT-002: Miniprog3 can be used as a USB to I2C bridge if your bootloader uses I2C.
- CY3240-I2USB: This kit contains a USB to I2C bridge device that can be used to connect your target to the USB port of a PC if your bootloader uses I2C.
- If using the PSoC4 Pioneer Kit, the on-board PSoC5LP device can be used as a USB to I2C bridge device (no external bridge device needed for bootloading).

Books for Embedded System Developers ZZ

2014-10-14T13:20:00.000-07:00

http://www.ganssle.com/bkreviews.htm

Here's links to various reviews of books useful to embedded system developers. They cover subjects from firmware development to hardware. First, one shameless plug - I've written a half dozen embedded books myself. More here.

Suggestion: Subscribe to my free newsletter which often has reviews of books about embedded systems.

Agile Estimating and Planning, Mike Cohn - Valuable for anyone building software.

Balancing Agility and Discipline, Barry Boehm and Richard Turner - Agile or more disciplined?

Bebop to the Boolean Boogie, Clive Maxfield - A fun and interesting digital design book.

Better Embedded System Software, Phil Koopman - An essential introduction to all areas of building embedded systems.

Building Parallel, Embedded, and Real-Time Applications with Ada, John McCormick, Frank SInghoff and Jerome Hugues - One of the best books on using Ada effectively in building embedded systems.

CMMI Survival Guide, Suzanne Garcia and Richard Turner - One guide to CMMI.

Computer Approximations - The best book on approximations ever. Hart's classic book is a "must have"... if you can find it.

Debugging, David Agans- A well written, quick read packed with war stories. Every new grad should read this.

Digital Apollo, David Mindell - An exploration of the relationship between human and computers.

Embedded Ethernet and Internet Complete, Jan Axelson - A good "how to" description of building internet-aware applications.

Embedded Linux Primer, Christopher Hallinan - A Practical Real World Approach- A book about putting the OS into firmware.

Embedded Systems Building Blocks, Jean LaBrosse - If you believe in reuse, well, here's stuff to reuse! Also has his firmware standard.

Embedded Systems Design, Arnold Berger - A great intro to the embedded world, with a focus on tools. Also has good hints on selecting processors.

Embedded Systems Security, David and Mike Kleidermacher - Practical methods for safe and secure software systems development.

An Embedded Software Primer, David Simon - One of the best introductory books to embedded development around.

Embedded Systems Design using the Rabbit 3000 Microprocessor, Kamal Hyder and Bob Perrin. - Required reading for users of the R3000, and a pretty darn good introduction to the entire realm of embedded systems development as well.

Extreme Programming Explained, Kent Beck - XP is garnering waves of adherents. A very good intro to the ideas and practices.

Extreme Programming Refactored, Matt Stephens and Doug Rosenberg - An infuriating but enlightening expose of eXtreme Programming.

Feature-Driven Development, A Practical Guide to, Stephen Palmer and John Felsing - A development methodology that is much more suited to most embedded efforts. Highly recommended.

The GE Transistor Manual. Everything about transistors, in the 1960s at least. A fascinating and fun book for EE history buffs.

Guidelines for the Use of the C Language in Vehicle Based Software, by MISRA - This is a list of dos and don't dos for writing reliable C code. Not a book per se, but a hundred page list of rules.

Ham Radio for Dummies, by Ward Silver - A great introduction for the newbies to the fascinating world of ham radio.

Hands-on XBEE Lab Manual, Jonathan Titus - Experiments that teach you XBEE wireless communications.

High Integrity Software, John Barnes - A fascinating description of the SPARK programming language.

High Speed Digital Design, Howard Johnson and Martin Graham - The best book around about high-speed issues.

How Computers Do Math, Clive "Max" Maxfield and Alvin Brown - All about the essential workings of computers.

If I Only Changed the Software, Why is the Phone on Fire, Lisa Simone - A fast paced book, interweaving software and hardware.

Introduction to the Personal Software Process, Watts Humphrey - All about the Personal Software Process.

MATH Toolkit for Real-Time Programming, Jack Crenshaw - If you're building approximations, or trying to learn about fixed-point math, this is your bible.

MicroC/OS-II, The Real Time Kernel, Jean Labrosse - The best book on real time operating systems.

MSP430 Microcontroller Basics, John Davies - A great book for novices, as well as experienced developers.

uC/OS-III, The Real-Time Kernel, Jean Labrosse - An entirely rewritten version of a classic.

Peer Reviews in Software, Karl Wiegers - The most readable book on code inspections.

Peopleware, DeMarco and Lister - Perhaps one of the most important books written about being more productive in a software environment.

Principles of Software Engineering Management, Tom Gilb - An interesting book that's essential to anyone planning to manage a software project.

Programming Embedded Systems in C and C++, Michael Barr - A very good intro book, with a focus on the 186 processor.

Real-Time Embedded Multithreading Using ThreadX and MIPS, Edward Lamie - A very organized book with lots of well written code that lends to an excellent presentation of the subject.

Real-Time UML Workshop for Embedded Systems, Bruce Powel Douglass - A precise and engaging, humorous at times book, yet clearly focused on getting complex ideas across.

Serial Port Complete, Jan Axelson - A very complete reference to serial communications.

Software Inspection, Tom Gilb and Dorothy Graham - THE book on code inspections.

Software Inspection - An Industry Best Practice, IEEE Collection - A good series of papers on software inspections.

Statistics in a Nutshell, Paul A Watters and Sarah Boslaugh - an ideal self study book, one of the best.

TCP/IP Lean, Jeremy Bentham - An intro to TCP/IP.

Test Driven Development, by Kent Beck - Kent Beck's view of building the system by producing tests first - Flawed but interesting.

Test Driven Development for Embedded C, James Grenning - hands down, the best book written on the subject.

The Art of Designing Embedded Systems, Jack Ganssle - How to go about building an embedded system, from process issues to tech ideas.

The Art of Programming Embedded Systems, Jack Ganssle - This book is now all but out of print.

The Definitive Guide to the ARM Cortex-M3, Joseph Yiu. A good intro to the very popular Cortex-M3.

The Digital I/O Handbook, Jon Titus and Tom O'Hanlan. A great introduction to a tough subject.

The Elements of Style, William Strunk and E. B. White - If your comments are lousy, so's your code. Here's a short classic about writing decent comments and prose.

The Embedded Systems Dictionary, by Jack Ganssle and Michael Barr - The only single-source of definitions of words used in our industry.

The Existential Pleasures of Engineering, Samuel Florman - If you enjoy the philosophy of engineering, you will like this book.

Understanding and UsingC Pointers, Richard Reese - A surprisingly worthwhile new book on using C pointers

USB Mass Storage, by Jan Axelson. The definitive guide to building memory systems using USB.

When Computers Were Human, David Alan Grier - Computers used to be flesh and blood.

Writing in Software Development, by Al Stavely. How to create great docs with your code.

What is a Pulse Width Modulation (PWM) Signal and What is it Used For?

2014-09-23T09:47:00.001-07:00

http://digital.ni.com/public.nsf/allkb/294E67623752656686256DB800508989

Hardware: Multifunction DAQ (MIO)

Problem:
I have heard that I may be able to use Pulse Width Modulation for my application. What is a pulse width modulation (PWM) signal and what is it used for?

Solution:
A Pulse Width Modulation (PWM) Signal is a method for generating an analog signal using a digital source. A PWM signal consists of two main components that define its behavior: a duty cycle and a frequency. The duty cycle describes the amount of time the signal is in a high (on) state as a percentage of the total time of it takes to complete one cycle. The frequency determines how fast the PWM completes a cycle (i.e. 1000 Hz would be 1000 cycles per second), and therefore how fast it switches between high and low states. By cycling a digital signal off and on at a fast enough rate, and with a certain duty cycle, the output will appear to behave like a constant voltage analog signal when providing power to devices.

Example: To create a 3V signal given a digital source that can be either high (on) at 5V or low (off) at 0V, you can use PWM with a duty cycle of 60% which outputs 5V 60% of the time. If the digital signal is cycled fast enough, then the voltage seen at the output appears to be the average voltage. If the digital low is 0V (which is usually the case) then the average voltage can be calculated by taking the digital high voltage multiplied by the duty cycle, or 5V x 0.6 = 3V. Selecting a duty cycle of 80% would yield 4V, 20% would yield 1V, and so on.

PWM signals are used for a wide variety of control applications. Their main use is for controlling DC motors but it can also be used to control valves, pumps, hydraulics, and other mechanical parts. The frequency that the PWM signal needs to be set at will be dependent on the application and the response time of the system that is being powered. Below are a few applications and some typical minimum PWM frequencies required:

Heating elements or systems with slow response times: 10-100 Hz or higher
DC electric motors: 5-10 kHz or higher
Power supplies or audio amplifiers: 20-200 kHz or higher

Note: Certain systems may need faster frequencies than what is listed here depending on the type of response desired.

Below are some graphs demonstrating PWM signals with different duty cycles.

25% Duty Cycle

50% Duty Cycle

75% Duty Cycle

Attached is a LabVIEW program that displays the basics of pulse width modulation. This example does not use any hardware.

zz Preprocessor Statements #ifdef, #else, #endif

2014-04-04T15:51:00.002-07:00

Preprocessor Statements #ifdef, #else, #endif

These provide a rapid way to "clip" out and insert code.
Consider;

     #define FIRST

     main()
     {
        int a, b, c;

#ifdef FIRST
       a=2; b=6; c=4;
#else
       printf("Enter a:");
       scanf("%d", &a);
     
       printf("Enter a:");
       scanf("%d", &a);

       printf("Enter a:");
       scanf("%d", &a);
#endif
       additonal code

Note that if FIRST is defined (which it is in the above) the values of a, b and c are hardcoded to values of 2, 6 and 4. This can save a lot of time when developing software as it avoids tediously typing everything in each and everytime you run your routine. When FIRST is defined, all that is passed to the compiler is the code between the #ifdef and the #else. The code between the #else and the #endif is not seen by the compiler. It is as if it were all a comment.
Once you have your routine working, and desire to insert the printf and scanfs, all that is required is to go back and delete the the #define FIRST. Now, the compiler does not see the;

     a=2; b=6; c=4;

statement, but does see the printf and scanfs.

Quite often you will have code which doesn't work, but you really don't want to throw it away. I see many students doing this;

/*
     unwanted code
*/

And this is acceptable. Of course a problem arises is you have a comment in the unwanted code.
Thus, it is better to do this

#ifdef OLD
     unwanted code
#endif

Note that if there is no #define OLD, the unwanted code is not passed to the compiler.

Delta-Sigma DAC

2013-10-07T08:53:00.002-07:00

http://www.maximintegrated.com/app-notes/index.mvp/id/1870

http://en.wikipedia.org/wiki/Delta-sigma_modulation

Introduction to the volatile keyword ZZ

2013-08-14T19:28:00.001-07:00

http://www.embedded.com/electronics-blogs/beginner-s-corner/4023801/Introduction-to-the-Volatile-Keyword

Signal and Image Processing with Wavelets

2013-04-19T15:01:00.002-07:00

https://www.ceremade.dauphine.fr/~peyre/teaching/wavelets/

The main reference for an indepth explanation of Wavelet processing is

A Wavelet Tour of Signal Processing

Stéphane Mallat, Academic Press; 2 edition (September 15, 1999)

Each one of these five lectures should take between 1h and 2h in order to test the various features of the scripts. One should copy/paste the provided code into a file named e.g. tp1.m, and launch the script directly from Matlab comand line > tp1;. Some of the scripts contain "holes" that you should try to fill on your own.

I also provide the complete correction of these lectures as a set of Matlab scripts, but you should try as much as possible to avoid using them.

Lecture 0	-	Basic Matlab instructions.
Lecture 1	-	Linear and non-linear wavelet approximation of signals.
Lecture 2	-	Linear and non-linear wavelet approximation of images.
Lecture 3	-	Denoising using filtering.
Lecture 4	-	Denoising using wavelet thresholding.
Lecture 5	-	Wavelet compression of 1D signals.
Lecture 6	-	Image Compression.

Collect and plot data from an instrument in real time

2013-04-19T14:31:00.002-07:00

Collect and plot data from an instrument in real time

http://www.mathworks.com/matlabcentral/fileexchange/25519-collect-and-plot-data-from-an-instrument-in-real-time

Controlling Instruments and Serial Devices with MATLAB and Simulink [Webinar]

https://www.mathworks.com/company/events/webinars/wbnr30422.html

Serial Interface (RS-232 and RS-485) and MATLAB

http://www.mathworks.com/products/instrument/supported/serial.html

Alamouti coding 2X1 and 2X2

2013-02-06T01:53:00.003-08:00

http://spacetimecodes.blogspot.com/p/alamouti-code.html

The codes:
http://spacetimecodes.blogspot.com/p/alamouti-code-for-2-transmiters-and-1.html
http://spacetimecodes.blogspot.com/p/alamouti-code-2x2-matlab-code.html

DFTS-OFDM for uplink transmission in LTE (ZZ)

2012-12-15T16:50:00.001-08:00

Today multi-carrier transmission and OFDM are means to allow for very high overall transmission bandwidth while still being robust to signal corruption due to radio-channel frequency selectivity. However, a drawback of OFDM modulation, as well as any kind of multi-carrier transmission, is the large variations in the instantaneous power of the transmitted signal. Such power variations imply a reduced power-amplifier efficiency and higher power-amplifier cost. This is especially critical for the uplink, due to the high importance of low mobile-terminal power consumption and cost. Several methods have been proposed on how to reduce the large power variations of an OFDM signal. However, most of these methods have limitations in terms of to what extent the power variations can be reduced. Furthermore, most of the methods also imply a significant computational complexity and/or a reduced link performance. Thus, there is an interest to consider also wider-band single-carrier transmission as an alternative to multi-carrier transmission, especially for the uplink, i.e. for mobile-terminal transmission. One of such single-carrier transmission scheme can be implemented using DFT-spread OFDM

DFT-spread OFDM (DFTS-OFDM) is a transmission scheme that can combine the desired properties for uplink transmission i.e. :

• Small variations in the instantaneous power of the transmitted signal (‘single carrier’ property).

• Possibility for low-complexity high-quality equalization in the frequency domain.

• Possibility for FDMA with flexible bandwidth assignment.

Due to these properties, DFTS-OFDM has been selected as the uplink transmission scheme for LTE, which is the long-term 3G evolution.

More detail can be accessed from here:
http://wirelesscafe.wordpress.com/2009/04/07/what-is-single-carrier-fdma-sc-fdma/

How to calculate/plot confidence interval

2012-12-03T17:16:00.001-08:00

http://people.richland.edu/james/lecture/m170/ch08-int.html

Matlab "Out of Memory"

2012-10-08T14:55:00.001-07:00

If you are using 32 bits Window XP, Vista and Window 7, the default memory loaded in Matlab is 2GB.

You can try to extend it by using the following:

1) Run the command in administrator:
2) > BCDEdit /set increaseuserva 3072

Restart the computer and matlab.

MWD wireless telemetry system by Dr. Liu@UH

2012-09-06T14:55:00.002-07:00

http://www.epmag.com/EP-Magazine/archive/MWD-telemetry-low-cost-radios_5675

Channel estimation in MIMO-OFDM

2012-09-04T17:43:00.001-07:00

Wireless LAN Comes of Age:Understanding theIEEE 802.11n Amendment
by Thomas Paul and Tokunbo Ogunfunmi

published in IEEE circuits and systems magazine
Tutorial for WLAN design (including 802.11n, 802.11ac)

Check Section III. 2.5

Also, some tutorial on least square estimation techniques, which is used to derive the results in channel estimation.

http://www.stat.math.ethz.ch/~geer/bsa199_o.pdf

Window Phone 7 programming

2012-09-03T19:02:00.001-07:00

A very nice step-to-step tutorial for Window Phone 7 Development.

http://channel9.msdn.com/Series/Windows-Phone-7-Development-for-Absolute-Beginners

http://channel9.msdn.com/blogs/egibson/windows-phone-7-jump-start-session-1-of-12-introduction

Write Your Own Module in GNU Radio ZZ

2012-08-17T01:52:00.002-07:00

Burn Firmware and FPGA

To connect USRP2 to an external clock, you need to change the firmware and FPGA code on the SD Card

Insert the SD card into the card reader
Use "dmesg" command to check which interface is in use. The following is an example output in my machine, where the SC card is installed in /dev/sdc

$ dmesg
sd 4:0:0:1: [sdc] 3878912 512-byte logical blocks: (1.98 GB/1.84 GiB)
sd 4:0:0:1: [sdc] Assuming drive cache: write through
sd 4:0:0:1: [sdc] Assuming drive cache: write through
sdc: unknown partition table

Run$ cd gnuratio/usrp2/firmware/ $ sudo ./u2_flash_tool --dev=/dev/XXXX -t s/w txrx.bin -w $ sudo ./u2_flash_tool --dev=/dev/XXXX -t fpga u2_rev3-20100603.bin -w Be careful: /dev/XXXX has to be replaced with the device for the SD card reader.
Insert the SD card to USRP2 and reboot USRP2. If your SD card is upgraded successfully, you should see all 6 LEDs flash, and LED 'D' and 'F' will remain on. If not, the card is not upgraded properly.

NOTE: Note that these firmware and FPGA codes work only when the external clock is in use. Otherwise, the USRPs behavior is unpredictable.

http://nms.citi.sinica.edu.tw/n+/software.html

Write Your Own Module

To create your own python module, you will need to write the python script (.py files), C library (.cc files), and the swig file (.i file). The simplest way to create a new module is to copy the existing module and modify it to what you want. We suggest modifying the 'mimo_ofdm_siso' module because it provides the most basic functionality so that you can build your own functions on top of it. In the following, we use modifying 'mimo_ofdm_siso' as the example to demonstrate how to create a new module, called 'mimo_ofdm_new'.

Create python files$ cd gr-mimo/python/ $ cp mimo_usrp2_ofdm_receiver_siso.py mimo_usrp2_ofdm_receiver_new.py $ ln -sf mimo_usrp2_ofdm_receiver_new.py mimo_usrp2_ofdm_receiver.py Edit 'mimo_usrp2_ofdm_receiver_new.py' and replace all strings "_siso" with "_new". You might need to make other modifications if you want to create a module with a different number of input ports and output ports.
Create C library$ cd ../lib/ $ cp mimo_ofdm_siso.cc mimo_ofdm_new.cc $ cp mimo_ofdm_siso.h mimo_ofdm_new.hEdit 'mimo_ofdm_new.cc' and 'mimo_ofdm_new.h', and replace all strings "_siso" and "_SISO" to "_new" and "_NEW", respectively. Modify the makefile 'Makefile.am'. Add "mimo_ofdm_new.h" under the tag "modinclude_HEADERS =", and add "mimo_ofdm_new.cc" under the tag "libgnuradio_mimo_la_SOURCES =".
Create .i file$ cd ../swig/ $ cp mimo_ofdm_siso.i mimo_ofdm_new.iEdit 'mimo_ofdm_new.i', and replace all strings "_siso" with "_new".

Add the following two lines in 'mimo.i'.#include "mimo_ofdm_new.h" %include "mimo_ofdm_new.i"Modify the makefile 'Makefile.am'. Add "mimo_ofdm_new.i" under the tag "mimo_swiginclude_headers =".
Re-build$ cd ../ $ make; sudo make install
Create the new transmitter code$ cd gnuradio/usrp2/host/apps/ $ cp mimo_siso_tx1.cc mimo_new.ccAdd "mimo_new.cc" in 'Makefile.am', and reinstall$ make; sudo make install
Run the example
In the receiver,$ cd gr-mimo/python $ sudo ./mimo_usrp2_rx.py -f 2.45G -d 64 -e eth0 --rx_ant_num 1 -vIn the transmitter,$ cd source/ $ sudo mimo_new -f 2.45G -i 64 -e eth1 -v

SC-FDMA vs OFDMA

2012-07-27T22:52:00.004-07:00

http://en.wikipedia.org/wiki/SC-FDMA

SC-FDMA has drawn great attention as an attractive alternative to OFDMA, especially in the uplink communications where lower PAPR greatly benefits the mobile terminal in terms of transmit power efficiency and terminal costs. It has been adopted as the uplink multiple access scheme in 3GPP Long Term Evolution (LTE), or Evolved UTRA.^[3]^[4]^[5]

The performance of SC-FDMA, in relation to OFDMA has been the subject of various studies.^[6]^[7]^[8] Although the performance gap is not much, SC-FDMA's additional advantage of low PAPR makes it a favorite especially for uplink wireless transmission in future mobile communication systems where transmitter power efficiency is of paramount importance.

Different transmitters (users) are assigned different Fourier coefficients. This assignment is carried out in the mapping and demapping blocks. The receiver side includes one demapping block, one IDFT block and one detection block for each user signal to be received.

Updated GNU Radio tutorial

2012-07-10T16:04:00.001-07:00

[0] http://gnuradio.org/redmine/projects/gnuradio/wiki/TutorialsWritePythonApplications
[1] http://gnuradio.org/redmine/projects/gnuradio/wiki/BlocksCodingGuide

and GRC docs, Doxgyen & Sphinx and a lot other goodies

http://gnuradio.org/redmine/projects/gnuradio/wiki/OutOfTreeModules

millimeter wave propagation study

2012-06-29T12:32:00.002-07:00

Dr. Theodore (Ted) S. Rappaport

Latest research in millimeter wave cellular propagation and broadband communications using adaptive antennas – 5th Generation Cellular

http://faculty.poly.edu/~tsr/

port usrp1 code to usrp2 (zz)

2012-05-28T10:01:00.000-07:00

from "The SDR blog"

This is by no means a complete list, and I will be updating it as I find more of them…

import usrp2
usrp.source_c() becomes usrp2.source_32fc(“eth0″, “”)
adc_rate is 100MS/s instead of 64MS/s, multiply decimation with ~1.5
set_decim_rate() becomes set_decim()
remove all “subdev”-related code
subdev.gain_range() becomes usrp2.gain_range()
subdev.set_gain() becomes usrp2.set_gain()
usrp.tune() becomes usrp2.set_center_freq()

////////////////////////////////////////////////////////////////////////////////////////

http://old.nabble.com/Modifications-in-benchmark_rx.py-for-USRP2-td22234620.html

Free e-Books (ZZ)

2012-05-25T16:15:00.001-07:00

Free e-Books

NOW Foundations and Trends® Books

F. Baccelli and B. Blaszczyszyn, “Stochastic Geometry and Wireless Networks, Volume 2: Applications,” FnT in Networking, vol. 4, no. 1-2

F. Baccelli and B. Blaszczyszyn, “Stochastic Geometry and Wireless Networks, Volume 1: Theory,” FnT in Networking, vol. 3, no. 3-4

M. Haenggi and R. K. Ganti, “Interference in Large Wireless Networks,” FnT in Networking, vol. 3, no. 2

D. Shah, “Gossip Algorithms,” FnT in Networking, vol. 3, no. 1

M. Chiang, P. Hande, T. Lan, and C. W. Tan, “Power Control in Wireless Cellular Networks,” FnT in Networking, vol. 2, no. 4

S. Shakkottai and R. Srikant, “Network Optimization and Control,” FnT in Networking, vol. 2, no. 3

C. Fragouli and E. Soljanin, “Network Coding Applications,” FnT in Networking, vol. 2, no. 2

C. Fragouli and E. Soljanin, “Network Coding Fundamentals,” FnT in Networking, vol. 2, no. 1

G. Kramer, I. Maric, and R. Yates, “Cooperative Communications,” FnT in Networking, vol. 1, no. 3-4

F. Xue and P. R. Kumar, “Scaling Laws for Ad Hoc Wireless Networks: An Information Theoretic Approach,” FnT in Networking, vol. 1, no. 2

L. Georgiadis, M. J. Neely, and L. Tassiulas, “Resource Allocation and Cross-Layer Control in Wireless Networks,” FnT in Networking, vol. 1, no. 1

A. M. Tulino and S. Verdu, “Random Matrix Theory and Wireless Communications,” FnT in Communications and Information Theory, vol. 1, no. 1

M. J. Wainwright and M. I. Jordan, “Graphical Models, Exponential Families, and Variational Inference,” FnT in Machine Learning, vol. 1, no. 1-2

Information and Communication Theory

D. J. C. MacKay, “Information Theory, Inference, and Learning Algorithms”

M. Mezard and A. Montanari, “Information, Physics, and Computation”

C. E. Shannon, “A Mathematical Theory of Communication”

D. Tse and P. Viswanath, “Fundamentals of Wireless Communication”

Networking Theory

M. Bramson, “Stability of Queueing Networks”

B. Hajek, “Analysis of Computer Networks” (Notes for ECE567)

V. B. Iversen, “Teletraffic Engineering Handbook”

F. P. Kelly, “Reversibility and Stochastic Networks”

S. P. Meyn, “Control Techniques for Complex Networks”

Game Theory

L. Buttyan and J.-P. Hubaux, “Security and Cooperation in Wireless Networks”

“Algorithmic Game Theory,” Edited by N. Nisan, T. Roughgarden, E. Tardos, and V. Vazirani (Errata)

Y. Shoham and K. Leyton-Brown, “Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations”

Probability, Random Processes, and Queueing Theory

I. Adan and J. Resing, “Queueing Theory”

D. Aldous and J. A. Fill, “Reversible Markov Chains and Random Walks on Graphs”

L. Devroye, “Non-Uniform Random Variate Generation”

R. M. Gray, “Probability, Random Processes, and Ergodic Properties”

R. M. Gray and L. D. Davisson, “Introduction to Statistical Signal Processing”

C. Grinstead and J. L. Snell, “Introduction to Probability”

B. Hajek, “An Exploration of Random Processes for Engineers” (Notes for ECE534)

D. A. Levin, Y. Peres, and E. L. Wilmer, “Markov Chains and Mixing Times”

R. Lyons and Y. Peres, “Probability on Trees and Networks”

S. P. Meyn and R. L. Tweedie, “Markov Chains and Stochastic Stability”

D. Pollard, “Convergence of Stochastic Processes”

W. Whitt, “Stochastic-Process Limits”

FREE online books on Queueing Theory, Probability and Stochastic Processes

Optimization

S. Boyd and L. Vandenberghe, “Convex Optimization”

A. Schrijver, “A Course in Combinatorial Optimization”

P. Varaiya, “Lecture Notes on Optimization”

Control Theory

D. P. Bertsekas and S. E. Shreve, “Stochastic Optimal Control: The Discrete-Time Case”

L. C. Evans, “An Introduction to Mathematical Optimal Control Theory”

E. D. Sontag, “Mathematical Control Theory: Deterministic Finite Dimensional Systems”

Graph Theory

J. A. Bondy and U. S. R. Murty, “Graph Theory with Applications”

R. Diestel, “Graph Theory”

Machine Learning

T. Hastie, R. Tibshirani, and J. Friedman, “The Elements of Statistical Learning: Data Mining, Inference, and Prediction”

D. Michie, D. J. Spiegelhalter, and C. C. Taylor (eds), “Machine Learning, Neural and Statistical Classification”

N. J. Nilsson, “Introduction to Machine Learning”

A. Rajaraman and J. D. Ullman, “Mining of Massive Datasets”

Algorithms & Complexity

S. Arora and B. Barak, “Computational Complexity: A Modern Approach”

S. Dasgupta, C. H. Papadimitriou, and U.V. Vazirani, “Algorithms”

J. Erickson, “Algorithms Course Materials”

O. Goldreich, “Computational Complexity: A Conceptual Perspective”

O. Goldreich, “P, NP, and NP-Completeness: The Basics of Complexity Theory”

R. Kannan and S. Vempala, “Spectral Algorithms”

H. Wilf, “Algorithms and Complexity”

D. P. Williamson and D. B. Shmoys, “The Design of Approximation Algorithms”

Misc.

D. P. Bertsekas and J. N. Tsitsiklis, “Parallel and Distributed Computation: Numerical Methods”

D. J. C. MacKay, “Sustainable Energy - without the hot air”

A. J. Menezes, P. C. van Oorschot, and S. A. Vanstone, “Handbook of Applied Cryptography”

Y. Saad, “Iterative Methods for Sparse Linear Systems” (1st edition)

R. Szeliski, “Computer Vision: Algorithms and Applications”

How to get your papers accepted (ZZ)

2012-05-15T14:09:00.003-07:00

http://matt-welsh.blogspot.com/2009/12/how-to-get-your-papers-accepted.html

Giving Technical Talks (zz)

2012-05-15T14:09:00.001-07:00

http://www.cs.dartmouth.edu/~scot/givingTalks/

802.11n CSI Tool

2012-04-17T13:30:00.002-07:00

http://dhalperi.github.com/linux-80211n-csitool/installation.html

Apple IOS development

2012-04-09T14:07:00.001-07:00

Apple development: (1) Learn Object-C (2) IPad&Iphone Tutorial