Skip navigation
1 2 3 Previous Next

Texas Instruments

72 posts

This is my fourth post on the TI FR2xx microcontrollers that feature FRAM memory.  The links to the previous posts are at the bottom of this post.

 

Introduction

 

I saw today where the MSP-EXP430FR2433 LaunchPad has been added to Energia, a modified version of the Wiring/Arduino IDE for select Texas Instruments microcontrollers and LaunchPads.

 

Energia

 

I have used Energia quite a bit in the past and most Arduino code and libraries will run on it, or at least port easily, provided they don't make direct register calls or use hardware specific to the microcontroller.  Energia runs on Windows, Linux, and MacOS.  To use the FR2433 with Energia make sure you are using the latest version and get the latest MSP430 core through the board manager in Energia.  Support for Energia is at http://forum.43oh.com/

 

The FR2433 should run acceptably with Energia since it has adequate FRAM and RAM.  I updated and ran the blink sketch successfully but don't plan on doing much more with it in the near-term as the project I have in mind will use the FR2011 and I don't have the overhead to spare for Energia.

 

Previous Posts

 

Texas Instruments MSP430FR2000 Microcontroller First Look                          FR2000

Texas Instruments FR2xx FRAM Microcontrollers Post No. 2                            FR2000, FR2011, and FR2433 overview

Texas Instruments FR2xx FRAM Microcontrollers Post No. 3                            FR2011 on a breadboard

Back in October, we launched a giveaway contest for the "new" Texas Instruments' Fundamentals of Power Supply Design Book. To compete in the contest, all you had to do was write a blog on the topic of TI power supply design and post it in the Texas Instruments Group.

 

About the Fundamentals of Power Supply Design Book

This well-written, superbly illustrated, and easy-to-read reference book was written by Bob Mammano, a power supply industry expert, who is considered the father of the Pulse Width Modulation (PWM) Controller. It's a interesting mix of power supply fundamentals along with a history of the power supply industry of which Texas Instruments has played an important part in developing.

 

The book unfolds with an easy introduction to power supply classification, voltage regulation basics and an examination of power supply components. Detailed discussions on switching power supply topologies, control algorithms, feedback loops, and magnetics design make it a comprehensive guide for anyone fascinated by the development power supply technology.

 

The Winners

The contest wrote and interesting  mix of blogs. Here are the winners:

 

hlipka : Power Supply Design Book - Helping me to deeper understanding of power supply  (Hendrik Lipka)

 

k.levente : The best DC-DC converter for your next battery powered IoT project (Levente Körmöczi)

 

rsjawale : My journey with TI power solutions (Rushiraj Jawale)

 

shabaz : Five scenarios where TI Power Supply circuits came to the rescue (Shabaz Yousaf)

 

rsc : Why I should win a TI "Fundamentals of Power Supply Design" book

 

Thanks to everyone who wrote a blog.

 

We'll be shipping them out to the winners sometime between Nov 27-30.

This is my third post on the TI FR2xx microcontrollers that feature FRAM memory.  The links to the previous posts are at the bottom of this post.

 

Introduction

 

The small breadboard breakout I designed for the FR2000 and FR2011 arrived in the mail today.  I was lucky and OshPark put my PCB alongside a rush order and I received it one week from submission - great!  I soldered it up and got it to blink without a problem - again, great!  In this post I will describe the board, show the schematic and update where I am in my explorations of small microcontrollers with FRAM.

 

Breadboard Compatible

 

The rows of breakout pins are placed 0.6 inches apart on 0.1 inch pitch so that it fits easily onto a standard breadboard with room to access the pins on the side.  Here it is, flashing away and powered by the LaunchPad that was used to upload the firmware:

The schematic is below:

FR2xx Breadboard Breakout Schematic

It has the basics needed to program and run the microcontroller from the eZ-FET on a LaunchPad plus provision for a LED on board if desired.  The FR2000 and FR2111 are pin compatible so either can be used.  All external pins are accessible.  I chose not to provide for an external crystal since I don't expect to need it in my project.  The microcontroller has a TSSOP form factor and the passives are all 0805 SMD.  If anyone is interested I will make the gerbers open on OshPark or send the KiCad files.

 

Next Steps

 

