import numpy as np
import matplotlib.pyplot as plt
# Parameters (afkomstig uit de college-slides)
stall_torque = 0.1 # [Nm]
torque_slope = 0.0005 # [Nm/(rad/s)]
last_const = 0.02 # [Nm]
J = 0.0004 # [kg m^2]
omega_window = (stall_torque-last_const)/torque_slope # (rad/s)
def torque_surplus(omega: float) -> float:
"""Overschot Tm - Tl bij gegeven omega."""
if 0 <= omega <= omega_window:
Tm = stall_torque - torque_slope*omega
Tl = last_const
return Tm - Tl
return 0.0
def simulate_steps(steps: int = 100):
omega = np.zeros(steps+1)
t = np.zeros(steps+1)
dω = omega_window/steps
omega[0] = 0.5*dω
for i in range(steps):
omega[i+1] = omega[i] + dω
Ts = torque_surplus(omega[i])
t[i+1] = t[i] + (J * dω / Ts)
return t, omega
# Run & plot
fig, ax = plt.subplots(1, 1, figsize=(6, 4))
o = np.linspace(0,1.1*omega_window,300)
ax.plot(o, stall_torque - torque_slope*o, label='motorkarakteristiek')
ax.plot(o, o*0+last_const, label='lastkarakteristiek')
ax.set_xlabel('Koppel (Nm)')
ax.set_ylabel('hoeksnelheid ω (rad/s)')
ax.grid(True)
ax.legend()
fig, ax = plt.subplots(1, 1, figsize=(6, 4))
t, omega = simulate_steps(steps=100)
ax.plot(t, omega, label='ω(t)')
ax.set_xlabel('tijd (s)')
ax.set_ylabel('hoeksnelheid ω (rad/s)')
ax.grid(True)
ax.legend()
plt.tight_layout()
plt.show()Aandrijving met DC-motoren
WB1643 Werktuigkundig Ontwerpproject 3
Inleiding
Deze pagina dient als naslag bij de colleges over “Aandrijven met DC-motoren” horende bij het vak WOP3A.
Wat is aandrijving?
Aandrijving is de omzetting van een of andere vorm van energie naar mechanische energie. Transmissie/overbrenging zet mechanische energie om naar mechanische energie (geen energievorm‑omzetting), naar een andere plek, of met een andere relatie tussen krachten en verplaatsing/snelheden.
Types motorkarakteristieken
Het koppel wat een motor kan genereren is afhankelijk van zijn hoeksnelheid op dat moment. De verschillende motor-typen hebben verschillende karakteristieken, dat wil zeggen relaties tussen koppel en hoeksnelheid, ook wel de koppeltoerenkromme genaamd.
In deze collegereeks focussen we op DC-motoren (Direct Current Motors), ofwel gelijkstroommotoren. Dit type motor vertoont een lineair afnemende karakteristiek:
Merk vooral op dat wanneer het maximale koppel optreedt de hoeksnelheid \(\omega (rad/s)\) gelijk is aan nul, en dat wanneer de hoeksnelheid maximaal is het koppel juist nul is. Het maximale koppel noemt met Stall torque, de maximale hoeksnelheid noemt men No-load speed.
De waardes van de Stall torque en van de No load speed zijn meestal te vinden in de specificaties van een DC motor. Meestal wordt de No load speed gegeven in omwentelingen per minuut, in het engels revolutions per miute (RPM). Het is aan te raden om dit gegeven om te zetten in radialen per seconde \((rad/s)\) voor later rekenwerk. Het is belangrijk om ervan bewust te zijn dat het maximale koppel én de maximale snelheid nooit tegelijkertijd bestaan. Wanneer de motor snel draait levert het een klein koppel, en wanneer het een groot koppel levert draait het langzaam. In formulevorm kan de karakteristiek worden gegeven als
\[T(\omega) = A - B\,\omega. \tag{1}\]
Hierin is \(A\) de stall torque (bij \(\omega=0\)) en \(\frac{A}{B}\) de no‑load speed (oplossing van \(\omega\) bij \(T=0\)).
Werking van een DC‑motor – Lorentzkracht
Een elektromotor zet electrische energie om in mechanische energie. Onderstaande video legt kort het electromechanisch aspect van een DC motor uit: Hoe ontstaat een koppel uit electrische stroom. Dit is geen tentamenstof, maar het is wel goed om daar een basis begrip van te hebben.
Waarom neemt koppel af met hoeksnelheid?
De beck‑EMF neemt toe met de hoeksnelheid, waardoor de stroom – en dus het koppel – afneemt. Deze video geeft daar een beknopte uitleg over: :::: {.content-visible when-format=“html”} :::{#fig-video2}
Deze video geeft een korte uitleg over het back-EMF effect, wat de rede is waarom het koppel afneemt met de snelheid. ::: ::::
Vermogen van de DC‑motor
Het vermogen van een motor is de hoeveelheid energie die omgezet kan worden per tijdseenheid. Bij de keuze van een motor voor een bepaalde taak is het vermogen meestal het eerst waar naar gekeken wordt. Ervan uitgaande dat de we de integratie van de motor juist ontwerpen (inclusief overbrenging, komt later aan bod) staat de vraag centraal: is een gegeven motor überhaubt in staat om de gewenste taak te verrichten, de hoeveelheid energie in de beschikbare tijd te leveren?
De bekende formule voor het vermogen \(P = Fv\) vertaalt in de rotatie-variant naar \(P = T\omega\). Gegeven de relatie tussen hoeksnelheid en koppel uit Vergelijking 1, wordt het geleverde vermogen als functie van de hoeksnelheid:
\[P(\omega) = T\,\omega = A\omega - B\omega^2.\]
Het vermogen is nul bij \(\omega=0\) en bij \(\omega=\omega_{max}\), bij de no load speed, en maximaal bij \(\omega = A/(2B)\) (halverwege de no‑load speed):
Spanning, Electrisch vermogen en Rendement
Bij de motorkarakteristieken zoals hiervoor besproken werd uitgegaan van een constante opgelegde elektrische spanning \(U\). De koppeltoerenkromme van een DC motor schaalt lineair zowel met betrekking tot het koppel als met betrekking tot de hoeksnelheid. Dus een verdubbeling van de spanning verdubbelt zowel de stall torque als de no‑load speed; het maximale vermogen schaalt dan kwadratisch.
Zoals duidelijk werd uit de video’s is het koppel in de motor proportioneel aan de elektrische stroomsterkte \(I\), met uitzondering van een kleine minimale stroomsterkte die ook aanwezig blijft bij nul koppel (max hoeksnelheid) als gevolg van interne wrijvingsverliezen. Het elektrisch vermogen wat de motor ingaat, gedefinieërd door \(P_e=UI\), volgt een soortgelijke trend:
Het rendement \(\eta\) van een motor wordt gedefinieerd als het aandeel aan opgenomen elektrisch vermogen \(P_e\) wat “nuttig” wordt omgezet in mechanisch vermogen \(P\):
\[ \eta = \frac{P}{P_e} \]
De rest van het vermogen (energie) gaat verloren in opgewekte warmte. Gezien het feit dat het mechanisch vermogen een kwadratisch verloop heeft als functie van de hoeksnelheid, terwijl het elektrisch vermogen lineair is, is het maximale rendement niet op dezelfde plek als waar het maximale vermogen is, maar iets rechts daarvan. Als richtlijn mag aangenomen worden dat het maximaal rendement zich tussen 70% en 90% van het bereik van de hoeksnelheid bevindt.
In bovenstaande beschouwing is ervan uitgegaan dat de benodigde stroomsterkte beschikbaar is. In de ptraktijk hebben de meeste stroombronnen, zoals ook de labvoeding die beschikbaar is gesteld voor het project, een beperkte stroomsterkte. Dit zorgt ervoor dat het koppel die bij lage snelheden beschikbaar is bijvoorbeeld niet overeenkomt met wat uit de motorkarakteristiek zou blijken. Ook is het belangrijk om niet langdurig grote stroomsterktes te hebben. Dit zorgt voor opwarming van de motor wat kan resulteren in het doorbranden ervan. Het maximale koppel kan dus in de praktijk alleen kortstondig geleverd worden. Ook is de interne koeling (met ventilator) bij lage snelheden niet heel effectief, waardoor dit probleem verergert.
Als het aangedreven systeem bij aansluiten van de voeding niet in beweging komt is het aan te raden om deze z.s.m. te ontkoppelen en dan pas te onderzoeken waar het door komt dat het systeem blokkeert.
Lasten en lastkarakteristieken
Tot nu toe hebben we motoren als op zichzelf staande systemen beschouwd. In de praktijk echter, wordt een motor altijd ingezet om iets aan te drijven: om ergens kracht/koppel aan te leveren en/of om iets in beweging te brengen. Dit noemen we de last. In de context van het ontwerpen of analyseren van een door een motor aangedreven systeem is het minstens zo belangrijk om de karakteristiek van de last in kaart te brengen: Hoe groot is de benodigde kracht/koppel en hoe varieert deze met de (hoek)snelheid?
Afhankelijk van het type kracht wat overwonnen moet worden, zijn er verschillende soorten lastkarakteristieken te onderscheiden. Enkele voorbeelden worden hieronder weergegeven:
Het is aan de ontwerper om te onderscheiden welke krachten een significante rol spelen en welke verwaarloosd kunnen worden.
Directe koppeling van motor en last
Als de motorkarakteristiek \(T_m\) en de lastkarakteristiek \(T_l\) bekend zijn kan het werkpunt bepaald worden: Dat is wanneer de twee koppels in evenwicht zijn. Het geleverde koppel en het nodige koppel zijn gelijk, dus het systeem versnelt niet. Het werkpunt is die koppel-hoeksnelheid combinatie waarin het systeem op den duur zal opereren, d.w.z. nadat de versnellingen om naar dat werkpunt te komen zijn afgenomen naar nul. Dit noemt men een stationaire situatie.
Bij een directe koppeling van de motor op de last kunnen de motor- en lastkarakteristieken in elkaar geschoven worden in hetzelfde assenstelsel, immers \(𝑇_𝑚=𝑇_𝑙\) en \(\omega_𝑚=\omega_𝑙\). Let op: Een directe koppeling komt bijna nooit voor.
Wanneer de motor- en lastkarakteristieken bekend zijn in formulevorm, is het een kwestie van de vergelijking \(T_m=T_l\) op te lossen voor \(\omega\).
Dynamisch gedrag zonder overbrenging
De stationaire situatie wordt niet direct bereikt. Uitgaande van een startsituatie waarin het geleverd motorkoppel \(T_m\) het benodigde lastkoppel \(T_l\) overstijgd, kan men spreken van een koppeloverschot \(T_m-T_l\). Dit koppeloverschot is evenredig aan de hoekversnelling die het veroorzaakt
\[T_m - T_l = J\,\frac{d\omega}{dt},\]
waarin J het massatraagheidsmoment in \((kgm^2)\) de evenredigheidsconstante is, op een soorgelijke manier zoals volgens de tweede wet van netwon een krachtonbalans een evenredige versnelling veroorzaakt waarin de massa de evenredigheidsconstante is.
Nadat het systeem in beweging is gekomen door een initiele versnelling, beland het systeem op een ander gebied van de karakteristieken waarin het koppeloverschot minder is geworden. Het systeem blijft versnellen maar in mindere mate. Nog een tijd later is het koppeloverschot nog minder en verminderd dus ook de versnelling. Dit process gaat door tot het evenwicht is bereikt, het werkpunt, de stationaire situatie.
Men kan bovenstaande differentiaalvergelijking oplossen voor \(\omega\) om het verloop van de hoeksnelheid als functie van de tijd te bepalen. Afhankelijk van de aard van de motor en de lastkarakteristieken kan deze oplossing al dan niet analystisch gevonden worden. Hieronder wordt een methode toegelicht om deze oplossing numeriek op te lossen, d.w.z. te benaderen door het probleem in een discreet aantal stappen op de delen.
De gediscretiseerde versie van de formule is
\[T_m - T_l = J\,\frac{\Delta\omega}{\delta t},\]
die omgeschreven kan worden naar \[ \delta t = J\,\frac{\Delta\omega}{\Delta\omega}.\]
In elke tijdstap \(n\) is het koppeloverschot bekend uit de karakteristieken, en de stapgrootte van de hoeksnelheid \(\Delta\omega\) is een gekozen constante: Het bereik van de hoeksnelheid tussen startsituatie en stationaire situatie gedeeld door het gekozen aantal stappen. Men kan nu voor elke stap de verlopen tijd \(\Delta t_n\) bepalen. Hiermee bepaalt men het verloop van de hoeksnelheid als functie van de tijd:
Met de hand (bijv. op een tentamen) zullen 3 á 4 stappen al veel werk opleveren. Vind uitgewerkte voorbeelden van deze procedure in de Oefenopgavenbundel van WOP3A. Maar met code kan men het aantal stappen hoog opvoeren voor een betere benadering, zie python script hieronder.
Koppeling van motor en last MET overbrengingen
Een DC motor wordt bijna nooit direct gekoppelt aan de last. Ten eerste draait een DC motor vaak te snel en levert het een te klein koppel voor de meeste toepassingen. Daarom zien we DC motoren vaak gepaard gaan met al dan niet ingebouwde tanwielkasten om het toerental te verlagen en het koppel te vergroten. We beschouwen dit type overbrenging/transmissie met daarbijhorende overbrengingverhouding \(i\) als eerst. Daarna beschouwen we ook de overige overbrengingen die in het aangedereven systeem aanwezig zijn, die veroorzaakt worden door bijvoorbeeld wieldiameters en andere elementen van het systeem.
Een tandwielkast bestaat meestal uit een seriële aaneenschakeling van tandwiel-sets. De totale transmissieratio, vaak aangeduid met de letter \(i\), vergroot het koppel van de motor en verkleint het toerental. We kunnen de overbrenging beschouwen als behorend tot de last (optie 1) of als behorend tot de motor (optie 2). Om de interactie tussen motor en last in te zien, bijvoorbeeld om het werkpunt te bepalen, kunnen we de twee karakteristieken pas op hetzelfde assenstelsel schuiven door eerst een tranformatie toe te passen.
Optie 1: Overbrenging behorende tot de last
De situatie op de motor-as wordt beschouwd, dus op het assenstelsel staat \(T_m\) en \(\omega_m\). De volgende transformatie wordt toegepast: \(T_m=\frac{T_l}{i}\) en \(\omega_m = \omega_l i\) waardoor de lastkarakteristiek in het assenstelsel van de motorkarakteristiek vertikaal krimpt met de factor \(i\) en horizontaal juist uitzet met dezelfde factor \(i\).
Optie 2: Overbrenging behorende tot de motor
De situatie op de last-as (of beter de uitgangs-as van de tandwielkast) wordt beschouwd, dus op het assenstelsel staat \(T_l\) en \(\omega_l\). De volgende transformatie wordt toegepast: \(T_l=T_m i\) en \(\omega_l = \frac{\omega_m}{i}\) waardoor de motorkarakteristiek in het assenstelsel van de lastkarakteristiek vertikaal uitzet met de factor \(i\) en horizontaal juist krimpt met dezelfde factor \(i\).
Koppeling van motor en last inclusief systeemoverbrengingen
In de praktijk wordt ook een motor met ingebouwde tandwielkast niet direct gekoppeld met de last. Denk aan overige overbrengingen in het systeem, bijvoorbeeld kettingoverbengingen, riemoverbrengingen, wielen, katrol-systemen, hefbomen, enz. In het algemeen kan een overbrenging ook een moment overzetten in een kracht (en dus rotatie omzetten in translatie) of andersom. De totale versterking door deze overige overbrengingen noemen we hier \(𝑜\). Terwijl de tandwielkastoverbrenging \(i\) in principe dimensieloos is, heeft \(o\) vaak de eenheid \(m^{-1}\), bijvoorbeeld wanneer het een moment omzet in een kracht.
De aanpak veranderd niet wezenlijk wanneer men een overige overbrenging wil meenemen. De motor of de lastkarakteristiek moeten getransformeerd worden, nu door gebruik te maken van factor \(i \cdot o\) in plaats van alleen \(i\).
Optie 1: Overbrenging inclusief systeemoverbrenging behorende tot de last
De gehele overbrenging \(i \cdot o\) hoort bij de last.
Optie 2: Overbrenging inclusief systeemoverbrenging behorende tot de motor
De gehele overbrenging \(i \cdot o\) hoort bij de motor. In dit voorbeeld veranderen de assen van de grafiek in van koppel-hoeksnelheid naar kracht-snelheid. Dit kan bijvoorbeeld het geval zijn van een aangedreven kar op een helling, zoals hieronder geïllustreerd.
In deze pyhon-script worden de grafieken van alle bovenstaande opties gemaakt voor een gegeven motor- en lastkarakteristiek.
import numpy as np
import matplotlib.pyplot as plt
plt.close("all")
# ----------------------------------------------------------
# Motor gegevens
# ----------------------------------------------------------
stall_torque = 0.02
maxRPM = 600
max_rot_speed = maxRPM * 2 * np.pi / 60
torque_slope = stall_torque / max_rot_speed
Pmax = 0.5 * stall_torque * 0.5 * max_rot_speed
omega_motor = np.linspace(1, 2 * max_rot_speed, 300)
Tmotor = stall_torque - torque_slope * omega_motor
# ----------------------------------------------------------
# Draw constant power curves (40–100%)
# ----------------------------------------------------------
def plot_power_limits(omega, Pmax):
fractions = [1.0, 0.8, 0.6, 0.4]
for f in fractions:
line = f * (Pmax / omega)
plt.plot(omega, line, 'grey', alpha=0.4)
plt.text(omega[-20], line[-20], f'{int(f*100)}% $P_{{max}}$')
# ----------------------------------------------------------
# Lastkarakteristiek Tl = A + B ω + C ω²
# ----------------------------------------------------------
A, B, C = 0.005, 0, 0.000002
Tlast = A + B * omega_motor + C * omega_motor**2
# ----------------------------------------------------------
# FIGURE 1 — Directe koppeling
# ----------------------------------------------------------
plt.figure(1)
plt.title('DIRECTE motor-last koppeling')
plt.plot(omega_motor, Tmotor, 'blue', label='$T_{motor}$')
plt.plot(omega_motor, Tlast, 'orange', label='$T_{last}$')
plot_power_limits(omega_motor, Pmax)
plt.grid()
plt.xlim(0, 2 * max_rot_speed)
plt.ylim(0, 2 * stall_torque)
plt.xlabel('$\\omega_{motor}$ [rad/s]')
plt.ylabel('$T$ [Nm]')
plt.legend()
# ----------------------------------------------------------
# FIGURE 2 — Overbrenging i behorende tot de last (optie 1)
# ----------------------------------------------------------
i = 3
plt.figure(2)
plt.title('Overbrenging i=%d behorende tot de last (optie 1)' % (i))
plt.plot(omega_motor, Tmotor, 'blue', label='$T_{motor}$')
plt.plot(omega_motor * i, Tlast / i, 'orange', label='$T_{last}$ transformed')
plot_power_limits(omega_motor, Pmax)
plt.grid()
plt.xlim(0, 2 * max_rot_speed)
plt.ylim(0, 2 * stall_torque)
plt.xlabel('$\\omega_{motor}$ [rad/s]')
plt.ylabel('$T$ [Nm]')
plt.legend()
# ----------------------------------------------------------
# FIGURE 3 — Overbrenging i behorende tot de motor (optie 2)
# ----------------------------------------------------------
i = 3
plt.figure(3)
plt.title('Overbrenging i=%d behorende tot de motor (optie 2)' % (i))
plt.plot(omega_motor / i, Tmotor * i, 'blue', label='$T_{motor}$ transformed')
plt.plot(omega_motor, Tlast, 'orange', label='$T_{last}$')
plot_power_limits(omega_motor / i, Pmax)
plt.grid()
plt.xlim(0, 2 * max_rot_speed)
plt.ylim(0, 2 * stall_torque)
plt.xlabel('$\\omega_{last}$ [rad/s]')
plt.ylabel('$T$ [Nm]')
plt.legend()
# ----------------------------------------------------------
# Last gedefinieërt in translatie domein (rijdende kar)
# ----------------------------------------------------------
i = 30
o = 0.4 * 3 / 0.05 #unit 1/m
v = np.linspace(0, 10, 300)
# Lastkarakteristiek karretje op helling: Luchtweerstand en zwaartekrachtscomponent
alpha = 0.4 # rad
m = 2 # kg
g = 9.81
rho = 1.29
Cw = 0.8
A_air = 0.3 * 0.3
F_load = m * g * np.sin(alpha) + 0.5 * rho * Cw * A_air * v**2
# ----------------------------------------------------------
# FIGURE 4 — Gehele overbrenging i*o behorende tot de last (optie 1)
# ----------------------------------------------------------
plt.figure(4)
plt.title('Gehele overbrenging i*o=%d * %d (1/m) behorende tot de last (optie 1)' % (i,o))
plt.plot(omega_motor, Tmotor, 'blue', label='$T_{motor}$')
plt.plot(v * (i * o), F_load / (i * o), 'orange', label='$F_{aandrijf}$ transformed')
plot_power_limits(omega_motor, Pmax)
plt.grid()
plt.xlim(0, 2 * max_rot_speed)
plt.ylim(0, 2 * stall_torque)
plt.xlabel('$\\omega_{motor}$ [rad/s]')
plt.ylabel('$T$ [Nm]')
plt.legend()
# ----------------------------------------------------------
# FIGURE 5 — Gehele overbrenging i*o behorende tot de motor (optie 2)
# ----------------------------------------------------------
plt.figure(5)
plt.title('Gehele overbrenging i*o=%d * %d (1/m) behorende tot de motor (optie 2)' % (i,o))
plt.plot(v, F_load, 'orange', label='$F_{aandrijf}$')
plt.plot(omega_motor / (i * o), Tmotor * (i * o), 'blue', label='$T_{motor}$ transformed')
plot_power_limits(omega_motor / (i * o), Pmax)
plt.grid()
plt.xlim(0, 2 * max_rot_speed / (i * o))
plt.ylim(0, 2 * max(F_load))
plt.xlabel('$v$ [m/s]')
plt.ylabel('$F$ [N]')
plt.legend()
plt.show()BONUS: Dynamisch gedrag met overbrenging
Voor het dynamisch gedrag van een directe koppeling gebruikten we de volgende formule: \[ \Delta T = J\,\frac{d\omega}{dt} \] waarin \(\Delta T\) het overschot aan koppel is, \(J\) de massatraagheid en \(\frac{d\omega}{dt}\) de hoekversnelling.
Omdat motor en last nu niet dezelfde hoeksnelheid hebben, moeten we iets specifieker zijn. Voor de last geldt dat \[ \Delta T_l = J_l \frac{d\omega_l}{dt}, \] maar er geldt ook dat \(\omega_m = i \omega_l\) en \(\Delta T_m = \frac{\Delta T_l}{i}\). Als we dus de massatraagheid die de motor ondervindt als gevolg van de massatraagheid van de last willen bepalen, voeren we de volgende substitutie uit: \[ \Delta T_m i = \frac{J_l}{i} \frac{d\omega_m}{dt}, \] en dus \[ \Delta T_m = \frac{J_l}{i^{2}}\frac{d\omega_m}{dt}. \]
De term \(J' = \frac{J_l}{i^{2}}\) noemt men de reflected inertia: als het ware de massatraagheid van de last, geprojecteerd op de as van de motor. Merk op dat de overbrengingsverhouding wordt gekwadrateerd!

























