Published May 4, 2022 © LGPL

PWM variable speed for DC motor (120V-15A) IGBT switching

Arduino controlled PWM chopper, acceleration and deceleration ramp, motor braking, OLED display and a little more...

AdvancedWork in progress3,968

PWM variable speed for DC motor (120V-15A) IGBT switching

Things used in this project

Hardware components

Arduino Nano R3

IGBT Single Transistor, 120 A

Maybe one could be enough ?

1.3 inch I2C OLED display

Transformer 400V to 48V - 250VA

Bridge Rectifier Diode, Three Phase

IR2109

Texas Instruments LM393 chip

Resistors, capacitors, relays, etc.

Heathsink eg. 40x20mm, 200mm length

Thermal resistance : about 3 K/W

Diode eg. BYV74-400

Maybe one could be enough ?

Story

I had to carry out this project in a hurry because the motor of my milling machine gave up the ghost. So please be indulgent because there are still sentences in French on the schematic that I have not taken the time to translate. There may also be inconsistencies, particularly in the pinouts of the connectors. Also the software looks more like a draft but it's working rather well.

Note that you need advanced skills before embarking on this achievement.

The motor:

A DC motor was lying around in my workshop for a while. On the motor's identification plate is written: Type: TTB-2923-00A / 156V - 11.3A - 210 rad/s / Peak: 50V - 55A

I have measured an inductance between the terminals of about 4.2mH at 1kHz

This gives us round 1.76 kW of power at full speed. I planned to use it on my mill at a lower voltage and speed, say at 120Vdc. So I expected an angular velocity of 210/156*120 = 160 rad/s which equals more or less to 160*60/2π = 1520 RPM. This is little more than the specified 1400 RPM of the original ac motor. At the end I measured the real speed of the motor: 1680 RPM. This corresponds to a spindle speed of 2600RPM with the belts on the maximum ratio.

I have a three-phase mains supply at home. So I can obtain this voltage by a three-phase rectification of the 48V output of the star-connected transformers. This gives approximately 48*√3= 83Vac between phases and 83*√2= 120Vdc after rectification and filtering.

The power switching board:

I am not used to deal with such high power switches, since I was a telephone technician, much more specialized with very low currents. After some tests and the destruction of several power mosfets, I tried my luck with IGBTs. Since they are quite expensive, I used them as a low side switch, relying on relays and contactors for reverse and for braking rather than using a full bridge structure.

A “low-side switch” structure also has the advantage of being able to lead to a cyclic conduction rate of 100%. You don't have to worry about charging a bootstrap capacitor like with a high side switch. To divide the current and reduce the saturation voltage, two IGBTs are connected in parallel. A 12 milliOhm balancing resistor is connected from each IGBT source pin to ground. These resistors are also used to limit and to measure the current through the IGBTs. A low pass suppresses spikes and a section of an LM393 serves as a comparator to inhibit the IR2109 driver if the current exceeds the setpoint. An adjustable resistance makes it possible to adjust the limitation from approximately 10 to 30 Ampere. I set it to 80mV which corresponds approximately to 13.3 A. The second section of the LM393 is connected as a pseudo integrator and provides an image of the average current for displaying it on the OLED. To avoid having to deal with inverted logic, the high side section of the IR2109 drives the IGBTs.

On the diagram I have provided a NTC resistor to measure the temperature of the heatsink. I finally did not mount it because the heatsink remained barely lukewarm.

The two vertical white components on the left are 10KΩ / 5W resistors in parallel on the 120V to discharge the capacitors when off. The small 10µH chokes were salvaged from old ATX power supplies. Likewise with BY74-400 freewheeling diodes. Most components are SMD parts mounted on bottom side.

The PCB was made on a 3018 CNC milling machine. But not everything went well and some tracks and ground planes have disappeared... I replaced them or supplemented them with wires. In particular, the power tracks (in blue on the diagram) have been reinforced with 16 gauge wire (Ø 1.29mm). I also made changes during the development. A dremel with a round cutter was a good help to add some more SMD components by cutting out part of the ground plane on the bottom of the PCB. Missing connections were made with 30AWG wire (Ø 0.25mm).

There are two 1/2W axial resistors in a strange "fly assembly" at the left rear, near to the brown 2 pin connector marked "CTN". They form a divider for measuring the drain-source voltage at the oscilloscope during development. The other probe for current measurement was connected to a golden coaxial connector matched to the probe on the midpoint of the current summing resistors R6-R7.

In order to avoid false triggering of the IGBT, the inhibit pin of IR2109 is held down at the power up by Q8 as long as the inhibit signal from the arduino does not pull to GND the cathode of D12. The collector of Q8 is OR-wired with the output of the LM393 overcurrent comparator. GND, +15V and inhibit are on the black HE14 connector in the middle left of the board. On the white HE14 are the PWM input and the I_measurement and I_limit signals. NTC temperature measurement was provided at the beginning but is finally not needed and thus not wired.

I used part of a broken RJ45 cable to connect the power board to the arduino. Each pair carries a signal and a GND or +15V (eg "GND-PWM", "GND-meas_I", "GND-I_limit", "+15V-inhibit") giving a total of 4 pairs. The GND wires are doubled with the shield wire. No wires remains for carrying temperature measurement... It is important to respect this allocation to limit the crosstalk between the signal wires.

The heathsink is an 40x20mm extruded profile with 6 wings, cut at a lenght of 200mm. It's thermal resistance is a little less than 3K/W. Insulation from the PCB's undelying tracks is done with 3 layers of kapton tape (in orange under the heatsink). The diodes and IGBTs are insulated from the heatsink with TO218 silicone rubber pads. They have about 0.5 K/W thermal resistance with thermal grease on each side.

The control board:

The control board is mainly built around an Arduino micro pro on a perforated vero board. Arduino micro pro was not the best choice because A4 (SDA) and A5 (SCL) pins are not easy to catch. Arduino nano would be the better choice but in the hurry I had none readily avalaible. Small on-board relays make the interface with the power relays and contactors. The driver transistors (BC337) are secured with hot glue.

The analog inputs of the Arduino are filtered with 18KΩ - 100nF low pass. The digital input "I_limit" has a 1KΩ - 100nF low pass.

An HE10 connector and a flat cable lead to the "control pannel".

It features :

A 0.96" OLED for future use (tachometer)

A 1.3" OLED to diplay different value in form of bargraphs

A 10KΩ potentiometer to select the maximun speed

A switch to select forward/reverse rotation. And in center of it:

a red LED indicating if current limit has been reached (in this case the LED will light up for 2s)

A switch to select if the air blow valve shall be activated (I often mill PVC, nylon or other plastics, so the air blowing is useful for clearing chips and cooling the cutter). And in center of it:

a green LED to indicate if the switch is set to air blow or not

A pneumatic valve to adjust the air flow

A switch shunting the external pedal for running permanently at the speed chosen with the potentiometer

A connector for an external pedal with a 20KΩ resistor for hand-free controlling the speed

The control pannel

The aluminum box screwed at the top with the green and red push buttons are the controls for the three-phase mains power contactor. As we deal with mains voltage, protective eath connection (PE) is mandatory on the metal boxes !

The 220V power supply for the control card passes through a hole between the two boxes. It is filtered by 4 passages of both wires through the hole of a ferrite core. There is an other ferrite with 4 passages on the ground wire that lead to the control box (e.g. TDK HF70RH16X28X9 or FAIR-RITE ref: 2643102002). These are 16x28mm ferrites with a 9mm hole that I had available. Perhaps another ferrite could also be suitable.

I had to put these two ferrites because the I2C OLED screen crashed regularly due to disturbances from the relay box.

The ferrite ferrite ring on the mains wires

A 1.3" graphic OLED is connected to the I2C A4-A5 port. It displays in combined form of a frame and a bar, the speed limit and the speed setpoint. On the bottom line of the display, a bar indicates the approximate current in the IGBTs. After 10 seconds without sollicitation, the OLED screen darkens to save its lifetime. After turning the potentiometer or pressing the pedal, the screen lights up again for 10 seconds. You can see it on the video below.

