How to output voltage from 2 different pins at the exact same time

Hello, I'm making an RC car that has two wheels. My car's speed depends on how long are the impulses. Here's the code:

``````int Xpin=A0;
int Ypin=A1;
int leftMotor=9;
int rightMotor=11;
int Xval;
int Yval;a
int Lon;
int Ron;
int off=10;

void setup() {
Serial.begin(9600);
pinMode(Xpin, INPUT);
pinMode(Ypin, INPUT);
pinMode(leftMotor, OUTPUT);
}

void loop() {

while(Yval>=516){
analogWrite(leftMotor, 0);
analogWrite(rightMotor, 0);
}

Serial.print("impulsas: ");
Serial.print(Ron);
Serial.print(", pauze: ");
Serial.println(off);

Lon=190./(-519.)*(Yval-519.)+10.;
Ron=190./(-519.)*(Yval-519.)+10.;

analogWrite(leftMotor, 167.96);
delay(Lon);
analogWrite(leftMotor, 0);
delay(off);

analogWrite(rightMotor, 167.96);
delay(Ron);
analogWrite(rightMotor, 0);
delay(off);

}
``````

how do i output voltage from 2 different pins at the exact same time. I need this because if I do it like I do now the pauses become too long because left motor has to wait for the other motor to turn on and off. Would also be thankful for some tips on my code.

You can start by taking-out the delays between the left & right writes...

The time between two successive writes is measured in microseconds so it shouldn't be a problem but they can't happen at exactly the same time (without adding hardware) because the processor only executes one instruction at at time and there is nothing in the hardware that allows you to "clock" the two outputs together.

The bigger problem is more-likely mechanical variations between the motors. Two "identical" motors won't run at exactly the same speed unless there is some kind of speed-control feedback.

``````analogWrite(rightMotor, 167.96);
``````

analogWrite() is 8-bit integer so 167.96 will be truncated to 167.

Unless the two pins are on the same output port register. But that is a rabbit hole we don't have to go down for this application.

If do you have this hard requierement do you need two Arduinos.

This is blocking code, nothing else can run while this is going on. If that's fine for your application, you're okay. But if you later want to keep other things running at the same time, you have a problem that can only be solved with round-robin programming techniques.

Lon and Yval are both integers. Is this floating point math really necessary? Also these are "magic numbers", i.e. the reason why those particular values are used is a mystery. You should reveal what they are by assigning the value to constants and using those instead, for example:

``````const float MoonPhase = 190.0; // explain the value here
const float MoonScale = -519.0; // explain the value here
const float MoonOffset = 10.0; // explain the value here
...
Lon = MoonPhase / MoonScale * (Yval - MoonScale) + MoonOffset;
``````

Here are some tutorials that will help:

See reply #3. But the OP doesn't really need it, just doesn't understand CPU time scales.

No! Let us go down the rabbit hole, pleeeeeeze!

a7

It sounds like your RC car might be using a standard ESC (Electronic Speed Control) for each of the two motors. Those are usually driven with the Servo library. Try this:

``````#include <Servo.h>

int Xpin = A0;
int Ypin = A1;
int LeftMotorPin = 9;
int RightMotorPin = 11;
int Xval;
int Yval;
int Lon;
int Ron;
int off = 10;

Servo LeftMotor;
Servo RightMotor;

void setup()
{
Serial.begin(9600);
// pinMode(Xpin, INPUT);
// pinMode(Ypin, INPUT);

LeftMotor.writeMicroseconds(1500);
LeftMotor.attach(LeftMotorPin);

RightMotor.writeMicroseconds(1500);
RightMotor.attach(RightMotorPin);
}

void loop()
{

while (Yval >= 516)
{
LeftMotor.writeMicroseconds(1500);
RightMotor.writeMicroseconds(1500);
}

//  Serial.print("impulsas: ");
//  Serial.print(Ron);
//  Serial.print(", pauze: ");
//  Serial.println(off);

Lon = 190. / (-519.) * (Yval - 519.) + 10.;
Ron = 190. / (-519.) * (Yval - 519.) + 10.;

LeftMotor.writeMicroseconds(Lon);
RightMotor.writeMicroseconds(Ron);
}``````

...inviting Golam Mostafa...

The ESP32 has the MCPWM that can do what you want.
Motor Control Pulse Width Modulator (MCPWM) - ESP32 - — ESP-IDF Programming Guide latest documentation (espressif.com) and works under the Arduino IDE.

Here is a code example of my use of the ESP32's MCPWM.

``````/*
Project, use solar cells to generate power
2/2/2020

*/
// https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/system/esp_timer.html
///esp_timer_get_time(void) //gets time in uSeconds like Arduino Micros. see above link
//////// http://www.iotsharing.com/2017/09/how-to-use-arduino-esp32-can-interface.html
#include "sdkconfig.h"
#include "esp_system.h" //This inclusion configures the peripherals in the ESP system.
#include "freertos/FreeRTOS.h"
#include "freertos/timers.h"
#include "freertos/event_groups.h"
// #include "esp32/ulp.h"
// #include "driver/rtc_io.h"
#include <SimpleKalmanFilter.h>
#include "esp_sleep.h"
#include "driver/mcpwm.h"
const int Priority3 = 3;
const int Priority4 = 4;
const int SerialDataBits = 115200;
volatile bool EnableTracking = true;
////
//
////
void setup()
{
Serial.begin( 115200 );
// set up A:D channels
log_i( "Setup A:D" );
// ADC1 channel 0 is GPIO36 (ESP32), GPIO1 (ESP32-S2)
//  // ADC1 channel 5 is GPIO33
//  // ADC1 channel 6 is GPIO34
//  // adc for light dark detection, ADC1 channel 7 is GPIO35 (ESP32)
// adc for solar cell voltage detection, ADC1 channel 4 is GPIO33 (ESP32)
//
log_i( "A:D setup complete" );
// control for relay to supply power to the servos
pinMode( 5, OUTPUT );
log_i( "setup MCPWM" );
//
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM1A, GPIO_NUM_4 ); // Azimuth
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, GPIO_NUM_12 ); // Altitude servo
//
mcpwm_config_t pwm_config = {};
pwm_config.frequency = 50;    //frequency = 50Hz, i.e. for every servo motor time period should be 20ms
pwm_config.cmpr_a = 0;    //duty cycle of PWMxA = 0
pwm_config.cmpr_b = 0;    //duty cycle of PWMxb = 0
pwm_config.counter_mode = MCPWM_UP_COUNTER;
pwm_config.duty_mode = MCPWM_DUTY_MODE_0;
log_i( "MCPWM complete" );
//
//
mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config);    //Configure PWM0A timer 0 with above settings
mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_1, &pwm_config);    //Configure PWM0A timer 1 with above settings
//  ////
fMoveAltitude( 1525 );
fMoveAzimuth( 1500 );
////
////  // esp_sleep_enable_timer_wakeup( (60000000 * 2) ); // set timer to wake up once a minute 60000000uS * 2

}
//
void fDaylight( void * pvParameters )
{
int lightLevel = 0;
log_i( "Start up fDaylight" );
while (1)
{
// sufficent voltage at the solar cells to do the thing?
{
{
log_i( "Light Level: %d", lightLevel );
EnableTracking = true;
digitalWrite( 5, LOW ); // power to relay module/servos
} else {
// if light level to low park boom
fMoveAltitude( 1475 );
fMoveAzimuth( 1900 );
//     put esp32 into deep sleep
digitalWrite( 5, HIGH ); // deenergize servo motors
EnableTracking = false;
esp_sleep_enable_timer_wakeup( (60000000 * 5) ); // set timer to wake up once a minute 60000000uS
esp_deep_sleep_start();
}
} else {
digitalWrite( 5, HIGH ); // deenergize servo motors
EnableTracking = false;
esp_sleep_enable_timer_wakeup( (60000000 * 5) ); // set timer to wake up once a minute 60000000uS
esp_deep_sleep_start();
}
} // while(1)
} // void fDaylight( void * pvParameters )
////
/**
@brief Use this function to calcute pulse width for per degree rotation
@param  degree_of_rotation the angle in degree to which servo has to rotate
@return
- calculated pulse width
*/
//static uint32_t servo_per_degree_init(uint32_t degree_of_rotation)
//{
//  const int SERVO_MIN_PULSEWIDTH = 500; //Minimum pulse width in microsecond
//const int SERVO_MAX_PULSEWIDTH 2500 //Maximum pulse width in microsecond
//const int SERVO_MAX_DEGREE 180 //Maximum angle in degree upto which servo can rotate
//  uint32_t cal_pulsewidth = 0;
//  cal_pulsewidth = (SERVO_MIN_PULSEWIDTH + (((SERVO_MAX_PULSEWIDTH - SERVO_MIN_PULSEWIDTH) * (degree_of_rotation)) / (SERVO_MAX_DEGREE)));
//  return cal_pulsewidth;
//}
////
void mcpwm_gpio_initialize(void)
{
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM1A, GPIO_NUM_4 );
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, GPIO_NUM_12 );
}
////
// void TrackSun( int Altitude, int Azimuth )
void TrackSun( void * pvParameters )
{
log_i( "Startup TrackSun" );
int64_t EndTime = esp_timer_get_time();
int64_t StartTime = esp_timer_get_time(); //gets time in uSeconds like Arduino Micros
int Altitude = 1500;
int Azimuth = 900;
int maxAltitudeRange = 2144;
int minAltitudeRange = 900;
int maxAzimuthRange = 2144;
int minAzimuthRange = 900;
float AltitudeThreashold = 10.0f;
float AzimuthThreashold = 10.0f;
float kalmanThreshold = 80.0f;
SimpleKalmanFilter kfAltitude0( AltitudeThreshold, kalmanThreshold, .01 ); // kalman filter Altitude 0
SimpleKalmanFilter kfAltitude1( AltitudeThreshold, kalmanThreshold, .01 ); // kalman filter Altitude 1
SimpleKalmanFilter kfAzimuth0( AzimuthThreshold, kalmanThreshold, .01 ); // kalman filter Azimuth 0
SimpleKalmanFilter kfAzimuth1( AzimuthThreshold, kalmanThreshold, .01 ); // kalman filter Azimuth 1
float filteredAltitude_0 = 0.0f;
float filteredAltitude_1 = 0.0f;
float filteredAzimuth_0 = 0.0f;
float filteredAzimuth_1 = 0.0f;
uint64_t AzimuthEndTime = esp_timer_get_time();
uint64_t AzimuthStartTime = esp_timer_get_time(); //gets time in uSeconds like Arduino Micros,but rolls over after 207 years
uint64_t AltitudeEndTime = esp_timer_get_time();
uint64_t AltitudeStartTime = esp_timer_get_time(); //gets time in uSeconds like Arduino Micros,
int StartupCount = 0;
int TorqueAmmount = 5;
while (1)
{

if ( EnableTracking )
{
//Altitude
AltitudeEndTime = esp_timer_get_time() - AltitudeStartTime; // produce elapsed time for the simpleKalmanFilter
kfAltitude0.setProcessNoise( float(AltitudeEndTime) / 1000000.0f );
kfAltitude1.setProcessNoise( float(AltitudeEndTime) / 1000000.0f );
// Serial.println( AltitudeEndTime,6 );
//      Serial.print( filteredAltitude_0 );
//      Serial.print( ", " );
//      Serial.print( filteredAltitude_1 );
//      Serial.print( ", " );
//      Serial.println();
if ( (filteredAltitude_0 > filteredAltitude_1) && (abs(filteredAltitude_0 - filteredAltitude_1) > AltitudeThreshold))
{
Altitude -= TorqueAmmount;
// log_i( "> Alt %d", Altitude );
if ( Altitude < minAltitudeRange )
{
Altitude = 900;
}
fMoveAltitude( Altitude );
AltitudeStartTime = esp_timer_get_time();
}
if ( (filteredAltitude_0 < filteredAltitude_1) && (abs(filteredAltitude_0 - filteredAltitude_1) > AltitudeThreshold) )
{
Altitude += TorqueAmmount;
if ( Altitude >= maxAltitudeRange )
{
Altitude = 900;
}
fMoveAltitude( Altitude );
// log_i( "< Alt %d", Altitude );
AltitudeStartTime = esp_timer_get_time();
}
//// AZIMUTH
AzimuthEndTime = esp_timer_get_time() - AzimuthStartTime; // produce elasped time for the simpleKalmanFilter
//      Serial.print( "," );
//      Serial.print( "," );
kfAzimuth0.setProcessNoise( float(AzimuthEndTime) / 1000000.0f ); //convert time of process to uS, update SimpleKalmanFilter q
kfAzimuth1.setProcessNoise( float(AzimuthEndTime) / 1000000.0f ); //convert time of process to uS, update SimpleKalmanFilter q
//      Serial.print( filteredAzimuth_0 );
//      Serial.print( ", " );
//      Serial.print( filteredAzimuth_1 );
//      Serial.println();
if ( (filteredAzimuth_0 > filteredAzimuth_1) && (abs(filteredAzimuth_0 - filteredAzimuth_1)) > AzimuthThreashold )
{
Azimuth += TorqueAmmount;
if ( Azimuth >= maxAzimuthRange )
{
Azimuth = 900;
}
// log_i( "> Az %d", Azimuth );
fMoveAzimuth( Azimuth );
AzimuthStartTime = esp_timer_get_time();
}
//    //
if ( (filteredAzimuth_0 < filteredAzimuth_1) && (abs(filteredAzimuth_1 - filteredAzimuth_0)) > AzimuthThreashold )
{
// log_i( "< Az %d", Azimuth );
Azimuth -= TorqueAmmount; // make new position to torque to
if ( (Azimuth >= maxAzimuthRange) || (Azimuth <= minAzimuthRange) )
{
Azimuth = 900;
}
fMoveAzimuth( Azimuth );
AzimuthStartTime = esp_timer_get_time();
} //azmiuth end
if ( StartupCount < 500 )
{
++StartupCount;
} else {
TorqueAmmount = 1;
// esp_sleep_enable_timer_wakeup( (60000000 / 30) ); // set timer to wake up
// esp_sleep_enable_timer_wakeup( (60000000 / 20) ); // set timer to wake up
// esp_light_sleep_start();
}
}
} // while(1)
} //void TrackSun()
////
void fMoveAltitude( int MoveTo )
{
mcpwm_set_duty_in_us(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_OPR_A, MoveTo);
}
//////
void fMoveAzimuth( int MoveTo )
{
mcpwm_set_duty_in_us(MCPWM_UNIT_0, MCPWM_TIMER_1, MCPWM_OPR_A, MoveTo);