The NetRadio project uses a Texas Instruments CC3200 WiFi-enabled ARM microcontroller as its central brain. All firmware development was done on a Launchpad (http://www.ti.com/tool/CC3200-LAUNCHXL). Basically, the “rest” of the radio hardware (power, DAC, amplifier) was developed as a BoosterPack board, to which the launchpad was connected. However, the hardware development would not be complete without a dedicated board for the MCU.
TI offers a “module” version of the CC3200 (http://www.ti.com/product/CC3200MOD) that makes it much easier to integrate the CC3200 into a custom board. This module includes not only a CC3200, but also all the passives needed to boot the processor and make it run at 80MHz. The module has a few limitations compared to the “bare” CC3200, mostly due to a smaller number of external pins, but this is easily offset by the fact that it is so much easier to work with.
For the NetRadio, only one pin had to be rerouted to a different one to make the firmware work with the CC3200MOD instead of the CC3200 on the launchpad, showing that is not so hard to go from the CC3200 launchpad to the CC3200MOD.
Starting out, it’s easiest if the board can be used directly in place of the launchpad, with no other hardware modifications. After substituting the LaunchPad with the new board, if anything doesn’t work like before, we know it’s caused by the new board, and not by any of the other hardware changes. For this reason, I decided to use the BoosterPack connectors for interfacing with the microcontroller.
The board itself is kept simple: the UART programming pins, the SOP2 pin, and the JTAG pins are broken out as single-function pins, i.e. we don’t take into account the other possible functions of these pins, and provide no provision for using them differently. The board also has a LED that can be used to test basic functionality (using a “blinky” type program).
As indicated, the board follows the same 40-pin BoosterPack standard as the CC3200 launchpad, except that certain pins are not broken out. There are 26 usable pins from the CC3200MOD on the BoosterPack connectors, so that still leaves a lot of potential for connectivity.
Power is taken from the BoosterPack 3.3V and GND pins (P1.1, P2.1/P3.2). The board includes a 100-220µF capacitor as a “power buffer”, and a 100nF decoupling capacitor for each of the three 3.3V pins on the CC3200MOD.
Power can also be supplied from the UART header. This is intended to be able to flash the board without having to power the system in which the board is used, or to be able to flash the board out-of-system.
The board includes a reset button.
The board has a u.FL connector to connect an antenna; there is no chip antenna on the board itself.
The board breaks out SOP2, to enable flashing the CC3200MOD.
The board breaks out the RX and TX connections for UART0. These are used for flashing the CC3200MOD. The pins on the CC3200MOD are pins 46 (GPIO1) and 47 (GPIO2). Because these pins are in fact GPIO pins, they could be used as such, however on this board, they are not routed to the BoosterPack connector. GPIO1 and GPIO2 on the CC3200MOD correspond to PIN_55 and PIN_57 on the CC3200, respectively. On the launchpad, these are routed to P2.9 and P3.3; on this board, P2.9 and P3.3 are not connected.
The board breaks out the JTAG connections (TCK, TDI, TDO, TMS). These pins are not routed to the BoosterPack connectors, meaning that CC3200 pins PIN_16, PIN17, PIN19 and PIN20 are not available for use as GPIOs. On the BoosterPack connector, P4.9 and P4.10 are not connected.
A LED is connected to GPIO10. This can be used to test the functionality of the board. The LED can be left unconnected by not populating R4 and/or R5.
This is the BoosterPack standard:
The following connections are available. The PIN_xy notation in this table corresponds to the “device pin no” column in the “Pin assignments” table (table 3.1) on p.8 of the CC3200MOD datasheet (http://www.ti.com/lit/ds/symlink/cc3200mod.pdf).
The following connections are not routed to the BoosterPack headers on the CC3200MOD board:
- P2.4 (PIN_45; not available on CC3200MOD)
- P2.8 (PIN_21; SOP2 on CC3200MOD; PIN59 can optionally be routed to pin 2.8, by populating R7)
- P2.9 (PIN_55; reserved for flashing)
- P3.1 (5V; no 5V available)
- P3.3 (PIN_57; reserved for flashing)
- P4.1 (PIN_29; antenna selection control)
- P4.3 (PIN_17; reserved for JTAG)
- P4.5 (PIN_51; not available on CC3200MOD)
- P4.9 (PIN_16; reserved for JTAG)
- P4.10 (PIN_17; reserved for JTAG)
The board takes its 3.3V power and GND from the BoosterPack connector (P1.1 and P3.2). Alternatively, in revision 2, it can also be powered from the UART header to enable usage and flashing from the LaunchPad emulator.
Flashing the CC3200MOD on the board is done through UART0, by booting up with SOP2 connected (like the Launchpad). The easiest way to do this, is by using an actual Launchpad, and connecting J6 (RX), J7 (TX) and GND to the respective UART pins on the board. Removing the jumpers from J6 and J7 on the LaunchPad disconnects the emulator on the LaunchPad from the on-board CC3200, and connects it to the CC3200MOD breakout board instead.
RX = grey; TX = white; GND = black.
In order to flash a program, make the connections described above,
place the SOP2 jumper, and press the reset button to put the
microcontroller in flash mode. Then, running the following command
will flash the
blinky program to the CC3200 breakout:
cc3200tool -p /dev/cu.usbserial-cc3101B --reset prompt write_file blinky.bin /sys/mcuimg.bin
After removing the SOP2 jumper and pressing reset, the LED on the breakout should start to blink.
(See CC3200 cheat sheet for more details on flashing and debugging.)
This is the first attempt to make a board with the CC3200MOD:
After figuring out that the footprint for the reset switch was rotated, the board started working fine. The reset switch is located in the top right; as you can see in the picture, the switch is mounted sideways to accommodate this error. Initially, the rotated switch caused the reset pin to be permanently pulled to GND, keeping the CC3200MOD in reset state and preventing it from booting. Mounting the switch sideways worked around this.
Apart from this error, there were a few other things that bothered me:
This revision of the board has to be powered with 3.3V from the BoosterPack pins; a 3.3V connection to the emulator is missing. This means the board cannot be easily powered from the emulator for flashing. Exposing a 3.3V pin in the UART header would make that possible.
According to the CC3200MOD datasheet, an RF bandpass filter is included in the module. I did some tests with a small application that simply dumps all visible WiFi network SSIDs and their RSSI values. This tests showed that there is no real difference in reception strength with or without the external bandpass filter.
The zero ohm resistor R4 is really not needed; just not populating R5 has the same effect as not populating R4. It can be left off.
The second iteration fixes these things and some more:
Changes on top of the ones mentioned above:
A 100K pull-down resistor was added for SOP1. The board seems to work fine without it, but the datasheet recommends it. I’ll assume it helps with stability.
The through-hole 220µF capacitor is replaced with SMD pads for a 100µF capacitor. The only through-hole parts left on the board are the headers and reset switch.
The antenna trace was straightened. Since I was touching the layout of this trace to remove the bandpass filter, I could just as well update it to be straight as well.
The first test program for the CC3200MOD breakout board is a simple blinky program that blinks the LED on the board. In fact, the CC3200 SDK contains a blinky example, that we can use out of the box.
The program is located in cc3200-sdk/examples/blinky. It is compiled with arm-none-eabi-gcc, using the GCC configuration files (link script) in the gcc subdirectory of the blinky example.
The references below link to a precompiled version of the blinky program.
The second test program for the CC3200MOD breakout board dumps WiFi network names and signal strengths on the UART. (Use screen /dev/<device-id> 115200 to see the UART output.) The original purpose of this program was to compare signal strengths for different configurations of the antenna section (with/without external RF filter, with/without pigtail antenna).
The output of this program looks like this:
Welcome to CC3200 signal strength dumper Starting... -- network: ssid: <network name> bssid: <network identifier> rssi: <network strength> security:<network security> -- network: ...
It lists all networks the CC3200MOD can see, one – network: section for each visible WiFi network.
The source code for the cc3200-signalstrength program is here:
A precompiled binary is linked below in the references.
References and files
- CC3200 cheat sheet
- The KiCad 5 project files:
- The Gerber files generated by KiCad:
- The blinky test program:
- The arm-none-eabi-gcc compiler and linker can be found here:
- The cc3200-signalstrength program: