Published November 1, 2025 © GPL3+

My own version of the Theremin

I’ve always wanted to make music without touching anything. So I decided to build a little theremin using distance sensors.

BeginnerShowcase (no instructions)10 hours38

Things used in this project

Hardware components

STMicroelectronics STM32 Nucleo-64 Board

Ultrasonic Sensor - HC-SR04 (Generic)

VL53L0X 2490

SPI TFT

Resistor 10k ohm

Resistor 330 ohm

LED RGB

speaker SP-6120

Software apps and online services

Microsoft Visual Studio Code Extension for Arduino

Story

Inroduction :

As part of a university project, we had to create a project of our choice in programming. Without even thinking twice, I decided to reproduce the instrument known as the theremin. This project means a lot to me because I really love music and I’m a musician myself.

Being a beginner in programming, I struggled quite a bit, but I’m actually proud of what I managed to accomplish in just a few weeks.

Let me present my project :

Here are the libraries I used :

#include <Arduino.h>
#include "Adafruit_VL53L0X.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>

The goal was to produce a sound using two sensors :

VL53L0X to modify the pitch (operates in I2C)
HC-SR04 to control the speed of the sound

I used 3 * 10 kΩ resistors for the ECHO pin of the HC-SR04 sensor to adjust the voltage. Indeed, this makes it possible to reduce the voltage from 5V to 3.3V, since the STM32 pins operate with a logic level of 3.3V.

How to create a frequency ?

I take the distance from the VL53L0X sensor and calculate a frequency according to the following equation: 5 * (distance - 20) + 150.

I obtain a frequency ranging from 50 Hz to 2000 Hz.

To limit the values, I used the constrain()function, which was very helpful.

How to generate a sound ?

To generate a sound, I used SP-6120 speakers. These are simple speakers that allow for safe testing. I used a mini-jack adapter/cable and connected it to pin PA4 : const int GENE_AUDIO = PA4;

To generate a sound, I used an easy and practical function : tone(GENE_AUDIO, frequence); and noTone() to stop the sound.

How to change the speed ?

To change the speed, I used the HC-SR04 sensor. To calculate its distance, I had to use a relation linking speed, distance, and time :

float distanceHC = duree * 0.0343 / 2.0; //We divide by two because we want to know the one-way distance (not the round-trip).

Three distance intervals will correspond to three different duration values, resulting in three distinct speeds and this interval will be added to the current time value to generate the sound.

How can two sensors be operated simultaneously?

The entire code uses a timer (millis()andmicros()) to prevent blocking and reduce slowdowns. No delay() was used except for the HC-SR04 sensor, where a microsecond delay is minimal and required for correct functioning.

After integrating the two sensors, I added an LED whose color changes depending on the distance measured by the VL53L0X sensor. This provides a visual indication in addition to the display.

To produce a gradient, I employed a very handy function :

map(distanceVL, 50, 200, 0, 255);

Explanation : distanceMin / distanceMax / valueMin / valueMax

I used 3 * 330 Ω resistors, one for each color of the RGB LED (Red - Green - Blue). This is essential to control the current flow.

Here is a short video :

Finally, I used an SPI TFT display to show the following values :

VL53L0X distance (50 to 500mm)
HC-SR04 distance (10 to 100cm)
The frequency (150Hz to 200Hz)
The speed (100ms to 300ms to 800ms between each beep)

Final Result :

Project code

#include <Arduino.h>
#include "Adafruit_VL53L0X.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>

Adafruit_VL53L0X lox = Adafruit_VL53L0X();

const int GENE_AUDIO = PA4;

//TFT_SPI
#define TFT_CS   D10
#define TFT_DC   D2
#define TFT_RST  D4
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

// Broches pour la LED RGB (cathode commune)
const int LED_R = PB3;
const int LED_G = PB4;
const int LED_B = PC7;
uint32_t tempsLED = 0;


// HC-SR04
const int TRIG_PIN = PA8;
const int ECHO_PIN = PA9;


bool enBip = false; //Indique si un bip est en cours
uint32_t tempsPrc = 0; //Moment du dernier changement (début bip ou pause)
uint32_t tempsAct = 0; //Temps actuel
uint32_t prochain_BIP = 0; //gestion de la vitesse



//Variables affichage (mémoriser les dernières valeurs affichées -> éviter de redessiner inutilement)
int lastDistanceVL = -1; //-1 au départ pour indiquer qu’aucune valeur n’a encore été affichée
int lastDistanceHC = -1;
int lastFrequence = -1;
int lastIntervalle_Bip = -1;



void Couleur(int r, int g, int b) {
  analogWrite(LED_R, r);
  analogWrite(LED_G, g);
  analogWrite(LED_B, b);
}



