A New Webstore

Today marks the close of the old NJC's MSP430 Store. The old system which was based on PayPal buttons was very difficult to use and did not lend itself to an aesthetic and functional store. Although the old store has been removed, a new store is ready to go on my other website, Hardware Breakout.

The blog on Hardware Breakout has a long way to go before it is finished, but the Hardware Breakout Webstore is complete! All of the products that you could purchase from the old webstore you will find at Hardware Breakout, except for the DEV.BO which has been discontinued. There are also many new products and breakout boards which I hope you all will love.

Please note there has been one big change, shipping is no longer free on order below $5 USD. For most of you, this will  not be an issue. Please read the Hardware Breakout Store shipping policy for more information. If you experience any problems with the new store or have any comments, please send me an email or leave a comment.

Using a Nokia LCD Library

SparkFun sells a great, low-cost, yet easy to use LCD display breakout board for the Nokia 5110 display. This LCD is perfect for any which requires a user interface. When I made the decision to build a reflow toaster oven, I also decided that I wanted to be able to view the oven's progress on a small display. This post supports the series I am writing about on HardwareBreakout.com which discusses building your own toaster oven "reflow oven".

This specific display has been used in many projects on many different microcontrollers, such as the Arduino. This means that there is already ample information out there on this LCD including libraries written for many different microcontrollers. Since reinventing the wheel is usually a bad idea, this post will discuss using an existing library for the MSP430 to meet our toaster oven needs.

Requirements

My goal for this project is to display real-time information on the reflow process. This includes the current temperature in the toaster oven, the temperature the toaster oven should be at, the current zone the oven is in (e.g. cooldown, reflow, preheat), and how long the process has been going on for. Given that all of the information I would like to display is text based, implementation is fairly straight forward.

There are many libraries written specifically for the MSP430 that interface with this display.

• RobG's Nokia 5110 display code
• Nokia 5110 C++ Template Class
• Volt/Amp/Watt meter

These are just three of the many libraries which can be found for the MSP430. For this post, I have decided to use RobG's Nokia 5110 as it uses the hardware SPI rather than a software SPI.

It is VERY important to give credit where credit is due. If you use someone else's code, always include comments in your code linking to the original author. It is great that we have such an awesome community, where code is shared freely.

The Nokia LCD

While it is not necessary to understand how the LCD works when using a fully functioning library, it can still be beneficial if you need to modify the library or if you run into problems with your project. The first step in figuring out how the Nokia 5110 works is to take a look at the datasheet.

Shows how each pixel is organized in DRAM. Image taken from the Nokia 5110 Datasheet

The above image shows how each pixel on the screen is organized. There are a total of 84x48 pixels, these pixels are organized into 6 horizontal banks (zero through five), and 84 columns. Each bank contains 8 pixels, which sum up to a total of 48 rows.

Shows how each byte in RAM relates to each pixels on the display. Image taken from the Nokia 5110 Datasheet

The above image shows how the RAM will map to a given pixel in the display. This image shows the whole display, with each row representing one bank. One byte in memory stores the data for each column in a given bank; this makes sense considering there are 8 rows of pixels in each bank.

Given that we are strictly displaying text on the screen using RobG's code, we do not really need to know any of this. That being said, understanding how the memory is mapped to the display is very important if you will be creating your own graphics or characters.

Creating an LCD Project in CCS

Since I prefer Code Composer Studio (CCS) over the other methods for programming the MSP430, I will quickly discuss how to use someone else's code in your projects.

The first step is to create a new project for your specific device, for this example I am using the MSP430G2553. While you can import any file to your project, I prefer to just copy and paste the code when using code posted online. For RobG's code you need to create one new file, "PCD8544.h" and copy his code directly into it. The simplest way to start with his library is to also copy his "main.c" and modify it for your project.

While it is possible to change some of the pin assignments around, be careful. Some of the pins need to stay where they are because they are special SPI pins built into the USCIB interface (in the MSP430G2553). To use this library in its most basic form, three functions are needed.

• clearBank(bank) - Clears an entire line on the LCD display and sets the current location to the beginning of the line.
• writeStringToLCD(string) - Write a string to the LCD in the current location.
• writeCharToLCD(char) - Write a character to the LCD in the current location.

