Arduino - Using digital potentiometers part 2 (MCP4251)

This is part two in a series of posts about using digital potentiometers with Arduino boards. Part one covered the AD8403 digital pot. This post will go over the MCP4251 from Microchip. The MCP4251 is a dual pot chip with the capability to individually disconnect the terminals of each wiper through software and a hardware shutdown pin that shuts down both wipers simultaneously. Communication with the chip is done over SPI. The chip is available in DIP and surface mount configurations. I bought the DIP version so I could use them on a breadboard. The specific part number I bought is MCP4251-103E/P which is a 10k ohm model with an 8 bit resistor network. The 8 bit versions have 256 possible positions for the wiper which works out to approximately 39 ohms increase in resistance for each wiper position on a 10k ohm model.

Two MCP4251 chips

I began searching for an Arduino software library for these pots. I found two but neither of them fit my needs. They didn't implement any of the TCON functionality which was the main reason I was interested in these pots. Here are links to those libraries if you are interested in trying them out:
   https://github.com/jmalloc/arduino-mcp4xxx and https://github.com/teabot/McpDigitalPot

Since there wasn't a preexisting library that would work for me I began figuring out how to talk to this chip. I started with the Arduino example in File > Examples > SPI > DigitalPotControl. The AD840x and AD520x series pots work right out of the box with this example but the MCP4xxx pots use different memory addresses so I started tweaking the example.

Understanding how to talk to the MCP4251

So lets start with the very basics of how to talk to these pots. Sending a command over SPI requires four steps:
1. Take the slave select pin LOW. This tells the chip to listen for commands.
2. Send the memory address for the item we want to change using SPI. This is the memory address for a wiper or terminal connections. This tells the chip what we want to change.
3. Send the new value for the item we specified in step 2. Wipers on the MCP4251 have 256 possible positions so this would be a decimal number between 0-255 or binary B00000000 - B11111111.
4. Take the slave select pin HIGH. This tells the chip to execute the changes.

The AD8406 covered in part 1 used decimal numbers 0-5 as memory addresses for each of the wipers which was very easy to understand. The MCP4251 doesn't use sequential values so I had to go digging in the data sheet to find the right values. Here is the memory map table from the data sheet:

Looking at the data sheet you can see the memory address and the data is made up of a total of 16 bits. The sheet says the data is 10 bits and the memory address is 6 bits but in practice you can send the data in two 8 bit chunks which allows you to use the 'B' binary formatter. The maximum possible value for a wiper is 255 which would be B11111111 in binary. So here is the list of memory addresses and tcon values I was able to determine:

wiper0writeAddr = B00000000;
wiper1writeAddr = B00010000;
  tconwriteAddr = B01000000;
  tcon_0off_1on = B11110000;
  tcon_0on_1off = B00001111;
 tcon_0off_1off = B00000000;
   tcon_0on_1on = B11111111;

The Wiring

Now that I had memory addresses figured out I wired up the digital pot on a breadboard with some LED's. I'm using LED's in this example because it's a good way to visualize the pots changing resistance values. I wired the shutdown pin to a 4.7k pull down resistor so the pot would go into shutdown mode if digital pin 7 wasn't HIGH. My example code also uses the software disconnects (TCON) to turn the LED's off and on.

The connections are:
* All A pins of MCP4251 connected to +5V
* All B pins of MCP4251 connected to ground
* An LED and a 220-ohm resistor in series connected from each W pin to ground
* VSS - to GND
* VDD - to +5v
* SHDN - to digital pin 7 and a 4.7k pull down resistor
* CS - to digital pin 10 (SS pin)
* SDI - to digital pin 11 (MOSI pin)
* SDO - to digital pin 12 (MISO pin)
* CLK - to digital pin 13 (SCK pin)

You can download the fritzing file here:
https://github.com/matt448/arduino/raw/master/MCP4251_tcon/MCP4251_tcon.fzz

and you can download the MCP4251 fritzing part I made here:
https://github.com/matt448/arduino/raw/master/MCP4251_tcon/MCP4251.fzpz

The code

