#include "SoftwarePWM.h"

int dir;
int dutyCycle;
unsigned long timer;

uint8_t pins [10] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
SoftwarePWM swPWM(pins, 10);

ISR(TIMER1_OVF_vect) {
  swPWM.refresh();
}

void setup()
{
  TCCR1A = 0;
  TCCR1B = 0;
  TCCR1A |= (1 << WGM11);
  TCCR1B |= (1 << CS10) | (1 << WGM13);
  TIMSK1 |= (1 << TOIE1);
  ICR1 = 4000; // Adjusted for simulation.
}

void loop() 
{
  unsigned long now = millis();
  if (now - timer > 10)
  {
    for (int i = 0; i < 10; ++i)
    {
      if (dir == 1)
      {
        if (dutyCycle < 255)
        {
          dutyCycle++;
        }
        else
        {
          dir = 0;
        }
      }
      else
      {
        if (dutyCycle > 0)
        {
          dutyCycle--;
        }
        else
        {
          dir = 1;
        }
      }
      swPWM.setDutyCycle(i, dutyCycle);
    }
    timer = now;
  }
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

SoftPWM

libraries.txt

#ifndef SOFTWARE_PWM_H
#define SOFTWARE_PWM_H

#include <Arduino.h>

void printVar(char* var);

typedef struct {
  int pin;
  bool state;
  int onTime;
  int offTime;
  float frequency;
  float dutyCycle;
  float resolution;
  float cycleLength;
  unsigned long pulseTime;
} pwm;

class SoftwarePWM
{
  public:
    SoftwarePWM(uint8_t assignedPins [], uint8_t size);
    void refresh();
    void setResolution(uint8_t pin, float resolution);
    void setFrequency(uint8_t pin, float frequency);
    void setDutyCycle(uint8_t pin, uint8_t dutyCycle);
  
  private:
    pwm* pins;
    uint8_t numPins;
};

#endif /* SOFTWARE_PWM_H */

SoftwarePWM.h

#include <Arduino.h>;
#include "SoftwarePWM.h";

SoftwarePWM::SoftwarePWM(uint8_t assignedPins [], uint8_t size)
{
  numPins = size;
  pins = (pwm*)malloc(sizeof(pwm) * numPins);
  for (int i = 0; i < numPins; ++i)
  {
    pins[i].pin = assignedPins[i];
    pins[i].frequency = 100;
    pinMode(pins[i].pin, OUTPUT);
    digitalWrite(pins[i].pin, LOW);
    pins[i].resolution = 255.0;
    pins[i].cycleLength = 1000000 / pins[i].frequency;
  }
}

void SoftwarePWM::refresh()
{
  for (int i = 0; i < numPins; ++i)
  {
    int duration = pins[i].state ? pins[i].offTime : pins[i].onTime;
    unsigned long microsNow = micros();
    if (microsNow - pins[i].pulseTime > duration)
    {
      digitalWrite(pins[i].pin, pins[i].state);
      pins[i].state = !pins[i].state;
      pins[i].pulseTime = microsNow;
    }
  }
}

void SoftwarePWM::setDutyCycle(uint8_t pin, uint8_t dutyCycle)
{
  pins[pin].dutyCycle = dutyCycle / pins[pin].resolution;
  pins[pin].onTime = pins[pin].dutyCycle * pins[pin].cycleLength;
  pins[pin].offTime = pins[pin].cycleLength - pins[pin].onTime;
}

void SoftwarePWM::setResolution(uint8_t pin, float resolution)
{
  pins[pin].resolution = resolution;
}

void SoftwarePWM::setFrequency(uint8_t pin, float frequency)
{
  pins[pin].frequency = frequency;
}