Category Archives: Stellaris

Stellaris LM3S

Stellaris ADS1118 Tutorial

November 19, 2013 Ant 2 Comments

Stellaris ADS1118 tutorial will show how a Stellaris LM3S6965 is interfaced with a ADS1118 16 bit ADC using the SPI bus.

The ADS1118 was chosen as it can be used to interface thermocouples, in this example only the temperature data from the on-die temperature sensor will be read. The thermocouple interfacing will be covered at a later date. The datasheet for the ADS1118 can be downloaded form here.

ADS1118 Package

The ADC was sourced in ADS1118IDGST package, then a symbol, package and device was constructed in EagleCAD. Once this was completed a small PCB was milled out, which can be seen below.

The SMD decoupling capacitor was placed as close to the IC as possible (milling machine restrictions) to reduce noise, additionally the bottom layer was used as a ground plane. This PCB layout uses male jumper pins, therefore allowing the ADS1118 to be plugged in and used with other test boards. For testing a small piece of veroboard was used with a few discrete components, and some female headers so the ADS1118 PCB could be plugged in. This was then connected directly to the Stellaris evaluation board, using the 3.3V line as the main supply for the ADC. The finished test board can be seen in the below image.

The ADS1118 uses the Serial Peripheral Interface (SPI) to send and receive data from a microcontroller, the Stellaris will be the master and the ADS1118 the slave. To ensure the SPI (known as SSI on the Stellaris) connections were correct, the the datasheet for the ADS1118 was read thoroughly, this was also necessary to familiarise oneself with ADS1118 control registers and SPI mode of operation. This is not a tutorial on SPI so there are some assumptions made, that you the reader knows some basics regarding the SPI protocol. Some useful links for SPI reference can be found here and here

The image below shows the ADS1118IDGST pinout, for this example pins 1 to 3 and 8 to 10 were used.

These were connecting to the Stellaris as follows:

ADS1118 SCLK —– Stellaris SSICLK

ADS1118 CS —– Stellaris SFSS

ADS1118 DIN —– Stellaris SSITX (MOSI)

ADS1118 DOUT —– Stellaris SSITX (MISO)

*These pins on the Stellaris are generally used for interfacing with the on board OLED display, in this example the OLED is not used. There is a second SPI peripheral on the LM3S6965 evaluation board.

ADS1118 SPI Operation

From the ADC datasheet we can find some useful information regarding the transmission cycle, and what information we need to send the ADS1118 to configure the control registers. The ADS1118 has 2 modes of operation: 32 bit data transmission cycle and a shorter 16 bit data transmission cycle, the former also allows the SS line to be tied to Gnd. The image below shows the 16 bit data transmission cycle, which is the method used in the code for this tutorial.

The SS line is controlled by the master, when this goes low the the master sends a 16 bit word to the ADS1118 on the MOSI line, this word contains the control register configuration settings. As the SPI interface allows data to be transmitted and received simultaneously, the ADS1118 sends a 16 bit word back on the MISO line. The master then takes the SS line high, and another 16 bit word transfer can take place as soon as this is taken low again.

The control register settings for the ADS1118 are used to configure various parameters i.e. Temperature Sensor Mode, Pull-Up resistors, Programmable Gain Amplifier Configuration etc. A full list of these parameters can be found on pages 21 and 22 of the datasheet. For this example we will be configuring the ADS1118 to function in a basic temperature sensing mode, using the internal temperature sensor. To configure the control register in this way the 16 bit word looks like this in binary 00000000 00010010 or 0x12 in hexadecimal. Bit 4 is set to 1 which places the device in Temperature Sensor Mode. Bit 1 and 2 have a fixed setting if the control register data is classed as ‘Valid data’, this is 01 anything other than this will mean the 16 bit word is invalid, and it will therefore not be written to the control register.

Information regarding the clock polarity (CPOL) and the clock phase (CPHA) can be found in Figure 1 on page 6 of the datasheet.

C Code

Now the code used in this project is loosely based on some Stellaris example code, which is bundled with Stellarisware, however this code is not in the examples for the LM3S6965 board. As with previous posts I will list some of the code in the post, and the complete C file can be downloaded at the end of the post.

All the SSI setup code has been bundled into one function called Setup_SSI()