The 0.96" dark OLED at the top is planned for a tachometer to be made in the future.

The relay box:

I didn't have a box big enough to put everything in. So I had to separate the PWM chopper board and the relays in two separate boxes.

From left to right: PWM chopper board, relay box and 2 and a half of the 3 transformers

Detaiil of the relay box

The brake resistor was eventually replaced with a homemade 2.2 Ohm wirewound resistor to increase braking.

The transformers:

There are 3 single-phase 400V-48V / 250VA transformers. The primaries are delta wired. The secondaries are star wired. I thus obtain 83Vac at the secondary. This gives 120Vdc after rectification and filtering. If you missed it, you can see the explanation at the end of the "The motor" chapter above.

Oscilloscope measurements:

Three-phase rectifier output without filter capacitors

The output voltage of the three phases after the transformers is a little different. This follows the mains-side primary voltage. But filtering a three-phase rectification is much easier than single-phase rectification. Despite the voltage difference between the phases, the ripple without filter capacitor is only 23V. With half-wave rectification the ripple would be of the full voltage (120 to 135V).

IGBT collector-emitter voltage (duty cycle ~20%)

Top trace: IR2109 PWM input (duty cycle ~20%)

Bottom trace: IGBT collector-emitter voltage

IGBT collector-emitter voltage (duty cycle ~80%)

Top trace: IR2109 PWM input (duty cycle ~80%)

Bottom trace: IGBT collector-emitter voltage

Activation of current limitation

Top trace: IR2109 PWM input (signal is inverted as it was the first prototype - where I used the low side section of the IR2109)

Bottom trace: IGBT collector-emitter voltage

This measurement was made during early development. It had been taken with a 60V-10A supply before the final supply was available. The current limitation had been set to the minimum. The PWM signal is inverted compared to the final realization because I had used the "low side" driver of the IR2109. To simplify the inhibit circuit at the startup, the high side driver section of the IR2109 was finally used to drives the IGBTs.

This measurement shows the action of the IR2109 inhibition input by the current limitation. The current limit is triggered once during the phase when the IGBT should be saturated. With the current limit hardware setting and the ramp-up timing chosen in the sofware, this normally does not happen.

Logic timing diagram:

Power-up and start sequence with ramp-up

On power-up, the inhibit input of the IR2109 is held low while the arduino boots up. First, the arduino closes the power relay by shunting the resistor used for slow capacitor pre-charge. After that, the inhibit input of IR2109 goes high. Only after, and if the switch or the pedal are activated, the PWM does start its ramp-up until the desired speed is reached.

Stop with ramp-down, brake and revert sequence

When the switch or the pedal are released, the PWM start a ramp-down sequence. When PWM signal remains low and after a short delay, a brake cycle is initiated by shorting the motor on a low Ohm power resistor.

If the position of the reverse switch is changed, nothing happens as long as pulses are sent on the PWM. As soon as PWM remains low, a braking cycle is initiated. After that, the relay changes its position. This prevents a reversal of direction while the spindle is still rotating in opposite.

The air blow solenoid valve is activated if the corresponding switch is ON and if speed is more than about 10% of the max. There is no need to blow air below this speed for my use.

Update:

At the chopper output I was relying on the motor inductance for filtering the pused current. BUT It turns out that the motor has a stray capacity between the winding and the housing of round 9nF. That can be approximated by two capacitors of 4.5nf forming a divider between the two wires and the frame. Half of the switching voltage is therefore found on the housing (about 55V measured with the oscilloscope). This causes an entry into limitation of the chopper if the ground wire is directly connected to the motor.

Since this capacity cannot be suppressed, the best way would be to feed the motor with filtered DC. I have built an 1.4 mH inductor with an old 150VA transformer. The winding removed, I rewound with 45 turns of enameled wire Gauge 12 (Ø 2.05mm).

First try with 0.6mm air gap, the iron core saturates while the motor was without load !

Iron core salvaged from an 150VA transformer