In addition to RobB's code I will be using the printf code which I discussed in my previous post. This allows us to display the content of our variables on the LCD display, for example the current temperature of the toaster oven. To use printf, you have to copy the printf.c file into your project and then create the following two functions in your main.c file. By using these functions, the output of printf is displayed on the LCD.

 /**  
  * puts() is used by printf() to display or send a string.. This function  
  *   determines where printf prints to. For this case it outputs a string  
  *   to a LCD, another option could be to send the string out via UART.  
  **/  
 void puts(char *s) {  
   writeStringToLCD(s);  
 }  
 /**  
  * puts() is used by printf() to display or send a character. This function  
  *   determines where printf prints to. For this case it outputs a  
  *   character to a LCD.  
  **/  
 void putc(unsigned b) {  
   writeCharToLCD(b);  
 }  

Code Snippet

The code below is a snippet from my project. This is just a quick example of using RobG's code with my project. I call this function whenever I want to display the current status of the toaster oven on the display. The variables it uses are global variables which will be updated as the program runs. I only call this function when a value is changed, so that the display is not updated unnecessarily. 

 void updateStatus() {  
   
      clearBank(0);               // Line 0 shows current temperature  
      printf("Current: ");  
      printf("%u", currentTemp);  
      writeCharToLCD(0x7f);     // Degree symbol  
      writeStringToLCD("C");  
      clearBank(1);               // Line 1 is empty  
   
      clearBank(2);               // Line 2 shows the desired temperature  
      writeStringToLCD("Desired: ");  
      printf("%u", desiredTemp);  
      writeCharToLCD(0x7f);     // Degree symbol  
      writeStringToLCD("C");  
      clearBank(3);               // Line 3 is empty  
   
      clearBank(4);               // Line 4 shows which zone the oven is in  
      printf("Zone: ");  
      writeStringToLCD(zoneString[zoneIndex]);  
      if (heatOn)                    // Line 4 includes an asterisk when the  
           printf("*");          // heating elements are on  
   
      clearBank(5);               // Line 5 shows the time the toaster oven   
      printf("Time: ");          // has been running  
      if (minutes < 10)          // Make sure there are always two digits  
           printf("0");  
      printf("%u:", minutes);  
   
      if (seconds < 10)          // Make sure there are always two digits  
           printf("0");  
      printf("%u", seconds);  
 }  
   

Conclusion

Overall, integrating RobG's library into my project was very simple. It went without a hitch. Modifying his code for custom characters is also fairly straight forward. I hope this post helped shed some light on how the Nokia 5110 display works. It has never been easier to use such a cool display in your projects. This post supports my series on Hardware Breakout which discusses building a toaster oven "reflow oven".

Leave a comment and post links of your projects using the Nokia 5110!

printf() for the MSP430

"The output function printf translates internal values to characters."

This simple definition comes from the book "C Programming Language" by Kernighan and Ritchie. I highly recommend this book to anyone who is interested in learning more about C, it is a must have for any embedded programmer.

The printf() function will allow us to display any value in your code so that it is human readable. What does this mean? Let's say you would like to tell the computer what temperature your MSP430 has measured; a typical output might be "Temperature: 71°F". We know how to read the internal temperature from a previous post, but how do we get our MSP430 to output the above string over UART? We use the printf() function.

printf("Temperature: %u°F\r\n", tempValue);

I will not be explaining how printf() actually works in this post. If you would like more information on how to use this function please see the above mentioned book, or this link. Due to the fact that the MSP430 has limited resources (e.g. memory), a compact version of the standard printf() function must be used.

Since the printf() included in Code Composed Studio is very large and will not fit on many of the value line MSP430s, we must add our own printf() function to our projects. oPossum on the 43oh.com forums has shared his printf() with the community and since reinventing the wheel is rarely a good idea, we will be using oPossum's code.

"This is a tiny printf() function that can be used with the chips that come with the Launchpad. Code size is about 640 bytes with CCS."

This is how oPossum describes his function. While this function does not support all of the standard printf() features, it is more than sufficient for use on an MSP430. Using this function, we can format 7 separate data types: character, string, integer, unsigned integer, long, unsigned long, and hexadecimal (16-bit) formatting.

I want to thank oPossum for sharing his code with the community. The code is very well written and works great! Thanks again!

