Table of Contents
STM_2: Using a digital potentiometer
Digital potentiometer DS1803 is an I2C-controlled device that digitally controls the resistance between the outputs as in a real turning potentiometer.
While in the turning potentiometers, there are wipers which are moving from minimal to a maximal value, in digital potentiometers there are no movable parts. Everything is implemented in a silicon.
DS1803 has two digital potentiometers controlled independently. We use just one with the lower cardinal number (index 0). In our example, it is a 100k spread between GND and VCC, and its output is connected to the ADC (analogue to digital converter) input of the STM32 SoC. This way, the potentiometer's electronic wiper is controlled remotely via the I2C bus.
The device's I2C address is 0x28, and the ADC input GPIO pin is 7.
The digital potentiometer in our laboratory node forms then a loopback device: it can be set (also read) via I2C, and the resulting voltage can be measured on the separate PIN (ADC) 1. This way, it is possible, e.g. to draw a relation between the potentiometer setting and ADC readings to check whether it is linear or forms some other curve.
Reading of the ADC is possible using the regular analogRead(pin) function. In STM32WB55 there are 16 analogue inputs, and the potentiometer is connected to the pin A4 (PC_3 in Nucleo numbering).
Prerequisites
To implement this scenario, it is advised to get familiar with at least one of the following scenarios first:
They enable you to present the data on the display (i.e. readings).
To handle communication with the DS1803 digital potentiometer, we use bare I2C programming. For this reason, we need to include only the I2C protocol library:
#include <Wire.h>
Below, we present a sample control library that you need to include in your code:
enum POT_LIST {POT_1 = 0xA9, POT_2=0xAA, POT_ALL=0xAF}; //We have only POT_1 connected typedef enum POT_LIST POT_ID; //Prototypes void setPotentiometer(TwoWire& I2CDev, byte potValue, POT_ID potNumber); byte readPotentiometer(TwoWire& I2CDev, POT_ID potNumber); //Implementation void setPotentiometer(TwoWire& I2CDev, byte potValue, POT_ID potNumber) { I2CDev.beginTransmission(DS1803_ADDRESS); I2CDev.write(potNumber); I2CDev.write(potValue); I2CDev.endTransmission(true); }; byte readPotentiometer(TwoWire& I2CDev, POT_ID potNumber) //reads selected potentiometer { byte buffer[2]; I2CDev.requestFrom(DS1803_ADDRESS,2); buffer[0]=I2CDev.read(); buffer[1]=I2CDev.read(); return (potNumber==POT_1?buffer[0]:buffer[1]); };
readPotentiometer(…) function returns a value previously set to the digital potentiometer, not an actual ADC voltage reading! It returns a set value by setPotentiometer(…), which is on the “digital” side of the DS1803 device. Actual ADC reading can be obtained using analogRead(pin).
Suggested Readings and Knowledge Resources
Hands-on Lab Scenario
Task to be implemented
Iterate over the potentiometer settings, read related voltage readings via ADC, and present them in graphical form (as a plot). As the maximum resolution of the potentiometer is 256, you can use a plot of 256 points or any other lower value covering all ranges. Present graph (plot) on either ePaper or OLED display, and while doing the readings, you should present data in the LCD (upper row for a set value, lower for a reading of the ADC).
Start
Check if you can see all the displays. Remember to use potentiometer 1 (index 0) because only this one is connected to the ADC input of the ESP32 MCU. In steps 1-3, we present how to handle communication with a digital potentiometer and how to read the ADC input of the MCU. Methods for displaying the measurements and plotting the graph are presented in steps 4 and 5. Remember to include the functions above in your code unless you want to integrate them with your solution.
Steps
Below, we assume that you have embedded functions handling operations on the digital potentiometer as defined above in your source file. Remember to include the Wire.h library.
Step 1
Define ADC pin and Digital potentiometer chip DS1803 I2C address. All definitions are present in the following code:
#define POT_ADC A4 #define DS1803_ADDRESS 0x28
Step 2
Declare an array of readings that fits an OLED display. Adjust for ePaper resolution (horizontal) if using it. OLED is 128×128 pixels:
static int16_t aGraphArray[128];
Step 3
Include functions present in the PREREQUISITES section.
Step 4
Initialise the I2C bus and configure ADC's GPIO as input. Change the ADC resolution to 12-bits.
Wire.begin(); pinMode(POT_ADC, INPUT); analogReadResolution(12);
Step 4
Perform the loop that sets 128 values (scaled to the range 0 to 256) on the potentiometer's output and read the value back from the digital potentiometer via ADC input. Store readings in the array:
for(byte i=0; i<128; i++) { setPotentiometer(Wire, 2*i, POT_1); aGraphArray[i]=analogRead(POT_ADC); }
Step 5
Display on the OLED. Assume the following handler to the pointer to the display controller class:
Adafruit_SSD1351 oled
More information on OLED display is in the scenario STM_7: Using OLED display.
Note, ADC measures in the 12-bit mode (we assume such configuration, adapt factor if using other sampling resolution), so values stored in an aGraphArray array are between 0 and 4095.
float factor = 128./4095.; for(byte x=0;x<128;x++) { int16_t y=128-round(((float)aGraphArray[x])*factor); display.setPixel(x,y); } display.display();
Result validation
A relation between the potentiometer set value and ADC reading should be almost linear from 0V up to the maximum. The linear correlation is never perfect, either because of the devices' implementation imperfection (STM32's ADC input and digital potentiometer output) or because of the electromagnetic noise. There are many devices in our lab room.
FAQ
The ADC readings are changing slightly, but I have not changed the potentiometer value. What is going on?: The ADC in ESP32 is quite noisy, mainly when using WiFi parallelly. Refer to the Coursebook and ESP32 documentation on how to increase measurement time that will make internally many readings and return to you an average. Use the analogSetCycles(cycles) function to increase the number of readings for the averaging algorithm. The default is 8, but you can increase it up to 255. Note that the higher the cycles parameter value, the longer the reading takes, so tune your main loop accordingly, particularly when using an asynchronous approach (timer-based). Eventually, you can implement low-pass filters yourself (in the software).