Outside dimensions of the iron core alone 96x80x45mm

Section of the central iron leg: 14.4mm² (32x45mm)

Air gap : 1.5mm (presspahn or rigid cardboard)

Winding: 45 turns of enameled wire Gauge 12 (Ø 2.05mm)

Resulting inductance: 1.4mH (measured at 1KHz)

The capacitive part of this filter is built with a 10000uF/125V high current polarized capacitor, and in parallel three 10uF/160V MKP1840 to reduce the current stress in the polarized capacitor.

The ferrite core coil between ground and the CONTROL board can now be removed. The motor also runs a little quieter and there is no longer a current limiting problem as long as the torque demand does not exceed the limit.

Finished, in working order, without the covers...

Code

DC_motor_speed_control_IGBT_V2

#include <PWM.h>                // https://github.com/RCS101/PWM/blob/master/PWM.h
#include "U8glib.h"             // https://github.com/olikraus/u8glib/ 
//#include <digitalWriteFast.h>   // https://github.com/mpflaga/Arduino-digitalWriteFast

/*     In I2C Fast Mode (400 kbit/s) termination of the SDA and SCL bus with 2.2K pullups
       (tested with 2 pairs of RJ45 cat4 cable up to 7m)
       Arduino I2C bus:   A4 = SDA    A5 = SCL
*/
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0 | U8G_I2C_OPT_FAST);
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0 | U8G_I2C_OPT_NO_ACK | U8G_I2C_OPT_FAST);
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0 | U8G_I2C_OPT_NO_ACK);    // go down to 100 kbit/s if problem occurs
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);
//U8GLIB_SSD1309_128X64 u8g(U8G_I2C_OPT_DEV_0 | U8G_I2C_OPT_NO_ACK | U8G_I2C_OPT_FAST);

// Pin Declaration
const byte Cde_Reverse = 11;      // "Forward/reverse" command
const byte Cde_EvAir = 10;        // "Air blowing" command
const byte Rel_Precharge = 5;     // "Precharge" relay (in fact not needed)
const byte Rel_Alim = 4;          // "Power ON" relay
const byte Rel_Reverse = 3;       // "Forward/reverse" relay
const byte Rel_Freinage = 6;      // "Brake" relay
const byte Rel_EvAir = 7;         // "Air blowing" solenoid valve relay
const byte led_I_limit = 12;      // current limit signalisation
const byte Pwm_Inhibit = 8;       // Inhibition du driver PWM IR2109
const byte Pwm_IGBT = 9;          // PWM output pin
const byte PinI_limit = 2;        // Current limitation Input (low if limitation activated)
const byte Pot_Nmax = A0;         // Maximum speed potentiometer
const byte Pot_Pedal = A1;        // Pedal potentiometer (20kOhm pressed if V <= 3.3V)
const byte I_measurePin = A2;     // Current measurement input
const byte Temp_measurePin = A2;  // temperature measurement input (for later use)
// const byte LED_BUILTIN = 13;   // For cycle time measurement (ramp UP or ramp DOWN in progress)
//
byte nbrLoop = 0;     // loop counter (refresh display takes long: do it only every 8 loops to save time)

// Dclaration des constantes et variables globales
const int32_t frequency = 20000;                // PWM frequency (in Hz)
const uint16_t hysteresis = 2;                  // something like a "deadzone"
const uint16_t rampStepTime = 5000;             // Ramp times between each increment
const uint16_t rampDownStepTime = 800;          // Ramp times between each decrement
/* decay time shall be about 2s from full speed to allow decrease of motorspeed. Else brake resistor may overheath  *
*/
const int16_t maxPedalPressed = 1023 * 2 / 3 ;  // ------ TO BE UPDATED AFTER TESTS ------
// byte PwmValue = 0;                           // low = IGBT blocked, motor stopped
/*      prechargeTime can be reduced by taking into account the reset time from the arduino       */
const uint16_t prechargeTime = 1000;            // charging time of the power capacitors
volatile bool flag_I_limit = false;
volatile bool startBrakeFlag = false;           // initiate the brake cycle
volatile bool brakeActiveFlag = false;
/*        Test and correct brakeTime value for full spindle stop from max RPM       */
const uint16_t brakeTime = 1500;        // Time brake relay shall remain closed (=>to be tested)
const uint16_t fadeTime = 8000;         // Time before the display is dimmed
volatile int16_t actualSpeed;
volatile int16_t Nmax = 0;              // Nmax potentiometer value
uint16_t V_pedal = 0;                   // Pedal potentiometer value
const float scale_I = 1.15;             // Not exact current measured - Only indicative value !!!