Code

Please scroll down for the rest of the post. One of these days I will figure out how to limit the height of my embedded code.


Customizing the Output

Depending on your project, you will want to have printf() output differently. For this example, printf() will send the formatted string out over the UART to a computer. For a different project, you might want to output the string to an LCD, or through USB. The code provided from oPossum allows you to define two functions, puts() and putc() which determines how printf() will output the formatted string. Without defining these two functions, the printf() will actually not do a thing. printf() uses puts(char *) to send out a string value, and uses putc(unsigned) to send out a character.

In the code above, my puts(char *) and putc(unsigned) functions sends the string and character out over UART using another of my functions, sendByte(unsigned char). The code in these functions is fairly straight forward, and will not be discussed here. If you would like to another output for printf(), you would create your own puts(char *) and putc(unsigned) functions as I have done in the code above.

Testing the printf() Function

I will be using a very similar setup as oPossum for testing the printf() function. The code above will send a test sequence to the computer when the MSP430 receives the character 't' over UART. I recommend using Realterm for interfacing with the MSP430 over UART. To connect, select the correct COM port and set the baud rate to 9600. Once connected, send the character 't' by clicking on the blank window and typing 't'. You should see the following response from the MSP430.

Test sequence from the MSP430

Conclusion

Use this code in your projects! It really is a great piece of code. To use this printf() function to your own CCS projects, just add printf.c to your project and create your own puts(char *) and putc(unsigned) in your main c file as I have done in this example.

In the next post, I will expand on the previous post by creating a real-time clock using the MSP430. Stay tuned!

Using ACLK and the 32kHz Crystal

The other day I decided to build a timer to control some lights in my apartment. As I hope to expand this mini project into a full-fledged home automation system built around the CC430, a simple light timer from Walmart would not do! Obviously, the LaunchPad is the perfect tool for the job.

For example, let's say that I wanted to keep my lights on for 5 hours at night while I am on vacation. The first thing you will need is a way to tell time; this requires some sort of real-time clock. Since the high frequency clock sources on the MSP430 are not accurate enough to keep reliable time over a large period of time (anything greater than 1 minute in my opinion), a lower frequency clock will be needed. Though many of the newer MSP430s have built in 32kHz clocks, such as the the MSP430F5510, the value line series does not!

The 32.768kHz Crystal

The first step for building this project is to install the 32.768kHz crystal onto the LaunchPad. From this point onward I will just be calling this 32kHz for simplicity. You might be wondering why a real time clock is based on 32.768kHz; 32768 is exactly 2^15. This number can be divided down using binary values to give you a frequency of 1Hz, or a period of 1 second. This is why 32kHz is the standard frequency used in real-time clocks.

The above image shows the crystal soldered onto my LaunchPad. There are many methods you can use to solder this on, one of which is nicely documented on Justin's Tech blog. I ended up soldering the base of the crystal first, ensuring that the clock was positioned correctly before I soldered the small leads. Use any method that works for you.

The LED Hello World

The first thing you should do once you have this soldered onto your board, is test it. Making sure that everything works before you start a complicated project is very important. Let's make an LED turn on every two seconds, for one second. Instead of changing the timer output pins directly as we did in an earlier post, lets blink the LED manually so that we can easily expand the functionality of this program in a future post. There are a few things you should notice in the code below.

In this code we divide the clock by 64 (lines 26 and 37) which causes the timer to increment 512 times a second (512Hz). Once the clock counts up to 512 511 (this is because we start counting at 0), one second has gone by, and an interrupt is thrown. Now that we are entering an interrupt routine instead of automatically toggling the output, we can use this interrupt routine in the future to expand the functionality of this code.

The last important line of code is line 27, where a capacitance value is set. This value matches the capacitors that come installed on your LaunchPad. In the next section, I will elaborate slightly on what this capacitance is.

Edit: This statement is actually incorrect. A big thank you goes out to Jens-Michael Gross for pointing it out to me.

"The capacitance setting is an internal switch that enables some silicon capacitors on the MSP die. The selection has to match the required load capacitance of the used watch crystal. You can set it to minimum (plain parasitic pin capacitance) and apply external capacitors of the proper value, if you want. However, the available options are sufficient for the most watch crystals, so external capacitors are unnecessary, even counterproductive. And external capacitors have a large tolerance that affects the crystal frequency. The LaunchPad I just got has no capacitors installed (the C21 and C22 pads are empty, as it should be if the XCAP options are used."

