Attiny85 Gelijktijdige programmering of pompoen met veelkleurige ogen - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:14

Door jumbleviewJumbleview.infoVolg meer door de auteur:

Over: Ik werk als software-engineer in een van de bedrijven in Bay Area (Californië). Wanneer ik tijd heb, programmeer ik graag microcontrollers, bouw ik mechanisch speelgoed en maak ik wat projecten voor huisverbetering. Meer over jumbleview »

Dit project laat zien hoe je twee 10 mm driekleurige gemeenschappelijke anode-LED's (veelkleurige ogen van Pumpkin Halloween Glitter) met Attiny85-chip kunt bedienen. Het doel van het project is om de lezer kennis te laten maken met de kunst van gelijktijdig programmeren en met het gebruik van Adam Dunkels protothreads-bibliotheek. Dit project gaat ervan uit dat de lezer kennis heeft van AVR 8-bit controllers, een C-programma kan schrijven en enige ervaring heeft met Atmel studio.

Projectcode gepubliceerd op GitHub:

Benodigdheden

Voor het programmeren moet nog de schakeling worden opgebouwd. Hier zijn componenten:

• Attiny85-controller (elke elektronische leverancier).
• Twee driekleurige 10 mm LED's met gemeenschappelijke anode. Adafruit-LED's
• Weerstanden 100 Ohm, 120 Ohm, 150 Ohm 0,125 of 0,250 Wt (elke elektronische leverancier).
• Zes-pins header voor AVR ISP-interface. Kan worden gemaakt van deze Adafruit-header
• Een broodplankje of een bedrukt sjabloonbord. Ik heb deze gebruikt
• AVR ISP MKII-interface en Atmel Studio 6.1 (een latere versie zou ook moeten werken).

Stap 1: Circuit

Ontwerp maakt gebruik van vijf chippinnen:

• Twee pinnen die worden gebruikt om anodes te besturen: elke LED-anode is bevestigd aan de speciale pin.
• Drie pinnen bevestigd (via weerstanden) aan LED-kathodes (dezelfde kleurkathode van elke led bevestigd aan dezelfde pin)

Men zou zich afvragen: waarom niet alle zes in/uit-pinnen van de chip gebruiken, zodat LED-anoden rechtstreeks worden aangesloten op +5 v en elke kathode zijn eigen pin heeft? Dat maakt het programmeren eenvoudig. Helaas is er het probleem: pin PB5 (RESET) is een zwakke pin die slechts ~2 mA van de stroom kan leveren, terwijl er ~20 mA nodig is.

Natuurlijk kan men een transistorversterker bouwen voor deze zwakke pin, maar ikzelf geef er de voorkeur aan om het probleem zoveel mogelijk op te lossen via de code.

Stap 2: Tijdschema

Timingdiagram helpt ons te begrijpen wat we moeten programmeren.

De bovenste twee rijen in het diagram tonen de spanningsverandering op LED-anodes. Spanning op pinnen aangesloten op LED-anodes oscilleert met een frequentie van ~ 250 Hz. Deze spanningsoscillatie voor de linker LED is tegengesteld aan de oscillatie van de rechter LED. Wanneer de spanning op de anode hoog is, kan de bijbehorende LED helder zijn. Als het laag is, is de bijbehorende LED donker. Dat betekent dat elke LED gedurende een interval van 2 milliseconden helder kan zijn en gedurende nog eens 2 milliseconden donker. Omdat het menselijk oog enige traagheid heeft, is het knipperen van 250 Hz niet waarneembaar voor de waarnemer. De onderste drie rijen op het diagram tonen de verandering van spanning op pinnen die zijn aangesloten op LED-kathodes. Laten we eens kijken naar de eerste diagramkolom. Het toont het geval wanneer de linker-LED in rode kleur is en de rechter-LED in groene kleur. Hier blijven de RODE kathodes laag terwijl de linker anode hoog is, de GROENE kathode laag terwijl de rechter anode hoog is, en de BLAUWE kathode blijft de hele tijd laag. Andere kolommen op het diagram tonen combinaties van kathode- en anodespanning voor verschillende kleuren.

Zoals we kunnen zien, is er een onderlinge afhankelijkheid van de status van de pinnen. Zonder enig kader zou het niet eenvoudig op te lossen zijn. En dat is waar de protothread-bibliotheek van pas komt.

Stap 3: Programmeren. Macro's en definities

Voorbeeld in programmeerstappen vertegenwoordigen enigszins vereenvoudigde versie. Het programma is ingekort en een symbolische definitie is vervangen door expliciete constanten.

Laten we bij het begin beginnen. Het programma bevat bestanden die bij Atmel Studio worden geleverd en de header van de protothread-bibliotheek. Vervolgens zijn er twee macro's om pinniveaus te manipuleren en enkele definities om logische namen aan pinsignalen te geven. Tot nu toe niets bijzonders.

Stap 4: Programmeren. Hoofdlus

Laten we dan naar het einde kijken om te zien wat de hoofdprocedure inhoudt.

Function main blijft na wat initialisatie in de lus voor altijd. In die lus maakt het de volgende stappen:

• Roept protothread-routine op voor de linker LED. Het verandert de spanning van sommige pinnen.
• Maak twee milliseconden vertraging. Er is geen verandering in pinspanning.
• Roept protothread op voor de juiste LED. Het verandert een aantal pinspanningen.
• Maak 2 MS vertraging. Er is geen verandering in pinspanning.

