I’ve seen a variety of motor-powered cycloidal drives, but I was particularly interested in how a stepper motor would handle one. While large-scale drive arms would be great for my project, I also wanted to explore smaller, light-load-bearing cycloidal drive setups that could work with stepper motors.

Wanting to get straight to testing without reinventing the wheel, I found an excellent open-source 3D Printed Cycloidal Drive for Robot Arms project.

This allowed me to jump right into printing and assembling the drive. However, one key realization struck me—this build only rotates about 190 degrees and doesn’t include stop switches or encoders. That meant I needed a way to control and test its movement, track torque, and evaluate the strain of a NEMA stepper motor.

So, I set out to write some Arduino code to manually control the movement, and was fairly quick to setup.

The Build Process

This project took a few weekends to come together. It didn’t take long to get to trimming and assembling, but at the end I hit my first roadblock—the drive wouldn’t budge. Just as a helpful note, tolerances are really key for this print project. A little bit of silicone grease and some tips from the video helped loosen things up, and before long, I had a functional cycloidal drive ready for testing.

Wiring It Up: The H-Bridge Setup

Now for the fun part—getting the stepper motor moving! Unlike a traditional motor, a stepper requires precise control over each movement. That’s where the H-Bridge motor driver comes in. This little piece of hardware allows us to control the direction and speed of the motor using an Arduino.

Basic Wiring Setup

• Motor power supply → H-Bridge (provides power to the motor)
• H-Bridge outputs → Stepper motor (controls movement direction)
• Arduino control pins → H-Bridge inputs (sends movement commands)

Here’s a simple wiring diagram for reference:

  Arduino          H-Bridge          Stepper Motor
  --------        ----------        --------------
  Pin 8  --------> IN1                
  Pin 9  --------> IN2
  Pin 10 --------> IN3
  Pin 11 --------> IN4
  GND    --------> GND
  5V     --------> VCC
                   Motor 1 + <------- Pin 2
                   Motor 1 - <------- Pin 3   
                   Motor 2 + <------- Pin 4
                   Motor 2 - <------- Pin 5     

With everything wired up, it’s time to write some code to bring it to life!

Writing the Arduino Code

I needed a way to manually position the motor, set a zero reference, define a max position, and create an oscillation mode for repeated movement testing. Here’s what I came up with: https://github.com/macroflux/simple-stepper-motor-robot-arm-test-control

#include <Stepper.h>

const int stepsPerRevolution = 600;
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
int stepSize = 10;
bool oscillate = false;
int maxPosition = 1000;
int currentPosition = 0;

void setup() {
  myStepper.setSpeed(30);
  Serial.begin(9600);
  Serial.println("Stepper Motor Ready. Use + to move forward, - to move back, o to oscillate, s to stop.");
}

void loop() {
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    if (command == "+") {
      myStepper.step(stepSize);
      currentPosition += stepSize;
      Serial.print("Moved forward. Position: ");
      Serial.println(currentPosition);
    } else if (command == "-") {
      myStepper.step(-stepSize);
      currentPosition -= stepSize;
      Serial.print("Moved backward. Position: ");
      Serial.println(currentPosition);
    } else if (command == "o") {
      oscillate = true;
      Serial.println("Starting oscillation...");
    } else if (command == "s") {
      oscillate = false;
      Serial.println("Stopping motion.");
    }
  }
  if (oscillate) {
    Serial.println("Moving to max position...");
    myStepper.step(maxPosition - currentPosition);
    currentPosition = maxPosition;
    delay(500);
    Serial.println("Returning to zero...");
    myStepper.step(-maxPosition);
    currentPosition = 0;
    delay(500);
  }
}

This script lets me manually move the stepper, define a zero position, set a max range, and run a simple oscillation test to simulate arm movements.

Testing and Results

Once the Arduino code was uploaded, I powered up the setup and put it through its paces. At first, the movements were stiff (probably due to tight tolerances in the 3D-printed parts), but after a few cycles, things started running much smoother. The oscillation mode worked well, cycling the arm back and forth consistently. Joint tested!

Note: I found that this build puts slightly more strain on the stepper than normal pulley and belt application. Depending on power source, the NEMA stepper motor may get very warm.

Final Thoughts

This project was an interesting dive into NEMA stepper motors as alternatives in robotic joints through the cycloidal drive. My takeaways are that this is a great light duty drive and application. Due to oscillation harmonics in the drive, it may not be advisable to push too much speed through the motor, but as the original video poster project used as a goal for lifting moderate weighted equipment, this design is perfect. For next steps I want to continue to involve optimizing movement precision and testing heavier loads to see how well the cycloidal drive holds up.

If you’re into robotics and always wanted to try a straightforward, simple effective cycloidal drive, I highly recommend giving this project a try!

One approach, in a previous walkthrough, I demonstrated a simple yet flexible approach to building an API connector to integrate a customer facing process with a Service Process Studio definition. This connector could pass data to the Service Process API call and kick off Service Catalog Request and Case creation. The goal was to create a universal method, one that avoids the need for a specialized Apex to map each individual use case or instance manually. Instead, we iterated through data from both Flow and OmniStudio, passing it over as strings to keep things streamlined, each value broken into a key:value pair to iterate over.

But here’s where things can get interesting, and tricky. Salesforce’s handling of field data types can be challenging. Let’s say you’re mapping data to the Case object as part of a Service Process API request. If one of the fields, like Date_of_Service__c, is a non-text type (like Date), you might run into issues. Simply passing a string value to that field through the API may not work without some additional handling. And if you’re using a minimalist approach, where you directly pass CaseAttributes as key-value pairs to the Case API fields, those data type mismatches can cause errors.

A potential workaround for this is to only send over ‘safe’ Case fields directly to a connector scenario that iterates Case destination data, and to handle Type fields on Case by adding Base Attributes in Service Process definition with their own respective field mapping and API names.

In this example, a Case field (Date_of_Service__c) is of Date type. If an Apex based controller that simply iterates over API and key:value pairs sent to it by a process were to attempt to send string values to the Date type field in the Service Process API call, an error may be encountered.

This could be handled in various ways of course, but in our goal to create a simple, universal method from a low maintenance perspective, we have a few options to keep with simple practice.

Here, an attribute mapping has been added to the Service Process definition, with its own API reference name, DateOfService. It is mapped to Case object as a Base attribute, and identified as data type Date. If in our original Omnistudio or Flow process we’ve created a key:value pair of data to send, we can reference this API field destination rather than the original ‘Date_of_Service__c’ field:

This type-mapping feature gives the Service Process definition even more flexibility and workarounds in use, towards the goal of creating simpler integrations, and reducing Apex overhead by leveraging built in features of Service Process Studio. Again, there are many ways to do things in Salesforce, but if this approach suits your development, it doesn’t have to be a showstopper when encountering special data type issues!