void setup() {
  Serial.begin(115200);
  while (!Serial);
  u8g.setFont(u8g_font_tpssb);  // font selection : https://github.com/olikraus/u8glib/wiki/fontsize
  u8g.setColorIndex(1);         // Instruction to set pixel to on. (displays the pixel in white)
  uint8_t contrast = u8g.setContrast(1);    //u8g.sleepOn();
  InitTimersSafe();             // initialize all timers except for 0, to save time keeping functions
  bool success = SetPinFrequencySafe(Pwm_IGBT, frequency);  //sets frequency for the specified pin
  /*
     Before setting the pin as output a pull-up resistor maintains a high level
  */
  digitalWrite(Pwm_Inhibit, HIGH);   // ensure that IR2009 remains inhibited
  pinMode(Pwm_Inhibit, OUTPUT);      // when the pin is set as output during setup
  digitalWrite(Pwm_Inhibit, HIGH);   //

  pinMode(Pwm_IGBT, OUTPUT);
  pwmWrite(Pwm_IGBT, 0);

  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(PinI_limit, INPUT_PULLUP);
  pinMode(Cde_Reverse, INPUT_PULLUP);
  pinMode(Cde_EvAir, INPUT_PULLUP);
  pinMode(Rel_Precharge, OUTPUT);
  pinMode(Rel_Alim, OUTPUT);
  pinMode(Rel_Freinage, OUTPUT);
  pinMode(Rel_Reverse, OUTPUT);
  pinMode(Rel_EvAir, OUTPUT);
  pinMode(led_I_limit, OUTPUT);
  digitalWrite(Rel_Alim, LOW);
  digitalWrite(Rel_Freinage, LOW);
  digitalWrite(Rel_Reverse, LOW);
  digitalWrite(Rel_EvAir, LOW);
  digitalWrite(Rel_EvAir, LOW);
  digitalWrite(led_I_limit, LOW);      // LED is OFF
  //  digitalWrite(Rel_Precharge, HIGH);    // Start charging power capacitors (Not longer needed if relay removed)
  /*     Precharge relay can be removed by putting the preload resistor
         permanently in parallel on the power relay "Rel_Alim" ...*/
  delay(prechargeTime);
  digitalWrite(Rel_Alim, HIGH);         // Give full power by shunting the precharge resistor
  // digitalWrite(Rel_Precharge, LOW);     // Not longer needed if relay removed ...
  delay(200);
  attachInterrupt(digitalPinToInterrupt( PinI_limit), irq_I_limit, FALLING);
  digitalWrite(Pwm_Inhibit, LOW);      // remove the inhibition of the IR2009 output
}


