Eindige-toestandsmachine op een MSP430 - Ajarnpa

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

Ik ga je laten zien hoe je een MSP430G2 Launchpad programmeert met Finite State Machines (FSM) met behulp van YAKINDU Statechart Tools rechtstreeks in Texas Instruments Code Composer Studio.

Deze tutorial bevat zes stappen:

1. YAKINDU Statechart Tools installeren als een plug-in voor Code Composer Studio
2. Aan de slag met State Machines in Code Composer Studio
3. Maak de Blinky State Machine
4. Genereer de State Machine C-code
5. De staatsmachine bellen vanuit uw code
6. Voer het project uit!

Dit project kan worden gebruikt als blauwdruk voor elke MPS430 of MSP432!

Benodigdheden

Software:

• YAKINDU Statechart-tools
• Code Composer Studio (CCS) Geïntegreerde ontwikkelomgeving (IDE)

Hardware:

MSP430G2 LaunchPad-ontwikkelkit

Stap 1: YAKINDU Statechart Tools installeren als plug-in voor Code Composer Studio

Eerst moet je TI's Code Composer Studio installeren. Ik heb de setup een keer met succes getest met CCS versie 9.2 en ouder. Een downloadlink vind je hier:

CCS downloaden

Klik om te downloaden en zorg ervoor dat u tijdens de installatie op zijn minst de MSP430 ultra-low-power MCU's hebt gekozen. Ondertussen kun je de update-site voor YAKINDU Statechart Tools pakken. Ga naar:

YAKINDU Statechart-tools downloaden

Klik op deze site op Nu downloaden en volg de instructies. Zoals je op de foto kunt zien: Het is gratis voor niet-commercieel gebruik. Na de registratie krijg je een overzicht van de downloadmogelijkheden. Klik op STANDAARD DOWNLOAD SITE en klik op INSTALLEREN VANAF UPDATE SITE. Daar krijg je een link onder Stable Releases. Pak deze link en sla hem op of plaats hem in je klembord.

Het installeren van YAKINDU Statechart Tools in Code Composer Studio kan een beetje lastig zijn, afhankelijk van de versie van Code Composer Studio die u gebruikt. Misschien zijn deze stappen ondertussen verouderd, maar aarzel niet om me in de reacties te vragen of je hulp nodig hebt.

Dit zijn mijn stappen:

Nadat u CCS met succes op uw systeem hebt geïnstalleerd, opent u het tabblad Help en klikt u op Nieuwe software installeren… Voeg in deze wizard de volgende updatesite toe via de knop Toevoegen…:

download.eclipse.org/releases/2018-09/

Voeg niets toe, het moet gewoon opgelost worden. Je kunt het zien op de foto.

Herhaal daarna de stappen en klik op de knop Toevoegen…. Voeg de YAKINDU Statechart Tools-updatesite in, die u hopelijk hebt opgeslagen. Schakel vervolgens het selectievakje YAKINDU License Management in en klik op volgende. Volg de instructies. Uw IDE kan een keer opnieuw worden opgestart.

Ten slotte kunt u YAKINDU Statechart-tools installeren. Herhaal de laatste stappen, maar kies deze keer voor YAKINDU Statechart Tools Standard Edition. Volg nogmaals de instructies. Na het herstarten heb je YAKINDU Statechart Tools met succes geïnstalleerd.

Stap 2: Aan de slag met State Machines in Code Composer Studio

Als u statusmachines wilt gebruiken, gaat u gewoon door en maakt u een nieuw CCS-project aan. Open het tabblad Bestand, open Nieuw en klik op CCS Project. Definieer een projectnaam, kies uw microcontroller en maak een leeg project aan, dat een leeg main.c-bestand bevat. Ik gebruikte de MSP430G2553.

Nu kun je aan de slag met staatsmachines!

Klik met de rechtermuisknop op het project, open Nieuw en kies Statechart Model. Er wordt een Wizard geopend waarin u uw project kunt selecteren en uw statechart een naam kunt geven. Noem het bijvoorbeeld blinkyStateMachine.sct.

Het Statechart-model verschijnt in de projectmap nadat u op Voltooien hebt geklikt. Klik op Ja als u wordt gevraagd om het perspectief te wijzigen.

Stap 3: Maak de Blinky State-machine

Nu kunt u beginnen met het maken van de staatskaart!

Aan de linkerkant vindt u de zogenaamde Definitiesectie. Daar kunt u tekstuele elementen aan het model toevoegen, bijvoorbeeld bewerkingen, die in de toestandsmachine kunnen worden aangeroepen.

Verwijder alles ervan en voeg eenvoudig deze drie bewerkingsdefinities toe:

intern:

operatie init() operatie redOn() operatie redOff()

Schakel daarna over naar het statechart-model en voeg drie staten toe:

• Initialisatie
• rode LED aan
• rode LED uit

Verbind de toestanden zoals getoond op de afbeelding en voeg de overgangen en invoeracties toe. Je vindt ze terug op de bijgevoegde foto.

Stap 4: Genereer de State Machine C-code

