If you're seeing this message, it means we're having trouble loading external resources on our website.

Ha webszűrőt használsz, győződj meg róla, hogy a *.kastatic.org és a *.kasandbox.org nincsenek blokkolva.

Fő tartalom

Trigonometria és erők: az inga

Emlékszel a néhány fejezettel korábban tárgyalt Newton törvényekre? Ott arra használtuk ezeket a törvényeket, hogy kiszámítsuk egy tárgy gyorsulását, aminek alapján kiszámoltuk és megrajzoltuk annak új helyzetét. Most arra fogjuk használni ezeket a törvényeket, hogy kiszámoljuk egy inga gyorsulását, majd kiszámoljuk és megrajzoljuk mozgása alatti adott helyzetét. Látni fogjuk, hogy ehhez szükségünk lesz a trigonometriára.
Az inga egy tengelyre felfüggesztett súly. Persze a valós világban az inga háromdimenziós térben létezik, de mi itt most egy egyszerűbb forgatókönyvet használunk: az ingát a kétdimenziós térben fogjuk vizsgálni a program által kezelt rajzvásznon.
Az Erők fejezetben megtanultuk, hogy az erő (mint amilyen a fenti ábrán is bemutatott gravitációs erő) hogyan készteti a tárgyakat gyorsulásra: F=MA, avagy A=F/M.
Ebben az esetben az ingán levő súly nem esik le a földre, mivel a tengely a felfüggesztési ponthoz rögzíti azt. Ehelyett a súly a nyugvópont felé lendül, és mi ki akarjuk számítani, hogy mekkora a súly gyorsulása a körív mentén. Ezt szöggyorsulásnak fogjuk hívni, mivel az inga egy ív mentén gyorsul.
Annak érdekében, hogy meghatározzuk az inga szöggyorsulását, a gravitációs erőt összetevőkre kell felbontani. Az egyik összetevő az inga tengelye mentén hat. Ezt elhanyagolhatjuk, mivel a tengely mindig ezzel szemben hat, ezért azt kioltja. A másik összetevő merőleges a tengelyre. Mi erre az erőre vagyunk kíváncsiak, mert ez az erő „oldalirányban" húzza az ingát, ennek hatására az inga kileng. Közelítsünk rá az inga ábrájára, és jelenítsük meg a gravitációs erő összetevőit:
Fg a lefelé ható gravitációs összerő. Fp a tengelyre merőleges gravitációs erő, ami az inga lengési irányával szemben hat. Fa a gravitációs erő tengely mentén ható összetevője, amit figyelmen kívül fogunk hagyni, mivel az a szöggyorsulást nem befolyásolja.
Hogyan kell kiszámolni Fp értékét? Itt lesz segítségünkre a trigonometria. Fg a derékszögű háromszög átfogója, a θ pedig a tengely által bezárt szög. A szinusz egyenlő a szemközti oldal osztva az átfogóval:
sin(θ)=FpFg
Ezért:
Fp=Fgsin(θ)
Nagyszerű, akkor van egy egyszerű képletünk az Fp kiszámítására. Most kanyarodjunk vissza az eredeti kérdéshez: mekkora az inga szöggyorsulása? Ha kiszámoljuk a szöggyorsulást, akkor meghatározhatjuk az inga új szögét a mozgástörvények alkalmazásával.
szögsebesség = szögsebesség + szöggyorsulás
szög = szög + szögsebesség
Newton második törvényének köszönhetően tudjuk, hogy kapcsolat áll fenn az erő és a gyorsulás között, azaz F=MA, vagy A=F/M, és ezt a kapcsolatot felhasználhatjuk a fenti képletben a szöggyorsulás kiszámításához. Tudod követni?
Ezzel kezdjük:
merőleges erő = gravitációs erő * sin(θ)
Ezután a jobb oldalt elosztjuk a tömeggel, ami megadja a gyorsulást Newton második törvénye alapján:
szöggyorsulás = (gravitációs erő · sin(θ)) / tömeg
És akkor rájövünk, hogy elég elosztani a gravitációs erőt a tömeggel, hiszen az ugyanaz, mint a gravitáció által okozott gyorsulás, úgyhogy csak be kell helyettesítenünk:
szöggyorsulás = gravitációs gyorsulás * sin (θ)
Hurrá! Most már ki tudjuk számítani a szöggyorsulást!
Ezt még tovább egyszerűsíthetjük, mivel ProcesingJS programozók vagyunk, nem fizikusok. Igen, tudjuk, hogy a Föld vonzásából adódó gravitációs gyorsulás értéke 9,8 méter per másodperc a négyzeten. Ez a szám azonban számunkra nem releváns. Programjainkban a „gravitáció” egy tetszőleges szám, amit arra használunk, hogy a gyorsulást nekünk megfelelő szinten tartsuk.
szöggyorsulás = gravitáció · sin(θ)
Csodálatos. Ennyi munka után egy nagyon egyszerű képlethez jutottunk. Mondhatnád azt is, miért kellett ennyit vesződni ezzel? Jó, jó, nagyszerű dolog tanulni, meg minden, de nem lett volna egyszerűbb azt mondani: „Figyelj! Az inga szöggyorsulása egyenlő a szög szinusza szorozva valamilyen konstans értékkel.”
Ne tévesszük szem elől, hogy ennek a tanfolyamnak nem az a célja, hogy megtanuljuk, hogyan leng az inga, vagy hogyan működik a gravitáció. Az a cél, hogy megtanuljunk kreatívan gondolkodni arról, hogyan tudunk számítógépes grafikai rendszerben tárgyakat mozgatni a képernyőn. Az inga csak egy esettanulmány. Ha megérted, hogyan kell nekiállni az inga programozásának, bárhogyan tervezed majd meg a számítógépes világodat, fel fogod tudni használni ugyanezeket a technikákat.
Persze még nem vagyunk készen. Örülhetünk az egyszerű, elegáns képletünknek, de még be kell azt illeszteni a programba. Ez most kiváló alkalom arra, hogy kihasználjuk az objektumorientált programozásról megszerzett tudásunkat, és készítsünk egy Pendulum (inga) objektumot. Gondoljuk végig, milyen tulajdonságokról beszéltünk a fenti fejtegetéseink során, amit az inga objektumunknak kell majd kezelni:
  • tengely hossza
  • szög
  • szögsebesség
  • szöggyorsulás
Ezen felül meg akarjuk adni az inga felfüggesztési pontját is, ezért a konstruktort elkezdhetjük így:
var Pendulum  = function(origin, armLength) {
    this.origin = origin;
    this.armLength = armLength;

    this.angle = PI/4;
    this.aVelocity = 0{,}0;
    this.aAcceleration = 0{,}0;
};
Írnunk kell még egy update() módszert az inga szögének módosításához a képletünk alapján...
Pendulum.prototype.update = function() {
    // Tetszőleges konstans
    var gravity = 0.4;
    // Gyorsulás számítása
    this.aAcceleration = -1 * gravity * sin(this.angle);
    // Sebesség növelése
    this.aVelocity += this.aAcceleration;
    // Szög növelése
    this.angle += this.aVelocity;    
};
…valamint egy display() metódust az inga megrajzolásához. Ez felveti a kérdést: „Nos, hova rajzoljuk az ingát?” Ismerjük a szöget és a tengely hosszát, de honnan tudjuk az inga felfüggesztési pontjához (hívjuk origónak), és a súly helyzetéhez tartozó x,y (Descartes-féle!) koordinátákat? Kis dolognak tűnik, de a válasz már megint a trigonometria. Nézzük csak a fenti ábrát!
Az origó az egy általunk kitalált dolog, mint ahogy a tengely hossza is. Tegyük fel, hogy az ingánkat így készítjük el:
var p = new Pendulum(new PVector(100, 10), 125);
Az aktuális szöget az angle tulajdonságban tároljuk. Az origóhoz képest az inga helyzete poláris koordinátákban van meg: (r,angle). Nekünk azonban a Descartes-féle koordinátára van szükségünk. Szerencsére a Szögek fejezetben eltöltöttünk egy kis időt a poláris koordináták Descartes-féle koordinátákra konvertálásával. Abban a részben a vízszintes tengellyel bezárt szöggel számoltunk, itt viszont a függőleges tengellyel bezárt szögünk van, ezért itt az x helyzethez a sin() függvényt fogjuk használni a cos() helyett, az y helyzethez a cos() függvényt a sin() helyett. Így tudjuk kiszámítani az origóhoz mért helyzetet a konverziós képlet fejhasználásával, majd az eredményt hozzáadjuk az origóhoz:
this.position = new PVector(
   this.armLength * sin(this.angle),
   this.armLength * cos(this.angle));
