Eenvoudige en complexe datatypen in C++ beheersen met PLCnext Engineer

Hallo allemaal,

In deze blogpost verkennen we eenvoudige en complexe datatypen in C++ en PLCnext Engineer. Het bevat twee verschillende oefeningen: een eenvoudige en een complexe.

Deze tutorial gaat ervan uit dat je enige ervaring hebt met C++ en PLCnext Engineer.

Start

Allereerst heb je de juiste tools nodig: een C++-editor, de PLCnext Engineer-software en een Phoenix Contact PLC om dit op te draaien. Dit zijn de materialen die ik gebruikte:

• AXC F 2152 op firmwareversie 2021.0.3
• PLCnext Engineer versie 2021.0.2
• Visual Studio 2019 Community versie 16.9.4

Ik heb persoonlijk Visual Studio gekozen als C++-editor, maar Eclipse kan ook gebruikt worden. Links naar de tutorials:

• Visual Studio
• Eclipse

PLCnext Engineer is te vinden op onze website.

Eenvoudige oefening

Voor dit eerste voorbeeld maken we een kleine applicatie die controleert of het juiste nummer vanuit de PLC wordt verstuurd. Maak eerst een nieuw C++-project. Ga vervolgens naar het header-bestand, de naam ziet er ongeveer uit als [NaamVanHetProject].hpp; er zijn ook bestanden met de naam [naamVanHetProject]component.hpp – die gebruiken we niet. Zodra je in het header-bestand bent, zie je een muur code, maar geen zorgen, het is simpel. Ten eerste definiëren we de poorten: één IN en één OUT. Voor eenvoudige datatypen kan dat als volgt:

//#port
//#attributes(input)
//#name(InputTest)
int64 InputTest = 0;

//#port
//#attributes(Output)
//#name(outputTest)
int64 OutputTest = 0;

Dan gaan we naar het volgende bestand waar we de daadwerkelijke code schrijven. Dit heet [NaamVanHetProject].cpp en bevat nog niet veel. Dat gaan we nu veranderen. Laten we code toevoegen om nummers te controleren, of met if-statements of een switch-case – dat is aan jou. Ik heb if-structuren gebruikt:

void PLMProjectReadInputProgram::Execute() {
    if (InputTest == 1) {
        OutputTest = 15;
    }
    if (InputTest == 2) {
        OutputTest = 150;
    }
    if (InputTest == 3) {
        OutputTest = 1500;
    }
    if (InputTest == 4) {
        OutputTest = 15000;
    }
}

Voordat we naar PLCnext Engineer gaan, moeten we dit C++-project bouwen tot een bibliotheek die de PLC begrijpt. Dat doe je door bovenaan op "Build" te klikken. Dit duurt even en laat weten wanneer de bibliotheek klaar is. Als deze stap onduidelijk is, raad ik je ten zeerste aan de bovenstaande tutorials te raadplegen.

Navigeer naar het hoofdprogramma in het Components-tabblad onder "Programming" in de map "Local", selecteer vervolgens "Variables" in het hoofdscherm om de variabelen in de PLC te zien. Hier kunnen we een naam en datatype kiezen en het gebruik. Datatypen in PLCnext Engineer moeten hetzelfde zijn als in het C++-programma; een link naar de verschillende typen en hun equivalenten vind je hier. "Usage" definieert of de variabelen lokaal zijn of gebruikt kunnen worden om data te zenden/ontvangen van buitenaf.

Na dit gaan we de variabelen koppelen nadat we de nieuwe bibliotheek hebben toegevoegd. Dit doe je als volgt:

De bibliotheek die je hebt gemaakt, vind je in de bin-map van je project; kopieer deze naar de bibliothekenmap voor PLCnext Engineer. De locatie ziet er ongeveer uit als:

C:\Users\Public\Documents\PLCnext Engineer\Libraries

Daarna gaan we terug naar PLCnext Engineer om de bibliotheek aan ons programma toe te voegen. We navigeren naar het Components-tabblad, openen de Libraries-box, rechtsklikken op Libraries en kiezen "Add user library". Dit brengt je naar de libraries-map waar we net waren. Kies de bibliotheek die je wilt gebruiken en ga verder.

Eenmaal dit gedaan is, moeten we het programma aan de taken toevoegen. Dit doe je als volgt. Aan de linkerkant van het scherm, in het plantgebied, dubbelklik op PLCnext. Het opent in het midden. Ga vervolgens naar het tabblad "Tasks and Events" en voeg een nieuw programma toe na de MainInstance. Dit kan op twee manieren: door het programmatype te selecteren of door het te slepen vanuit het Components-gebied onder "PLCnext Components & Programs".

