Published October 9, 2026

Build an Arduino-Controlled Analog Audio VCA with SSM2018S

Explore voltage-controlled analog audio with the Analog Devices SSM2018S VCA and an Arduino-compatible controller.

IntermediateWork in progress18

Build an Arduino-Controlled Analog Audio VCA with SSM2018S

Things used in this project

Hardware components

Analog Devices SSM2018S

Main voltage-controlled audio amplifier; verify the exact package and pinout against its datasheet

Arduino Uno R4 WiFi

Generates digital control commands

MCP4725 DAC module

Converts I²C commands into an analog control voltage

Dual regulated bench power supply

Provides the required positive and negative analog rails

Audio signal generator

Supplies a repeatable test signal

Oscilloscope

Monitors input and output waveforms

Audio source and line-level output connectors

Connect the circuit to test equipment

Precision resistors and ceramic capacitors

Implement the manufacturer reference circuit and supply decoupling

Breadboard

Assembly; a PCB is preferable for low-noise testing

Jumper wires and connectors

Signal and control connections

Software apps and online services

Arduino IDE

upload the controller firmware.

KiCad

draw the schematic and design a PCB.

Oscilloscope software

inspect waveforms and compare signal levels.

Analog Devices SSM2018 datasheet

use the manufacturer's reference circuit for the analog stage.

Hand tools and fabrication machines

Digital multimeter

Oscilloscope probes and test leads

Soldering iron (generic)

solder

Wire cutters

wire strippers

Tweezers

small screwdrivers

Story

Introduction

Audio volume control seems simple: turn a knob, reduce the signal, and listen. However, controlling an analog audio signal from a microcontroller introduces an interesting engineering challenge. A digital controller cannot directly generate an arbitrary analog voltage, and a conventional digital potentiometer is not always the best solution for every audio path.

For this project, I want to explore a different approach using the Analog Devices SSM2018S, a voltage-controlled amplifier (VCA) designed for audio signal-level control.

The SSM2018S is particularly interesting because its gain is controlled by a voltage rather than by a mechanical potentiometer. The device provides differential inputs, an internal output amplifier, and a wide gain-control range. Analog Devices specifies a typical THD+N of 0.006% at 1 kHz and unity gain under the datasheet's stated test conditions.

The part is obsolete, so this project is also an opportunity to learn from a classic analog IC that may already be available in an existing component inventory.

Project Goals

The objective is to build a digitally controlled analog audio attenuator and use it to investigate the relationship between control voltage and output amplitude.

The prototype will have three main functions:

Accept a low-level line-audio signal from a signal generator or audio source.
Adjust the analog gain through a digitally commanded control voltage.
Measure the input and output amplitudes to evaluate attenuation, distortion, noise, and control stability.

Rather than claiming studio-grade performance before testing, I will compare the measured results against the reference circuit and document the limitations of the assembled hardware.

How the Circuit Works

The SSM2018S uses a control voltage at pin 11 to set its gain. At approximately 0 V, the device operates at unity gain. A positive control voltage produces attenuation, while a negative control voltage produces gain.

The control law is approximately −30 mV/dB under the specified operating conditions. This makes the control input suitable for experiments with a DAC, provided the voltage is correctly scaled and remains within the permitted range.

An Arduino Uno provides the user interface and sends commands over I²C to an external DAC. The DAC output passes through a suitable scaling and buffering stage before reaching the SSM2018S control input. This avoids connecting the Arduino's 0–5 V output directly to the analog control port.

The audio path follows the manufacturer's basic VCA configuration. The input resistors convert the audio voltages into input currents, and the feedback network establishes the intended operating configuration. The output is taken from pin 14.

Building and Testing

I would start by reproducing the datasheet's basic VCA circuit rather than designing a new gain stage from scratch.

First, I would inspect the IC package, confirm its pinout, and check every power and ground connection. I would then verify the ±15 V supply rails, confirm the control-voltage range, and measure the output with no audio input.

Next, I would inject a low-amplitude 1 kHz sine wave and record the input and output RMS voltages. By changing the DAC command in small increments, I could plot measured gain in decibels against control voltage.