void Setup_SSI()
{
    // Configures the system clock, the LM3S6965 has a 8MHz crystal onboard
    SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                   SYSCTL_XTAL_8MHZ);

    // Enable the SSI0 peripheral
    SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);

    // The SSI0 peripheral is on Port A and pins 2,3,4 and 5.
    // Enable GPIO port A
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    // This function/s configures the pin muxing on port A pins 2,3,4 and 5
    // It uses the values DEFINED at the top of the program and takes 1 parameter
    GPIOPinConfigure(GPIO_PA2_SSI0CLK);
    GPIOPinConfigure(GPIO_PA3_SSI0FSS);
    GPIOPinConfigure(GPIO_PA4_SSI0RX);
    GPIOPinConfigure(GPIO_PA5_SSI0TX);

    // Configures the pins for use by the SSI, takes 2 parameters
    GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 |
                   GPIO_PIN_2);

    // Configures the SSI port for SPI master mode, it takes 6 parameters
    SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_1,
                       SSI_MODE_MASTER, SysCtlClockGet()/8, 16);

    // Enables the SSI0 module
    SSIEnable(SSI0_BASE);
}

void Setup_SSI()

{

// Configures the system clock, the LM3S6965 has a 8MHz crystal onboard

SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

SYSCTL_XTAL_8MHZ);

// Enable the SSI0 peripheral

SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);

// The SSI0 peripheral is on Port A and pins 2,3,4 and 5.

// Enable GPIO port A

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

// This function/s configures the pin muxing on port A pins 2,3,4 and 5

// It uses the values DEFINED at the top of the program and takes 1 parameter

GPIOPinConfigure(GPIO_PA2_SSI0CLK);

GPIOPinConfigure(GPIO_PA3_SSI0FSS);

GPIOPinConfigure(GPIO_PA4_SSI0RX);

GPIOPinConfigure(GPIO_PA5_SSI0TX);

// Configures the pins for use by the SSI, takes 2 parameters

GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 |

GPIO_PIN_2);

// Configures the SSI port for SPI master mode, it takes 6 parameters

SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_1,

SSI_MODE_MASTER, SysCtlClockGet()/8, 16);

// Enables the SSI0 module

SSIEnable(SSI0_BASE);

}

First of all the clock is setup which is part of any hardware setup and required not just for the SSI. Next the SSI0 module is enabled, followed by GPIO port A being enabled which the SSI0 module uses.

After the port is enabled the next function configures the pin muxing feature for port A, which relates to the pin_map.h header file in the Stellarisware. Not all stellaris devices support pin muxing, so check the datasheet for your device. The GPIO pins are then configured to be used by the SSI module using the function GPIOPinTypeSSI(), this takes 2 parameters, the port base address and then the individual pins on that port.

Then SSIConfigSetExpClk() is used to configure the SSIO peripheral, with 6 parameters:

The first parameter specifies the module base address, SSI0 is used here. The second parameter specifies the rate of the clock supplied to the SSI, system clock is used in this case. The third parameter specifies the SPI mode used (there are 4 variations), in this case Mode 1 is used. The forth parameter specifies if the Stellaris will function as a master or a slave device. The fifth parameter specifies the clock rate, in this case the system clock is divided by 8 so 1MHz, and finally the sixth specifies the number of bits transferred per frame, 16 bits are used in the example.

As mentioned the SPI protocol has 4 transfer modes, this is dependent on the clock polarity (CPOL) and the clock phase (CPHA). The links provided earlier in this post will prove useful in understanding the mode of choice, as well as reading the datasheet for the slave device to ascertain which mode of operation it uses.

The final function call is to enable the SSI0 module.

Now that the SSI0 module has been setup, the functions to send and receive data can be used. In order to store the data to be sent and received, the code example uses an unsigned long array for the transmitted and received data. Also a further unsigned long is used as a counter variable making the process easier, if further data words were being sent. This format is overkill for this example, as only one 16 bit word is required to be transmitted and received. However in this example two 16 bit words will be sent, one containing the correct control register data, and another with invalid control register data. The number of data arrays is determined by a #define NUM_SSI_DATA 2.

// Number of bytes to send and receive used in the ulDataTx and ulDataRx arrays, this will equal 2 bytes
#define NUM_SSI_DATA 2

unsigned long ulDataTx[NUM_SSI_DATA];	// An array of 2 data bytes to be Tx
unsigned long ulDataRx[NUM_SSI_DATA];	// An array of 2 data bytes to be Rx
unsigned long ulindex;			// Used to count the number of bytes Tx or Rx