A key objective of my project is to store incoming data into FRAM and then have it persist when power is removed.  The data will then be retrieved when power is restored by sending it out over serial to a PC or other device.  I have FRAM working in persist mode now as described in the last post and also have the ring buffer working from a previous project done on a MSP430F5529 which should port easily since it is just C code.  It looks at the moment like everything will fit in the FR2111 which is nice since it is inexpensive and easy to design around.  Of course, not everything is going well.

 

Over the weekend I worked a bit on bog standard serial over the UART and for some reason couldn't get it to work on the FR2433.  I didn't expect a problem with serial as I have used it on the F5529 and other MSP430s a fair amount and never had a problem.  I still haven't figured out what I am doing wrong after spending considerable time in debug mode on CCS and then hauling out the logic analyzer.  I know I am in trouble when the logic analyzer comes out.  But something in the back of my mind tells me I have seen the problem before, but I just can't place it.  Anyway, now I will change over to the FR2111 and see how I do with that.

 

Previous Posts

Texas Instruments MSP430FR2000 Microcontroller First Look

Texas Instruments FR2xx FRAM Microcontrollers Post No. 2

Introduction

I previously made a post on the MSP430FR2000 but decided to expand it into a more general series on the MSP430FR2xx family of microcontrollers.  I will aim this at people with microcontroller experience who may not be familiar with the MSP430 microcontrollers and FRAM (Ferromagnetic RAM).  In this post I will show how FRAM can retain the contents of a variable in memory for future use, even if power is lost.

 

The FR2xx series is a relatively low cost line with memory sizes of 0.5 to 4KB of FRAM.  Currently I am working with the following 3 variants:

MicrocontrollerFRAM (Kbytes)SRAM (Bytes)
MSP430FR20000.5512
MSP430FR21113.751024
MSP430FR243315.36 + 0.54096

All can run at supply voltages from 1.8 to 3.6 V with clock frequency up to 16 MHz.  The MSP430 family is known for low power but my primary interest is in the persistent nature and shared space offered by FRAM.  FRAM is fully unified memory and can be used for program code, constants, arrays, or any other kind of storage.  Storage can be made persistent - that is it can be retained even when powered off and used again when powered on.

 

The FR2433 is only available in VQFN and BGA packages while the other two can be obtained in TSSOP.  I guess I might have to get a toaster oven and learn to solder VQFN if I keep working with the FR2433.

 

New MSP-EXP430FR2433 LaunchPad

As stated in my last post, the FR2000 does not have enough memory for the project I have in mind.  Texas instruments has recently come out with the MSP-EXP430FR2433, a new LaunchPad that contains the FR2433 and I purchased one.  I like the changes that TI has made to the newer LaunchPads.  This one has buttons on the side which should be easier to reach when there is a BoosterPack (daughterboard) on top as well as female headers on the bottom of the board that the original G2 LaunchPads did not have.  It also has eZ-FET debug onboard which makes it easy to program and debug (and is a huge improvement over the emulation provided on the G2 LaunchPads).  The ez-FET can be used to program custom boards and I do that regularly.  The kit contains everything needed to get started, including a USB cable.

Storing Variables in FRAM

The following example demonstrates persistent storage of a variable using the FR2433 LaunchPad and TI Code Composer Studio (CCS) with the TI compiler.

/*
 * Test_FRAM demonstrates the persistent nature of FRAM by storing a variable
 * that controls the number of LED flashes.  An endless loop counts from 1
 * to 10 and starts over again.  Each time through the loop it flashes the
 * current count and then increments until 10 is reached.  If powered down
 * after displaying say 5 flashes it will flash 6 times when powered up again.
 *
 * Frank Milburn     18 Nov 2017
 * Tested on MSP-EXP430FR2433 with CCS V7.2.0.00013
 *           compiler ti-cgt-msp430_17.9.0.STS
 */
#include "driverlib.h"
#define  RED_LED               GPIO_PORT_P1,GPIO_PIN0
#define  FRAM_enableWrite()    SYSCFG0=FRWPPW
#define  FRAM_disableWrite()   SYSCFG0=FRWPPW|PFWP
#pragma  PERSISTENT(i)
int i = 1;
//--------------------------------  m a i n  -----------------------------------
void main(void)
{
    WDT_A_hold(WDT_A_BASE);                   // stop watchdog timer
    PMM_unlockLPM5();                         // Activate port settings
    GPIO_setAsOutputPin(RED_LED);             // set red LED to output direction
    while (1){
        int j;
        for (j = 1; j <= i; j++) {
           GPIO_setOutputHighOnPin(RED_LED);
           _delay_cycles(300000);
           GPIO_setOutputLowOnPin(RED_LED);
           _delay_cycles(30000);
        }
        _delay_cycles(1045000);
        FRAM_enableWrite();
        i++;
        if (i > 9){
            i = 1;
        }
        FRAM_disableWrite();
    }
}