Here is a Gist with the example code. The most recent version will be my the github repo here:
https://github.com/matt448/arduino/tree/master/MCP4251_tcon

	/*
	Matthew McMillan
	@matthewmcmillan
	http://matthewcmcmillan.blogspot.com
	Created 12 Mar 2014
	Digital Pot Control (MCP4251)
	This example controls a Microchip MCP4251 digital potentiometer.
	The MCP4251 has 2 potentiometer channels. Each channel's pins are labeled:
	A - connect this to voltage
	W - this is the pot's wiper, which changes when you set it
	B - connect this to ground.
	The MCP4251 also has Terminal Control Registers (TCON) which allow you to
	individually connect and disconnect the A,W,B terminals which can be useful
	for reducing power usage or motor controls.
	A value of 255 is no resistance
	A value of 128 is approximately 5k ohms
	A value of 0 is 10k ohm resistance
	The MCP4251 is SPI-compatible. To command it you send two bytes,
	one with the memory address and one with the value to set at that address.
	The MCP4251 has few different memory addresses for wipers and tcon (Terminal Control)
	*Wiper 0 write
	*Wiper 0 read
	*Wiper 1 write
	*Wiper 1 read
	*TCON write
	*TCON read
	The circuit:
	* All A pins of MCP4251 connected to +5V
	* All B pins of MCP4251 connected to ground
	* An LED and a 220-ohm resistor in series connected from each W pin to ground
	* VSS - to GND
	* VDD - to +5v
	* SHDN - to digital pin 7 and a 4.7k pull down resistor
	* CS - to digital pin 10 (SS pin)
	* SDI - to digital pin 11 (MOSI pin)
	* SDO - to digital pin 12 (MISO pin)
	* CLK - to digital pin 13 (SCK pin)
	created 12 Mar 2014
	Thanks to Heather Dewey-Hagborg and Tom Igoe for their original tutorials
	*/
	// inslude the SPI library:
	#include <SPI.h>
	// set pin 10 as the slave select for the digital pot:
	const int slaveSelectPin = 10;
	const int shutdownPin = 7;
	const int wiper0writeAddr = B00000000;
	const int wiper1writeAddr = B00010000;
	const int tconwriteAddr = B01000000;
	const int tcon_0off_1on = B11110000;
	const int tcon_0on_1off = B00001111;
	const int tcon_0off_1off = B00000000;
	const int tcon_0on_1on = B11111111;
	void setup() {
	// set the slaveSelectPin as an output:
	pinMode (slaveSelectPin, OUTPUT);
	// set the shutdownPin as an output:
	pinMode (shutdownPin, OUTPUT);
	// start with all the pots shutdown
	digitalWrite(shutdownPin,LOW);
	// initialize SPI:
	SPI.begin();
	}
	// This loop adjusts the brightness of two LEDs and
	// uses the TCON registers to indvidually disconnect
	// the wipers which turns off the LEDs.
	void loop() {
	digitalWrite(shutdownPin,HIGH); //Turn off shutdown
	delay(1000);
	digitalPotWrite(wiper0writeAddr, 200); // Set wiper 0 to 200
	digitalPotWrite(wiper1writeAddr, 200); // Set wiper 1 to 200
	delay(1000);
	digitalPotWrite(tconwriteAddr, tcon_0off_1on); // Disconnect wiper 0 with TCON register
	delay(1000);
	digitalPotWrite(tconwriteAddr, tcon_0off_1off); // Disconnect both wipers with TCON register
	digitalPotWrite(wiper0writeAddr, 255); //Set wiper 0 to 255
	delay(1000);
	digitalPotWrite(tconwriteAddr, tcon_0on_1on); // Connect both wipers with TCON register
	}
	// This function takes care of sending SPI data to the pot.
	void digitalPotWrite(int address, int value) {
	// take the SS pin low to select the chip:
	digitalWrite(slaveSelectPin,LOW);
	// send in the address and value via SPI:
	SPI.transfer(address);
	SPI.transfer(value);
	// take the SS pin high to de-select the chip:
	digitalWrite(slaveSelectPin,HIGH);
	}

view raw MCP4251_tcon.ino hosted with ❤ by GitHub

Up next

Part 3 in my series of digital potentiometer posts will cover reading data from the MCP4251 to determine the wiper positions and the tcon status. Part 4 will cover using multiple SPI digital potentiometers. I will add a links here as I complete those posts.