RF Transceiver using the MRF49XA

Transceiver breakout boards

I'm just finishing up my last class ever!!! (for credit, anyway.) It was a really fun, mostly because I decided to have fun with my last class, and make it a 4/5 (undergrad/graduate). This meant that it was much easier and less theory-heavy than those that I'm used to. Anyway, as a grad student, I was expected to do something extra, and I decided to make a RF transceiver module. I looked around for a little while, and I settled on the Microchip MRF49XA. In general, it's a nice chip. It has about the same capability as the Micrel MICRF6xx modules that I've used in the past. The Micrel modules cost $20/ea. and the Microchip IC is around $3. I was able to make the whole breakout board for the MRF49XA for less than the Micrel module alone. One of these days, I should dig out my notes from the Micrel project and post them, but I digress. I noticed a distinct lack of programming information using the MRF49XA, so I'm posting not only my schematic and PCB, but the software library I wrote for the Atmel AVRmega.

Breakout board schematic

The schematic I created for the breakout board is, in large part, copied from the reference schematic from the datasheet. There are a few parts that make up the complete schematic, including power regulation, microcontroller interface, RF balun, and the IC. Everything but the balun is really easy to understand; the power input can be +5 volts or more (probably up to about 14 volts) while using the LM317, or if the LM317 is omitted, +3.3 volts. The MRF49XA is really a 3.3 volt part, and expects 3.3 volt I/0. Originally, and on the PCB I had made, I had 2 ground pins. Since then I realized it would be useful to output regulated 3.3 volt output, so I changed one of the grounds for that. The only other major portion of the circuit is the balun. This is used to transform the balanced RF input/output from the IC to the unbalanced antenna connector. This circuit also provides power to the RF power amplifier inside the IC.

Breakout board top

The PCB designed from the schematic is also fairly straight-forward. A few things are worth noting, however. I've added some silkscreen between 2 of the pins on the LM317. These are to indicate where you could jumper if the breakout board is supplied with regulated power. I used a 0805 0-ohm resistor(see the image below). The voltage output of the LM317 is selected with R1 and R2. I decided not to include the "stop" layer on this image so as to not clutter it, but near the word "Fence" there is a strip without solder mask over the vias. If you wanted to isolate the RF from the outside, you could build a fence out of copper foil (or something). The Antenna connector is an end-launch SMA, though it could also be raw coax if you want to save some money.

Close up

The only pins necessary for complete functioning of the device are the standard SPI set (MOSI, MISO, SCK, !CS), and IRO (interrupt request out). The IRO pin is not strictly necessary, but strongly recommended. The MRF module uses the IRO pin to notify the microcontroller of a few time-sensitive events, such as FIFO full/empty conditions.

MCU interface while transmitting

The diagram included above (from the MRF49XA datasheet) provides a useful overview for the transmitting process. The take-away message is that you first send the "Transmit data enable" TXDEN command, which loads 0xAAAA into the transmit FIFO. You can either leave this in there, as a preamble, or replace it with data of your choice. Then, you send the "Transmit carrier enable" TXCEN command. At this point, the PLL starts, and the PA turns on, then transmission starts. When the first full byte leaves the FIFO the IRO asserts. Hopefully, this forces the MCU to jump to your interrupt service routine. Once there, if the CS pin is held low, the MRF will bring SDO (MISO) high. This is a clear signal that the FIFO needs attention. You can continue this process for as long as you have data. Once you're done, you need to load a "dummy byte" into the FIFO so your last data byte makes it out. Finally, on the next interrupt, shut down the transmitter by setting TXCEN and TXDEN to 0.

Receiving FIFO usage

This diagram illustrates another detail of the interface to the MRF, also borrowed from the datasheet. It describes the way to access the receive FIFO using SPI. Typically, SPI interfaces don't have a notion of registers quite like I2C does. The MRF is an exception to this general rule. To get access to the receive FIFO you initiate an SPI transfer to the MRF module with the contents equal to the address of the receive FIFO. In this case it's 0xA000. Once the first byte of the transfer is complete, the MRF begins outputting the FIFO value on the SDO pin. It is also possible to gain access to the receive FIFO using FSEL (FIFO Select, called "Data" on the schematic) pin.

Baseband Bandwidth calculation

Before going into some details on the implementation of the library, I'd like to talk briefly about the RF frequency, deviation, and bit rate determination. I've attached another snippet from the datasheet (hopefully the last one), and I'm going to go through the math quickly with numbers for my application. I'musing 434 Mhz band, with 9600 baud, using a 10ppm crystal. This means that \(f_{xerror} = 10 * \frac{434000}{1000000} = 4.34 Khz\). Then, our deviation must be \(9.6 +2*f_{xerror} + 10 = 28.28\); the closest modulation is 30 Khz. Therefore, \(BBBW =30*2 - 10 = 50Khz\). The closest BBBW is 67 Khz.