Nu is het tijd om de C-Code te genereren. Hiervoor moet een generatormodel worden toegevoegd. Klik nogmaals met de rechtermuisknop op het project en open Nieuw en klik op Code Generator Model. Kies een naam voor het sgen-bestand. Het is een goede gewoonte om bij de naam van de staatsmachine te blijven. Noem het blinkyStateMachine.sgen en klik op Volgende. Kies de gewenste State Machine door op het selectievakje te klikken. Zorg ervoor dat u de YAKINDU SCT C Code Generator hebt gekozen (omdat we C-Code willen genereren) en klik op Voltooien.

Gewoonlijk wordt de C-code automatisch gegenereerd, maar als dat niet het geval is, kunt u met de rechtermuisknop op het sgen-bestand klikken en op Generate Code Artifacts klikken om dit te doen. De mappen src en src-gen zouden in uw project moeten verschijnen. Ze bevatten de gegenereerde C-code, die automatisch wordt bijgewerkt wanneer u de statusgrafiek bewerkt en opslaat.

Omdat deze statechart op tijd gebaseerde gebeurtenissen gebruikt, moet een timerservice worden geïmplementeerd. Om dit voor te bereiden, heb je deze twee bestanden nodig: sc_timer_service.c en sc_timer_service.h Je kunt ze ophalen van GitHub of ze hier downloaden. Je moet ze toevoegen aan de src-map.

Stap 5: De staatsmachine bellen vanuit uw code

Eindelijk kan de toestandsmachine worden gebruikt in uw hoofdfunctie!

Eerst moet u de statusmachine en de timerservice opnemen. Vervolgens moeten de statusmachine, de timerservice en de vereiste functies voor de timerservice worden gedeclareerd en gedefinieerd. Bovendien moeten de gedefinieerde handelingen die de rode led in- en uitschakelen, worden uitgevoerd.

#erbij betrekken

#include "src-gen/BlinkyStateMachine.h" #include "src/sc_timer_service.h" BlinkyStateMachine blinky; #define MAX_TIMERS 4 statische sc_timer_t timers [MAX_TIMERS]; statisch sc_timer_service_t timer_service; //! callback-implementatie voor het instellen van tijdgebeurtenissen extern void blinkyStateMachine_setTimer (BlinkyStateMachine * handle, const sc_eventid evid, const sc_integer time_ms, const sc_boolean periodic) { sc_timer_start (&timer_service, handle, evid, time_ms, periodic); } //! callback-implementatie voor het annuleren van tijdgebeurtenissen. externe void blinkyStateMachine_unsetTimer (BlinkyStateMachine*-handle, const sc_eventid evid) {sc_timer_cancel (&timer_service, evid); } //! bewerkingen definiëren extern void blinkyStateMachineInternal_init (const BlinkyStateMachine * handle) {WDTCTL = WDT_MDLY_32; IE1 |= WDTIE; P1DIR |= BIT0; } extern void blinkyStateMachineInternal_redOn (const BlinkyStateMachine * handle) { P1OUT |= BIT0; } extern void blinkyStateMachineInternal_redOff (const BlinkyStateMachine * handle) { P1OUT &= ~BIT0; }

De hoofdfunctie bestaat uit twee delen:

De initialisatie en de enter-functie van de statusmachine en de initialisatie van de timer.

Het tweede deel is een eindeloze lus - de while(1)-lus. Binnen deze lus wordt de run cycle-functie van de toestandsmachine aangeroepen. Daarna wordt de MSP430 in de Low Power Mode 0 gezet en wordt de General Interrupt Enable-bit ingesteld. Nu slaapt de microcontroller en wacht op een onderbreking. Na de onderbreking van de WDT gaat de timer verder. Dit betekent dat elke timer wordt bijgewerkt en dat de verstreken tijd wordt verhoogd met 32 - de tijd in milliseconden, die wordt uitgevoerd na elke onderbreking van de WDT.

void main(void) { WDTCTL = WDTPW | WDTHOLD; // Stop waakhondtimer

// Init timer en state machine sc_timer_service_init(&timer_service, timers, MAX_TIMERS, (sc_raise_time_event_fp) &blinkyStateMachine_raiseTimeEvent); blinkyStateMachine_init(&blinky); blinkyStateMachine_enter(&blinky);

terwijl (1)

{ // bel state machine elke 32 ms blinkyStateMachine_runCycle (&blinky); _bis_SR_register(LPM0_bits + GIE); sc_timer_service_proceed(&timer_service, 32); } }

// WDT ISR

#pragma vector=WDT_VECTOR _interrupt void watchdog_timer(void) {_bic_SR_register_on_exit(LPM0_bits + GIE); }

Stap 6: Voer het project uit

Dat is alles - Nu kunt u het programma bouwen en uploaden naar uw MSP430!

Hopelijk heeft deze tutorial je geholpen om met succes een project voor je MSP430 te maken. Nu is het tijd om uw eigen ideeën uit te voeren!

Voor het genereren van code is YAKINDU Statechart Tools vereist als plug-in in uw Code Composer Studio.

Je kunt de update-site hier downloaden! <

Het begint met een proefversie van 30 dagen. Daarna kunt u een gratis licentie krijgen voor niet-commercieel gebruik!