// Number of bytes to send and receive used in the ulDataTx and ulDataRx arrays, this will equal 2 bytes

#define NUM_SSI_DATA 2

unsigned long ulDataTx[NUM_SSI_DATA]; // An array of 2 data bytes to be Tx

unsigned long ulDataRx[NUM_SSI_DATA]; // An array of 2 data bytes to be Rx

unsigned long ulindex; // Used to count the number of bytes Tx or Rx

Inside the main function contained within a while loop, the first function is called as follows

while(SSIDataGetNonBlocking(SSI0_BASE, &ulDataRx[0])) {}

1	while(SSIDataGetNonBlocking(SSI0_BASE, &ulDataRx[0])) {}

This functions gets the received data from the receive FIFO of the SSI0 module (the first parameter), and places the data into the location specified by the second parameter, which is a pointer to the storage location. If there is no data the function returns zero.

After this the data arrays for transmit and receive are initialized, here the values previously discussed for the control register are loaded.

    // Initialize the data to send.
    ulDataTx[0] = 0x12;	// Control Register setup for the ADS1118
    ulDataTx[1] = 0x00;
    ulDataRx[0] = 0;
    ulDataRx[1] = 0;

// Initialize the data to send.

ulDataTx[0] = 0x12; // Control Register setup for the ADS1118

ulDataTx[1] = 0x00;

ulDataRx[0] = 0;

ulDataRx[1] = 0;

Next a for loop is used to control the flow of data being transmitted to the slave.

    // For loop used to transmit 2 bytes of data, using ulindex as the counter variable
    for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)
    {
        // Send the data using the "blocking" put function.
        SSIDataPut(SSI0_BASE, ulDataTx[ulindex]);

        while(SSIBusy(SSI0_BASE)) {}
        // This takes the SS line high between 16 bit word transfers
        // Last parameter uses the pin masking so only affects GPIO A Pin 3
        GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3, 0x08);
    }

// For loop used to transmit 2 bytes of data, using ulindex as the counter variable

for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)

{

// Send the data using the "blocking" put function.

SSIDataPut(SSI0_BASE, ulDataTx[ulindex]);

while(SSIBusy(SSI0_BASE)) {}

// This takes the SS line high between 16 bit word transfers

// Last parameter uses the pin masking so only affects GPIO A Pin 3

GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3, 0x08);

}

The SSIDataPut() function call takes 2 parameters, the base address of the SSI module and the data to be transmitted over the SSI interface. This function uses a blocking send function, it places data into the transmit FIFO of the SSI module. If there is no space available in the transmit FIFO, it waits until there is space before returning. This then ensures all the data is sent.

The SSIBusy() function simply ensures that the program waits while the SSI0 module is busy. Lastly the SS line is taken high to indicate the end of the 16 bit word transfer.

The next piece of code uses another for loop to control the flow of data being received from the slave.

    // For loop used to receive 2 bytes of data, using ulindex as the counter variable
    for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)
    {
        // Receive the data using the "blocking" get function.
        SSIDataGet(SSI0_BASE, &ulDataRx[ulindex]);

        while(SSIBusy(SSI0_BASE)){}
    }

// For loop used to receive 2 bytes of data, using ulindex as the counter variable

for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)

{

// Receive the data using the "blocking" get function.

SSIDataGet(SSI0_BASE, &ulDataRx[ulindex]);

while(SSIBusy(SSI0_BASE)){}

}

The SSIDataGet() function call takes 2 parameters, the base address of the SSI module and the data to be received over the SSI interface. This function uses a blocking get function, it will wait until there is data in the receive FIFO of the SSI module. The data is then placed into the function location specified by the second parameter pointer address. If there is no data the function waits until data is received before returning.

The SSIBusy() function is used again here as with the previous for loop.

Before we look at the rest of the code, which is used to calculate the temperature data from the ADS1118, lets firstly look at the SPI timing diagram produced by the code.

The timing diagram was captured with a USB logic analyzer, which also has a function to decode the SPI bus protocol. As can be seen in the waveform the SS line drops low to allow data to be sent, and remains low while data in being trasnmitted and receieved. The serial clock starts shortly after the SS line drops low, and data is transmitted from master to slave on the MOSI line, and from slave to master on the MISO line. The SS line can be seen to go high between each 16 bit word transfer.

The decoded data shown at the top, is the same as displayed on the MOSI and MISO lines below, it just saves counting the 0’s and 1’s and then calculating the hexadecimal value. From this it is easy to see the transmitted data values match, the values placed in the transmit FIFO by the code. Also it can be seen that the second invalid control register data just instigates a transmit and receive sequence. The data coming back from the slave are temperature values, which don’t mean a great deal in their present form, so some additional code is required to interpret and calculate the current temperature.

We know the temperature data is being sent in a 16 bit word, reading the datasheet especially the chapter titled ‘Temperature Sensor’ provides all the necessary information. Only the upper most 14 bits are valid temperature data, so the last 2 LSB can be discarded. The data is also sent in 2’s compliment format, this example does not go into negative values for the temperature, but this is good to know dependent on the temperature range being measured. Also the datasheet provides a temperature constant of 0.03125 degrees C, which equals 1 bit of the 14 bit number, so a simple multiplication is required.

3 variables are used to calculate the temperature sensor reading.

// Variables used to calculate the temperature reading from the ADS1118
unsigned int Raw_Value = 0;
float ADC_Conv = 0.03125;	// Temperature constant for the ADS1118 on-die temperature sensor
float Temp;					// Result of temperature calculation is copied to Temp

// Variables used to calculate the temperature reading from the ADS1118

unsigned int Raw_Value = 0;

float ADC_Conv = 0.03125; // Temperature constant for the ADS1118 on-die temperature sensor

float Temp; // Result of temperature calculation is copied to Temp

Firstly the raw 16 bit word is assigned to the unsigned int Raw_Value. Looking back at the SPI timing diagram this value would be 0x0BF8 or 0000101111111000 in binary. We are however only interested in the 14 MSB, shown in bold.

// Assign the value in first array to the unsigned int Raw_Value
Raw_Value = ulDataRx[0];

1 2	// Assign the value in first array to the unsigned int Raw_Value Raw_Value = ulDataRx[0];

This value is turned from a 16 bit word to a 14 bit word by shifting to the right by 2 places. After the binary value has been shifted it reads 00001011111110 or 766 in decimal.

// 16 bit word is shift to the right by 2 bits.
Raw_Value = Raw_Value >> 2;

1 2	// 16 bit word is shift to the right by 2 bits. Raw_Value = Raw_Value >> 2;

The next step is to multiply the 14 bit raw value with the temperature constant for the ADS1118 temperature sensor. Therefore 766 multiplied by 0.03125 equals 23.9375 degrees C.

// Raw_Value is multiplied with the temperature constant for the ADS1118
Temp = (Raw_Value * ADC_Conv);

1 2	// Raw_Value is multiplied with the temperature constant for the ADS1118 Temp = (Raw_Value * ADC_Conv);

Using Code Composer Studio v5.5 the next screen shot shows the data captured in the debug mode. A breakpoint was set and adjusted to simply update the view, therefore the variables could be seen to change in real time. The Raw_Value 767 is 3068 divided by 4 which is basically the operation the right shift is performs.

Example Code

The link below contains the zip file with the complete C code, there is a small advert page first via Adfly, which can be skipped and just takes a few seconds, but helps me to pay towards the hosting of the website.

Stellaris ADS1118 SPI C code

I take great care when writing all the tutorials and articles, ensuring all the code is fully tested to avoid issues for my readers. All this takes time and a great deal of work, so please support the site by using the Adfly links etc. If you have found this useful or have any problems implementing, please feel free to leave a comment and I will do my best to help.

C Programming, Stellaris

Stellaris LM3S6965 PWM Tutorial

September 28, 2013 Ant 2 Comments

In this tutorial the Stellaris LM3S6965 Evaluation board will be used to demonstrate a simple PWM (Pulse Width Modulated) example. This is part of a larger project I am working on, which is not covered in this tutorial but will be posted at a later date.

When carrying out any programming on the Stellaris LM3S series, I would highly recommend downloading the Peripheral Driver Library PDF, this contains details of all the functions used to control the on chip peripherals. The current release at the time of writing is spmu019p.pdf and can be downloaded from here