this.position.add(this.origin);
stroke(0, 0, 0);
fill(175, 175, 175);
line(this.origin.x, this.origin.y, this.position.x, this.position.y);
ellipse(this.position.x, this.position.y, 16, 16);
Mielőtt mindezt összeraknánk, van még egy utolsó részlet, amit eddig még nem említettem. Nézzük meg, mi az inga tengelye! Fémrúd? Kötéldarab? Gumiszalag? Hogy van felfüggesztve? Milyen hosszú? Mekkora a súlya? Fúj-e a szél ma? Egy csomó kérdést tehetünk fel, ami befolyásolhatja a szimulációt. Persze mi a képzelet világában élünk, ahol az inga tengelye egy idealizált rúd, ami soha nem hajlik meg, a súly tömege pedig egy végtelen kis pontba koncentrálódik.
Bár nem akarunk ezekkel a részletekkel behatóan foglalkozni, azért még egy változót hozzá kellene adni a szöggyorsulás számításához. Hogy ne bonyolítsuk túl a a dolgokat, a számítások során feltételeztük, hogy az inga tengelyének a hossza 1. A valóságban a tengely hossza nagyban befolyásolja a gyorsulást: minél hosszabb a tengely, annál lassabb a gyorsulás. Azért, hogy pontosabb legyen az inga szimulációja, osztani fogunk a tengely hosszával, ebben az esetben az armLength változóval. A részletes magyarázatért látogass el a Matematikai inga tanulmányozása weboldalra!
this.aAcceleration = (-1 * gravity / this.armLength) * sin(this.angle);
Végül, a valódi inga mozgását még némi súrlódás (a felfüggesztési pontnál) és légellenállás is fogja csökkenteni. Ha a programunkat ebben a formában hagyjuk, az inga a végtelenségig fog lengeni, úgyhogy a nagyobb realitás kedvéért bevetünk egy „csillapító” trükköt. Trükköt mondok, mert az ellenállási erők pontos modellezése helyett (ahogy azt az Erők fejezetben megtettük), hasonló eredményt érhetünk el, ha egyszerűen csökkentjük a szögsebességet minden ciklusban. Az alábbi kódrészletben 1%-kal csökkentettük a sebességet (mondhatjuk úgy is, hogy megszoroztuk 99%-kal) minden egyes animációs képkockában.
this.aVelocity *= this.damping;
Mindent összerakva az alábbi példát kapjuk. Hozzáadtunk még egy kis funkcionalitást, hogy könnyen elhúzható legyen a súly, így különböző magasságokból lehessen indítani az ingát. Próbáld ki! (A programban található megjegyzések: 1. sor: Dan Shiffman, natureofcode.com példája alapján; 3. sor: Egy egyszerű inga objektum; 4. sor: Tartalmaz olyan funkcionalitást, ami lehetővé teszi, hogy a felhasználó rákattintson az ingára és elhúzza azt; 8. sor: Ezt a konstruktort meg lehet úgy változtatni, hogy változatosabb ingákat tudjunk készíteni; 17. sor: Tetszőleges csillapítás; 19. sor: Tetszőleges sugarú labda; 30. sor: Mindaddig hagyjuk lengeni, amíg a felhasználó nem húzza el újra; 32. sor: Tetszőleges konstans; 34. sor: Gyorsulás számítása (lásd: https://phet.colorado.edu/sims/html/pendulum-lab/latest/pendulum-lab_hu.html ); 36. sor: Sebességnövelés; 38. sor: Tetszőleges csillapítás; 40. sor: Szög növelése; 46. sor: Átváltás polárisról Descartes-félére; 53. sor: Tengely rajzolása; 59. sor: Súly rajzolása; 63. sor: Metódusok az egér követéséhez; 65. sor: Ez azt vizsgálja, hogy rákattintottak-e a súlyra; 73. sor: Ez azt mutatja meg, hogy elengedték-e az egérgombot; 75. sor: Megszűnik a sebesség, ha elengedték a gombot; 80-82. sor: Ha húzzák a súlyt, kiszámítjuk az inga origója és az egér helyzete közötti szöget, és ezt a szöget hozzárendeljük az ingához; 84. sor: Két pont közötti különbség; 86. sor: A függőleges tengellyel bezárt szög.)
Ez a „Természetes szimulációk" tananyag a Daniel Shiffman által készített „The Nature of Code” alapján készült, a Creative Commons Attribution-NonCommercial 3.0 Unported License szerint.

Szeretnél részt venni a beszélgetésben?

Még nincs hozzászólás.
Tudsz angolul? Kattints ide, ha meg szeretnéd nézni, milyen beszélgetések folynak a Khan Academy angol nyelvű oldalán.