Analog Read | Technology Tutorials

Unfortunately the Raspberry Pi has no built in Analog to Digital converters for reading analog voltage values. So, what was a very easy task on the arduino becomes a more difficult task on the Pi. However, many applications and projects on the pi require reading analog values. In order to do this, we must interface to a ADC0834 Analog to Digital Converter chip. The video above provides in depth description of how to do this, but the resources below should also help you.

This diagram shows to to connect the ADC8034 to the Raspberry PI

You can click on the image for a closer view of the diagram.

In order to use the chip, you will need to install a python library on the raspberry pi. Create a python file on your raspberry pi, and name it:

ADC0834.py

You must name it exactly that. Note the 0 in the above file name is a zero. Now copy and paste the following code into the file:

#!/usr/bin/env python3
#-----------------------------------------------------
#
#		This is a program for all ADC chip. It 
#	convert analog singnal to digital signal.
#
#		This program is most analog signal modules' 
#	dependency. Use it like this:
#		`import ADC0834`
#		`sig = ADC0834.getResult(chn)`
#
#	*'chn' should be 0,1,2,3 represent for ch0, ch1, ch2, ch3
#	on ADC0834
#		

import RPi.GPIO as GPIO 
import time

ADC_CS  = 17
ADC_CLK = 18
ADC_DIO = 27

# using default pins for backwards compatibility
def setup(cs=17,clk=18,dio=27):
    global ADC_CS, ADC_CLK, ADC_DIO
    ADC_CS=cs
    ADC_CLK=clk
    ADC_DIO=dio
    GPIO.setwarnings(False)
    GPIO.setmode(GPIO.BCM)			# Number GPIOs by BCM mode
    GPIO.setup(ADC_CS, GPIO.OUT)		# Set pins' mode is output
    GPIO.setup(ADC_CLK, GPIO.OUT)		# Set pins' mode is output

def destroy():
    GPIO.cleanup()

# using channel = 0 as default for backwards compatibility
def getResult(channel=0):	 				# Get ADC result, input channel

    sel = int(channel > 1 & 1)
    odd = channel & 1
    # print("sel: {}, odd: {}".format(sel, odd))

    GPIO.setup(ADC_DIO, GPIO.OUT)
    GPIO.output(ADC_CS, 0)
    
    # Start bit
    GPIO.output(ADC_CLK, 0)
    GPIO.output(ADC_DIO, 1)
    time.sleep(0.000002)
    GPIO.output(ADC_CLK, 1)
    time.sleep(0.000002)

    # Single End mode
    GPIO.output(ADC_CLK, 0)
    GPIO.output(ADC_DIO, 1)
    time.sleep(0.000002)
    GPIO.output(ADC_CLK, 1)
    time.sleep(0.000002)

    # ODD
    GPIO.output(ADC_CLK, 0)
    GPIO.output(ADC_DIO, odd)
    time.sleep(0.000002)
    GPIO.output(ADC_CLK, 1)
    time.sleep(0.000002)

    # Select
    GPIO.output(ADC_CLK, 0)
    GPIO.output(ADC_DIO, sel)
    time.sleep(0.000002)
    GPIO.output(ADC_CLK, 1)

    time.sleep(0.000002)
    GPIO.output(ADC_CLK, 0)
    time.sleep(0.000002)

    # ODD
    # GPIO.output(ADC_CLK, 0)
    # GPIO.output(ADC_DIO, channel)
    # time.sleep(0.000002)
    # GPIO.output(ADC_CLK, 1)
    # GPIO.output(ADC_DIO, 1)
    # time.sleep(0.000002)
    # GPIO.output(ADC_CLK, 0)
    # GPIO.output(ADC_DIO, 1)
    # time.sleep(0.000002)

    dat1 = 0
    for i in range(0, 8):
        GPIO.output(ADC_CLK, 1);  time.sleep(0.000002)
        GPIO.output(ADC_CLK, 0);  time.sleep(0.000002)
        GPIO.setup(ADC_DIO, GPIO.IN)
        dat1 = dat1 << 1 | GPIO.input(ADC_DIO)  
    
    dat2 = 0
    for i in range(0, 8):
        dat2 = dat2 | GPIO.input(ADC_DIO) << i
        GPIO.output(ADC_CLK, 1);  time.sleep(0.000002)
        GPIO.output(ADC_CLK, 0);  time.sleep(0.000002)
    
    GPIO.output(ADC_CS, 1)
    GPIO.setup(ADC_DIO, GPIO.OUT)

    if dat1 == dat2:
        return dat1
    else:
        return 0

def getResult1():
    return getResult(1)


