Stap 5: macro's
Macro's zijn zeer vergelijkbaar met de subroutines die we in de laatste stap, besproken behalve dat zij "argumenten". Met andere woorden, de macro's zijn in wezen "functies." In feite, is het belangrijkste verschil tussen assembler en alle talen "hoger niveau" die gebruiken mensen is dat iemand een bos van vaak gebruikte functies heeft gecompileerd in macro's. Hier zullen we macro's gebruiken om de dezelfde eindigt, met één belangrijk verschil, onze macro's zullen daar in de code voor ons bekijken en aanpassen als we willen.
Onze filosofie in deze tutorials is te ontdoen van alle van de "zwarte dozen" en ontdek wat is achter de schermen gaande er. We willen niet iets gebeuren tenzij we weten en vertelde het om dat te doen. Dat is de reden waarom dit heet "Command Line Assembly Language Programming". We zijn met behulp van de opdrachtregel in plaats van enkele Java gebaseerde IDE zoals de arduino een (in feite, ik gebruik de opdrachtregel zelfs met arduino programmering). Een java ide venster is als een zwarte doos voor mij. Ik kan nooit absoluut zeker dat er geen hypothesen worden achter de schermen bij de communicatie van mijn instructies aan de microcontroller en ik houd niet van die links zijn. Ik houd niet ook hoe opgeblazen en cpu verbruiken van java is. In feite, is dat ook waarom we "avra" gebruikt in plaats van de assembler ATmel IDE. Ik realiseer me dat wanneer u een deskundige coder, of een complete beginner, u al weet bent, of u niet schelen, wat achter de schermen gebeurt er, maar hier zullen we het opofferen van het gemak om zwarte-boxness en vetheid te voorkomen.
Nu wat zijn macro's toch? Nou misschien je hebt gemerkt bij het lezen door middel van het programma dat we de subroutine "vertraging" all over the place gebruiken. Niet alleen van binnen main, maar van binnen andere subroutines ook. Dit leidt tot spaghetti en wij houd niet van spaghetti. (tekenen van de lijnen tussen elke subroutine codeblok in het diagram als één blok roept en u snel zien zult dat de "vertraging" subroutine het diagram veroorzaakt te laten uitzien als een kom met de spaghetti)
Hier is hoe "vertraging" meestal heet:
U ziet dat we eerst de variabele (d.w.z. werkende register) "milliseconden" op de waarde 25 instellen en dan we de subroutine noemen "vertraging". De subroutine zal 25 ms vertragen en vervolgens terug te keren. Naast spaghetti is een ander probleem met deze manier van doen dat als we vergeten de waarde voor milliseconden onmiddellijk voordat we contact opneemt met de subroutine die we hebben geen idee wat de vertraging zal zijn. Welke waarde die we in milliseconden ergens anders zal zijn. Dit is een riskante manier om code te schrijven. Dus om te lossen alle dit gewoon schrijven we een "macro". Hier ' tis:
Het is een assembler richtlijn dat wij op de top van ons programma dat doet dezelfde dingen we in onze vertraging subroutine hadden vertragen, het heet vertraging, maar het belangrijke verschil heeft dat we vaststellen om de variabele "milliseconden" erin! Het symbool (teken nul) staat voor wat we naast vertraging plaats wanneer wij het noemen. Hier is hoe we noemen het dan. Als we een vertraging van 25ms ergens in ons programma wilden schrijven we gewoon
en de assembler vervangt het in de macro met 25 en krijgen we onze vertraging van 25 ms.
Waarom goed kunt u macro's die veel meer argumenten als je wilt hebben schrijven. In dat geval zou u en enzovoort. Dan wanneer u de functie aanroepen zou u moeten leveren alle argumenten die betrekking hebben op deze @ dingen in de macro.
Ik denk dat nu kun je zien hoe ze de opdracht van de Arduino taal "vertraging(20)" gelijk gemaakt?
Oefening 2: een macro toevoegen in het programma en alle van de subroutines wijzigen zodat ze de macro in plaats van een vertraging-subroutine aanroepen. (Let op! In één van de incidenten zal je moet zoeken rond om erachter te komen wat de vertraging wordt verondersteld te worden! Ik opzettelijk weggelaten de ldi milliseconden in dat geval)
