A window will pop up with your Adafruit IO. Keep a copy of this in a safe place. We'll need it later.

Creating the Servo Feed

Next, you will need to create a feed called Servo. If you need help getting started with creating feeds on Adafruit IO, check out the Adafruit IO Feed Basics guide.

Adding the Slider Block

Next, add a new Slider Block to a new or existing dashboard. Name the block whatever you would like, and set min value to 0 and max value to 180. Make sure you have selected the Servo feed as the data source for the slider.

If you need help getting started with Dashboards on Adafruit IO, check out the Adafruit IO Dashboard Basics guide.

When you are finished editing the form, click Create Block to add the new block to the dashboard.

Next, we will look at wiring the circuit.

Arduino Wiring

We're going to use a combination of the Adafruit IO Client Library and Adafruit's CircuitPython to control a Raspberry Pi over Adafruit IO. 

If you're following along with a Raspberry Pi, we're going to use a T-Cobbler Plus for the IO Basics Projects. This add-on prototyping board lets you easily connect a Raspberry Pi (Raspberry Pi Model Zero, A+, B+, Pi 2, Pi 3) to a solderless breadboard:

Want to create an automatic fish-feeder, a door-lock system with vibration-feedback, or maybe you want to just chain a bunch of lights and motors together and control them with Adafruit IO?

You'll need a few PWM outputs. This guide requires only one for the servo.

The Raspberry Pi is limited to one PWM output. While we could use this PWM output for the servo, we're going to use the Adafruit 16-Channel 12-bit PWM/Servo driver. This board can be used to control up to 16 PWM outputs. This means you can have a bunch of servos, DC motors, LED lights, or even a combination of both.

We are powering the servo from an external 5V 2A switching power supply connected to the terminal block on the breakout board via a DC adapter. 

Make the following connections between the Raspberry Pi and the PCA9685:

• Pi 3.3V to Power Rail
• Pi GND to Ground Rail
• 3.3V to PCA9685 VCC
• GND to PCA9685 GND
• Pi SDA to PCA9685 SDA
• Pi SCL to PCA9685 SCL

Make the following connections between the servo and the PCA9685's Channel 0:

• Servo Black/Brown to PCA9685 GND
• Servo Red to PCA9685 V+
• Servo Yellow to PCA9685 PWM

Finally, connect the PCA9685's screw terminal to the external power supply:

• PCA9685 V+ to the Power Supply + (positive)
• PCA9685 GND to the Power Supply - (negative)

If you're following along with a Raspberry Pi, Beaglebone or any other supported small linux computer, we'll use a special library called adafruit_blinka (named after Blinka, the CircuitPython mascot) to provide the layer that translates the CircuitPython hardware API to whatever library the Linux board provides. It's CircuitPython, on Pi!

If you haven't set up Blinka and the Adafruit IO Python Library yet on your Raspberry Pi, follow our guide:

• Blinka + Adafruit IO Setup

Enable I2C

We use two pins on the Pi (SDA/SCL) to communicate over I2c with the PCA9685. You only have to do this step once per Raspberry Pi, the I2C interface is disabled by default.

• Enabling I2C

Once you're done with this and have rebooted, verify you have the SPI devices with the command:

sudo i2cdetect -y 1

If your PCA9685 Breakout is wired up correctly, it'll show up at 0x40:

Install the CircuitPython-PCA9685 Library

You'll also need to install a library to communicate with the PWM breakout. Since we're using Adafruit Blinka (CircuitPython), we can install CircuitPython libraries on our Raspberry Pi. In this case, we're going to install the CircuitPython-PCA9685 library.

Run the following command to install the CircuitPython-PCA9685 library:

pip3 install adafruit-circuitpython-PCA9685

Note: While this package is dependent on two other packages adafruit-circuitpython-busdevice and adafruit-circuitpython-register, they're installed with the package. 

Install the CircuitPython-Motor Library