After validating the basic response, I would test several audio frequencies, check for clipping, listen for audible artifacts, and examine whether the control voltage introduces unwanted noise into the output.

What I Hope to Learn

This project demonstrates a useful connection between embedded control and analog electronics. The microcontroller does not process the audio waveform directly; it controls the analog circuit that processes the waveform.

The same general design approach can be useful in experimental audio mixers, remote volume controls, analog effects, and automated test equipment. The exact suitability of the SSM2018S depends on the required signal levels, noise performance, gain range, and availability of the obsolete component.

I will publish the schematic, firmware, measurement setup, and measured results as the prototype develops, including any problems discovered during testing.

Code

#include <Wire.h>
#include <Adafruit_MCP4725.h>

Adafruit_MCP4725 dac;

// MCP4725: commonly 0x60 or 0x61, depending on board
const uint8_t DAC_ADDRESS_UNUSED = 0x60;

// Calibrate this for your DAC reference and analog scaling circuit.
// These values represent the desired voltage at the SSM2018 VC pin,
// NOT necessarily the raw MCP4725 output voltage.
const float VC_MIN = 0.0;  // Unity gain
const float VC_MAX = 2.4;  // Example attenuation target; verify hardware

const float ATTENUATION_MIN_DB = 0.0;
const float ATTENUATION_MAX_DB = 80.0;

float clampFloat(float x, float lo, float hi) {
  if (x < lo) return lo;
  if (x > hi) return hi;
  return x;
}

// Datasheet control law is approximately -30 mV/dB.
// Positive VC therefore produces attenuation.
// This conversion describes the desired VC voltage.
float attenuationToVC(float attenuationDb) {
  attenuationDb = clampFloat(
    attenuationDb,
    ATTENUATION_MIN_DB,
    ATTENUATION_MAX_DB
  );

  return attenuationDb * 0.030;
}

// Convert a desired VC voltage to a 12-bit DAC code.
// This simple version assumes a 0-5 V DAC output and a
// direct connection, which is ONLY appropriate if the external
// scaling/buffer circuit has been designed for that relationship.
uint16_t voltageToDacCode(float voltage, float dacFullScale = 5.0) {
  voltage = clampFloat(voltage, 0.0, dacFullScale);
  return (uint16_t)(voltage * 4095.0 / dacFullScale + 0.5);
}

void setAttenuation(float attenuationDb) {
  float targetVC = attenuationToVC(attenuationDb);

  // In a real build, convert targetVC to the raw DAC voltage
  // using the measured transfer function of your scaling circuit.
  float rawDacVoltage = targetVC;

  uint16_t code = voltageToDacCode(rawDacVoltage);
  dac.setVoltage(code, false);

  Serial.print("Requested attenuation: ");
  Serial.print(attenuationDb, 1);
  Serial.print(" dB, target VC: ");
  Serial.print(targetVC, 3);
  Serial.print(" V, DAC code: ");
  Serial.println(code);
}

void setup() {
  Serial.begin(115200);
  Wire.begin();

  // Set the I2C address appropriate for your DAC board.
  dac.begin(0x60);

  setAttenuation(0.0);

  Serial.println();
  Serial.println("SSM2018 VCA controller");
  Serial.println("Enter attenuation in dB, from 0 to 80.");
}

void loop() {
  if (Serial.available()) {
    float attenuationDb = Serial.parseFloat();

    if (attenuationDb >= ATTENUATION_MIN_DB &&
        attenuationDb <= ATTENUATION_MAX_DB) {
      setAttenuation(attenuationDb);
    } else {
      Serial.println("Enter a value between 0 and 80 dB.");
    }

    while (Serial.available()) {
      Serial.read();
    }
  }
}

Credits

Robert Fletcher

22 projects • 1 follower

Senior semiconductor engineer at AVAQ Semiconductor. With extensive experience in electronic components, supply chain solutions & sourcing.

Embed the widget on your own site

Build an Arduino-Controlled Analog Audio VCA with SSM2018S

Build an Arduino-Controlled Analog Audio VCA with SSM2018S

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

Project Goals

How the Circuit Works

Building and Testing

What I Hope to Learn

Code

Code

Credits

Robert Fletcher

Comments

Related channels and tags