Custom Design

One thing I wanted to mention before this post comes to a close, is how you can take this design off the LaunchPad and make it your own. Many projects work out so well that you just want to create a PCB or make it permanent in some other way.

Working with crystals can be tricky for beginners, as there is one thing you must look out for. All crystals require a load capacitance to remain stable, Wikipedia (Pierce Oscillator) and Texas Instruments both have some quality information on the topic. The value of these two capacitors depend on which crystal you use. Even two crystals with the same frequency which are made by the same manufacture might require different load capacitor values. Please check the crystal's datasheet for this information. For example, the LaunchPad uses 12pF capacitors to load the crystal we just installed, yet many crystals require 22pF.

Edit: This statement is actually incorrect. Another big thank you goes out to Jens-Michael for pointing it out to me. Thanks for reading!

"12pF is the typical load for most crystals I've ever seen. But due to the electric connection, a 12pF load means [there will be 2] 24pF capacitance on each of the crystals sides. Reason is that (seen from the crystal), the two capacitors are in series to each other and parallel to the crystal. […] Subtract the ~2pF pin capacitance of the MSPs pins and you get [two separate] 22pF [for] external capacitors, resulting in 12pF load. The XCAP settings already include pin capacitance and the /2 factor."

A bit more information and great advice from Jens-Michael!

"Experiments have shown that the G devices (in opposition to the AFE2x and some other x2 family devices without HFXT1 input) will accept a high-frequency TTL clock signal (e.g. from a self-oscillating quartz oscillator) on the XTIN pin, when in bypass mode. The Datasheet limits external clock to 50kHz, but there were no problems with 16MHz."

Conclusion

As you can see by the following screenshot from my oscilloscope, this timer is pretty darn accurate.

Hopefully you enjoyed this post and found it informative. I am going to try to keep things a bit more bite-sized from now on. Let me know what you think.

Post links to your projects which use the ACLK or the 32kHz crystal in the comment section below!

Programming the DEV.BO and External Targets with a LaunchPad

Many readers have been asking me how to program the DEV.BO with the LaunchPad. Likewise, many of you are also wondering how to program the newer MSP430 microcontrollers with the LaunchPad, such as the MSP430F55xx series.

Since this seems to have sparked quite a bit of confusion, I want to make this post complete and thorough. There are two ways to program an MSP430: the first is using four-wire JTAG, the second is using two-wire JTAG. The LaunchPad can only use the two-wire JTAG method, which is also known as Spy-Bi-Wire (SBW). For the rest of this post, I will be referring to the two-wire JTAG as SBW and four-wire JTAG as just JTAG.

I want to make sure this is clear before I continue; JTAG and SBW are two separate methods for programming an MSP430. The LaunchPad can program MSP430s using SBW, not JTAG. That being said, not all MSP430s can be programmed using SBW, some of the older MSP430s can only be programmed using JTAG. TI has a document, SLAU157, which shows which chips support either just JTAG or both JTAG and SBW.

Now that we know JTAG and SBW are different methods of programming newer MSP430s, how do we use the LaunchPad to program all these cool devices? Spy-Bi-Wire needs two wires to program an MSP430: RST and TEST. The image below shows where you can find these two pins on the Launchpad.

The programming pins on the LaunchPad

The RST pin is shown by a yellow square, TEST is shown by a green square, and all of the GND pins are shown by blue squares. What about power? Well, you can either use the LaunchPad to power the DEV.BO (or your target MSP430 that supports SBW) or use an external power source. Regardless of how you power the target, you will need to also connect the LaunchPad's GND pin to the target. This is because you need a common reference for the data pins (RST and TEST); so technically you actually need a minimum of three wires to program an MSP430.

DEV.BO programming header

For this post we will use the LaunchPad to not only program the DEV.BO, but to also power it during programming. The image above shows which signals make up the programming header on the DEV.BO. There is a reason that I designed the programming header pins in that order. They are the same order as the LaunchPad; this is very important. What about the GND pin on the LaunchPad? Though there is no GND pin on the programming header, the LaunchPad does have a few GND pins available on board. Depending on what you have to connect the boards together, determines which GND you should choose.