As stated in the comment at the top of the code, the program counts endlessly from 1 to 10 and starts over again.  At each count it blinks out the current count on the red LED on the LaunchPad.  If power is removed at any point, the count has been saved and it starts up again at the same count when power is regained.  Here is a description of the code:

 

  • Line 12:  DriverLib is a library provided by TI for accessing peripherals.  They are mostly written in C, are reasonably efficient, and much easier to understand than direct register access.  I tend to use them when possible.
  • Line 13:  I like to give the pins a name that describes what they are doing and put them in a #define
  • Lines 14, 15:  When using FRAM on the FR2xx and FR4xx microcontrollers it is necessary to twiddle bits before writing.  This is unnecessary on some of the higher end FRAM microcontrollers when using PERSISTENT due to the capabilities of their Memory Protection Unit which is in hardware.  While not too much bother, I wish TI would have included the same capability on the FR2xx and FR4xx.  Here I have created the macros FRAMenableWrite and FRAMdisableWrite that  are more human readable than the direct register writes to the write protection bits.
  • Lines 16, 17: #pragma  PERSISTENT() contains the magic words.  It instructs the compiler and the linker to place whatever variable, array, struct, etc. contained in the parenthesis in FRAM and make it persistent.  That is, it will be available after power loss or low power modes where SRAM is lost, and will be in memory instead of the value initialized at compile time.  In this case it is a counter variable named "i".  The variable is defined to be an int on the next line and must be initialized, in this case to one. (1)
  • Line 21: The watchdog timer must be explicitly turned off or petted.  Here I turn it off.
  • Line 22: When some of the more recent microcontrollers in the MSP430 family come out of the low power state LPM5 the ports must be unlocked before they can be used.  Just stick this line in and it will do it.
  • Line 23: A good example of a DriverLib API and how it improves code readability
  • Lines 24 - 31:  Some inefficient code that blinks the red LED the same number of times as the current contents of the FRAM variable "i".
  • Lines 33 - 38:  This is important code.  As stated earlier, before writing to FRAM it is necessary to set the write bits that control access.  The macro FRAMenableWrite() does this and then the counter "i" is incremented.  When the counter gets to 10 it is reset to 1.  To maintain some sort of control over willy-nilly writing to memory that is also used for program space it is then protected again with the macro FRAMdisableWrite().

 

Conclusion

Try it out by letting it run for a while and watch the LED blink out the current value of "i".  When it gets to 4 or 5 blinks unplug it.  When it starts back up again it will be where it left off at 6 blinks or so instead of starting over at one.

 

There is no protection in this code.  For example, if the power is lost during a write to FRAM the value could be in error.  In my project I intend to use a ring buffer with a check after writing data.  Data points with errors can then be flagged.

 

By necessity this has been a relatively short post and there are other APIs, examples, and options for FRAM in the TI documentation.  If there are other features or matters you think important, please comment.  As well, I am a intermediate level self taught programmer as is probably evident.  If you see errors please point them out.  Thanks for reading...

 

Frank

 

Note (1):  The CCS compiler and linker take care of memory when PERSISTENT is used.  To see things are placed, open up the Debug folder in CCS and look for the .map file.  In the Section Allocation Map look for .TI.persistent and you should see the origin and length of whatever has been placed there.

Introduction

This is my first look at the Texas Instruments MSP430FR2000 microcontroller.  It got my attention because of this recent post at Texas Instruments:  http://newscenter.ti.com/2017-11-08-Texas-Instruments-offers-25-functions-for-25-cents-with-new-MSP430-TM-microcontrollers

Twenty five functions for 25 cents sounds pretty good but be aware that if you are a hobbyist buying in small quantities you won’t be able to get these MCUs for anywhere near 25 cents.  However, they are reasonably priced and well worth having a look at the free e-book in the link above. 

I don’t have a project in mind for the FR2000 but the concept of adding inexpensive microcontrollers to something like the Raspberry Pi is interesting.  For example, it could be used to expand GPIO or add ADC capability.  It could also be used to add real time response when needed.  The FRAM nonvolatile memory also has interesting possibilities. 

