Digitale MOSFET belasting voor hoge stromen

Ik moest mijn AmpVolt Power Meter tot het uiterste drijven, maar ik had geen DC-belasting die meer dan 2 A kon trekken. Op dat moment had ik weinig tijd en middelen, dus besloot ik er zelf maar eentje te maken. Met deze digitale MOSFET belasting kon ik ruim 8 A bereiken.

Een oplossing voor kleine digitale ladingen

In elk lab kan het belang van testapparatuur niet genoeg worden benadrukt. Het betekent vaak het verschil tussen ‘goed genoeg’ en perfectie. Hoogwaardige testapparatuur zorgt ervoor dat de ontworpen hardware voldoet aan de verwachtingen en onder verschillende omstandigheden blijft presteren, zodat wordt voldaan aan de hoge normen die worden verwacht bij moderne elektronica. Maar als geen testapparatuur ter beschikking staat en de tijd dringt, of als we gewoon ‘nu meteen’ wilen testen, dan moeten we zelf een oplossing bedenken. Dit is precies de situatie waarmee ik werd geconfronteerd toen ik de grenzen van de AmpVolt-vermogensmeter wilde testen en ik geen apparaat had waarmee ik met meer dan 2 A kon belasten. Deze beperking dwong me een kleine, maar effectieve oplossing te ontwikkelen die kan worden gebruikt als er geen ‘echte’ DC-belasting beschikbaar is.

Wanneer we de term ‘belasting’ in de elektronica gebruiken, denken we vaak als eerste aan een vermogensweerstand. Het concept van een digitale belasting biedt echter aanzienlijke voordelen vergeleken met de traditionele resistieve opties, wat vooral gunstig is in moderne testomgevingen. Een digitale belasting maakt gebruik van vermogenshalfgeleiders zoals MOSFET’s, IGBT’s, BJT’s enzovoort om zich dynamisch aan te passen aan wisselende elektrische omstandigheden, waardoor een nauwkeurige simulatie van elektrisch gedrag mogelijk wordt zonder dat handmatige aanpassingen nodig zijn. Dit stroomlijnt testprocessen en verhoogt de nauwkeurigheid. Bovendien kunnen digitale belastingen meet- en datalogging-mogelijkheden integreren, gekoppeld aan efficiënt thermisch beheer en ingebouwde veiligheidsfuncties.

De schakeling

Het schema staat in figuur 1. De IRF3205-MOSFET is bewust gekozen. Met een maximaal toelaatbare spanning van 55 V en een maximale stroom van 110 A kan hij zware tests zonder aarzeling aan. Met een koellichaam kan hij probleemloos warmte afvoeren, ondanks de strenge eisen die aan continue vermogensdissipatie worden gesteld.

Centraal in het ontwerp staat het kleine XIAO ESP32S3 microcontroller break-out board van Seeed. Om het bouwen van het prototype te vereenvoudigen, heb ik een zeer compact uitbreidingsboard voor deze XIAO-module gebruikt. (Inmiddels hebben we ons eigen Elektor XIAO-uitbreidingsboardontwikkeld, zie .) Op zo’n uitbreidingsboard zijn de GPIO’s op de pinheaders van het XIAO-board voorzien van Grove-connectoren, die altijd een pin voor GND, een pin voor 3,3 V en twee input/output/bus-pinnen hebben. Deze connectoren zijn in het schema te zien als K2, K1, J1 en J2, de laatste twee zijn speciaal voor I²C.

K2/K4 zijn met elkaar verbonden om LED1 en LED2 aan te sturen, die worden gebruikt om de bedrijfsstatus aan te geven en visuele feedback te geven over de toestand van de belasting. K1/K3 worden gebruikt met een PWM-uitgang die de MOSFET schakelt en een analoge ingang die de stand van de potmeter registreert. Met die laatste is het mogelijk om de firmware de PWM duty cycle te laten aanpassen, wat in nauwkeurige instelling van de belasting voorziet.

R1 is een pull-down weerstand tussen de gate en de source van de MOSFET, die ervoor zorgt dat de gate goed wordt ontladen als het PWM-signaal uit is, waardoor onbedoeld schakelen wordt voorkomen.

Het schema van de digitale belasting bevat opties voor toekomstige uitbreidingen, zoals een OLED-display en een stroomsensor. Omwille van de eenvoud van het initiële ontwerp wordt echter een potmeter gebruikt voor eenvoudige handmatige regeling van de belasting. Deze aanpak maakt een basisbediening mogelijk en houdt tegelijkertijd de deur open voor complexere functionaliteit die later kan worden geïntegreerd.

Testopstelling

Ik heb een test gedaan met het rechterdeel van de schakeling, door een PWM-signaal van een signaalgenerator aan te sluiten op pen 4 van K3. Een digitale voeding was aangesloten op connector K5, met de source van T1 verbonden met de negatieve klem en de drain van T1 verbonden met de positieve klem van de stroombron. Daarna werd een PWM-signaal op de gate gezet met een periode van 20 µs, een amplitude van 3,3 Vpp en een duty cycle van 3...50%, terwijl ik de stroom door de MOSFET met de digitale voeding en een multimeter heb gemeten.