//  ******************************************************************************
void loop() {
  static unsigned long previousMillis = 0;
  unsigned long currentMillis;
  static int16_t previousNmax = 0;
  flag_I_limit = checkCurrentLimit(flag_I_limit);
  byte targetSpeed = GetSpeedSetpoint();
  //  Serial.print("/  ");
  //  Serial.print (targetSpeed);
  //  Serial.println("  /  ");
  set_motor_speed(targetSpeed);         // target speed to reach (following ramp UP or ramp DOWN)
  digitalWrite(LED_BUILTIN, LOW);
  if ((actualSpeed <= (targetSpeed - 5)) || (actualSpeed >= (targetSpeed + 5))) {
    digitalWrite(LED_BUILTIN, HIGH);    // Speed is NOT reached
    previousMillis = millis();
  }
  if ((previousNmax <= (Nmax - 2)) || (previousNmax  >= (Nmax + 2))) {
    previousMillis = millis();
    previousNmax = Nmax;
  }

  /* --- OLED display dimming --- */
  currentMillis = millis();
  if (currentMillis - previousMillis <= fadeTime) {
    uint8_t contrast = u8g.setContrast(255);
  }
  else {
    uint8_t contrast = u8g.setContrast(1);
  }
  /* ---------------------------- */

  brake(actualSpeed, targetSpeed);      // do not brake if "actualSpeed" is not zero
  checkReverse(actualSpeed);
  blowAir(actualSpeed);
  int16_t Imeasure = measureCurrent(scale_I);
  nbrLoop++;          // refresh display takes too much time.  Do it only every 8 loops
  if (nbrLoop >= 8) {
    displayValues(Nmax , targetSpeed, Imeasure);
    nbrLoop = 0;
  }
}


//  ******************************************************************************
void checkReverse(byte speedVal) {
  static bool prevState = false;
  bool state = digitalRead(Cde_Reverse);
  if (prevState != state) {
    startBrakeFlag = true;
    prevState = state;
  }
  else if ((actualSpeed == 0) && (startBrakeFlag == false) && (brakeActiveFlag == false)) {
    digitalWrite(Rel_Reverse, state);
  }
}

//  ******************************************************************************
void brake(byte valSpeed, byte targetSpeed) {
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();
  if (valSpeed == 0) {                    // wait "actualSpeed" to be null before braking
    if (startBrakeFlag == true) {
      digitalWrite(Rel_Freinage, HIGH);
      previousMillis = currentMillis;
      brakeActiveFlag = true;
      startBrakeFlag = false;
    }
  }
  if (currentMillis - previousMillis >= brakeTime) {
    digitalWrite(Rel_Freinage, LOW);
    brakeActiveFlag = false;
  }
  if (valSpeed >= 3) digitalWrite(Rel_Freinage, LOW);
  if (targetSpeed >= 10) {
    digitalWrite(Rel_Freinage, LOW);
    brakeActiveFlag = false;
    startBrakeFlag = false;
  }
}


//  ******************************************************************************
void blowAir(byte valSpeed) {
  /*   valSpeed == 25 ~ 10% of max speed (no need to blow air below this speed  */
  if ((digitalRead(Cde_EvAir)) && (valSpeed >= 25)) {
    digitalWrite(Rel_EvAir, HIGH);
  }
  else digitalWrite (Rel_EvAir, LOW);
}


//  ******************************************************************************
int16_t measureCurrent(float scale) {
  int16_t measure = analogRead(I_measurePin);
  return measure * scale;
}


//  ******************************************************************************
bool checkCurrentLimit(bool limitFlag) {
  const uint32_t interval = 2000;           // minimal duration of the LED ON state
  static uint32_t previousMillis = 0;
  uint32_t currentMillis = millis();
  if (limitFlag == true) {
    digitalWrite(led_I_limit, HIGH);     // switch the LED ON
    previousMillis = currentMillis;
    limitFlag = false;
  }
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    digitalWrite(led_I_limit, LOW);    // switch the LED OFF
  }
  return limitFlag;
}


//  ******************************************************************************
byte GetSpeedSetpoint() {
  uint16_t PWMSpeed;
  Nmax = 0;
  V_pedal = 0;
  for (byte i = 0; i <= 7; i++) {
    Nmax += analogRead(Pot_Nmax);
    V_pedal += analogRead(Pot_Pedal);
  }
  Nmax = Nmax >> 3;
  V_pedal = V_pedal >> 3;

  if (V_pedal <= maxPedalPressed) {
    PWMSpeed = map(V_pedal, 0, maxPedalPressed, Nmax, 0);
  }
  else {
    PWMSpeed = 0;
  }
  PWMSpeed = PWMSpeed >> 2;             // max value for PWM is 255 (one byte)
  if (PWMSpeed <= 5) PWMSpeed = 0;
  return byte(PWMSpeed);
}