Stap 5: Programmeren. Hulpfuncties

Voordat we protothreads gaan bespreken, moeten we kijken naar enkele helperfuncties. Eerst zijn er functies om een bepaalde kleur in te stellen. Ze zijn rechtlijnig. Er zijn net zoveel functies als het aantal ondersteunde kleuren (zeven) en nog een functie om LED donker in te stellen (NoColor).

En er is nog een functie die direct wordt aangeroepen door de protothread-routine. De naam is DoAndCountdown().

Technisch gezien is het gebruik van zo'n functie niet verplicht, maar ik vond het wel handig. Het heeft drie argumenten:

• Aanwijzer naar functie-instelling LED-kleur (zoals RedColor of GreenColor of etc.)
• Beginwaarde van omgekeerde teller: aantal hoe vaak deze functie moet worden aangeroepen in een bepaald protothread-stadium.
• Wijzer naar omgekeerde teller. Er wordt aangenomen dat wanneer er een verandering in de kleur is, de omgekeerde teller 0 is, dus de eerste iteratiecode zal de initiële waarde van de teller toewijzen. Na elke iteratie wordt de teller verlaagd.

Functie DoAndCountdown() retourneert de waarde van de omgekeerde teller.

Stap 6: Programmeren. Protothread-routines

En hier is de kern van het raamwerk: protothread-routine. Eenvoudigheidshalve voorbeeld beperkt tot drie stappen: voor kleurverandering naar ROOD, naar GROEN en naar BLAUW.

Functie wordt aangeroepen met twee argumenten:

• Aanwijzer naar protothread-structuur. Die structuur werd geïnitialiseerd door main voordat de hoofdlus begon.
• Wijzer naar omgekeerde teller. Het werd door main op 0 gezet voordat de hoofdlus begon.

Functie set spanningen om linker LED actief te maken en start dan protothread segment. Dit segment bevindt zich tussen de macro's PT_BEGIN en PT_END. Binnenin is er een code die in ons geval alleen macro's PT_WAIT_UNTIL herhaalt. Deze macro's voeren het volgende uit:

• Aanroep van de functie DoAndCountdown. Dat stelt de spanning op LED-kathodes in om een bepaalde kleur uit te zenden.
• Geretourneerd resultaat vergeleken met 0. Als de voorwaarde 'false' is, keert de protothread-functie onmiddellijk terug en geeft de controle aan de hoofdlus.
• Wanneer protothread de volgende keer wordt aangeroepen, voert het opnieuw code uit vóór PT_BEGIN en springt vervolgens direct binnen de PT_WAIT_UNTIL-macro's waaruit het de vorige keer terugkeerde.
• Dergelijke acties worden herhaald totdat het resultaat van DoAndCountdown 0 is. In dat geval is er geen terugkeer, het programma blijft in de protothread en voert de volgende regel van de code uit. In ons geval is het de volgende PT_WAIT_UNTIL, maar over het algemeen kan het bijna elke C-code zijn.
• Bij de eerste uitvoering van de tweede PT_WAIT_UNTIL is de omgekeerde teller 0, dus procedure DoAndCountdown() zet deze op de beginwaarde. Tweede macro's worden opnieuw 250 keer uitgevoerd totdat de teller op 0 staat.
• Status van struct pt wordt gereset zodra de besturing PT_END macro's bereikt. Wanneer de protothread-functie wordt aangeroepen de volgende keer dat het protothread-segment begint, voert u de regel van de code direct na PT_BEGIN uit.

Er is een vergelijkbare protothread-routine voor de juiste LED. In ons voorbeeld dwingt het alleen een andere volgorde van kleuren af, maar als we het helemaal anders mogen doen: er is geen strakke koppeling tussen de linker en rechter LED-routine.

Stap 7: Binnenwerk

Het hele programma is minder dan 200 regels code (met opmerkingen en lege regels) en neemt minder dan 20% van het Attiny85-codegeheugen in beslag. Indien nodig is het mogelijk om hier meerdere protothread-routines te gebruiken en er veel gecompliceerdere logica aan toe te kennen.

Protothreads-bibliotheek is de eenvoudigste vorm van gelijktijdig programmeren van computers. Gelijktijdig programmeren is een benadering waarmee het programma in logische delen kan worden verdeeld: soms worden ze coroutines genoemd, soms draad, soms taken. Het principe is dat elk van deze taken dezelfde processorkracht kan delen, terwijl de code min of meer lineair en onafhankelijk van andere delen blijft. Taken vanuit logisch oogpunt kunnen gelijktijdig worden uitgevoerd.

Voor geavanceerde systeemcontroles van dergelijke taken die worden uitgevoerd door de kernel van het besturingssysteem of door taalruntime ingebed in het uitvoerbare bestand door de compiler. Maar in het geval van protothreads regelt de applicatieprogrammeur het handmatig door de protothreads-macrobibliotheek in taakroutines te gebruiken en dergelijke routines aan te roepen (meestal buiten de hoofdlus).

U wilt waarschijnlijk weten hoe protothread eigenlijk werkt? Waar de magie verborgen? Protothreads vertrouwen op een speciale C-taalfunctie: het feit dat de C-switch case-statement kan worden ingebed in if of een ander blok (zoals while of for). Details kunt u vinden op de website van Adam Dunkels

Elektronica internals van dit project zijn heel eenvoudig. Foto hierboven geeft je een idee. Ik weet zeker dat je het beter kunt.