Spectrum plot from alternating 1s and0s

I recently gained access to a spectrum analyzer courtesy of the OSU Robotics Club. This is a spectrum plot of 0xAA, or alternating 1′s and 0′s. It's a little strange that the distance between peaks is about 90 Khz, as it should be more like 60 Khz. The comb-like appearance on the flanks is due to the transceiver switching from 1 to 0 across the scan.

Transmitting '1'

This plot is while transmitting all 1′s. It's obvious this is much cleaner, but very little information is actually being transmitted here.

With respect to the Atmel AVR library that I wrote, it includes a header file devoted entirely to defining the registers and bits as defined in the datasheet. Each section includes a comment block description, and in the cases where some bit values need to be calculated, the equations used. On the occasions where a bitfield is used for some integer value, I include a mask to ensure that if the derived values overrun the width of the bitfield they don't pollute unrelated settings. Below, I've included an example.

/******************************************************************************
 * Convenience definitions for band setting   
 *   
 * These defines are provided for use configuring the MRF49XA module.
 * Select the frequency band for the given hardware by uncommenting the
 * appropriate line. Set the crystal load capacitance using the MRF_XTAL_LD_CAP
 * value.
 *
 * The load capacitance is given by the following equation:
 *
 * Cap pF = 8.5 + (LCS / 2)
 * LCS = (10 - 8.5) * 2
 *
 * For 10pF: LCS = (10 - 8.5) * 2 = 1.5 * 2 = 3
 *****************************************************************************/
#pragma mark General Configuration Register
#define MRF_GENCREG    0x8000  // General config. register
#define MRF_TXDEN      0x0080  // TX Data Register enable bit
#define MRF_FIFOEN     0x0040  // FIFO enable bit
#define MRF_FBS_MASK   0x0030  // Mask for the band selection
#define MRF_LCS_MASK   0x000F  // Load capacitance mask

// 10pF Crystal load capacitance
#define MRF_LCS        3       // Crystal Load capacitance

// Frequency band settings
#define MRF_FBS_434    0x0010  // 434 MHz band
#define MRF_FBS_868    0x0020  // 868 MHz band
#define MRF_FBS_915    0x0030  // 915 MHz band

All of the files in the library depend on a "hardware.h" file that defines the qualities of the hardware. The hope is that this file is the only place that implementation-specific code lives. There are some holes still, however. Finally, the "mrf49xa.c" and "mrf49xa.h" files behave the way you would expect. The module requires a total of 5 pins and one interrupt. Some of those pins may be shared with other SPI devices.

void     MRF_init(void);
uint8_t  MRF_is_idle();
uint16_t MRF_statusRead(void);

// the maximum payload size
#define MRF_PAYLOAD_LEN 40

// Space for preamble, sync, length and dummy
#define MRF_TX_PACKET_LEN MRF_PAYLOAD_LEN + 5

typedef struct {
    	uint8_t length;
    	char    payload[MRF_PAYLOAD_LEN];
} MRF_packet_t;

// Packet based functions
void MRF_transmit_packet(MRF_packet_t *packet);
MRF_packet_t* MRF_receive_packet();

I've included a snippet of the header file above so I could mention the basic process for using the MRF module. The MRF_init function expects the SPI bus to be configured, and it performs the basic initialization of the device. Once it's started, the interrupts on the AVR must be enabled. In the main loop (or at least as often as a packet can be transmitted) you should call MRF_receive_packet. This function will return NULL if no packet was received, and a pointer to a packet structure if it was. MRF_transmit_packet takes a packet structure and transmits it. This is an asynchronous operation, and you may use the packet structure (or its memory) once it returns. This is useful if you want to use a packet structure created on the stack. It is possible to get yourself into trouble with MRF_packet_transmit, as it spin-loops on a lock set in the ISR. If, for whatever reason, that lock isn't unlocked at some point you can hard lock. I've done my best to ensure that it doesn't happen, but beware.

And, finally, links to the files. If there seems to be sufficient interest,I'll open up a SVN (maybe Google Code, who knows) with these files and a main program useful for telemetry and the like. Post in the comments if you're interested, or send me a line.

hardware.h

MRF49XA_definitions.h

MRF49XA.c

MRF49XA.h

spi.h

spi.c

Also, the PCB is available as a public design from BatchPCB. I'll include a bill of materials if necessary, though the components are clearly printed on the silkscreen.

Oh! before you ask: No, I don't know what the range is. The longest I've tried is about 20 feet, and there weren't any errors, but it was only about 100bytes. The chip is rated to 7dBm, I think, so go from there.

Update:

Here is a simple bill of materials, I used the Eagle export feature, and attempted to place digikey part numbers for each part. I'm not saying they're all right, you may want to make sure you're getting what you think is correct.

partlist.txt

Also, here are the eagle files. They aren't necessarily finalized

eagle_files.zip