Arduino - Using digital potentiometers (AD8403)

I have seen several blog posts covering the use of digital potentiometers with an Arduino but I haven't seen any that demonstrate digital pots that contain a shutdown circuit. I'm working on a project that needs this particular feature.

The shutdown circuit is of interest to me because I plan on interfacing with something that controls movement. In that application any value on the digital pot will cause a motor to move. Lower resistive values move forward and higher resistive values move back. I need a way to completely disable the potentiometer. My first prototype used two relays, two transistors and two resistors with different values. The Arduino would turn off and on the relays to cause movement. It worked because I could simply turn off both relays but it was quite bulky and the mechanical relays were noisy. A friend recommend a digital potentiometer as a replacement. A single digital pot chip would replace six components. I began researching them and found that not all of them include a shutdown circuit. I settled on the Analog Devices AD8403 chip. It is a quad channel, 256 position digitally controlled variable resistor. Communication is done through an SPI interface.

So lets start with a demonstration of what happens when there is no shutdown circuit on a digital potentiometer and the Arduino is reset. The circuit and code cycles through each digital pot varying the brightness of an LED by running up and down all 255 positions of the pot. While this is running I press the reset button on the Arduino.



In this situation the digital pot chip still has power and the value of one the pots is stuck while the Arduino resets (demonstrated by the LED staying lit). In my real application this would cause movement to continue until the board finished restarting which is highly undesirable. This effect could be minimized somewhat by including code to reset values of the four pots on startup but there would still be a second or two of uncontrolled movement while the board restarts.

Next is a demonstration of the same circuit but with the shutdown circuit enabled. The shutdown pin is connected to a pull down resistor. This causes the chip to go into shutdown mode if the Arduino resets or loses power. Again I press the reset button on the Arduino as it is running the code.



This is getting close to what I want but there is still the problem of the pot being set to some unknown value when the AD8B403 is taken out of shutdown mode. To handle this I added code to the setup function that sets the pots to a known value (zero in this case) before taking the chip out of shutdown mode.

Circuit

Here is a photo and Fritzing diagram of the circuit.

The connections are:

  * All A pins of AD8403 connected to +5V

  * All B pins of AD8403 connected to ground

  * An LED and a 220-ohm resisor in series connected from each W pin to ground

  * RS - to +5v

  * SHDN - to digital pin 7 and a 10k ohm pull down resistor

  * CS - to digital pin 10  (SS pin)

  * SDI - to digital pin 11 (MOSI pin)

  * CLK - to digital pin 13 (SCK pin)

The AD8403 is the 10k ohm version.

The Fritzing diagram is available here: https://github.com/matt448/arduino/raw/master/SPI_Digital_Pot_AD8403/SPI_Digital_Pot_AD8403.fzz

Code

The most update to date version of the code is available here: https://github.com/matt448/arduino/blob/master/SPI_Digital_Pot_AD8403/SPI_Digital_Pot_AD8403.ino