In this blog post I will show how I hooked a MSP430FR2000 up for use on a breadboard and my give first impressions.

Getting Started

It comes in 16 pin TSSOP or 24 pin VQFN versions.  I chose the TSSOP because I am able to hand solder those without too much difficulty.   Here is the seemingly obligatory photo of the device next to a coin:

Here is the pinout:

 

The FR2111 is the same package and pin compatible.  The difference is memory and of course cost:

DeviceProgram FRAM (Kbytes)SRAM (Bytes)Small Qty Cost (US$)
MSP430FR21113.751024$1.16
MSP430FR20000.5512$0.85

 

I had a 28 pin TSSOP adapter on hand and soldered the FR2000 to it.  The connections to program it are simple and clearly described in the datasheet.  I used a 1 uF capacitor to ground for DVCC and a 1 nF capacitor to ground for RST.  It is also necessary to put a 47 k ohm pull-up resistor on RST.  Here it is on a breadboard ready to be programmed:

 

I program using with a TI LauchPad – just hook GND, 3V3, RST, and TST to their equivalents on the emulator side of the LaunchPad and you are ready to go.  This is one of the things I like about the MSP430 – really cheap and easy to get going.

 

Programming

I used Texas Instruments Code Composer Studio to program and the free TI v17.9.0.STS compiler.  I am a self-taught amateur programmer and with this little memory can use all the help I can get.  The code memory model and the data memory model were set to small in the Compile Processor Options.  The Optimization level was set to optimize size.  By the way, the e-book in the link above has helpful hints on minimizing code size as well as porting to larger MSP430 MCUs if needed.

It wouldn’t be right to start off with a simple blink program, so here is a simple counter that displays in binary on LEDs instead.

 

And here is the code:

 

/*
 *  MSP430FR2000 Binary Counter Display
 *
 *  Description: counts to 255 and displays on LEDs on Port 1
 *  ACLK = n/a, MCLK = SMCLK = default DCO
 *
 *                MSP430FR2000
 *             -----------------
 *         /|\|             P1.0|-->LED
 *          | |             P1.1|-->LED
 *          --|RST          P1.2|-->LED
 *            |             P1.3|-->LED
 *            |             P1.4|-->LED
 *            |             P1.5|-->LED
 *            |             P1.6|-->LED
 *            |             P1.7|-->LED
 *
 *  Frank Milburn
 *  November 2017
 */

#include 

void main(void) {
    WDTCTL = WDTPW | WDTHOLD;               // Stop watchdog timer
    PM5CTL0 &= ~LOCKLPM5;                   // Disable the GPIO power-on default high-impedance mode
                                            // to activate previously configured port settings
    P1OUT &= 0x00;                          // Set port 1 off
    P1DIR |= 0xFF;                          // Set port 1 to output direction

    for(;;) {
        int i;
        for (i = 0; i < 256; i++){
            int temp;
            temp = 0x00;                    // Zero temporary variable
            temp |= i;                      // Set bits to display
            P1OUT = temp;                   // Display bits
            volatile unsigned int j;        // volatile to prevent optimization
            j = 2500;                       // SW Delay
            do j--;
            while(j != 0);
        }
    }
}

 

The code compiles and reports the following memory usage:  FRAM 132 bytes and RAM 160 bytes.

If you are accustomed to writing directly to registers then the comments will make it pretty clear what is going on.  Recently I have been avoiding this style though as I find it difficult to debug when I go back after a period of time.  I don’t do enough programming to remember what register is what.  Instead, I tend to use DriverLib when I can.

TI describes DriverLIb as an abstracted API that provides easy to use function calls with helpful documentation to write complete projects with minimal overhead.  In use it involves more typing but I can live with that.  I wondered how much if any overhead there would be to this simple example so here it is rewritten using the DriverLib API to set up the pins the way I might normally do it (output for binary display remains the same).

/*
 *  MSP430FR2000 Binary Counter Display using DriverLib to set up pins
 *
 *  Description: counts to 255 and displays on LEDs on Port 1
 *  ACLK = n/a, MCLK = SMCLK = default DCO
 *
 *                MSP430FR2000
 *             -----------------
 *         /|\|             P1.0|-->LED
 *          | |             P1.1|-->LED
 *          --|RST          P1.2|-->LED
 *            |             P1.3|-->LED
 *            |             P1.4|-->LED
 *            |             P1.5|-->LED
 *            |             P1.6|-->LED
 *            |             P1.7|-->LED
 *
 *  Frank Milburn
 *  November 2017
 */