//  ******************************************************************************
void set_motor_speed(byte targetSpeed) {
  /*  Note that the pwm register shall be feed with inverted value of "targetSpeed" since
      the motor standstill if PWM pin is high (255) and at max speed if PWM pin is low (0)
  */
  static uint32_t previousMicros = 0;
  uint32_t currentMicros = micros();
  byte temp ;
  /*           ramp UP (acceleration)  */
  if ((actualSpeed < targetSpeed) && (brakeActiveFlag == false)) {
    startBrakeFlag = false;                  // true indicates if braking shall be done
    if (currentMicros - previousMicros >= (rampStepTime)) {
      previousMicros = currentMicros;
      if (actualSpeed < 255)  actualSpeed += 2;
      if (actualSpeed >= 255) actualSpeed = 255;
    }
  }
  /*           ramp DOWN (deceleration)  */
  if ((actualSpeed > (targetSpeed + hysteresis)) || (targetSpeed <= hysteresis)) {
    if (currentMicros - previousMicros >= rampDownStepTime) {
      previousMicros = currentMicros;
      if (actualSpeed > 0) {
        actualSpeed -= 2;
        if (actualSpeed <= 0) actualSpeed = 0;
        if (actualSpeed == 0) startBrakeFlag = true;
      }
    }
  }
  // temp = actualSpeed ^ 255;           // invert each bit of "targetSpeed"
  //                                     // Not longer needed since IR2009 rewired
  digitalWrite(LED_BUILTIN, HIGH);
  //  pwmWrite(Pwm_IGBT, temp );
  pwmWrite(Pwm_IGBT, actualSpeed );
}


//  ******************************************************************************
void displayValues(uint16_t val_1, uint16_t val_2, uint16_t val_3) {
  // les valeurs vont de 0  120 avec un offset eventuel...
  val_1 = map(val_1, 0, 1023, 5, 125);
  val_2 = map(val_2, 0, 255, 1, 120);
  val_3 = map(val_3, 0, 1023, 0, 120);
  u8g.firstPage();
  do {
    u8g.drawStr( 1, 30, "0%");      // bauche du cadre "Vitesse" (le cadre complet de
    u8g.drawStr( 55, 30, "50%");    // dimensions variables est dans la procdure "draw()")
    u8g.drawStr( 108, 30, "100");
    u8g.drawHLine(0, 13, 128);
    u8g.drawVLine(4, 14, 5);

    u8g.drawVLine(34, 14, 3);
    u8g.drawVLine(64, 14, 5);
    u8g.drawVLine(94, 14, 3);
    u8g.drawVLine(123, 14, 5);
    u8g.drawStr( 1, 64, "0");       // Cadre "Courant"
    u8g.drawStr( 35, 64, "5A");
    u8g.drawStr( 70, 64, "10A");
    u8g.drawStr( 108, 64, "15A");
    u8g.drawFrame(0, 38, 128, 10);  // on cre le frame de dimensions fixes
    u8g.drawVLine(4, 48, 5);
    u8g.drawVLine(24, 48, 3);
    u8g.drawVLine(44, 48, 5);
    u8g.drawVLine(64, 48, 3);
    u8g.drawVLine(84, 48, 5);
    u8g.drawVLine(104, 48, 3);
    u8g.drawVLine(123, 48, 5);
    draw(val_1, val_2, val_3);  // les 3 paramtres setPoint, rpmSetting, current sont transmis
  } while ( u8g.nextPage() );   // on marque ici la fin de la procdure d'affichage
}


//  ******************************************************************************
void draw(byte setPoint, byte rpmSetting, byte current) {
  u8g.drawFrame(0, 0, setPoint, 14);  // ce frame indiquera la consigne max RPM
  u8g.drawBox(4, 1, rpmSetting , 12);  //  rectangle plein RPM demand...
  u8g.drawBox(4, 41, current, 4);     // rectangle plein courant approximatif
}


//  ******************************************************************************
void irq_I_limit() {
  flag_I_limit = true;
}

Credits

daniel23

8 projects • 10 followers