//Fonction Affichage TFT_SPI
void afficherTFT(int distanceVL, int distanceHC, int intervalle_BIP, int frequence) {
  //VL53L0X
  if (distanceVL != lastDistanceVL) {
    tft.setTextSize(2);
    tft.setTextColor(ILI9341_CYAN, ILI9341_BLACK);
    tft.setCursor(10, 10); tft.println("VL53:");
    tft.setTextSize(3);
    tft.setCursor(10, 40); 
    tft.fillRect(10, 40, 150, 30, ILI9341_BLACK); // efface juste la valeur
    tft.print(distanceVL); tft.println(" mm");
    lastDistanceVL = distanceVL;
  }

  //HC-SR04
  if (distanceHC != lastDistanceHC) {
    tft.setTextSize(2);
    tft.setTextColor(ILI9341_YELLOW, ILI9341_BLACK);
    tft.setCursor(170, 10); tft.println("HC:");
    tft.setTextSize(3);
    tft.setCursor(170, 40); 
    tft.fillRect(170, 40, 140, 30, ILI9341_BLACK);
    tft.print(distanceHC); tft.println(" cm");
    lastDistanceHC = distanceHC;
  }

  //Intervalle_BIP
  if (intervalle_BIP != lastIntervalle_Bip) {
    tft.setTextSize(2);
    tft.setTextColor(ILI9341_MAGENTA, ILI9341_BLACK);
    tft.setCursor(10, 130); tft.println("BIP:");
    tft.setTextSize(3);
    tft.setCursor(10, 160); 
    tft.fillRect(10, 160, 150, 30, ILI9341_BLACK);
    tft.print(intervalle_BIP); tft.println(" ms");
    lastIntervalle_Bip = intervalle_BIP;
  }

  //Fréquence
  if (frequence != lastFrequence) {
    tft.setTextSize(2);
    tft.setTextColor(ILI9341_GREEN, ILI9341_BLACK);
    tft.setCursor(170, 130); tft.println("Freq:");
    tft.setTextSize(3);
    tft.setCursor(170, 160); 
    tft.fillRect(170, 160, 140, 30, ILI9341_BLACK);
    tft.print(frequence); tft.println(" Hz");
    lastFrequence = frequence;
  }
}



void setup() {
  Serial.begin(115200); //Vitesse de communication 9600bits/s
  
  pinMode(GENE_AUDIO, OUTPUT); //Configure la broche P4A en mode sortie

  pinMode(TRIG_PIN, OUTPUT); //Configure HC-SR04
  pinMode(ECHO_PIN, INPUT);

  pinMode(LED_R, OUTPUT); //Configure les broches en SORTIE
  pinMode(LED_G, OUTPUT);
  pinMode(LED_B, OUTPUT);

  digitalWrite(LED_R, LOW); //Initialise à 0
  digitalWrite(LED_G, LOW);
  digitalWrite(LED_B, LOW);

  while (!Serial) { delay(1); } //Attend que le port série soit prêt

  if (!lox.begin()) { //Tente d'initialiser le capteur VL53L0X
    Serial.println(F("Failed to boot VL53L0X"));
    while(1);
  }


  //Initialisation TFT_SPI
  tft.begin();
  tft.setRotation(1);
  tft.fillScreen(ILI9341_BLACK);
}



void loop() {
  tempsAct = millis();

  //Lecture du capteur VL53L0X (pitch)
  VL53L0X_RangingMeasurementData_t measure; //Créé une structure measure pour stocker les données de mesure
  lox.rangingTest(&measure, false); //Lance une mesure de distance avec le capteur
  
  int distanceVL = measure.RangeMilliMeter;
  distanceVL = constrain(distanceVL, 50, 500);
  int frequence = constrain(5 * (measure.RangeMilliMeter - 20) + 150, 150, 2000); //Calcule une fréquence sonore en fonction de la distance et limite la fréquence entre 150 Hz et 2000 Hz


  //LED RGB
  if (tempsAct - tempsLED > 50) {
    
    tempsLED = tempsAct;
    int r = 0, g = 0, b = 0;
    
    if (distanceVL < 200) {
    //Rouge vers Jaune
    r = 255;
    g = map(distanceVL, 50, 200, 0, 255); //50 = min, 200 = max
    b = 0;
    } else if (distanceVL < 350) {
    //Jaune vers Vert vers Cyan
    r = map(distanceVL, 200, 350, 255, 0);
    g = 255;
    b = map(distanceVL, 200, 350, 0, 255);
    } else {
    //Cyan vers Bleu
    r = 0;
    g = map(distanceVL, 350, 500, 255, 0);
    b = 255;
    }
    Couleur(r, g, b);
  }


  //Lecture du capteur HC-SR04 (vitesse)
  digitalWrite(TRIG_PIN, LOW); //fonction bloquante mais nécessaire pour pouvoir utiliser le capteur + temps négligeable
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  unsigned long duree = pulseIn(ECHO_PIN, HIGH, 30000); // timeout 30ms
  float distanceHC = duree * 0.0343 / 2.0; //d = t * v
  distanceHC = constrain(distanceHC, 10, 100);

  int intervalle_BIP;
  if (distanceHC <= 20) 
    intervalle_BIP = 100;
  else if (distanceHC <= 50) 
    intervalle_BIP = 300;
  else 
    intervalle_BIP = 800;

    
  //Démarrer un bip si intervalle écoulée
  if (!enBip && tempsAct >= prochain_BIP) {
    enBip = true;
    tempsPrc = tempsAct;
    tone(GENE_AUDIO, frequence); // tone() génère un son sur la broche GENE_AUDIO (un signal PWM à 50% de rapport cyclique)
    prochain_BIP = tempsAct + intervalle_BIP;
    Serial.print("Distance HC-SR04: "); Serial.print(distanceHC);
    Serial.print(" cm | Intervalle BIP: "); Serial.print(intervalle_BIP);
    Serial.print("ms | frequence: "); Serial.println(frequence);
  }

  //Arrêter le bip après 100 ms
  if (enBip && (tempsAct - tempsPrc >= 100)) {
    enBip = false;
    noTone(GENE_AUDIO); //stop bip
  }

  //TFT_SPI
  afficherTFT(distanceVL, distanceHC, intervalle_BIP, frequence);
}