You will also need to install StellarisWare which is the Texas Instruments library files for the Stellaris and also contains code examples. Viewing the various libraries while in code composer can be very useful to fully understand what each function does. The 2 files for the PWM are pwm.h and pwm.c, which can be found in the StellarisWare installation folder, in my case this C:/StellarisWare/driverlib/

The first thing that needs to be setup with the Stellaris is the system clock, the following code below uses the external crystal oscillating at 8MHz.

// Set the system clock to run directly from the crystal
	SysCtlClockSet(
			SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN
					| SYSCTL_XTAL_8MHZ);

// Set the system clock to run directly from the crystal

SysCtlClockSet(

SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN

| SYSCTL_XTAL_8MHZ);

Next the PWM peripheral needs to be enabled, there are 3 PWM modules on the LM3S6965 evaluation board. For this example PWM0 will be used, which is located on GPIO port F.

// Enables PWM pheripheral
	SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);
// Enables GPIO port F where PWM0 is located
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

// Enables PWM pheripheral

SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM);

// Enables GPIO port F where PWM0 is located

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

The next step is assign a pin type to the GPIO, there is a specific function to configure a pin or pins for use by the PWM peripheral.

//PWM0 is on GPIO port F, pin 0
	GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0);

1 2	//PWM0 is on GPIO port F, pin 0 GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0);

PWM0 and GPIO pin 0 on port F is assigned, this combination was used for the PWM as it allows the onboard status LED to be controlled by varying the brightness, and will also allow a meter to be used to measure the frequency from the PWM. The image below and left shows the I/O Break Pads, the image on the right the on board peripheral signals, both are extracts from the LM3S6965 evaluation board user guide.

After the GPIO is setup the PWM can now be configured. As stated before there are 3 PWM modules on this particular microprocessor, only 1 is being used in this example PWM0. Each PWM generator module has a 16 bit counter, 2 PWM comparators, a PWM signal generator, a dead-band generator and an interrupt/ADC-trigger selector. This program example will just produce a simple output using the up down counter.

PWMGenConfigure() is used to set the mode of operation for the PWM generator. The counting mode, syncronization mode, and debug behaviour are all configured. Once configured the generator is in a disabled state. A code snippet of this function is shown below.

// Configuring PWM Generator,
// \param ulBase is the base address of the PWM module
// \param ulGen is the PWM generator to configure.  This parameter must be one
// of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2.
// PWM_GEN_0 controls PWM0 and PWM1
// \param ulConfig is the configuration for the PWM generator and uses a
// logical OR carry out the configuration
// Here PWM_GEN_MODE_UP_DOWN sets the counting mode to counting down and
// PWM_GEN_MODE_NO_SYNC sets the counter load and comparator update sync mode
	PWMGenConfigure(PWM_BASE, PWM_GEN_0,PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);

// Configuring PWM Generator,

// \param ulBase is the base address of the PWM module

// \param ulGen is the PWM generator to configure. This parameter must be one

// of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2.

// PWM_GEN_0 controls PWM0 and PWM1

// \param ulConfig is the configuration for the PWM generator and uses a

// logical OR carry out the configuration

// Here PWM_GEN_MODE_UP_DOWN sets the counting mode to counting down and

// PWM_GEN_MODE_NO_SYNC sets the counter load and comparator update sync mode

PWMGenConfigure(PWM_BASE, PWM_GEN_0,PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);

PWMGenPeriodSet() is used to set the period of the PWM generator. Note the comment regarding the placement of this function with regards to PWMGenConfigure().

// **Should be called after PWMGenConfigure has been called as changes to the
// mode affect the period of the PWM signals produced**
// \param ulBase is the base address of the PWM module
// \param ulGen is the PWM generator to be modified.  This parameter must be
// one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2.
// PWM_GEN_0 controls PWM0 and PWM1
// \param ulPeriod specifies the period of PWM generator output, measured
// in clock ticks.
// Clock is set to 8MHz therefore the period is 125nS
// Therefore 333*125nS gives a frequency of 24.024kHz
	PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 333);

// **Should be called after PWMGenConfigure has been called as changes to the

// mode affect the period of the PWM signals produced**

// \param ulBase is the base address of the PWM module

// \param ulGen is the PWM generator to be modified. This parameter must be

// one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2.

// PWM_GEN_0 controls PWM0 and PWM1

// \param ulPeriod specifies the period of PWM generator output, measured

// in clock ticks.

// Clock is set to 8MHz therefore the period is 125nS

// Therefore 333*125nS gives a frequency of 24.024kHz

PWMGenPeriodSet(PWM_BASE, PWM_GEN_0, 333);

PWMPulseWidthSet() is used to set the width of the pulse for the specified PWM ouput. Note the comment regarding the placement of this function with regards to PWMGenConfigure().

// **Should be called after PWMGenConfigure has been called as changes to the
// mode affect the period of the PWM signals produced**
// Sets the pulse width for the specified PWM output.
// \param ulBase is the base address of the PWM module.
// \param ulPWMOut is the PWM output to modify.  This parameter must be one
// of \b PWM_OUT_0, \b PWM_OUT_1, \b PWM_OUT_2, \b PWM_OUT_3, \b PWM_OUT_4,
// \b PWM_OUT_5.
// \param ulWidth specifies the width of the positive portion of the pulse.
// With a period of 333, a value of 166 here should produce nice a square wave
	PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, 166);

// **Should be called after PWMGenConfigure has been called as changes to the

// mode affect the period of the PWM signals produced**

// Sets the pulse width for the specified PWM output.

// \param ulBase is the base address of the PWM module.

// \param ulPWMOut is the PWM output to modify. This parameter must be one

// of \b PWM_OUT_0, \b PWM_OUT_1, \b PWM_OUT_2, \b PWM_OUT_3, \b PWM_OUT_4,

// \b PWM_OUT_5.

// \param ulWidth specifies the width of the positive portion of the pulse.

// With a period of 333, a value of 166 here should produce nice a square wave

PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, 166);

PWMGenEnable() is used to enable the timer/counter of the PWM generator.

// Enables the timer/counter for a PWM generator block.
// \param ulBase is the base address of the PWM module.
// \param ulGen is the PWM generator to be enabled.  This parameter must be
// one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2.
	PWMGenEnable(PWM_BASE, PWM_GEN_0);

// Enables the timer/counter for a PWM generator block.

// \param ulBase is the base address of the PWM module.

// \param ulGen is the PWM generator to be enabled. This parameter must be

// one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2.

PWMGenEnable(PWM_BASE, PWM_GEN_0);

PWMOutputState() enables or disables the PWM outputs.

// Enables or disables PWM outputs.
// \param ulBase is the base address of the PWM module.
// \param ulPWMOutBits are the PWM outputs to be modified.  This parameter
// must be the logical OR of any of \b PWM_OUT_0_BIT, \b PWM_OUT_1_BIT,
// \b PWM_OUT_2_BIT, \b PWM_OUT_3_BIT, \b PWM_OUT_4_BIT, \b PWM_OUT_5_BIT.
// \param bEnable determines if the signal is enabled or disabled.
// The parameter \e bEnable determines the state of the selected outputs.  If \e bEnable is
// \b true, then the selected PWM outputs are enabled, or placed in the active
// state.  If \e bEnable is \b false, then the selected outputs are disabled
// or placed in the inactive state.
	PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, 1);

// Enables or disables PWM outputs.

// \param ulBase is the base address of the PWM module.

// \param ulPWMOutBits are the PWM outputs to be modified. This parameter

// must be the logical OR of any of \b PWM_OUT_0_BIT, \b PWM_OUT_1_BIT,

// \b PWM_OUT_2_BIT, \b PWM_OUT_3_BIT, \b PWM_OUT_4_BIT, \b PWM_OUT_5_BIT.

// \param bEnable determines if the signal is enabled or disabled.

// The parameter \e bEnable determines the state of the selected outputs. If \e bEnable is

// \b true, then the selected PWM outputs are enabled, or placed in the active

// state. If \e bEnable is \b false, then the selected outputs are disabled

// or placed in the inactive state.

PWMOutputState(PWM_BASE, PWM_OUT_0_BIT, 1);

In this example a frequency of approximately 24kHz was generated, with approximately a 50% duty cycle. The image below shows a basic multimeter with a frequency counter, displaying a value which coincided with the example program, and 2 further images showing Oscilloscope traces with the PWM duty cycle at 50% and 15%.

Image with PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, 166);

Image with PWMPulseWidthSet(PWM_BASE, PWM_OUT_0, 50);

Example Code

Stellaris LM3S6965 PWM C code

Arduino, C2000, Electronics, MSP430, Raspberry Pi, Stellaris, Tiva

Microcontroller GPIO Protection Tutorial

July 17, 2013 Ant 4 Comments

Microcontroller GPIO protection is an essential element of any circuit design.

GPIO ports generally have maximum voltage and current ratings, if these are exceeded it can result in the microcontroller being damaged or completely destroyed.

Therefore it is important to use external circuitry to protect the ports from excessive voltage, or excessive current being sourced from a pin.

The principles used in this post are for the MSP430G2231, however they can be applied to Arduino, Raspberry Pi and other microcontrollers, by taking into account the voltage and current specifications for each microcontroller, then changing the zener diode and resistor value accordingly.

Over Voltage Protection

This is fairly easy to achieve with some basic external components, to explain this a simple example will be used based on the Texas Instruments MSP430G2231. The maximum ratings for the integrated circuit need to be determined, this information can be obtained from the devices datasheet, MSP430G2231 datasheet can be found here.

The image below shows an extract from the MSP430G2231 datasheet, the maximum voltage rating can clearly be seen as 4.1V, there is also a cautionary warning which should be noted.

Now lets assume we are using one of the ports as an ADC input for a sensor, the voltage range for the ADC input on the MSP430G range is 0V to 3V. So now we know the operating range and the maximum voltage, we can design some simple interface circuitry to ensure the microcontroller is protected.

The schematic diagram below shows a basic circuit which could be used to protect against over voltage.

The main components here that provide the over voltage protection, are D1 and R3. D1 is a 3V3 Zener diode, which clamps the voltage if it exceeds 3.3V. R3 has a dual purpose firstly if the voltage exceeds 3.3V the excess voltage will be dropped across the resistor, as the diode will have 3.3V across it i.e. over voltage is 5V, R3 will have 1.7V across it and D1 will have the remaining 3.3V across it. R3 also acts as a current limit resistor, and Ohm’s Law can be used to calculate the maximum current with a known voltage. Something to note here is the zener diode will take approximately 5mA of current in normal operation, this is less than ideal for battery operated applications.

The other components R1, R2 and the opamp are here to simulate a dummy sensor input. However by designing a circuit using a single rail to rail opamp, the output of the opamp cannot exceed it’s rail to rail voltage, so with a supply of 0 to 3.3V the output cannot exceed 3.3V. Therefore using a rail to rail opamp in a configuration similar to the one shown, can eliminate the need for the zener diode altogether.

Over Current Protection

Over current protection as with over voltage protection, is quite simple to achieve. Again it is best to consult the datasheet for the device to determine the current ratings, as can be seen below in an extract from the MSP430G2231 datasheet.

So the maximum recommended current that can be sourced or sunk is 6mA, and the total maximum current for all ports is 48mA (MSP430G2231 has 10 GPIO pins in total). There are some further graphs shown in the datasheet, these show that it is possible to source 8mA from a GPIO pin, but the voltage on this pin will drop to approximately 2.7V as a result of the high current. I would not recommend placing a load which draws 8mA, especially not on more than 1 pin, I always try to keep the current drawn from a GPIO around 1mA in most circumstances. We can also see the voltage from the GPIO pins will be 3V.

By placing a resistor directly connected to the GPIO pin before any additional circuitry, we can limit the amount of current being sourced from the pin. This resistor can be calculated by taking the 3V provided by the GPIO pin, lets assume we want to limit the current to 1mA, this gives us a value of 3kΩ the nearest standard value (going up) is therefore 3.3kΩ. This calculation can also be reversed and used to prevent excessive currents being sunk by the microcontroller.

3V rated at 1mA is not going to give much scope for driving external circuitry i.e. an LED or a relay, so it is best to use this to drive a transistor, using the transistor as a switch.

Coder-Tronics

Category Archives: Stellaris

Stellaris ADS1118 Tutorial

ADS1118 Package

ADS1118 SPI Operation

C Code

Example Code

Stellaris LM3S6965 PWM Tutorial

Example Code

Microcontroller GPIO Protection Tutorial

Over Voltage Protection

Over Current Protection

Microcontrollers, Electronics and C Programming

ADS1118 Package

ADS1118 SPI Operation

C Code

Example Code

Share this:

Example Code

Share this:

Over Voltage Protection

Over Current Protection

Share this:

Microcontrollers, Electronics and C Programming