Java &GraalVM Native Image:Verbetering van de databaseconnectiviteit in productie-apps

Het huidige landschap van toepassingen in de productie-industrie is verdeeld in een rigide hiërarchie. Van management met behulp van ERP-systemen tot planningssystemen met MES en supervisiesystemen met SCADA tot en met besturingssystemen gerealiseerd met PLC's en veldsystemen helemaal onderaan.

Terwijl de meeste systemen voor management, planning en toezicht worden geïmplementeerd in objectgeoriënteerde programmeertalen op hoog niveau, worden besturingssystemen volledig geïmplementeerd in talen op laag niveau, waarbij C de dominante programmeertaal is.

Deze abrupte verandering van een hoog niveau naar een laag niveau van de hiërarchie zorgt voor verschillende problemen. Er zijn compleet andere tools en ecosystemen nodig. Voor de implementatie moeten totaal verschillende ontwikkelaars met een andere manier van denken worden ingeschakeld om een ​​taak uit te voeren. Tussen de twee werelden of systemen moeten interfaces worden gedefinieerd. Alleen maar omdat er geen mogelijkheid is om verder te gaan met een programmeertaal op hoog niveau die bekend is vanaf het supervisieniveau tot het besturingsniveau. Dit is nu veranderd. Door gebruik te maken van containertechnologie op het besturingsniveau van een PLC kunnen we bijvoorbeeld programmeertalen zoals Java op dit hiërarchieniveau gebruiken en de starre hiërarchieën doorbreken.

Java is een veelgebruikte, objectgeoriënteerde programmeertaal op hoog niveau. Het heeft een levendige community en ecosysteem van bibliotheken en frameworks die extra functionaliteit bieden, waardoor u bestaande tools en oplossingen kunt gebruiken om uw applicatie sneller en efficiënter te bouwen.

We zullen laten zien hoe Java beschikbaar is op een Phoenix Contact PLCnext om de ontwikkeling te vereenvoudigen van een applicatie die op PLCnext draait en rechtstreeks communiceert met een database om applicatierelevante informatie op te halen en op te slaan en deze op een webinterface te presenteren. Een van de meest populaire raamwerken in Java is Hibernate. Het vereenvoudigt het proces van het toewijzen van Java-objecten aan relationele databasetabellen, waardoor de hoeveelheid standaardcode die nodig is voor databasebewerkingen wordt verminderd. Hibernate biedt een hoog abstractieniveau, waardoor ontwikkelaars met objecten kunnen werken in plaats van rechtstreeks met SQL-query's. Dit kan leiden tot snellere ontwikkelingscycli en verminderde ontwikkelingsinspanningen. Hibernate abstraheert de verschillen tussen verschillende databaseleveranciers, waardoor het gemakkelijker wordt om tussen databases te schakelen zonder noemenswaardige codewijzigingen. Dit artikel beschrijft de integratie van Hibernate voor het verbinden van software op PLC's met databases.

Moderne Java-applicatie op PLCnext

Om te beginnen met het implementeren van een moderne Java-applicatie raden we aan applicatieframeworks zoals Quarkus of Spring Boot te gebruiken. Deze raamwerken vereenvoudigen de configuratie van het project, het afhankelijkheidsbeheer.

Voor dit voorbeeld starten we onze applicatie met behulp van de Quarkus' Using Hibernate ORM en Jakarta Persistence Guide. Een voorbeeld van de broncode is te vinden op het github-project hibernate-orm-quickstart.

We beginnen met het aanpassen van de broncode van de applicatie. We kunnen de Java-klasse Fruit.java wijzigen in Event.java en voeg een nieuw veld date toe .

Voorbeeld van code Event.java :

...
@Entity
@Table(name = "Events")
public class Event {
 @Id
 @GeneratedValue
 private Long id;
 
 private String title;
 
 @Column(name = "eventDate")
 private LocalDateTime date;
 
...

We kunnen de database-URL en de inloggegevens configureren door het bestand application.properties te wijzigen

Voorbeeld van src/main/resources/application.properties

quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=myusername
quarkus.datasource.password=mypassword
quarkus.datasource.jdbc.url=jdbc:postgresql://myremotehost/mydatabase
quarkus.datasource.jdbc.max-size=8
quarkus.datasource.jdbc.min-size=2
quarkus.hibernate-orm.database.generation=create
...

Wanneer de applicatie wordt gestart, wordt er een tabel in de database gemaakt en indien nodig geïnitialiseerd. Na het opstarten kunnen we communiceren met de database via een webinterface die draait op poort 8080 op de PLCnext:

Houd er rekening mee dat dit allemaal gebeurt op het controleniveau van onze hiërarchie, zonder enig extra systeem ertussen.

GraalVM-eigen afbeelding

Veel ontwikkelaars zijn nog steeds van mening dat Java een zogenaamde Java Runtime Environment nodig heeft om Java Byte-Code uit te voeren en niet de noodzakelijke prestaties levert. Bij embedded applicaties is dit niet langer het geval. In dit voorbeeld gebruiken we de GraalVM Native Image-technologie om Java-code te compileren in een native applicatie. De native image-compilatie van GraalVM biedt een overtuigende oplossing voor het aanpakken van de uitdagingen van opstarttijd en geheugengebruik in Java-applicaties, vooral in omgevingen met beperkte bronnen, zoals ingebedde systemen. Door Java-applicaties van tevoren te compileren in native uitvoerbare bestanden, vermindert GraalVM de opstarttijd en geheugenoverhead aanzienlijk in vergelijking met traditionele Just-In-Time (JIT)-compilatie.

GraalVM van MicroDoc heeft de unieke mogelijkheid om binaire bestanden voor ingebedde apparaten te genereren. Op het moment dat deze tutorial wordt geschreven, ondersteunt GraalVM 32-bits en 64-bits ARM- en x86-processors.

Om onze Java-applicatie van tevoren te compileren, gericht op de PLC AXC F 1152 , kunnen we MicroDoc's GraalVM gebruiken en enkele compileropties configureren in het bestand application.properties .

...
quarkus.native.additional-build-args=--target=linux-arm,-H:CompilerBackend=llvm,-H:+PreserveFramePointer,-Dllvm.bin.dir=/llvm/bin,--native-compiler-path=/arm-none-linux-gnueabihf-g++,-H:CAPCacheDir=/cap-cache/armv7a-linux-gnueabihf

Meer informatie over het proces van cross-compileren en debuggen vindt u in het volgende artikel:Java-native images van MicroDoc GraalVM Embedded bouwen en debuggen

Om de applicatie te bouwen, kunt u gewoon het volgende commando gebruiken:

$ mvn -Pnative package

Vervolgens starten we de PLCnext-simulator. De simulator wordt geleverd als een qemu-afbeelding. De simulator zal ons begroeten met de volgende regel:

PLCnext Linux 2023.0 sim-axcf1152 ttyAMA0
sim-axcf1152 login:

De gegenereerde binaire bestanden kunnen met het commando scp naar de PLC worden gekopieerd die een beveiligde shell naar de PLC opent en het binaire bestand naar het doelsysteem overbrengt. U kunt de toepassing starten met het volgende commando:

$ ./application

Met behulp van de PLCnext cockpitclient kunnen we ook het huidige geheugen- en opslaggebruik bekijken:

We zijn echter ook geïnteresseerd in het opstart- en geheugenverbruik van onze enkele applicatie in vergelijking met het uitvoeren van de applicatie in een Java Runtime Environment zoals OpenJDK. We hebben dus beide waarden gemeten, zoals weergegeven in de volgende tabel:

Opstarttijd (minder is beter), geheugengebruik (minder is beter)

GraalVM-eigen afbeelding: 0,413 s, 87 MB

OpenJDK: 13 sec., 128 MB

GraalVM Native Image biedt aanzienlijk betere prestaties op het gebied van zowel opstarttijd als geheugengebruik in vergelijking met OpenJDK, wat de effectiviteit ervan aantoont bij het optimaliseren van het bronnenverbruik voor een efficiënte implementatie van applicaties.

Samenvatting

Het gebruik van Java op besturingsniveau zoals een PLC heeft meerdere voordelen. In de eerste plaats is er geen sprake van een technologische beperking tussen het supervisieniveau en het controleniveau. Hetzelfde personeelsbestand kan applicaties implementeren en profiteren van het Java-ecosysteem en de beschikbare tools. Ten tweede kan de GraalVM Java-code compileren als native applicaties op embedded apparaten zoals 32-bits en 64-bits ARM- en x86-processors. Uw ontwikkelaars hoeven zich dus niet bezig te houden met de onderliggende architectuur en kunnen uw applicatie implementeren in een objectgeoriënteerde taal op hoog niveau. Ten derde hebben we dankzij de containerondersteuning van PLCnext van Phoenix Contact rechtstreeks toegang tot de interfaces van de PLC in dezelfde hardwarecomponent en kunnen we de rigide hiërarchieën in de huidige toepassingen van de productie-industrie doorbreken.

Opmerking:

Op de Makers Blog worden toepassingen en gebruikersverhalen van communityleden getoond die niet door Phoenix Contact zijn getest of beoordeeld. Gebruik ze op eigen risico.