def loop():
    while True:
        for i in range(4):
            res = getResult(i)
            print ('res{} = {}'.format(i,res))
            time.sleep(0.1)
        time.sleep(1)

if __name__ == '__main__':		# Program start from here
    setup()
    try:
        loop()
    except KeyboardInterrupt:  	# When 'Ctrl+C' is pressed, the child program destroy() will be  executed.
        destroy()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

#!/usr/bin/env python3

#-----------------------------------------------------

# This is a program for all ADC chip. It

# convert analog singnal to digital signal.

# This program is most analog signal modules'

# dependency. Use it like this:

# `import ADC0834`

# `sig = ADC0834.getResult(chn)`

# *'chn' should be 0,1,2,3 represent for ch0, ch1, ch2, ch3

# on ADC0834

import RPi.GPIO as GPIO

import time

ADC_CS = 17

ADC_CLK = 18

ADC_DIO = 27

# using default pins for backwards compatibility

def setup(cs=17,clk=18,dio=27):

global ADC_CS, ADC_CLK, ADC_DIO

ADC_CS=cs

ADC_CLK=clk

ADC_DIO=dio

GPIO.setwarnings(False)

GPIO.setmode(GPIO.BCM) # Number GPIOs by BCM mode

GPIO.setup(ADC_CS, GPIO.OUT) # Set pins' mode is output

GPIO.setup(ADC_CLK, GPIO.OUT) # Set pins' mode is output

def destroy():

GPIO.cleanup()

# using channel = 0 as default for backwards compatibility

def getResult(channel=0): # Get ADC result, input channel

sel = int(channel > 1 & 1)

odd = channel & 1

# print("sel: {}, odd: {}".format(sel, odd))

GPIO.setup(ADC_DIO, GPIO.OUT)

GPIO.output(ADC_CS, 0)

# Start bit

GPIO.output(ADC_CLK, 0)

GPIO.output(ADC_DIO, 1)

time.sleep(0.000002)

GPIO.output(ADC_CLK, 1)

time.sleep(0.000002)

# Single End mode

GPIO.output(ADC_CLK, 0)

GPIO.output(ADC_DIO, 1)

time.sleep(0.000002)

GPIO.output(ADC_CLK, 1)

time.sleep(0.000002)

# ODD

GPIO.output(ADC_CLK, 0)

GPIO.output(ADC_DIO, odd)

time.sleep(0.000002)

GPIO.output(ADC_CLK, 1)

time.sleep(0.000002)

# Select

GPIO.output(ADC_CLK, 0)

GPIO.output(ADC_DIO, sel)

time.sleep(0.000002)

GPIO.output(ADC_CLK, 1)

time.sleep(0.000002)

GPIO.output(ADC_CLK, 0)

time.sleep(0.000002)

# ODD

# GPIO.output(ADC_CLK, 0)

# GPIO.output(ADC_DIO, channel)

# time.sleep(0.000002)

# GPIO.output(ADC_CLK, 1)

# GPIO.output(ADC_DIO, 1)

# time.sleep(0.000002)

# GPIO.output(ADC_CLK, 0)

# GPIO.output(ADC_DIO, 1)

# time.sleep(0.000002)

dat1 = 0

for i in range(0, 8):

GPIO.output(ADC_CLK, 1); time.sleep(0.000002)

GPIO.output(ADC_CLK, 0); time.sleep(0.000002)

GPIO.setup(ADC_DIO, GPIO.IN)

dat1 = dat1 << 1 | GPIO.input(ADC_DIO)

dat2 = 0

for i in range(0, 8):

dat2 = dat2 | GPIO.input(ADC_DIO) << i

GPIO.output(ADC_CLK, 1); time.sleep(0.000002)

GPIO.output(ADC_CLK, 0); time.sleep(0.000002)

GPIO.output(ADC_CS, 1)

GPIO.setup(ADC_DIO, GPIO.OUT)

if dat1 == dat2:

return dat1

else:

return 0

def getResult1():

return getResult(1)

def loop():

while True:

for i in range(4):

res = getResult(i)

print ('res{} = {}'.format(i,res))

time.sleep(0.1)

time.sleep(1)

if __name__ == '__main__': # Program start from here

setup()

try:

loop()

except KeyboardInterrupt: # When 'Ctrl+C' is pressed, the child program destroy() will be executed.

destroy()

This file, ADC0834.py, should then be put in the following directory:

/usr/lib/python3.7/

Moving or copying the file to that directory might require use of Sudo if you get a permissions error.

Now the following code will allow you to read the analog value coming from the potentiometer in the above circuit diagram:

import RPi.GPIO as GPIO
import ADC0834
import time

GPIO.setmode(GPIO.BCM)
ADC0834.setup()
try:
    while True:
        analogVal=ADC0834.getResult(0)
        print(analogVal)
        time.sleep(.2)
        
except KeyboardInterrupt:
    GPIO.cleanup()
    print('GPIO Good to Go')

import RPi.GPIO as GPIO

import ADC0834

import time

GPIO.setmode(GPIO.BCM)

ADC0834.setup()

try:

while True:

analogVal=ADC0834.getResult(0)

print(analogVal)

time.sleep(.2)

except KeyboardInterrupt:

GPIO.cleanup()

print('GPIO Good to Go')

In this lesson we will create a dimable LED. We will read an analog voltage from a potentiometer, and use that to set the brightness on an LED. In order to proceed with this lesson, you will need to connect the following circuit:

Potentiometer Reading is Used to Set LED Brightness

Note we are using P9_32 as the reference voltage on the voltage divider, we are using P9_34 as the reference ground, and we are using P9_33 as the analog sense pin. We also using P9_14 as the PWM output pin. Note the current limiting resistor in series with the LED is 330 Ohm.

The object of this circuit is to read the value of the potentiometer and then to use that to set the brightness on the LED. We know that the value we read from the potentiometer will be between 0 and 1. We know that what we can control on the PWM pin is the duty cycle of the 3.3 volt signal. We know that when the potentiometer reads 0, we want a 0% duty cycle on the PWM pin, which would have the LED off. This is our first point:

(0,0)

We also know that when we read 1 from the potentiometer, we want to apply a duty cycle of 100%, or have the LED be full bright. This is our second point:

(1,100)

If we created an equation for the line between these two points, we could calculate the duty cycle that should be applied based on the potentiometer reading. The problem with this is the way our eye perceives changes in brightness. We perceive exponential changes, so if we connected the two points with a linear relationship we would see lots of change at the low end of the scale, but as we continued to move the potentiometer, the brightness would appear to saturate. In order to have a nice smooth transition from full dim to full bright as the potentiometer is moved from left to right, we need to fit an exponential curve between the two points above. We want the LED to be off when the pot is full left, and full bright when the pot is fully to the right. We could use the following exponential equation:

Duty Cycle = C^(Analog Read) – B

This should do the trick, but we need to figure out what the constants C and B need to be. We do this by first plugging in the first point (0,0) from above:

0 = C^0 – B

Anything raised to 0 power is 1, so we have:

0= 1 – B

So B = 1. There, we have our first constant. We use this, and our second point to find C.

100 = C^1 – 1

101=C^1

C=101

Now we have everything we need to calculate the Duty Cycle from the value we read from the potentiometer. The final equation is:

Duty Cycle = 101^(Analog Read) – 1

This Chart Shows how to Map Duty Cycle onto Analog Read

Note that this relationship has the desired properties. When we read a 0 from the potentiometer, we apply a Duty Cycle of 0% to the PWM pin, and the LED is off. When we read a 1 from the potentiometer, we apply a Duty Cycle of 100% to the LED and it is full bright. The exponential shape of the curve between these two points ensures that we will perceive a smooth increase in brightness as we turn the potentiometer up. Math works! It would be very hard to do this by trial and error.

We are now ready to begin developing our code. The video lesson explains the code line-by-line, and we are using commands we learned in the last few lessons.

import Adafruit_BBIO.ADC as ADC
import Adafruit_BBIO.PWM as PWM
from time import sleep
LED="P9_14"
pot="P9_33"
ADC.setup()
PWM.start(LED,0,1000)
while(1):
        analogRead=ADC.read(pot)
        dutyCycle=(101)**analogRead -1
        print dutyCycle
        PWM.set_duty_cycle(LED,dutyCycle)
        sleep(.2)

import Adafruit_BBIO.ADC as ADC

import Adafruit_BBIO.PWM as PWM

from time import sleep

LED="P9_14"

pot="P9_33"

ADC.setup()

PWM.start(LED,0,1000)

while(1):

analogRead=ADC.read(pot)

dutyCycle=(101)**analogRead -1

print dutyCycle

PWM.set_duty_cycle(LED,dutyCycle)

sleep(.2)

The code works very well, and produces a very smooth transition from fully off to fully bright.

Technology Tutorials

Tag Archives: Analog Read

Reading Analog Signals with the Raspberry Pi and the ADC0834

Beaglebone Black LESSON 10: Dimable LED using Potentiometer

Making The World a Better Place One High Tech Project at a Time. Enjoy!