Bij een duty cycle van ongeveer 21,3% trok de elektronische belasting bijna 4,9 A (figuur 2). Het verder opvoeren van de duty cycle kan de stroom nog verder verhogen, maar dan wordt de behuizing van de MOSFET ook warmer, tot wel 70 °C (zonder actieve koeling) dus het is aan te raden om een groot koellichaam met actieve koeling te gebruiken. Het gebruik van twee of meer MOSFET’s parallel kan ook de maximale stroom verhogen en de temperatuur verlagen.

Software

De firmware werd gebouwd met Arduino IDE, om een PWM-signaal te genereren met behulp van een ESP32, een potentiometer om de duty cycle aan te passen en LED’s om de status van het systeem aan te geven (listing 1). Als eerste worden de pinnen voor de potentiometer, PWM-uitgang en LED’s gedefinieerd, en worden de PWM-parameters ingesteld, waaronder een frequentie van 50 kHz, een resolutie van 8 bits en een maximale PWM-waarde van 255. In de setup-functie wordt de seriële interface geïnitialiseerd voor debugging en worden de LED-pinnen geconfigureerd als uitgangen. De PWM wordt uitgevoerd op de gespecificeerde pin met de gedefinieerde frequentie en resolutie. In eerste instantie leest de code de stand van de potentiometer en controleert of deze de minimum-spanningsdrempel overschrijdt. Als dat het geval is, gaat de rode LED branden en wacht het systeem tot de gebruiker de potentiometer op zijn minimumwaarde instelt.

In de hoofdlus leest de code continu de waarde van de potmeter en zet deze om in een spanning die de duty cycle van het PWM-signaal bepaalt in een bereik van 0 tot 50% van de maximale waarde. Een signaal met deze duty cycle wordt vervolgens naar de PWM-pin gestuurd. De groene LED gaat aan om de normale werking aan te geven. Bovendien stuurt de code debuginformatie, inclusief het duty cycle-percentage en de potmeterspanning, naar de seriële monitor. Figuur 3 toont het systeem in actie, waarbij de belasting wordt aangepast met behulp van van de potentiometer.

Voor degenen die dit project willen nabouwen of aanpassen, zijn alle schema’s en de code beschikbaar op GitHub . Daarmee kunt u dan aan de slag om de elektronische belasting aan te passen aan eventuele bijzondere eisen. Omdat we een ESP32 gebruiken, is het mogelijk om de digitale belasting draadloos te bedienen, door een webserver op de ESP32 te laten draaien om de belasting via een webinterface (WiFi of zelfs via internet) te bedienen. De mogelijkheden zijn eindeloos!

Opmerking van de redactie: Dit artikel (240203-03) verschijnt in de Elektor Circuit Special 2024.

Listing 1: Basis-firmware.

#include <Arduino.h>

// Pin definitions

#define POT_PIN 3

#define PWM_PIN 2

#define RED_LED_PIN 9

#define GREEN_LED_PIN 8

// PWM parameters

const long pwmFrequency = 50000; // 50 kHz to achieve a 20 us period

const uint8_t pwmResolution = 8; // 8-bit resolution for PWM

const uint8_t maxPwmValue = 255; // Maximum value for 8-bit resolution PWM

// ADC and Voltage settings

const float referenceVoltage = 3.3; // ADC reference voltage in volts

const int adcMaxValue = 4095;       // Maximum ADC value for 12-bit resolution

const float minimumVoltage = 0.1;   // Minimum voltage threshold to start PWM

void setup() {

  // Initialize Serial for debug output

  Serial.begin(9600);

  // Set up LED pins

  pinMode(RED_LED_PIN, OUTPUT);

  pinMode(GREEN_LED_PIN, OUTPUT);

  // Initialize PWM on pin

  ledcSetup(0, pwmFrequency, pwmResolution);

  ledcAttachPin(PWM_PIN, 0);

  // Check initial position of the potentiometer

  float initialVoltage = (analogRead(POT_PIN) * referenceVoltage) / adcMaxValue;

  if (initialVoltage > minimumVoltage) {

    digitalWrite(RED_LED_PIN, HIGH); // Turn on red LED

    digitalWrite(GREEN_LED_PIN, LOW); // Make sure green LED is off

    while ((analogRead(POT_PIN) * referenceVoltage / adcMaxValue) > minimumVoltage) {

      // Wait for the user to adjust the potentiometer to minimum

      delay(100); // Delay to avoid excessive reading

      Serial.println("Adjust potentiometer to minimum to start.");

      Serial.println((analogRead(POT_PIN) * referenceVoltage / adcMaxValue));

    }

  }

  // Potentiometer is at minimum value, proceed with normal operation

  digitalWrite(RED_LED_PIN, LOW);

  digitalWrite(GREEN_LED_PIN, HIGH);

}

void loop() {

  // Read the potentiometer value and convert to voltage

  float potVoltage = (analogRead(POT_PIN) * referenceVoltage) / adcMaxValue;

  // Calculate the PWM duty cycle (0 - 50% of maximum PWM value)

  int pwmDutyCycle = map(potVoltage * 1000, 0, referenceVoltage * 1000, 0, 128);

  // Set the PWM duty cycle

  ledcWrite(0, pwmDutyCycle);

  digitalWrite(GREEN_LED_PIN, HIGH);

  // Debug output to Serial Monitor

  Serial.print("Duty Cycle: ");

  Serial.print((float)pwmDutyCycle / maxPwmValue * 100);

  Serial.println("%");

  Serial.print("Potentiometer Voltage: ");

  Serial.print(potVoltage);

  Serial.println(" V");

}