The code to control this isn't very complex. This is my first time using an SPI device and I found it to be very straight forward. The Arduino IDE has an example sketch for controlling SPI digital pots under File > Examples > SPI > DigitalPotControl. I started with the example and modified it to include shutdown control. That example code also ran a bit slow because of the serial console messages so I removed all the serial communication code.

	/*
	Digital Pot Control
	This example controls an Analog Devices AD8403 digital potentiometer.
	The AD8403 has 4 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 AD8403 is SPI-compatible. To command it you send two bytes.
	The first byte is the channel number starting at zero: (0 - 3)
	The second byte is the resistance value for the channel: (0 - 255).
	The AD8403 also contains shutdown (SHDN) and reset (RS) pins. The shutdown
	pin disables all four of the potentiometers when taken low and enables all
	pots when high. The values of the pots can be adjusted while shutdown is active.
	The reset pin sets all of the pots back to their center value when taken low.
	Reset may or may not be useful for your particular application. In this circuit
	reset is simply tied to +5v to keep it inactive.
	The circuit:
	* All A pins of AD8403 connected to +5V
	* All B pins of AD8403 connected to ground
	* An LED and a 220-ohm resisor in series connected from each W pin to ground
	* RS - to +5v
	* SHDN - to digital pin 7 and a pull down resistor
	* CS - to digital pin 10 (SS pin)
	* SDI - to digital pin 11 (MOSI pin)
	* CLK - to digital pin 13 (SCK pin)
	Thanks to Tom Igoe and Heather Dewey-Hagborg for their code which this was built on.
	*/
	// 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;
	void setup() {
	// set the slaveSelectPin as an output
	pinMode (slaveSelectPin, OUTPUT);
	// set the shutDownPin as an output
	pinMode (shutDownPin, OUTPUT);
	// initialize SPI
	SPI.begin();
	//Shutdown the pots to start with
	digitalWrite(shutDownPin, LOW);
	//Set all pots to zero as a starting point
	for (int channel = 0; channel < 4; channel++) {
	digitalPotWrite(channel, 0);
	}
	}
	void loop() {
	digitalWrite(shutDownPin, LOW);
	int channel = 0;
	// Loop through the four channels of the digital pot.
	for (int channel = 0; channel < 4; channel++) {
	// Change the resistance on this channel from min to max.
	// Starting at 50 because the LED doesn't visibly change
	// before that point.
	digitalWrite(shutDownPin, HIGH);
	for (int level = 50; level < 255; level++) {
	digitalPotWrite(channel, level);
	delay(2);
	}
	// wait a bit at the top
	delay(5);
	digitalWrite(shutDownPin, LOW);
	// change the resistance on this channel from max to min:
	digitalWrite(shutDownPin, HIGH);
	for (int level = 0; level < 205; level++) {
	digitalPotWrite(channel, 255 - level);
	delay(2);
	}
	}
	digitalWrite(shutDownPin, LOW);
	}
	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 SPI_Digital_Pot_AD8403.ino hosted with ❤ by GitHub

Comment on shutdown pin

So after getting through all this testing I noticed a limitation of the shutdown pin, it shuts down all four pots at the same time. In my real application I plan on controlling movement on four separate motors and moving them to a certain positions. Once the motor reaches it's position I want it to stop. But the only way to stop the motor is activate the shutdown which deactivates all four pots. This is a problem because the other three motors may not have reached their position when I need to shutdown. I did some more looking and found that Microchip makes a digital pot that has individually controllable software shutdown for each pot. I'm going to order a couple MCP4251 chips and I'll write up another post when I test them out.

UPDATE 3/17/2014: Post about the MCP4251 is available here
UPDATE 3/27/2014: Added list of connections and resistor values. Also added links to github repo.

Arduino - Sending data over a CAN bus

I have been tinkering with CAN buses due to my interest in cars. It's fascinating to me that packets are flying around a modern vehicle controlling nearly everything. Gauges, lights, locks, engine sensors, etc. To have a better understanding of the basics of a CAN bus I wanted to build the simplest possible setup to send and receive CAN messages. I chose two Arduino Uno's with a Seeed Studio CAN-BUS shield attached to each Uno. The Seeed shield is very straight forward and inexpensive. The Sparkfun CAN-BUS shield has an SD card slot, LCD connector and GPS connector. All of which are cool but drive up the price and complexity. The Seeed shield only does CAN bus and includes screw terminals which are handy for testing.

Arduino Uno R3	Seeed CAN-BUS Shield