De variabelen moeten nu verschijnen in het tabblad "Port List" naast "Tasks and Events". Open dit om al je variabelen uit C++ en PLCnext te zien. Het zou er ongeveer zo uit moeten zien:

Als je alles correct hebt gedaan, zou je de OUT-poorten van je PLC met de IN-poort van het C++-programma moeten kunnen verbinden, en andersom. Als dit niet werkt, controleer dan je datatypen.

Om een dummy-waarde aan onze variabele toe te voegen, navigeren we naar het hoofdprogramma in het Components-tabblad, selecteren "Code" in het hoofdscherm om de code te zien en voegen wat eigen code toe. We zetten de uitgaande variabele op een numerieke waarde, in dit geval 1.

Nu deployen we het project naar de PLC en we zouden 15 als reactie van de C++-code moeten krijgen. Je kunt de variabelen zien in de "Port List" van daarnet.

Complexe oefening

In dit voorbeeld maken we een kleine applicatie die een array van structs naar en van de PLC stuurt. Maak eerst een nieuw C++-project. Ga weer naar het header-bestand ([NaamVanHetProject].hpp). We maken een struct voor een auto:

public: // typedefs
    struct StrCar {
        StaticString<80> sbrand;
        int16 iHorsepower;
        int16 iYear;
        boolean xInsured;
    };

BELANGRIJK! De namen en typen in C++ en PLCnext Engineer moeten identiek zijn! Datatypen vind je hier.

Dan definiëren we de poorten: één IN en één OUT, maar omdat het lijsten van data zijn, maken we ze als arrays van 'auto's:

//#port
//#attributes(Input)
//#name(CarIn)
StrCar CarToC[2];

//#port
//#attributes(Output)
//#name(CarOut)
StrCar CarFromC[2];

Ga naar het .cpp-bestand voor de daadwerkelijke code. Hier wijzigen we de waarden van auto één en twee.

// Zet het eerste lid van de autolijst gelijk aan de auto van de PLC
CarFromC[0].sbrand = CarToC[1].sbrand;
CarFromC[0].iHorsepower = CarToC[1].iHorsepower;
CarFromC[0].iYear = CarToC[1].iYear;
CarFromC[0].xInsured = CarToC[1].xInsured;

// Voeg dummy-waarden toe aan het tweede lid
CarFromC[1].sbrand = CarToC[0].sbrand;
CarFromC[1].iHorsepower = CarToC[0].iHorsepower;
CarFromC[1].iYear = CarToC[0].iYear;
CarFromC[1].xInsured = CarToC[0].xInsured;

We bouwen weer de bibliotheek (klik op Build).

Voordat we variabelen in PLCnext Engineer kunnen maken, moeten we een eigen datatype aanmaken: een struct Car en een array carList. Dit doe je in een datatypes-bestand, te vinden en aan te maken hier:

Open dit bestand en maak onze struct als volgt:

TYPE
    StrCar:
    STRUCT
        sBrand: STRING;
        iHorsepower: INT;
        iYear: INT;
        xInsured: BOOL;
    END_STRUCT
END_TYPE

BELANGRIJK! Namen en typen in C++ en PLCnext Engineer moeten identiek zijn! Datatypen vind je hier.

Na het maken van de struct maken we een array van dit type in hetzelfde bestand:

TYPE
    carList: ARRAY[0..1] OF StrCar;
END_TYPE

Om een variabele met het type carList aan te maken, navigeer naar het hoofdprogramma in het Components-tabblad onder "Programming", map "Programs", selecteer "Variables" in het hoofdscherm. Kies een naam, als datatype selecteer ons zelfgemaakte type.

Daarna koppelen we de variabelen na toevoeging van de nieuwe bibliotheek (dezelfde stappen als bij de eenvoudige oefening).

Voeg het programma toe aan de taken (zoals eerder beschreven).

De variabelen verschijnen in het "Port List"-tabblad.

Als alles correct is, kun je de OUT-poorten van de PLC verbinden met de IN-poort van het C++-programma, en andersom. Werkt het niet? Controleer datatypen en variabelennamen.

Voor dummy-waarden navigeer naar het hoofdprogramma, selecteer "Code" en voeg eigen code toe. We vullen de uitgaande variabele met autospecificaties (kies willekeurig, maar match datatypen).

CarToC[0].sBrand := 'Audi';
CarToC[0].iHorsepower := 200;
CarToC[0].iYear := 2020;
CarToC[0].xInsured := TRUE;

CarToC[1].sBrand := 'Mazda';
CarToC[1].iHorsepower := 120;
CarToC[1].iYear := 2001;
CarToC[1].xInsured := FALSE;

Na deployen zou de uitgaande lijst omgewisseld moeten zijn ten opzichte van de binnenkomende lijst. Je kunt de variabelen zien in de "Port List".