#include "driverlib.h"

int main(void) {

    WDT_A_hold(WDT_A_BASE);

    PMM_unlockLPM5();

    GPIO_setOutputLowOnPin(
        GPIO_PORT_PA,
        GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 + GPIO_PIN3 +
        GPIO_PIN4 + GPIO_PIN5 + GPIO_PIN6 + GPIO_PIN7
        );

    GPIO_setAsOutputPin(
        GPIO_PORT_PA,
        GPIO_PIN0 + GPIO_PIN1 + GPIO_PIN2 + GPIO_PIN3 +
        GPIO_PIN4 + GPIO_PIN5 + GPIO_PIN6 + GPIO_PIN7
        );

    for(;;) {
        int i;
        for (i = 0; i < 256; i++){
            int temp;
            temp = 0x00;                    // Zero temporary variable
            temp |= i;                      // Set bits to display
            P1OUT = temp;                   // Display bits
            volatile unsigned int j;        // volatile to prevent optimization
            j = 2500;                       // SW Delay
            do j--;
            while(j != 0);
        }
    }
}

 

The program now compiles to FRAM: 282 bytes and RAM: 160 bytes.

RAM remains the same but program memory in FRAM has increased by 150 bytes and only 218 bytes remain.  The good news is that DriverLib is available (it isn’t on the MSP430G series) but for this particular chip tighter coding is needed and I wouldn’t expect it to be useful.  Even using traditional register access with C my skills are in question.  Therefore, I will probably be using the FR2111 and its larger memory for my own small projects.

This is not meant to come across as a negative as I am aware of amazing examples of what can be done with 1 K and of course there are those 25 functions in the e-book above.  I have had limited time to explore those and have other pressing matters but hope to come back to them in future.  I did try the SPI_IO_EXPANDER_CCS example with the thought of reproducing the binary counter display discussed above but driven from a master.  Unfortunately I was unsuccessful on my first attempt late last night, possibly due to setting up the master SPI wrong (and being sleepy).

Thanks for reading.  I would be interested if others are using this or other small microcontrollers and in what kind of projects.

Correction:  11/16/2017  Cost table had costs reversed for FR2000 and FR2111, corrected now

I have already a book of Mike Engelhardt:

The LTSpice IV Simulator: Manual, Methods and Applications

and I have read it from power applications perspective. But it was Linear chips approach and their chips. So now I would like to take another point of view-TI's. And i would like to simulate all the examples from the book in a free open source Falstad interactive circuit simulator and maybe even send some patches to it. Of course I would share the circuit files here on the element14.

Every electronics hobbyist is using a power supply of some kind. You might start with a simple battery, but sooner or later you get yourself a 'real' power supply. Probably (right behind after blinking an LED) it the most frequent DIY-project. I'm no exception for that - actually I did three of them. But they are all based on the venerable LM317, since its so easy to use.

The other part one comes into contact with all the power supply issues is when you need to power your project. One might get away with just 5V from a USB wall wart, but sometimes there are special needs (e.g. higher or lower voltages). In my projects I got quite fond of Texas Instruments Simple Switcher modules, and their power modules. For example, for my K8200 3D printer I used the PTN78020 6A switcher module to generate the 15V needed for the main board and the stepper motors:

The Raspberry PI controlling it is powered by a LMZ14203 Simple Switcher module. I even designed my own small PCB to hold the module (Disclaimer: this was part of my project for the 'Raspberry Pi DIN Enclosure road test:

Using these reduces the hassle of building your own switching regulator, and they are more reliable than the cheap modules you get at Ebay. You can use these modules more or less like a linear regulator (just need to be careful with the required capacitance at input and output), but get much better efficiency.

But as a hobbyist I still strife to learn more, and hopefully this book helps me at this. I learned quite a lot just from experimenting with TIs switch mode converter boards during my recent road tests, but with the book I can also get into all the theory behind them. The project I'm finally targetting is to build (yet another) power supply - this time a linear one with a switch mode pre-regulator.

Nowadays there is a big hype about IoT devices and it’s not surprising. Many creative project and business idea is based on this new technology, the opportunity is limitless. I also had a good project idea – to design a battery operated motion sensor device.

First I started to think on system level, and later on I have realized that as always, the power supply circuit is one of the most critical part of the design. A battery operated IoT device has to have low power consumption and because of this reason, a DC-DC converter is almost always the best choice. I defined a few criteria and after that I started to search for the most suitable DC-DC converter chip for my project.

 

The winner was the Texas Instruments TPS63050 DC-DC Buck-Boost converter IC:

- It is a Buck-Boost converter with 1 A switches and with an input voltage range from 2.5 V to 5.5 V. This means I can use different battery types for generating the required 3.3 V system rail. It operates in Buck mode if I use a 3.6V Lithium thionyl chloride battery or it will operate in Boost mode in the case of two alkaline battery in series. This gives me a huge flexibility and the coolest thing is that it provides a seamless transition from Buck to Boost or from Boost to Buck operation.

- The device has an efficiency > 90% in Boost Mode and > 95% in Buck Mode. No question, these are industry leading numbers. With the “Automatic Power Save Mode” feature and its low quiescent current (< 60 μA) I was able to further optimize the power consumption of my IoT device and extend the battery life.

- This converter IC is available in a 2.5mm x 2.5mm 12-pin HotRod™ QFN package which was good news for me, because my plan was to build a prototype with a single soldering iron without a hot air station. With a magnifier and a little patience it is possible to hand solder these QFN packages.          

 

During the design phase I strictly followed the datasheet and the reference design provided by TI. The quality of the TI datasheets are amazing. I was able to find all the required information to finish the schematic and the PCB design. After assembling my first prototype it started to work for the first time. I was completely satisfied.

 

Here is my final schematic:

TPS63050 DC-DC converter schematic

 

Of course every design can be fine-tuned. This requires the right tools and the right knowledge on power supply design topic. If I could win a Fundamentals of Power Supply Design book written by Robert A. Mammano, I could dive more deeply into this topic, and design more sophisticated power supplies for my next projects.

Before I write how and why I started using TI ICs for designing power supplies let's take a look at my past projects.

I often design analog circuits and microcontroller based projects. Since, I need portability in most of my projects I used to use the cheap 9V batteries.

Initially, they worked good in the testing phase and I didn't have any knowledge about capacity of the battery or I didn't care about the capacity.

But until one day when I designed an analog line following robot with LM358 Dual opamp ICs. The 9V battery used to last only for about 10-15mins,

and it couldn't supply the required amount of power. Since, the robot used the opamps as comparators the voltage drop used to de calibrate the

light sensors as the threshold voltage of comparators kept on dropping.

 

That's when I started looking for some nice power supplies. I came across some cheap buck/boost converters on eBay. But being an electronics engineer,

I decided to build one on my own. I had a 3.7V Li-ion battery but it was useless for 5V microcontrollers. I decided to make a boost converter.

 

The TI Webench design tool helped a lot in choosing the proper boost converter IC and external components. LM2765 is the part I used for the power supply.

Since then I have been using the same battery and the boost converter to power up my projects. It's been 2 years now.

I have also made many DC-DC step down power supplies using TI's buck converters.

 

TI has helped me learn about power supplies and the datasheets and applications circuits on the website help a lot too. Especially the TI Webench tool let's you input the

parameters and displays a list of ICs as per your requirements. It simulates the result of the selected product and displays a lot of important details like the BOM, efficiency,

steady state parameters, etc.

 

I believe the book will help me explore more such power supply designs. It will help me to design a MPPT based solar battery charger.

I would like to be considered for a copy of Bob Mammano's Power Supply Design book for the following reasons...

 

First of all; it looks like the ideal companion book to sit beside my "Art of Electronics".

 

Also, for many years now when I have needed a power supply I have been rather lazy; opting for a simple linear regulator and wasting power as heat or buying the cheapest board available off the internet. However there is an increasing number of times I'd like to find a better solution - and by that I mean proudly designing an exact solution rather than copying from the internet. This may be because of a compact design to fit in a case, something that requires longer life from a battery (like my current Bluetooth project), something with dual supplies or sometimes a high current capability. Last Christmas I couldn't afford a decent PSU for my 5v Christmas lights and so cobbled together something using multiple 2A linear regulators and a large lump of aluminum.....The phrase "could do better" sums it up.

 

Another reason I'd love to have a copy of this book is that Bob's expertise in PSU design would undoubtedly assist me in my other electronics task, one I'm sure we are all familiar with...that of mending everything that goes wrong in my house or that of family and friends; a large percentage of which consist of a PSU failure.

 

Lastly; it is a TI book...say no more.

Introduction

The Texas Instruments product range has thousands of interesting power supply and related integrated circuits. I thought it could be interesting to review a few designs I’ve experimented with, and discuss what particular devices were used.

 

Powering an iPod/iPhone for Automotive Use

This is a snippet of a schematic from an in-car project – this is the iPod/iPhone charger portion of the circuit using the TPS40200TPS40200 as a step-down controller. I’ve used it for many years, it has survived many winters in the car. It has survived a failing alternator, and several jump-starts and so on during this time. It has lasted longer than both my iPod and Alpine in-car amplifier, and come to think of it has lasted longer than the existing electrical wiring connections (RCA connectors are awful, I wish they would be phased out of consumer electronics gear).

 

I used the ‘soft start’ (SS) pin to control the power supply, so that it could be remotely switched on.

 

Building a LiPo Battery Charger

I thought the BQ2409X series of battery charger ICs were awesome. Some earlier generation devices from other manufacturers had limited safety features. In contrast the TI BQ2409X series of devices have lots of in-built features such as a timer, external thermistor for the cell, and even over-voltage protection if the input source goes faulty.

 

For my design, I added a MOSFET on the ISET2 pin, so that the charge current was under computer control.

 

Building a Solar Charger

I’ve blogged about this in more detail here: Building a Solar Charger . The BQ24650BQ24650 is particularly useful because of its flexibility. It allows a user to start the circuit design even if the final solar panel and final cell/battery and cell chemistry has not been selected yet. I was highly impressed at the flexibility of this integrated circuit.

 

Wide Input Range Step-Down Power Supply

I love that TI seem to have a solution for everything. In this situation, I wanted to have a device that could be powered from a 12V or a 24V source normally (e.g. industrial applications), but I also wanted the ability for a user to disconnect it from the power source, and run it from a PC, using the USB connection (5V) for troubleshooting or firmware upgrades, etc. The TPS54540TPS54540 allows for inputs from 4.5V to 42V, which met and exceeded my needs!

 

 

Using DC-DC Converter Modules

Sometimes it is just easier to trust the TI experts and use off-the-shelf DC-DC converter modules that they have designed. I used two of them in a project: RIoTboard: Building a TFT LCD Display and Digitizer - Part 2: Circuit

I used them to connect a laptop TFT screen to a RIoTboard computer. The use of off-the-shelf modules means that the PCB doesn’t need to be a multi-layer board; one or two layers is fine!

 

The DC-DC converter modules that were used have an adjustable output controlled by a single resistor. I used two resistors in parallel to allow me to select popular resistance values. The PTH04000WAHPTH04000WAH is a step-down converter that I used to obtain 3.3V from a 5V supply, and the PTN04050CAHPTN04050CAH is a step-up converter that I used to power the screen backlight.

 

Summary

A small selection of power supply circuits and their use-cases were presented. I hope it was interesting. It would be great to hear from people about their tips for interesting power supply ICs and what use that they were put to!

TI not only makes a lot of great hardware for designers, but also has a lot of great software tools.

One tool that I have used for many years is a power supply design program called Switcher Pro.

It makes power supply design as easy as inputting a few parameters and picking one of TI's many power devices.

Updates for Switcher pro ended in 2011, and its features were integrated into TI's new online application, WebBench Power Designer.

 

WebBench has all the power tools of Switcher Pro, but adds support for filters, sensors, interface, reference, led, clock and FPGA/uP.

It's a very good tool for any designer, though I haven't forgotten where it all started from.

I have been building power supplies since I was 11 year old.  The first was when my father's friend gave me a few boxes of ham radio parts he didn't want when he moved to Florida.

I had dozens of vacuum tubes, and no way to light them up.  A trip to Radio Shack, and a few days reading up at the library later, I had a transformer plugged into the wall, and a bright tube filament at the other end.

I remember blowing up many LEDs with a 9V battery before learning about current limiting resistors, and filled my room with toxic smoke once after plugging a string of DC capacitors directly into the 115VAC outlet.

(Mom was not impressed).

I was most pleased in the '80s when I learned about DC to AC inverters, and I could take "indoor" equipment outside to play.  With a big enough stack of car batteries, you could do almost anything.

We stuck a shopvac on a 4ftx8ft sheet of plywood with a garbage bag skirt, with an inverter and battery pack on a sled, and made the coolest hovercraft in the world!

My friends and I had built a "fort" in the trees on some city-owned land with 12V lights, a full car music system with a security system based on a garage door opener IR sensor.  We just had to drag the batteries home periodically to charge them. Solar panels would have been nice back then.

In college I learned that a VIC20 could be operated directly from 12V, so we mounted one in a minivan with a portable B/W TV and built a rally computer for the 1985 SCCA POR contest.

https://en.wikipedia.org/wiki/Press-on-Regardless_Rally

After college, I was working at Chrysler corp. and attended an EMI  seminar with Henry Ott -  home page , and learned quite a bit about electromagnetic noise and interference that day.  All my power supply designs changed after that seminar.  There are many tips and tricks to power supply design, I've built 1V LED supplies, shrunk quarters with thousands of volts, and built a 750,000 volt pair of Tesla coils, and I'm still learning how to do it right.

I have many students come through my labs each year, and having this book on the shelf would be useful to all of us.

That's why I should win a TI "Fundamentals of Power Supply Design" book.

fundamentals of power supply designTexas Instruments recently released a book on the Fundamentals of Power Supply Design. It 's written by Bob Mammano, a power supply industry expert who is considered the father of the Pulse Width Modulation (PWM) Controller. It's a interesting mix of power supply fundamentals along with a history of the power supply industry of which Texas Instruments has played an important part in developing.

 

It's written for the beginner as well as the expert, covering power supply basics such as voltage regulation and power component selection, and also addresses advanced topics such as magnetics design, minimizing EMI, and topology selection.

 

The book unfolds with an easy introduction to power supply classification, voltage regulation basics and an examination of power supply components. Detailed discussions on switching power supply topologies, control algorithms, feedback loops, and magnetics design make it a comprehensive guide for anyone fascinated by the development power supply technology.

 

Interested in reading the book? It is currently available by clicking here.

motor drive.PNGIsolators are devices that minimize direct current (DC) and unwanted transient currents between two systems or circuits, while allowing data and power transmission between the two. In most applications, in addition to allowing the system to function properly, isolators also act as a barrier against high voltage.

 

For example, in this motor drive system, the isolated insulated gate bipolar transistor (IGBT) gate drivers level shift low-voltage signals from the control module to IGBT gate-drive controls referenced to the inverter outputs. At the same time, they also form a protective barrier between the high voltage (DC bus, inverter outputs, and input power lines) and the control module, which may have human accessible connectors and interfaces.

 

In high-voltage applications, failure of the isolation barrier can result in a potential hazard to human operators, or cause damage to sensitive control circuitry leading to further system malfunction. Therefore, it is important to understand what may cause the isolator to fail, both under normal and fault conditions.

 

Types of Failure Modes

There are two possible failure modes of isolators. The first is when the voltage across the isolation barrier exceeds the isolator’s rated limits. The first is when the voltage across the isolation barrier exceeds the isolator’s rated limits. The second is when circuits or components integrated in the isolator close to the isolation barrier are damaged by a combination of high voltage and high current. Potentially this can cause damage to the isolation barrier. To learn the more about the failure modes of isolators, click here to download the details.

 

Combating Isolator Failures

The ISO7841x device is a high-performance, quad-channel digital isolator with a 8000-VPK isolation voltage. This device has reinforced isolation certifications according to VDE, CSA, CQC, and TUV. The isolator provides high electromagnetic immunity and low emissions at low-power consumption, while isolating CMOS or LVCMOS digital I/Os. Each isolation channel has a logic input and output buffer separated by a silicon-dioxide (SiO2) insulation barrier.

ISO7841.jpg

This device comes with enable pins that can be used to put the respective outputs in high impedance for multi-master driving applications and to reduce power consumption. The ISO7841 device has three forward and one reverse-direction channels. If the input power or signal is lost, the default output is high for the ISO7841 device and low for the ISO7841F device. See the Device Functional Modes section for further details.

 

Used in conjunction with isolated power supplies, this device helps prevent noise currents on a data bus or other circuits from entering the local ground and interfering with or damaging sensitive circuitry. Through innovative chip design and layout techniques, electromagnetic compatibility of the ISO7841 device has been significantly enhanced to ease system-level ESD, EFT, surge, and emissions compliance. To learn more about the ISO7841X Quad-Channel Digital Isolator, click here.