The programming connection on the LaunchPad's side

The image above shows how I connect the DEV.BOs header to the LaunchPad. That nice six pin rainbow connector is available here at SparkFun and it works great for this task. Notice how I am using female connectors on this LaunchPad which makes it easy for me to connect GND to the rainbow connector using just a short breadboard wire. If you don't have access to this nice rainbow ribbon cable, you can use any method to connect these pins together.

Hopefully that should clear up any confusion on how to program the DEV.BO. Using this method, you can also program any other MSP430 that supports SBW; just connect up the necessary pins and you can program away.

I have two last things I want to mention. The RXD and TXD pins are not needed for programming but I included them on the DEV.BO in case they are ever needed for a project. The second thing is that you need to make sure the correct chip is selected in CCS or whatever IDE you use when programming the MSP430, otherwise it probably won't work.

I hope this clears up any confusion on how to program external MSP430s, including the DEV.BO, using the LaunchPad. Please leave a comment if you have any questions about this post. Don't forget to check out the DEV.BO, which is available in my online store.

Comment away!

Bluetooth Breakout and Free Shipping

I would like add yet another product to my online store, NJC's Bluetooth breakout board. I would also like to announce that there is now free shipping on all orders within the contiguous United States for items on my online store.

This board is based off of the RN-42 module which is very easy to use and add to your current projects. A few weeks ago I actually wrote a post on how to add Bluetooth to your MSP430 project that mentioned this breakout board. The circuit board is a modified design of SparkFun's Bluetooth breakout board which adds status LEDs and all the passive components needed to make this board "plug and play" right into your project while keeping all the important yet non-essential pins available. The module is also small enough that it can be added to existing projects with ease.

Populated Bluetooth breakout board

You have two options when buying this board, either completely assembled or as a bare PCB. The completely assembled board is a good option for those of you who don't want to fuss with surface mount components, and want a guaranteed working board. The bare PCB is a great option for those of you who have no problem soldering surface mount components and who want to add Bluetooth to their project while spending as little as possible.

Top of the PCB with each pin labeled

The picture above shows the pinout of the board, which should make it very easy for you to incorporate into your project. You just need to connect the RX, TX, 3.3V, and GND to your project, and you are ready to go. The full schematic of the board can be downloaded below.

Interested? Pick one up at my online store!

Please let me know if you have any questions!


Documentation
RN-42 Datasheet
RN-42 User Manual
NJC Bluetooth Breakout Schematic

Introducing the MAVRK

What is the MAVRK? MAVRK stands for Module and Versatile Reference Kit. It is a new hardware platform developed by Texas Instruments which will allow you to evaluate almost any configuration of Texas Instruments' products. I have been given the opportunity to evaluate this kit before it is released and will be generating content for the community. This post will introduce you to the MAVRK and give a brief explanation of what the kit is.

While I am still not sure who Texas Instruments is targeting with this board , I think that professionals, students, and hobbyists all will be able to find some interesting uses for this system.

MAVRK with two modules installed.

This is a picture of the MAVRK board with two modules installed. I think it's pretty cool looking!

Instead of trying to explain exactly what the MAVRK is, I will give you a scenario in which you would want to use the MAVRK. Imagine you want to build a quadcopter that can be monitored and/or controlled wirelessly from a nearby computer. Instead of taking lots of time and money building prototype after prototype till you get the design right, you can use the MAVRK. First you would need a motor module, a wireless module (say Wi-Fi for example), an MSP430 module, and a few analog or digital input modules. All of these things TI apparently plans on offering at quite low prices.

You would plug everything in to the motherboard, hook any accelerometers you have to the input modules, hook a few test motors up to the motor module, and start programming away. The MAVRK programming tool chain is supposed to make the integration of these modules easy and quick. If all goes to plan, you should have a working model within days, not weeks. Now all that is left is to take the MAVRK setup, and turn your working design into a custom PCB; this step should also be easy considering the MAVRK and all the modules are open source, including the hardware.

I will be started a separate blog about the MAVRK system which will go into more detail about the kit and how to get started with the kit. Stay tuned! Let's see what this baby can do!