Controlling the PCA9865's channels directly is not an easy task. You'll need to manually set the duty cycle of each channel. Luckily, "there's a CircuitPython library for that".

CircuitPython-Motor is a helper library for easily controlling motors, servos, and PWM-based outputs.

Run the following command to install the CircuitPython-Motor library: 

pip3 install adafruit-circuitpython-motor

The imports for this guide are similar to the other guides in this series involving analog PWM output (Color, Analog Output), except this time it uses an extra library: adafruit-circuitpython-motor

import time # system 
from board import SCL, SDA # blinka 
from busio import I2C
from adafruit_pca9685 import PCA9685 # PCA Module 
from Adafruit_IO import Client, Feed, RequestError # adafruit io 
from adafruit_motor import servo # servo library

1
2
3
4
5
6

import time # system 
from board import SCL, SDA # blinka 
from busio import I2C
from adafruit_pca9685 import PCA9685 # PCA Module 
from Adafruit_IO import Client, Feed, RequestError # adafruit io 
from adafruit_motor import servo # servo library

By default, the servo channel is on channel 0 of the PCA9685. If you'd like to change this, you can do so by modifying the SERVO_CHANNEL variable at the top of the code:

SERVO_CHANNEL = 0

Before we run the script, we'll need to change ADAFRUIT_IO_USERNAME and ADAFRUIT_IO_KEY to the username and key for your Adafruit IO account.

# Set to your Adafruit IO username.
ADAFRUIT_IO_USERNAME = 'YOUR_IO_USERNAME'

# Set to your Adafruit IO key.
ADAFRUIT_IO_KEY = 'YOUR_IO_KEY'

1
2
3
4
5

# Set to your Adafruit IO username.
ADAFRUIT_IO_USERNAME = 'YOUR_IO_USERNAME'

# Set to your Adafruit IO key.
ADAFRUIT_IO_KEY = 'YOUR_IO_KEY'

Next, we set up the PCA9685 by creating an I2C bus, and passing that into a PCA9685 class. Then, we set the PWM frequency. 

i2c_bus = I2C(SCL, SDA)
pca = PCA9685(i2c_bus)
pca.frequency = 50

1
2
3

i2c_bus = I2C(SCL, SDA)
pca = PCA9685(i2c_bus)
pca.frequency = 50

Then, we instantiate a servo object called my_servo: 

my_servo = servo.Servo(pca.channels[SERVO_CHANNEL])

in the while True loop, we first grab the servo feed value. Then, we compare it against the previous feed value. If it the feed value is different from the previous value, we set the servo angle to the feed's value.

while True:
    # grab the `servo` feed value
    servo_angle = aio.receive(servo_feed.key)
    if servo_angle.value != prev_angle:
        print('received <- ', servo_angle.value)
        # write the servo to the feed-specified angle
        my_servo.angle = int(servo_angle.value)
    prev_angle = servo_angle.value
    # timeout so we don't flood IO with requests
    time.sleep(0.5)

1
2
3
4
5
6
7
8
9
10

while True:
    # grab the `servo` feed value
    servo_angle = aio.receive(servo_feed.key)
    if servo_angle.value != prev_angle:
        print('received <- ', servo_angle.value)
        # write the servo to the feed-specified angle
        my_servo.angle = int(servo_angle.value)
    prev_angle = servo_angle.value
    # timeout so we don't flood IO with requests
    time.sleep(0.5)

Unlike the Arduino example code, we don't need to handle the servo going past it's maximum or minimum angle, the adafruit-circuitpython-motor library handles that for us.

Change the slider value on your Adafruit IO dashboard, and you should see the values output from your terminal:

received <-  120 Degrees
received <-  70 Degrees
received <-  30 Degrees
received <-  90 Degrees

1
2
3
4

received <-  120 Degrees
received <-  70 Degrees
received <-  30 Degrees
received <-  90 Degrees

You should also observe the servo change position depending on what value you send: