🌎 Google Translate

• The PWMDcMotor.cpp controls brushed DC motors by PWM using standard full bridge IC's like L298, SparkFun Motor Driver - Dual TB6612FNG, or Adafruit_MotorShield (using PCA9685 -> 2 x TB6612).
• The EncoderMotor.cpp.cpp controls a DC motor with attached encoder disc and slot-type photo interrupters to enable driving a specified distance.
• The CarPWMMotorControl.cpp controls 2 motors simultaneously like it is required for most Robot Cars.
• To compensate for different motor characteristics, each motor can have a positive compensation value, which is subtracted from the requested speed PWM if you use the setSpeedPWMCompensation() functions. For car control, only compensation of one motor is required.
• 4 wheel mecanum car control movements are fully supported with extended directions like DIRECTION_LEFT, DIRECTION_DIAGONAL_LEFT_BACKWARD, DIRECTION_TURN_RIGHT_IN_PLACE etc..

1. Direction / motor driver control. Can be FORWARD, BACKWARD, BRAKE (motor connections are shortened) or RELEASE (motor connections are high impedance).
2. SpeedPWM which is ignored for BRAKE or RELEASE. Some functions allow a signed speedPWM parameter, which includes the direction as sign (positive -> FORWARD).

• init(uint8_t aForwardPin, uint8_t aBackwardPin, uint8_t aPWMPin).
• setDirection(uint8_t aMotorDirection).
• setSpeedPWM(uint8_t aSpeedPWM).
• setSpeedPWMAndDirection(uint8_t aRequestedSpeedPWM, uint8_t aRequestedDirection).
• setSpeedPWMAndDirection(int SignedRequestedSpeedPWM).
• stop() or setSpeedPWMAndDirection(0).
• startRampUp(uint8_t aRequestedDirection).
• getSpeed(), getAverageSpeed(), getDistanceMillimeter() and getBrakingDistanceMillimeter() for encoder motors or MPU6050 IMU equipped cars.

Driving speed PWM (2.0 V) is the PWM value to use for driving a fixed distance. If it is set higher than RAMP_VALUE_OFFSET_SPEED_PWM (2.3 V), the software generates a ramp up from RAMP_VALUE_OFFSET_SPEED_PWM to requested driving speed PWM at the start of the movement and a ramp down to stop.

• goDistanceMillimeter(uint8_t aRequestedSpeedPWM, unsigned int aRequestedDistanceMillimeter, uint8_t aRequestedDirection);
  For non encoder motors, distance and drive speed PWM is used in a formula to convert millimeters into motor driving time.
• updateMotor() - call this in your loop if you use the start* functions e.g. startGoDistanceMillimeter(int aRequestedDistanceMillimeter).

• rotate(int aRotationDegrees, turn_direction_t aTurnDirection, bool aUseSlowSpeed, void (*aLoopCallback)(void)).
• Plus all functions from above like setSpeedPWM() etc. They now affect both motors.

4WD car with IR receiver and Bluetooth module and 4 AA rechargeable batteries.	Instructable

This library was tested with the bipolar full bridge IC L298 and the (recommended) MOSFET full bridge IC TB6612.

The L298 has a loss of around 2 volt, which is the reason for the attached heat sink	The TB6612 has almost no loss
L298 voltages at both motor pins @7.5 V	TB6612 effective motor voltage @7.6 V

• PWM period is 600 µs (1.6 kHz) for Adafruit Motor Shield V2 using PCA9685.
• PWM period is 1030 µs (970 Hz) for AnalogWrite on pin 5 + 6.

The examples are available at File > Examples > Examples from Custom Libraries / PWMMotorControl.

One motor starts with DriveSpeedPWM / 2 for one second, then runs 1 second with DriveSpeedPWM. After stopping the motor, it tries to run for one full rotation (resulting in a 90 degree turn for a 2WD car). Then the other motor runs the same cycle. For the next loop, the direction is switched to backwards.

4 times drive 40 cm and 90 degree left turn. After the square, the car is turned by 180 degree and the direction is switched to backwards. Then the square starts again.

This example prints PWM, speed and distance / encoder-count diagram of an encoder motor. The encoder increment is inverted at falling PWM slope to show the quadratic kind of encoder graph. Timebase is 20 ms per plotted value.

Diagram for free running motor controlled by an MosFet bridge supplied by 7.0 volt	Diagram for free running motor controlled by an L298 bridge supplied by 7.6 volt
Here you see that the speed is proportional to the PWM, but the minimal power to start the motor is 33/255 = 13% PWM or 0.9 volt.	Due to losses and other effects in the L298, the start voltage is much higher.
MosFet bridge supplied by only 3.5 volt	Start diagram for L298 with 6.2 volt
Here, the start voltage can be observed better. There is no stop at the same voltage, so the distance gets virtually negative.	Higher start voltage and a non linear speed / PWM ratio here.

Prints PWM, speed and distance diagram of the right (encoder) motor of a car equipped with a MPU6050 IMU. Encoder and IMU (MPU6050) data are printed simultaneously, to compare and to detect slipping.
It does a start and stop car first with and second without ramp. It starts with DEFAULT_DRIVE_SPEED_PWM and doubles speed for next turn until MAX_SPEED_PWM.

Diagram for car controlled by an MosFet bridge	Diagram for car controlled by an L298 bridge

The code uses a TCRT 5000 3-channel sensor.

According to the 8 different states of the 3 sensor inputs, we perform the following actions: 0 - All sensors are dark or not connected -> stop or go forward after sharp turn 1 - Mid and right sensors are dark -> sharp right 2 - Left and right sensors are dark -> panic stop, because this is unexpected 3 - Only right sensor is dark -> right 4 - Mid and left sensors are dark -> sharp left 5 - Only mid sensor is dark -> forward 6 - Only left sensor is dark -> left 7 - All sensors are not dark -> stop or go backward after turn

Template for your RobotCar control. Currently implemented is: Drive until distance too low, then stop, go backwards and turn random amount.

Implements basic car control by an IR remote. Mapping between keys of any IR remote sending NEC protocol (all the cheap china ones) and car commands can be done in IRCommandMapping.h.
To support mapping, the received IR code is printed at the serial output if INFO is defined.

The 3 supported IR remotes	Back view of 2 IR remotes

The car tries to hold a distance between 30 and 40 cm to an obstacle. Only forward and back movement, no turn! The measured distance range is converted to a pitch as an acoustic feedback.

The car tries to hold a distance between 22 and 30 cm to an target. If the target vanishes, the distance sensor rotates and scans up to 60 cm to get the vanished (or a new) target.

If an IR Receiver is attached, the following IR commands are available:

• Reset i.e. stop car and set all values to default.

• Drive forward / backward for a complete wheel turn. Each repeat will extend the distance by another 1/4 of a wheel turn.

• Increase / decrease driving speed PWM by 1/16 of max PWM, but clip at start speed PWM, which depends on motor supply voltage.

• Set driving speed PWM to default, which depends on motor supply voltage.

• Turn in place left / right by around 15 degree.

• Toggle keep distance mode.

• Toggle follower mode (the one that scans).

• Step the distance feedback modes:

  • No feedback tone (default).
  • Pentatonic frequency feedback tone.
  • Continuous frequency feeedback tone.

• Switch distance source, if a IR distance (Sharp GP2Y0A21YK / 1080) as well as an ultrasonic distance (HC-SR04) sensor are connected.

  • Use IR as distance sensor (default).
  • Use US as distance sensor.
  • Use minimum of both sensors as distance.
  • Use maximum of both sensors as distance.

• Toggle scan speed of distance servo.

• TestRotate: Check the current EEPROM stored values for rotation.

  1. Rotate left forward by 9 times 10 degree -> 90 degree.
  2. Rotate right forward by 90 degree -> car has its initial direction but moved left forward.
  • Do the same the other direction i.e. first right, then left.
  • Do the same again, but turn in place.

• TestDrive. Drive the car 2 times forward and and 2 times backward, each for a full wheel turn, to check the current values set for driving distance.

• Test: Drive the car for 2 times 1/8, wheel turn, then 1/ and 1/2 wheel turn. First forward, then backward. If distance driving formula and values are correct, this results in 2 full wheel turns ending at the start position.

• Calibrate speed and rotation.

Motor speed depends from motor supply voltage at a given PWM value.

First measure the motor supply voltage under normal load, i.e the fixed DEFAULT_DRIVE_SPEED_PWM, while turning in place and adjust PWM according to this voltage.

Second calibrate rotation.

1. Start a 2 * 360 degree turn (4 * 360 for 2 wheel cars, which turn faster) to be sure to reach 360 degree.
2. The user should press the stop button when 360 degree is reached.
3. Then compute the internal MillimeterPer256Degreee value used for rotations.
4. Move 90 degree left and right using the new computed values.

• If a IR command is received in the first 4 seconds after start of rotation, it is taken as abort command.
• If no IR command is received, it is also taken as abort. This enable an easy check, i.e if calibration is correct, the 720 degree are reached.

The steps 1 to 4 are first executed with turn in place, then with turn forward, since the values for both are different, so you must press the stop button twice for a complete calibration.

Requires the Arduino library BlueDisplay.

Enables autonomous driving of a 2 or 4 wheel car with an Arduino.
To avoid obstacles a HC-SR04 Ultrasonic sensor mounted on a SG90 Servo continuously scans the environment. Manual control is implemented by a GUI using a Bluetooth HC-05 Module and the BlueDisplay library.

To customize the library to different requirements, there are some compile options / macros available.
These macros must be defined in your program before the line #include <CarPWMMotorControl.hpp>, #include <EncoderMotor.hpp> or #include <PWMDcMotor.hpp>to take effect.
Modify them by enabling / disabling them, or change the values if applicable.

These values are for a standard 2 WD car as can be seen on the pictures below.

These values are used by functions and some can be overwritten by set* functions.

To customize the software to different car configurations, there are some compile options / macros available.

Connection schematic of the L298 board for the examples. If motor drives in opposite direction, you must flip the motor to L298 connections.

2 wheel car from LAVFIN with battery case for two 18650 Li-ion batteries, and IR receiver, with power wires in original length.

Connections on the Arduino and on the L298 board.

2 wheel car with encoders, slot-type photo interrupter, 2 Li-ion batteries, Adafruit Motor Shield V2, HC-05 Bluetooth module, and servo mounted head down. 4 wheel car with servo mounted head up. Encoder slot-type photo interrupter sensor Servo mounted head down VIN sensing

• Added 2 functions startGoDistanceMillimeterWithSpeed(uint8_t aRequestedSpeedPWM, ...).
• ESP32 core 3.x support.
• Improved examples, especially follower examples.

• Improved examples, especially follower examples.
• Added convertMillimeterToMillis() etc.
• Added Variable computedMillisOfMotorForDistance.
• Added MillimeterPer256Degree and function setMillimeterPer256Degree() instead of using always constants.

• Renamed instance from RobotCarPWMMotorControl to RobotCar.
• MecanumWheelCar support.
• IMUCarData improved.
• Added Voltage handling functions like getVoltageAdjustedSpeedPWM() etc.

• Removed all *Compensated functions, compensation now is always active.
• Removed StopSpeed from EepromMotorinfoStruct.
• Removed StartSpeed.
• Renamed *.cpp to *.hpp.
• Added and renamed functions.
• IMU / MPU6050 support.
• Support of off the shelf smart cars.
• Added and renamed functions.
• Converted to voltage based formulas.
• Easy configuration of different car features.

• Initial Arduino library version.