Pro Micro Microcontroller PWM

My Friends,

I have got the code to a point now, where it is a very useful project! Utilising a wide range of PWM: 0.001 - 8 MHz or so.

Here is the Arduino Code:

////////////////////////////////////////////////////////////////////////////////////////////////////
// PWM Software written by Chris Sykes.                                                           //
// NOTE: 16 bit Timers currently used. 32 Bit Timers need all shorts changed to longs!            //
// Software written and shared as is, no warrantys are given. Use at your own risk.               //
////////////////////////////////////////////////////////////////////////////////////////////////////
// Your MCU Clock Frequency: 16000000 or 16e6, retrieved by F_CPU.                                //
long fclock = F_CPU;


////////////////////////////////////////////////////////////////////////////////////////////////////
// Most MCU's have:                                                                               //
//   0,                                                                                           //
//   8,                                                                                           //
//   64,                                                                                          //
//   256,                                                                                         //
//   1024                                                                                         //
// as Prescaler Values:                                                                           //
long Prescaler = 8;


////////////////////////////////////////////////////////////////////////////////////////////////////
// Serial Connection Hook:                                                                        //
bool Hook = true;


////////////////////////////////////////////////////////////////////////////////////////////////////
// The MCU Setup Method:                                                                          //
void setup() {//////////////////////////////////////////////////////////////////////////////////////

  // Init Serial:
  Serial.begin(115200);
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Configure Timer:                                                                               //
void ConfgureTimer(){///////////////////////////////////////////////////////////////////////////////

  // The counter simply overruns when it passes its maximum 16-bit value
  // (MAX = 0xFFFF (65535)) and then restarts from the BOTTOM (0x0000).

  // Timer One PWM Pin: 
  // Mega = Pin 12
  // Pro Micro = Pin 10
  // Check your Datasheet!
  pinMode(10, OUTPUT);

  // Reset Timer One:
  TCCR1A = 0;
  TCCR1B = 0;

  // ComA and B need to be set for Compare Match Pins:
  TCCR1A |= (1 << COM1A1) | (1 << COM1B1);
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Set Prescaler:                                                                                 //
void SetPrescaler(short prescaler){/////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  // See your Datasheet! See: Clock Select Bit Description                                                 //
  //-------------------------------------------------------------------------------------------------------//
  // CS02     CS01     CS00     Description                                                                //
  //  0        0        0        No clock source (Timer/Counter stopped)                                   //
  //  0        0        1        clkI/O/(No prescaling)                                                    //
  //  0        1        0        clkI/O/8 (From prescaler)                                                 //
  //  0        1        1        clkI/O/64 (From prescaler)                                                //
  //  1        0        0        clkI/O/256 (From prescaler)                                               //
  //  1        0        1        clkI/O/1024 (From prescaler)                                              //
  //  1        1        0        External clock source on T0 pin. Clock on falling edge.                   //
  //  1        1        1        External clock source on T0 pin. Clock on rising edge.                    //
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // Configure Prescaler (CSX):
  switch (prescaler) {
    case 1:
      //  Set 0: clkI/O/(No prescaling)
      TCCR1B |= (1 << CS10);
      break;
    case 8:
      // Set 8: clkI/O/8 (From prescaler)
      TCCR1B |= (1 << CS11);
      break;
    case 64:
      // Set 64: clkI/O/64 (From prescaler)
      TCCR1B |= (1 << CS11) | (1 << CS10);
      break;
    case 256:
      // Set 256: clkI/O/256 (From prescaler)
      TCCR1B |= (1 << CS12);
      break;
    case 1024:
      // Set 1024: clkI/O/1024 (From prescaler)
      TCCR1B |= (1 << CS12) | (1 << CS10);
      break;
    default:
      // Set Off: No clock source (Timer/Counter stopped)
      TCCR1B |= (0 << CS12) | (0 << CS11) | (0 << CS10);
      break;
  }
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Set PWM Mode:                                                                                  //
void SetPWMMode(){//////////////////////////////////////////////////////////////////////////////////

  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // See your Datasheet!                                                                                            //
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Waveform Generation Mode Bit Description                                                                       //
  //----------------------------------------------------------------------------------------------------------------//
  //                                     Timer/Counter Mode of                    Update of       TOV Flag (1)(2)   //
  // Mode    WGM3   WGM2   WGM1   WGM0   Operation                     TOP        OCRx at         Set on            //
  //  0      0      0      0      0      Normal                        0xFFFF     Immediate       MAX               //
  //  1      0      0      0      1      PWM, Phase Correct, 8-bit     0x00FF     TOP             BOTTOM            //
  //  2      0      0      1      0      PWM, Phase Correct, 9-bit     0x01FF     TOP             BOTTOM            //
  //  3      0      0      1      1      PWM, Phase Correct, 10-bit    0x03FF     TOP             BOTTOM            //
  //  4      0      1      0      0      CTC                           OCRnA      Immediate       MAX               //
  //  5      0      1      0      1      Fast PWM, 8-bit               0x00FF     TOP             TOP               //
  //  6      0      1      1      0      Fast PWM, 9-bit               0x01FF     TOP             TOP               //
  //  7      0      1      1      1      Fast PWM, 10-bit              0x03FF     TOP             TOP               //
  //  8      1      0      0      0      PWM, PnFC                     ICRn       BOTTOM          BOTTOM            //
  //  9      1      0      0      1      PWM, PnFC                     OCRnA      BOTTOM          BOTTOM            //
  //  10     1      0      1      0      PWM, Phase Correct            ICRn       TOP             BOTTOM            //
  //  11     1      0      1      1      PWM, Phase Correct            OCRnA      TOP             BOTTOM            //
  //  12     1      1      0      0      CTC                           ICRn       Immediate       MAX               //
  //  13     1      1      0      1      (Reserved)                    –          –               –                 //
  //  14     1      1      1      0      Fast PWM                      ICRn       TOP             TOP               //
  //  15     1      1      1      1      Fast PWM                      OCRnA      TOP             TOP               //
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // NOTE: PnFC = Phase and Frequency Correct.

  // Fast PWM needs bits (WGM10 & WGM12) set to One:
  TCCR1A |= (1 << WGM11);

  // Configure Fast PWM Mode (WGM12 and 13):
  TCCR1B |= (1 << WGM12) | (1 << WGM13);
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// The MCU Loop Method:                                                                           //
void loop() {///////////////////////////////////////////////////////////////////////////////////////

  // Look for Serial Connection:
  if(Serial && Hook){

    // Connection Hook:
    Hook = false;

    // Print Welcome Message:
    Serial.println("Welcome to Serial PWM Controller by Chris Sykes!");
  }

  // Look for Serial Data:
  if(Serial.available()){

    // Read Serial String:
    String data = Serial.readString();

    // Check Data and Process: && data.endsWith(">") would be nice...
    if(data.length() > 0 && data.startsWith("<"))
      ProcessSerialData(data);

    // Flush Serial:
    Serial.flush();
  }
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Process the Serial Data:                                                                       //
void ProcessSerialData(String data){////////////////////////////////////////////////////////////////

  // Get Frequency: <15624|3906|1024> = 1Hz @ 25% Duty Cycle.
  long F = data.substring(1, data.indexOf('|')).toInt();
  long D = data.substring(data.indexOf('|') + 1, data.lastIndexOf('|')).toInt();
  Prescaler = data.substring(data.lastIndexOf('|') + 1, data.indexOf('>')).toInt();

  // Print Data:
  Serial.print("MCU set Frequency Register to: ");
  Serial.print(F);
  Serial.print(" or F: ");
  Serial.println(ConvertToFrequency(F));
  Serial.print("MCU set Duty Cycle Register to: ");
  Serial.println(D);
  Serial.print("MCU set Prescaler to: ");
  Serial.println(Prescaler);
  Serial.print("MCU Register Resolution: ");
  Serial.println(CalculateResolution(F));


  // Confgure Timer:
  ConfgureTimer();

  // Set the Prescaler:
  SetPrescaler(Prescaler);

  // Set PWM Mode:
  SetPWMMode();

  // Set Frequency:
  ICR1 = F;

  // Set Duty Cycle:
  OCR1B = D;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Calculate the Frequency:                                                                       //
short ConvertToFrequency(long ocrx){////////////////////////////////////////////////////////////////

  // Calculate OCR1A from specified Frequency:
  return (short)(fclock / (Prescaler * (1 + ocrx)));
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Calculate the Frequency:                                                                       //
short CalculateFrequency(double frequency){/////////////////////////////////////////////////////////

  // Calculate OCR1A from specified Frequency:
  return (short)(fclock / ((frequency * Prescaler) - 1));
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Calculate the DutyCycle:                                                                       //
short CalculateDutyCycle(int period, double duty){//////////////////////////////////////////////////

  // Calculate OCR1B from OCR1A and specified Duty Cycle:
  return (short)(period * (duty / 100L));
}


////////////////////////////////////////////////////////////////////////////////////////////////////
// Calculate Register Resolution:                                                                 //
double CalculateResolution(long ocrx){//////////////////////////////////////////////////////////////

  return (log((double)ocrx + 1.0D)/log(2.0D));
}

Here is the Windows Forms Code:

namespace SerialPWMController
{



    #region Using Statements:



    using System;
    using System.IO.Ports;
    using System.Windows.Forms;



    #endregion




    public partial class Form1 : Form
    {



        #region Fields:



        /// <summary>
        /// The Microcontroller Clock Frequency:
        /// </summary>
        int fclock = 16000000;



        /// <summary>
        /// The Clock Frequency Prescaler:
        /// </summary>
        int Prescaler = 1024;



        /// <summary>
        /// Create a new SerialPort Reference.
        /// <para>
        ///     See: https://docs.microsoft.com/en-us/dotnet/api/system.io.ports.serialport?view=dotnet-plat-ext-3.1
        /// </para>
        /// </summary>
        SerialPort serialPort = new SerialPort();



        #endregion



        #region Properties:



        /// <summary>
        /// The System Frequency.
        /// </summary>
        public double Frequency { get; set; } = 1.00;



        /// <summary>
        /// The System Duty Cycle.
        /// </summary>
        public double DutyCycle { get; set; } = 50.00;



        /// <summary>
        /// The Frequency Track Bar Multiplier.
        /// </summary>
        private int Multiplier { get; set; } = 1;



        /// <summary>
        /// Serial Port Name:
        /// </summary>
        public string PortName
        {
            get { return serialPort.PortName; }
            internal set { serialPort.PortName = value; }
        }



        /// <summary>
        /// Serial Port BaudRate:
        /// </summary>
        public int BaudRate
        {
            get { return serialPort.BaudRate; }
            internal set { serialPort.BaudRate = value; }
        }



        /// <summary>
        /// Serial Port Parity:
        /// </summary>
        public Parity Parity
        {
            get { return serialPort.Parity; }
            internal set { serialPort.Parity = value; }
        }



        /// <summary>
        /// Serial Port DataBits:
        /// </summary>
        public int DataBits
        {
            get { return serialPort.DataBits; }
            internal set { serialPort.DataBits = value; }
        }



        /// <summary>
        /// Serial Port StopBits:
        /// </summary>
        public StopBits StopBits
        {
            get { return serialPort.StopBits; }
            internal set { serialPort.StopBits = value; }
        }



        /// <summary>
        /// Serial Port Handshake:
        /// </summary>
        public Handshake Handshake
        {
            get { return serialPort.Handshake; }
            internal set { serialPort.Handshake = value; }
        }



        #endregion



        /// <summary>
        /// Form Constructor.
        /// </summary>
        public Form1()
        {

            // Form Init:
            InitializeComponent();

            // Add Port Names:
            foreach (string PortName in SerialPort.GetPortNames())
                if (!PortNameComboBox.Items.Contains(PortName))
                    PortNameComboBox.Items.Add(PortName);

            // Standard Baud Rates:
            int[] BaudRates = new int[] { 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200, 128000, 256000 };

            // Add Port Names:
            foreach (int BaudRate in BaudRates)
                BaudRateComboBox.Items.Add(BaudRate);

            // Set Selected Index:
            BaudRateComboBox.SelectedItem = 115200;

            // Attach Frequency TrackBar Value Changed Event Handler:
            this.FrequencyTrackBar.ValueChanged += new System.EventHandler(this.FrequencyTrackBar_ValueChanged);
        }



        /// <summary>
        /// Form Load Event.
        /// </summary>
        private void Form1_Load(object sender, EventArgs e)
        {

            // Set Initial Frequency:
            FrequencyTextBox.Text = "1111.111";

            // Set Initial Duty Cycle:
            DutyCycleTextBox.Text = DutyCycle.ToString();

            // Set Duty Cycle Track Bar:
            DutyCycleTrackBar.Value = (int)(50.0 * 1000.00);
        }



        /// <summary>
        /// Calculate the Frequency:
        /// </summary>
        /// <param name="frequency">The desired Frequency: 3.73Hz</param>
        /// <returns>int representing the resolution on the Register (16 bits).</returns>
        int CalculateFrequency(double frequency)
        {

            // Calculate OCR1A from specified Frequency:
            return (int)(Convert.ToDouble(fclock) / (frequency * Convert.ToDouble(Prescaler)) - 1.0);
        }



        /// <summary>
        /// Calculate the Duty Cycle:
        /// </summary>
        /// <param name="period">Period, or 1 / F</param>
        /// <param name="duty">The desired Duty Cycle: 50.0%</param>
        /// <returns>int representing the resolution on the Register (16 bits).</returns>
        int CalculateDutyCycle(int period, double duty)
        {

            // Calculate OCR1B from OCR1A and specified Duty Cycle:
            return (short)(Convert.ToDouble(period) * (duty / 100.00));
        }



        /// <summary>
        /// Calculate Register Resolution:
        /// </summary>
        /// <param name="ocrx">The Register Value, E.G: CalculateFrequency(1024.57)</param>
        /// <returns>double representing the Resolution at the current Register Value.</returns>
        double CalculateResolution(int ocrx)
        {

            return (Math.Log((double)ocrx + 1.0D) / Math.Log(2.0D));
        }



        /// <summary>
        /// Send Button Click Event.
        /// </summary>
        private void SendButton_Click(object sender, EventArgs e)
        {

            // Parse the Frequency Value:
            if (!double.TryParse(FrequencyTextBox.Text, out double Frequency))
            {

                // Show Error:
                richTextBox1.AppendText("Input Error!" + Environment.NewLine);

                // Return:
                return;
            }

            // Parse the Duty Cycle Value:
            if (!double.TryParse(DutyCycleTextBox.Text, out double DutyCycle))
            {

                // Show Error:
                richTextBox1.AppendText("Input Error!" + Environment.NewLine);

                // Return:
                return;
            }

            // Check Values:
            if (Frequency == 0.00 || DutyCycle == 0.00)
            {

                // Show Error:
                richTextBox1.AppendText("Error!\r\nCant Divide by Zero!" + Environment.NewLine);

                // Return:
                return;
            }

            // Check Values:
            if (Frequency < 0.00 || DutyCycle < 0.00)
            {

                // Show Error:
                richTextBox1.AppendText("Error!\r\nOnly Positive Numbers can be used!" + Environment.NewLine);

                // Return:
                return;
            }

            // Calculate Prescaler:
            Prescaler = CalculatePrescaler(Frequency);

            // Calculate Resolutions:
            int FrequencyResolution = CalculateFrequency(Frequency);
            int DutyCycleResolution = CalculateDutyCycle(FrequencyResolution, DutyCycle);

            // Set Resolution:
            ResolutionLabel.Text = CalculateResolution(FrequencyResolution).ToString();

            try
            {

                // Send the Data:
                serialPort.WriteLine(String.Format("<{0}|{1}|{2}>", FrequencyResolution, DutyCycleResolution, Prescaler));
            }
            catch
            {

                // Show Error:
                richTextBox1.AppendText("Error!\r\nSerial is not Connected, please connect and try again!" + Environment.NewLine);

                // Return:
                return;
            }
        }



        /// <summary>
        /// Calculate the Prescaler.
        /// </summary>
        /// <param name="frequency"></param>
        /// <returns></returns>
        private int CalculatePrescaler(double frequency)
        {

            if (frequency >= 300000.00)
                return 1;

            if (frequency <= 300000.00 && frequency >= 10000.00)
                return 8;

            if (frequency < 10000.00 && frequency >= 3000.00)
                return 64;

            if (frequency < 3000.00 && frequency >= 500.00)
                return 256;

            if (frequency < 500.00 && frequency >= 0.00)
                return 1024;

            return 0;
        }



        /// <summary>
        /// Serial Data Received Event.
        /// </summary>
        private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {

            // Handle Data here...
            string data = ((SerialPort)sender).ReadExisting();
            Invoke(new Action(() =>
            {
                richTextBox1.AppendText(data + Environment.NewLine);
                richTextBox1.ScrollToCaret();
            }));
        }



        /// <summary>
        /// Connect Button Click Event.
        /// </summary>
        private void ConnectButton_Click(object sender, EventArgs e)
        {

            if (ConnectButton.Text == "Connect")
            {

                // RichTextBox Clear:
                richTextBox1.Clear();

                // Configure Serial Properties:
                string Port = PortNameComboBox.SelectedItem.ToString();
                int Baud = Convert.ToInt32(BaudRateComboBox.SelectedItem.ToString());
                serialPort = new SerialPort(Port);
                BaudRate = Baud;
                Parity = Parity.None;
                DataBits = 8;
                StopBits = StopBits.One;
                Handshake = Handshake.None;

                // Gets or sets a value indicating whether the Request to Send (RTS) signal is enabled during serial communication.
                serialPort.RtsEnable = true;

                // Attach Data Reveived Event:
                serialPort.DataReceived += SerialPort_DataReceived;

                try
                {
                    // Open the Serial Port:
                    serialPort.Open();

                    // Change Button Text:
                    ConnectButton.Text = "Disconnect";

                    // Return:
                    return;
                }
                catch (Exception exc)
                {

                    // Show Error:
                    richTextBox1.AppendText(exc.Message + Environment.NewLine);

                    // Return:
                    return;
                }
            }

            if (ConnectButton.Text == "Disconnect")
            {

                // Close the Serial Port:
                serialPort.Close();
                serialPort.Dispose();

                // Change Button Text:
                ConnectButton.Text = "Connect";

                // Return:
                return;
            }
        }



        /// <summary>
        /// The Frequency TrackBar Value Changed Event.
        /// </summary>
        private void FrequencyTrackBar_ValueChanged(object sender, EventArgs e)
        {

            // Detach Frequency TrackBar Value Changed Event Handler:
            FrequencyTrackBar.ValueChanged -= new System.EventHandler(FrequencyTrackBar_ValueChanged);

            // Get TrackBar Frequency Value:
            int Value = (sender as TrackBar).Value;

            // Check Frequency Values:
            if (Value >= FrequencyTrackBar.Maximum)
            {

                // Increment the Multiplier:
                Multiplier = Multiplier + 100;

                // Check for Ones Value:
                if (Multiplier == 101)
                {
                    Multiplier = 100;
                    Frequency = 1.00;
                }

                // Reset Track Bar after Value Underflow:
                FrequencyTrackBar.Value = FrequencyTrackBar.Minimum + 1;
            }
            else
            if (Value <= FrequencyTrackBar.Minimum)
            {

                // Decrement the Multiplier:
                Multiplier = Multiplier - 100;

                // Reset Multiplier:
                if (Multiplier <= 0)
                {
                    Multiplier = 1;
                    Frequency = 0.001;
                }

                // Check Zero Values:
                if (Frequency >= 1)
                    // Reset Track Bar after Value Overflow:
                    FrequencyTrackBar.Value = FrequencyTrackBar.Maximum - 1;
            }

            // Reattach Frequency TrackBar Value Changed Event Handler:
            FrequencyTrackBar.ValueChanged += new System.EventHandler(FrequencyTrackBar_ValueChanged);

            // Set the Frequency:
            // Track Bar Max Value is: 100000 so / 1000 gives increments of 100, with 3 Decimal places: 100.123
            FrequencyTextBox.Text = ((Frequency * Convert.ToDouble(Multiplier)) + (Convert.ToDouble(Value) / 1000.0D)).ToString();
        }



        /// <summary>
        /// The Duty Cycle TrackBar Value Changed Event.
        /// </summary>
        private void DutyCycleTrackBar_ValueChanged(object sender, EventArgs e)
        {

            // Calculate Duty Cycle:
            DutyCycle = Math.Round(DutyCycleTrackBar.Value / 1000.00D, 3);

            // Set the Duty Cycle Text Box:
            this.DutyCycleTextBox.Text = DutyCycle.ToString();
        }



        /// <summary>
        /// Frequency TextBox Leave Event.
        /// </summary>
        private void FrequencyTextBox_Leave(object sender, EventArgs e)
        {

            // Get the Frequency:
            double.TryParse(FrequencyTextBox.Text, out double FrequencyOut);

            // Get Hundreds:
            int Hundreds = Convert.ToInt32(Math.Floor(FrequencyOut / 100));

            // Check Multiplier:
            if (Hundreds <= 0.00 && FrequencyOut < 100.00)
                // Set Multiplier:
                Multiplier = 1;
            else
                if (Hundreds <= 0.00 && FrequencyOut > 100.00)
                // Set Multiplier:
                Multiplier = 100 * 1;
            else
                // Set Multiplier:
                Multiplier = 100 * Hundreds;

            // Detach Frequency TrackBar Value Changed Event Handler:
            FrequencyTrackBar.ValueChanged -= new System.EventHandler(FrequencyTrackBar_ValueChanged);

            // Calculate the Frequency Divider, including the 3 Decimal places:
            double FrequencyDivider = Convert.ToInt32(FrequencyOut * 1000);

            // Set the Frequency TrackBar Value:
            if (FrequencyDivider < FrequencyTrackBar.Maximum)
                FrequencyTrackBar.Value = Convert.ToInt32(FrequencyDivider);
            else
            {
                FrequencyTrackBar.Value = Convert.ToInt32(FrequencyDivider % FrequencyTrackBar.Maximum);
            }

            // Reattach Frequency TrackBar Value Changed Event Handler:
            FrequencyTrackBar.ValueChanged += new System.EventHandler(FrequencyTrackBar_ValueChanged);
        }
    }
}

A Video:

Guys, this project has been very helpful in my work!

Best wishes, stay safe and well My Friends,

   Chris