What I wanted to do with this experiment was transmit the value of an analog pin hooked up to a linear potentiometer. The data would be sent from one Arduino to another over a CAN bus and then display that value on an LCD connected to the second Arduino. Here is a picture of my setup. (Ignore the Mega2560 above the LCD. It's not used here.)

And here is a Fritzing diagram minus the CAN-BUS shields.

CAN bus termination

A CAN bus requires 120 Ohm termination resistors at each end of the bus. The Seeed Studio shields have built in termination resistors. When you connect two Seeed CAN bus shields togther like I did in this example you will have a properly terminated CAN bus. If you plan on connecting into an existing CAN bus that already has termination you can disable the built in termination resistors. To disable termination you can cut trace P1 or you can desolder resistor R1.

Close up view of the Seeed CAN bus shield
 termination resistors.

**Note: I have recently discovered the Seeed Studio CAN-BUS shield v1.0 uses a 60 ohm termination resistor for R3. While that worked for this small demo I later ran into issues when trying to use this shield with other nodes on a CAN bus. This 60 ohm resistor caused me many hours of frustration. If you are going to use this shield with on a bus with multiple nodes I would recommend desoldering R3 and using the correct 120 ohm resistance at the ends of your bus. 

Connecting into an existing CAN bus

If you are planning on connecting into an existing CAN bus (like in a car) you need to remove/disable the termination resistor on the shield as explained above. The CAN bus in a vehicle already has termination resistors. Adding a new node with a termination resistor will cause errors and disrupt communication on the bus.

Another important step is to connect a common ground between your Arduino board and the vehicle. If you are connecting at the OBD2 port pin 5 provides a signal ground. If you can't find a signal ground wire a chassis ground will suffice.

CAN bus messages

So I should probably explain a bit about CAN bus messages. Each message is made up of an id and some data. The id's in hex start at 0x000 and go to 0x7FF or 0 to 2047 in decimal. In most systems lower id values are considered more important. The bus handles collisions by letting the lower id win the collision. The data can be between 1 and 8 bytes for each message. Each byte can have a value from 0 to 255 or in hex 0x00 to 0xFF. When you send a CAN bus message you transmit the id, how many bytes you are sending (this is called DLC) and the actual data. The receiver will only read the number of bytes you said should be in the message. So if you send a DLC of 4 but the message contains 8 bytes the receiver will only read the first 4 bytes. Eight bytes per message is a bit limiting but the tradeoff is the high reliability of the bus. So sometimes you have to be creative with stuffing data into those bytes. If the value you are sending is less than 255 you can just use a single byte. Larger numbers will require using multiple bytes. Ascii codes can be sent but only eight characters per message. Whatever method you use to stuff the data in will also have to be used to un-stuff the data on the receiver. In my simple example here I did some math to limit the range of values to 0-255. An analog pin produces values between 0-1024. I simply divided the result by four to give me data I could send in a single byte.

CAN buses can operate at several different speeds up to 1 Mbit/s. Typical rates are 100 kbit/s, 125 kbit/s and 500 kbit/s. Slower rates allow for longer length buses. All devices on a bus must transmit at the same speed. The CAN bus wikipedia page is a good place to start if you want to learn more about the CAN protocol.

Code

I started with the example code provided by Seeed and modified it to add in the LCD output on the 'receiver' device and added reading of the potentiometer on A0 for the value that is transmitted. They have basic examples for send and receive. You can find some good info on their wiki page. Their libraries are available here. On my Mac I created the directory ~/Documents/Arduino/libraries/CAN_BUS_Shield for the library files. I unzipped the file and copied over the .h and .cpp files into that new directory. The zip file also contains the send and receive examples.

Note that normally devices on a CAN bus are both receivers and transmitters of data. This is a simplified example where each device is only doing one task.

Sender code

	// demo: CAN-BUS Shield, send data
	#include <mcp_can.h>
	#include <SPI.h>
	//Pot for adjusting value
	int sensorPin = A0;
	int sensorValue = 0;
	int cantxValue = 0;
	void setup()
	{
	Serial.begin(115200);
	// init can bus, baudrate: 100k
	if(CAN.begin(CAN_100KBPS) ==CAN_OK) Serial.print("can init ok!!\r\n");
	else Serial.print("Can init fail!!\r\n");
	}
	//Some sample CAN messages
	unsigned char msg1[8] = {0, 1, 2, 3, 4, 5, 6, 7};
	unsigned char msg2[8] = {0xFF, 0x01, 0x10, 0x0A, 0x00, 0x00, 0x00, 0x00};
	unsigned char msg3[4] = {0xFF, 0x01, 0x10, 0x0A};
	void loop()
	{
	//Read the value of the pot
	sensorValue = analogRead(sensorPin);
	//Each CAN bus byte can store a value between 0-255.
	//Dividing sensorValue by 4 puts us in that range.
	cantxValue = sensorValue / 4;
	Serial.print("cantxValue: ");
	Serial.print(cantxValue);
	Serial.println();
	//Create data packet for CAN message
	unsigned char canMsg[8] = {cantxValue, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	// send data: id = 0x123, standrad flame, data len = 8, stmp: data buf
	CAN.sendMsgBuf(0x07B, 0, 8, canMsg);
	delay(100);
	}

view raw can_sender.ino hosted with ❤ by GitHub

Receiver code

	// demo: CAN-BUS Shield, receive data
	#include "mcp_can.h"
	#include <SPI.h>
	#include <LiquidCrystal.h>
	#include <stdio.h>
	#define INT8U unsigned char
	INT8U Flag_Recv = 0;
	INT8U len = 0;
	INT8U buf[8];
	INT32U canId = 0x000;
	char str[20];
	LiquidCrystal lcd(9, 8, 7, 6, 5, 4);
	void setup()
	{
	lcd.begin(20, 4);
	CAN.begin(CAN_100KBPS); // init can bus : baudrate = 100k
	attachInterrupt(0, MCP2515_ISR, FALLING); // start interrupt
	Serial.begin(115200);
	}
	void MCP2515_ISR()
	{
	Flag_Recv = 1;
	}
	void loop()
	{
	if(Flag_Recv) // check if data was recieved
	{
	Flag_Recv = 0; // clear flag
	CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf
	canId = CAN.getCanId();
	//Print data to the serial console
	//and the LCD display
	Serial.println("CAN_BUS GET DATA!");
	Serial.print("CAN ID: ");
	Serial.println(canId);
	lcd.setCursor(0, 0);
	lcd.print("CAN ID: ");
	lcd.print(canId);
	lcd.setCursor(0, 2);
	Serial.print("data len = ");Serial.println(len);
	//This loops through each byte of data and prints it
	for(int i = 0; i<len; i++) // print the data
	{
	Serial.print(buf[i]);Serial.print("\t");
	lcd.print(buf[i]);
	lcd.print(" ");
	}
	Serial.println();
	delay(50);
	}
	}

view raw can_reciever.ino hosted with ❤ by GitHub

Video

[Updated 2014-05-25: Noted value of A0 potentiometer in the Fritzing diagram]
[Updated 2014-07-21: Added section about termination resistors]
[Updated 2014-09-25: Added note about incorrect value of resistor R3 on Seeed's shield]
[Updated 2015-03-10: Added additional notes about termination resistors]
[Updated 2017-03-27: Added new section 'Connecting into an existing CAN bus']
[Updated 2018-06-15: Fixed broken links for Seeed-Studio wiki and libraries]

Nagios monitoring for Amazon SQS queue depth

I have found that a bunch of messages stacking up in my SQS queue's can be the first sign of something breaking. Several things can cause messages to stack up in the queue. I have seen malformed messages, slow servers and dead processes all cause this at different times. So to monitor the queue depth I wrote this Nagios check / plug-in. The check simply queries the SQS api and finds out the count of messages in each queue. Then it compares the count to the warning and critical levels.

This check is written in python and uses the boto library. It includes perfdata output so you can graph the number of messages in the queue. The the AWS API for SQS does wildcard matching of queue names so you can monitor a bunch of queues with one check if they have some sort of common prefix to the name. The way I use this is I have several individual checks using the complete explicit name of the queue and then a catchall using a wildcard set to a higher number that will catch any queues that have been added. Make sure you have a .boto file for the user that will be running this nagios check. It only requires read permissions.

Some queues may be more time sensitive than others. That is the case for my setup. For queues that are time sensitive I set the warning and critical counts to low values. Less time sensitive queues are set to higher count values. This screenshot is an example of that:

Config

Here is the command definition I use for Naigos:

# 'check_sqs_depth' command definition
define command{
        command_name    check_sqs_depth
        command_line    /usr/lib/nagios/plugins/check_sqs_depth.py --name '$ARG1$' --region '$ARG2$' --warn '$ARG3$' --crit '$ARG4$'
        }

and here is the service definition I'm using

define service{
        use                                 generic-service   
        host_name                      sqs.us-east-1
        service_description          example_name SQS Queue
        contact_groups                admins,admins-page,sqs-alerts
        check_command             check_sqs_depth!example_name!us-east-1!150!300!
        }

Code

The code is available on my github nagios-checks repository here: https://github.com/matt448/nagios-checks and I have posted it as a gist below. My git repository will have the most up-to-date version

	#!/usr/bin/python
	##########################################################
	#
	# Written by Matthew McMillan, matthew.mcmillan@gmail.com
	#
	# Requires the boto library and a .boto file with read
	# permissions to the queues.
	#
	import sys
	import argparse
	import boto
	import boto.sqs
	def printUsage():
	print
	print "Example: ", sys.argv[0], "--name myqueue --region us-east-1 --warn 10 --crit 20"
	print
	#Parse command line arguments
	parser = argparse.ArgumentParser(description='This script is a Nagios check that \
	monitors the number of messages in Amazon SQS \
	queues. It requires a .boto file in the user\'s \
	home directroy and AWS credentials that allow \
	read access to the queues that are to be monitored.')
	parser.add_argument('--name', dest='name', type=str, required=True,
	help='Name of SQS queue. This can be a wildcard match. \
	For example a name of blah_ would match blah_1, \
	blah_2, blah_foobar. To monitor a single queue, enter \
	the exact name of the queue.')
	parser.add_argument('--region', dest='region', type=str, default='us-east-1',
	help='AWS Region hosting the SQS queue. \
	Default is us-east-1.')
	parser.add_argument('--warn', dest='warn', type=int, required=True,
	help='Warning level for queue depth.')
	parser.add_argument('--crit', dest='crit', type=int, required=True,
	help='Critical level for queue depth.')
	parser.add_argument('--debug', action='store_true', help='Enable debug output.')
	args = parser.parse_args()
	# Assign command line args to variable names
	queueName = args.name
	sqsRegion = args.region
	warnDepth = args.warn
	critDepth = args.crit
	if critDepth <= warnDepth:
	print
	print "ERROR: Critical value must be larger than warning value."
	printUsage()
	exit(2)
	qList = []
	depthList = []
	statusMsgList = []
	statusMsg = ""
	msgLine = ""
	perfdataMsg = ""
	warnCount = 0
	critCount = 0
	exitCode = 3
	# Make SQS connection
	conn = boto.sqs.connect_to_region(sqsRegion)
	rs = conn.get_all_queues(prefix=queueName)
	# Loop through each queue and get message count
	# Push the queue name and depth to lists
	for qname in rs:
	namelist = str(qname.id).split("/") # Split out queue name
	qList.append(namelist[2])
	depthList.append(int(qname.count()))
	if args.debug:
	print
	print '========== Queue List ============='
	print qList
	print '=================================='
	print
	# Build status message and check warn/crit values
	for index in range(len(qList)):
	if depthList[index] >= warnDepth and depthList[index] < critDepth:
	warnCount += 1
	if depthList[index] >= critDepth:
	critCount += 1
	#print index, ": ", qList[index], depthList[index]
	msgLine = qList[index] + ":" + str(depthList[index])
	statusMsgList.append(msgLine)
	# Set exit code based on number of warnings and criticals
	if warnCount == 0 and critCount == 0:
	statusMsgList.insert(0, "OK - Queue depth (")
	exitCode = 0
	elif warnCount > 0 and critCount == 0:
	statusMsgList.insert(0, "WARNING - Queue depth (")
	exitCode = 1
	elif critCount > 0:
	statusMsgList.insert(0, "CRITICAL - Queue depth (")
	exitCode = 2
	else:
	statusMsgList.insert(0, "UNKNOWN - Queue depth (")
	exitCode = 3
	# Build status message output
	for msg in statusMsgList:
	statusMsg += msg + " "
	# Build perfdata output
	for index in range(len(qList)):
	perfdataMsg += qList[index] + "=" + str(depthList[index]) + ";" + str(warnDepth) + ";" + str(critDepth) + "; "
	# Finalize status message
	statusMsg += ") [W:" + str(warnDepth) + " C:" + str(critDepth) + "]"
	# Print final output for Nagios
	print statusMsg + "|" + perfdataMsg
	# Exit with appropriate code
	exit(exitCode)

view raw check_sqs_depth.py hosted with ❤ by GitHub