Opleidingen
58.498
resultaten
Kotlin Fundamentals
Utrecht
wo 21 mei 2025
en 8 andere data
Deze driedaagse opleiding biedt een complete introductie tot Kotlin, een moderne programmeertaal die volledig interoperabel is met Java en geschikt is voor Android, backend- en webdevelopment. Je leert de unieke syntax van Kotlin, null-veiligheid, functionele programmeerconcepten en het bouwen van efficiënte applicaties. De training bevat praktische oefeningen zoals het ontwikkelen van een Android-app (basis) en een REST API met Ktor. Na afloop ben je vertrouwd met JetBrains-tools (IntelliJ), Gradle-builds en Kotlin’s uitbreidingen zoals coroutines.
Waarom Kotlin?
Kotlin is concis, veilig en veelzijdig, ontwikkeld door JetBrains. Kenmerken:
Null safety: compile-time checks voorkomen NullPointerException.
Interoperabel met Java: bestaande Java-bibliotheken en frameworks.
Multiplatform: Android, iOS (KMM), web (Kotlin/JS), native.
Moderne syntax: data classes, extension functions, coroutines.
Officiële taal voor Android: aanbevolen door Google.
Community-driven: open source met actieve updates.
Studiebelasting:
Contacturen: 3 dagen × 8 uur = 24 uur.
Zelfstudie: 6–10 uur (oefeningen, projecten).
Totaal: ca. 30–34 uur.
Android-developers die overstappen van Java naar Kotlin.
Backend-developers die Kotlin met Spring of Ktor willen gebruiken.
Java-ontwikkelaars die moderne taalfeatures willen benutten.
Beginners die een productietaal voor meerdere platforms leren.
Dag 1: Kotlin Basis en Functionele Concepten
Installatie van IntelliJ IDEA en Kotlin-plugin configuratie.
Basis syntax: fun main(), val vs var, type inference.
Datatypes: primitief (Int, Double, Boolean), String, Any, Unit.
Controlestructuren: if als expressie, when, for/while-loops.
Functies: default parameters, named arguments, single-expression functies.
Dag 2: OOP, Null Safety en Uitbreidingen
Klassen: primary/secondary constructors, init-blokken.
Data classes: data class User(val name: String), copy(), destructuring.
Null safety: ?, !!, let/also/apply scope functions.
Uitbreidingen: extension functions (fun String.reverse()).
Objecten en companions: object Singleton, companion object.
Dag 3: Geavanceerde Features en Integration
Collecties: List, MutableList, Map, filter/map/groupBy.
Lambdas en hogere-ordefuncties: (Int) → Boolean, fold/reduce.
Coroutines: launch, async/await, suspend functies.
Ktor-basis: eenvoudige REST API bouwen met routing.
Android-integratie (optioneel): Activity, RecyclerView (basis).
Programma:
Basisconcepten:
Variabelen (val, var), type inference, string templates (${var}).
Ranges: 1..10, until, step, downTo.
Type checks en casts: is, as, as?.
Functioneel Programmeren:
Hogere-ordefuncties: functies als parameters retourneren.
Lambda-expressies: syntaxis, it-keyword.
Inline functies: inline fun voor performance-optimalisatie.
OOP en Uitbreidingen:
Overerving: open classes, override, abstracte klassen.
Interfaces: default methoden, properties.
Sealed classes: beperkte class-hiërarchieën.
Null Safety en Scope Functions:
Elvis-operator (?:), safe calls (?.).
run, let, apply, also, with voor contextbeheer.
Coroutines en Asynchroon:
Coroutine-scopes: GlobalScope, CoroutineScope.
Dispatchers: IO, Main, Default.
Job en Deferred voor concurrencybeheer.
Android/Backend Integration:
Room Database: @Entity, @Dao, basisqueries.
Ktor: routing, statuscodes, JSON-serialisatie (kotlinx.serialization).
Tools en Build Systems:
Gradle: Kotlin DSL, dependencies toevoegen.
Debugging: breakpoints, coroutine-inspectie.
Linting: detekt-configuratie voor codekwaliteit.
Bereidt voor op Google Associate Android Developer (AAD)-certificering.
Relevant voor JetBrains Academy-projecten (geen officieel examen).
€1.695
Klassikaal
max 12
3 dagen
Object Oriented Programming OOP and Design Patterns
Eindhoven
wo 7 mei 2025
en 9 andere data
Wil je je objectgeoriënteerde programmeervaardigheden verbeteren en efficiëntere code schrijven? In deze tweedaagse training leer je de kernprincipes van OOP, zoals encapsulatie, overerving en polymorfisme. Daarnaast ontdek je hoe veelgebruikte design patterns zoals Factory Method, Singleton, Adapter en Observer bijdragen aan schaalbare en onderhoudbare software. Je werkt hands-on met praktijkcases, zoals het ontwerpen van een winkelwagensysteem en een rapportgenerator met Template Method.
Wat leer je in deze training?
OOP-basisprincipes – Encapsulatie, overerving en polymorfisme.
Creational patterns – Singleton en Factory Method.
Structural patterns – Adapter en Composite.
Behavioral patterns – Observer, Strategy en Template Method.
Praktische refactoring – Code verbeteren met SOLID-principes.
Deze training is ideaal voor junior en medior developers, zelfstudie-programmeurs en teams die hun code consistentie willen verbeteren. De focus ligt op direct toepasbare technieken en best practices. Je werkt met Engelstalig lesmateriaal, praktijkgerichte opdrachten en moderne tools, onder begeleiding van een Nederlandstalige docent.
Junior developers (6-18 maanden ervaring)
Medior ontwikkelaars die patterns willen formaliseren
Zelfstudie-programmeurs die praktijkkennis missen
Teams die code consistentie willen verbeteren
Dag 1: Basis OOP & Eerste Patterns
OOP Pilaren: Encapsulatie, Overerving, Polymorfisme
SOLID Basics: Single Responsibility, Open/Closed principe
Creational Patterns: Factory Method, Singleton (eenvoudig)
Structural Patterns: Adapter, Composite
Hands-on: Pizza bestelsysteem met Factory Method
Dag 2: Intermediate Patterns & Praktijkcases
Behavioral Patterns: Observer, Strategy, Template Method
Dependency Injection: Basisconcepten en constructor injection
Refactoring: If/else ketens vervangen door Strategy
Real-world Use Cases:
Winkelwagen met Composite + Observer
Betalingsverwerker met Adapter pattern
Rapportgenerator met Template Method
Programma
Basisconcepten
Encapsulatie: Private velden met getters/setters
Overerving: Basisklassen voor herbruikbaarheid (bv. Animal → Dog)
Polymorfisme: Interface voor verschillende implementaties (IDatabase)
Creational Patterns
Factory Method: Objectcreatie verbergen (PaymentFactory.create())
Singleton: Configuratieklasse met getInstance() (niet thread-safe)
Structural Patterns
Adapter: Legacy PDF-generator aanpassen aan modern systeem
Composite: Hiërarchische menu-structuren bouwen
Behavioral Patterns
Observer: Email notificaties bij orderstatuswijziging
Strategy: Sorteeralgoritmes wisselen (BubbleSort ↔ QuickSort)
Template Method: Stappenplan voor rapportexports (CSV/PDF)
Tools & Technieken
UML: Eenvoudige class diagrams met draw.io
Refactoring lab: Switch-case omzetten naar Strategy
Code analysis: ESLint/SonarLint voor code smells
Aan deze training is geen examen verbonden.
Wel wordt een certificaat van deelname afgegeven.
€1.195
Klassikaal
max 12
2 dagen
PHP MySQL
Utrecht
di 20 mei 2025
en 7 andere data
Wil je PHP leren en server-side webontwikkeling beheersen? In deze driedaagse training bouw je dynamische websites met PHP en MySQL. Je leert basisconcepten zoals variabelen, loops en formulieren, maar ook geavanceerde onderwerpen zoals sessiebeheer, OOP en security. Via praktijkcases zoals een contactformulier met validatie en een eenvoudig CMS-systeem pas je de theorie direct toe.
Wat leer je in deze training?
PHP-basis – Syntax, controlestructuren en formulierverwerking.
Databases & MySQL – CRUD-operaties, prepared statements en PDO.
Sessies & cookies – Gebruikersbeheer en authenticatie.
Objectgeoriënteerd programmeren – Klassen, methoden en overerving.
Security best practices – SQL-injectie en XSS-preventie.
Deze training is ideaal voor beginners, frontend-developers en WordPress-ontwikkelaars die hun PHP-kennis willen verdiepen. Je werkt met Engelstalig lesmateriaal, praktijkgerichte opdrachten en moderne tools, ondersteund door een Nederlandstalige docent.
Beginners die server-side webdevelopment willen leren.
Frontend-developers die hun stack willen uitbreiden.
WordPress-ontwikkelaars die dieper in PHP willen duiken.
Backend-developers in opleiding (voor Laravel/Symfony).
Dag 1: PHP Basis en Formulierverwerking
Installatie van PHP, XAMPP/MAMP, en een IDE (bijv. PHPStorm of VSCode).
Syntax: variabelen, datatypes (string, int, float, bool, array, null).
Operatoren: rekenkundig, vergelijking, logisch, concatenatie (.).
Controlestructuren: if/elseif/else, switch, for, while, foreach.
Formulierverwerking: $_GET, $_POST, inputvalidatie (basis).
Dag 2: Functies, Arrays en Sessiebeheer
Functies: definiëren, parameters, return-waarden, typehinting (basis).
Arrays: indexeerde en associatieve arrays, array_push(), array_filter(), array_map().
Superglobals: $_SERVER, $_SESSION, $_COOKIE.
Sessiebeheer: session_start(), gebruikersauthenticatie (basis).
Bestandsafhandeling: fopen(), fwrite(), file_get_contents().
Dag 3: Databases en OOP Introductie
MySQL-integratie: verbinding maken met mysqli of PDO.
SQL-basis: SELECT, INSERT, UPDATE, DELETE, prepared statements.
Databaseklasse bouwen: herbruikbare connectie en queries.
Introductie OOP: klassen, objecten, methoden, eigenschappen.
Security: basis van SQL-injectiepreventie, htmlspecialchars().
Programma:
Basisconcepten en Syntax:
Variabelen: $variabele, datatypes (string, int, float, bool, array, null, resource).
Type Juggling en expliciete conversie: (int), (string), (array).
Operatoren:
Rekenkundig: +, -, , /, %, *.
Vergelijking: ==, ===, !=, !==, >, <.
Logisch: &&, ||, !, and, or.
String-concatenatie: . en .=.
Controlestructuren:
if/elseif/else, switch met case/default.
Loops: for, while, do…while, foreach (voor arrays).
Formulierverwerking en Validatie:
Superglobals: $_GET, $_POST, $_FILES (bestandsuploads).
Input sanitization: trim(), stripslashes(), htmlspecialchars().
Validatie: filter_var() met filters (FILTER_VALIDATE_EMAIL, FILTER_SANITIZE_STRING).
Basis regex: preg_match() voor patroonvalidatie.
Bestandsuploads: $_FILES-array, move_uploaded_file(), mime-type checks.
Arrays en Functies:
Array-types:
Indexeerde arrays: $arr = [1, 2, 3];.
Associatieve arrays: $assoc = ["naam" ⇒ "Jan", "leeftijd" ⇒ 30];.
Array-functies: count(), array_push(), array_merge(), array_key_exists().
Functies:
Definities: function naam($param) { … }.
Optionele parameters: default values (function tel($a, $b = 0)).
Type declarations: function add(int $a, int $b): int.
Anonieme functies en closures.
Sessies en Cookies:
Sessiestart: session_start(), $_SESSION-variabelen.
Cookie-beheer: setcookie(), $_COOKIE, vervaldatums.
Veiligheid: sessie-ID-regeneratie (session_regenerate_id()).
Bestands- en Directorybeheer:
Bestanden lezen/schrijven: file_get_contents(), file_put_contents().
Directory-functies: scandir(), mkdir(), rmdir().
Bestandspermissies: chmod(), is_readable().
Database-integratie (MySQL):
MySQLi:
Verbinden: mysqli_connect().
Queries: mysqli_query(), prepared statements (mysqli_prepare(), bind_param()).
Resultaten ophalen: mysqli_fetch_assoc(), mysqli_fetch_all().
PDO:
Verbinden: new PDO("mysql:host=…;dbname=…", $user, $pass).
Prepared statements: prepare(), execute(), fetch().
Transacties: beginTransaction(), commit(), rollback().
CRUD-operaties: Create, Read, Update, Delete.
OOP (Objectgeoriënteerd Programmeren):
Klassen en objecten: class Gebruiker { … }, new Gebruiker().
Eigenschappen en methoden: public, private, protected.
Constructor/destructor: construct(), destruct().
Static methods/properties: self::$teller, static::methode().
Overerving: extends, parent::__construct().
Security Best Practices:
SQL-injectie voorkomen: prepared statements (MySQLi/PDO).
XSS-preventie: htmlspecialchars(), strip_tags().
Wachtwoordhashing: password_hash(), password_verify().
CSRF-tokens: basisimplementatie voor formulieren.
Tools en Praktijkcases:
Composer: package manager, composer.json, autoloading (PSR-4).
PHPUnit: basis testcases schrijven.
Praktijk:
Contactformulier met validatie en e-mailverzending (mail()).
Inlogsysteem met sessies en wachtwoordbeveiliging.
Blog met database-CRUD en paginering.
Bestandsbeheersysteem (upload/download/delete).
Error Handling en Debugging:
Foutmeldingen: error_reporting(), ini_set("display_errors", 1).
Custom error handler: set_error_handler().
Uitzonderingen: try/catch/throw new Exception().
Logging: error_log(), logbestanden analyseren.
Bereidt voor op het Zend PHP Certification Associate-examen.
Basis voor vervolgtrainingen zoals Laravel of WordPress Development.
Examen is extern af te leggen (niet inbegrepen).
€1.695
Klassikaal
max 12
3 dagen
PHP CakePHP Ontwikkeling
Eindhoven
di 6 mei 2025
en 8 andere data
Deze opleiding leert je efficiënte webapplicaties bouwen met het CakePHP framework, met nadruk op "convention over configuration". Je leert snelle ontwikkelingstechnieken met de ingebouwde Bake CLI, terwijl je robuuste applicaties creëert volgens best practices.
De training behandelt moderne CakePHP 4.x features inclusief ORM-integratie, middleware stacks en API ontwikkeling. Speciale aandacht voor security-aspecten, testautomatisering en het migreren van legacy CakePHP-applicaties.
Waarom PHP CakePHP?
Rapid development: Scaffolding via Bake CLI
Strikte conventies: Minder configuratie nodig
Security first: Ingebouwde XSS/CSRF protectie
Flexibel ORM: Database-agnostische queries
Lange termijn ondersteuning: Actief sinds 2005
Studiebelasting
2 lesdagen (8 uur per dag)
10-14 uur praktijkopdrachten
6 uur aanbevolen zelfstudie
PHP developers die productiviteit waarderen
Teams die legacy CakePHP apps onderhouden
Full-stack developers die API’s willen bouwen
Beheerders van middelgrote webapplicaties
Dag 1: CakePHP Fundamentals
Project setup: composer create-project --prefer-dist cakephp/app
MVC-structuur: Conventies voor controllers/tabellen
Bake CLI: Scaffolding met bin/cake bake all
ORM Basics: Table/Entity klassen relaties
Formulieren: FormHelper en data validation
Routing: Custom routes configureren in routes.php
Basic API: JSON responses met _serialize
Dag 2: Geavanceerde Technieken
Middleware: Pipelining met Authentication/CSRF
Plugins: Gebruik van FriendsOfCake packages
Testing: PHPUnit integratie met FixtureFactories
Security: Secure component en Content Security Policy
Performance: Caching layers en Eager Loading
Deployment: Docker configuratie met cakephp/docker
Migraties: Phinx migrations voor database changes
Programma
Installatie met Composer en Docker
Bake CLI commando’s:
bake controller --prefix Admin
bake template --theme BootstrapUI
ORM Associations:
hasMany, belongsToMany
contain() voor eager loading
FormHelper validatieregels:
scaffold.ini configuratie
Custom validation classes
Middleware stack configuratie:
CsrfProtectionMiddleware
BodyParserMiddleware
RESTful resource routing:
$routes→resources('Articles')
JWT authenticatie met plugins
Unit testing:
Table- en Entity tests
Mocking services
Database migraties:
Phinx change() methodes
Seed data injectie
Performance optimalisatie:
CacheHelper configuratie
DebugKit integratie
Deployment strategieën:
.env configuratie
Asset compressie
Security hardening:
Security component
CSP headers config
Voorbereiding op: * CakePHP Core Certification * Zend PHP Certification * CIW Web Development Associate
€1.195
Klassikaal
max 12
2 dagen
PHP Laravel Ontwikkeling
Eindhoven
di 6 mei 2025
en 8 andere data
Deze praktijkgerichte opleiding leert je moderne webapplicaties bouwen met het Laravel framework. Je leert zowel fundamentele concepten als geavanceerde technieken, met aandacht voor efficiënte workflows, security best practices en schaalbare architectuur.
Tijdens de training werk je met actuele Laravel features zoals Eloquent ORM, Blade templating, Artisan CLI en het ecosystem van packages. We besteden specifiek aandacht aan REST API ontwikkeling, real-time functionaliteit en geoptimaliseerde database-interacties.
Waarom PHP Laravel?
Productivity focus: Built-in tools voor veelvoorkomende taken
Elegante syntax: Expressieve code met minder boilerplate
Actieve community: 16k+ packages via Packagist
Modern stack: Ondersteuning voor Vue/React frontends
Enterprise-ready: Horizontale schaalbaarheid via Redis/queues
Studiebelasting
2 lesdagen (8 uur per dag)
10-15 uur praktijkopdrachten
5 uur aanbevolen zelfstudie
PHP developers die willen moderniseren
Full-stack developers die een robuust framework zoeken
Teams die onderhoudbare applicaties moeten bouwen
Backend developers die API-expertise willen uitbreiden
Dag 1: Laravel Fundamentals
Project setup: composer create-project + Docker configuratie
MVC-architectuur: Routes, Controllers, Views structuur
Artisan CLI: make: commando’s voor model-generatie
Eloquent ORM: Relationships (hasMany, belongsToMany)
Migrations & Seeders: Database schema beheer
Blade templating: Components, layouts en directives
Basic form handling: Validation en CSRF protection
Dag 2: Geavanceerde Technieken
API Development: Resource controllers en JSON responses
Middleware: Custom auth guards en rate limiting
Queues & Jobs: Asynchrone taakverwerking
Testing: Feature tests met PestPHP
Security: Sanctum voor API auth, XSS prevention
Performance: Eager loading, caching strategieën
Deployment: Forge/Envoyer configuratie basics
Programma
Laravel installatie met Sail/Docker
Artisan CLI: php artisan make:model -a
Eloquent relationships: MorphTo, Polymorphic
Query Builder vs Eloquent ORM
Blade components met slots
Form request validation
API Resources en Fractal patterns
Sanctum token management
Task scheduling met cron expressies
Event/Listener architecture
Real-time notifications met Pusher
Database seeding met Faker
Eager loading N+1 problematiek
Caching strategies: Redis vs file
Multi-tenancy implementatie
Deployment pipeline setup
Error tracking met Bugsnag/Ray
Localization en multi-taal support
Full-text search met Scout
Voorbereiding op: * Laravel Certified Developer * Zend PHP Certification * AWS Certified Developer (associateniveau)
€1.195
Klassikaal
max 12
2 dagen
PHP Symfony Ontwikkeling
Eindhoven
di 6 mei 2025
en 8 andere data
Deze opleiding biedt een diepgaande introductie in het bouwen van enterprise-grade applicaties met het Symfony framework. Je leert modulaire, onderhoudbare oplossingen ontwikkelen met aandacht voor design patterns, testbaarheid en schaalbaarheid.
De training behandelt zowel Symfony componenten (Form, Security, Console) als geavanceerde integraties met API Platform en Messenger. Speciale focus op Doctrine ORM, service container configuratie en performance optimalisatie.
Waarom PHP Symfony?
Enterprise focus: Geschikt voor complexe systemen
Modulaire opbouw: Flexibel componentengebruik
Lange termijn ondersteuning (LTS versies)
Rijke ecosystem: 60+ officiële componenten
Strikte coding standards: PSR compliance
Studiebelasting
2 lesdagen (8 uur per dag)
12-16 uur praktijkopdrachten
6 uur aanbevolen zelfstudie
Backend developers in enterprise omgevingen
Teams die werken aan onderhoudbare codebases
Developers die moeten migreren naar Symfony
Technisch architects die design patterns leren
Dag 1: Symfony Fundamentals
Project setup: composer create-project symfony/website-skeleton
Architectuur: Bundles, Services, Environments
Doctrine ORM: Entities, Repositories, DQL
Twig templating: Extends, blocks en macros
Form component: Data transformers en validatie
Console commands: bin/console workflow
Debug toolbar: Profiling en performance metrics
Dag 2: Advanced Patterns & Deployment
REST API’s: API Platform configuratie
Security: Voters, Guard authenticators
Asynchrone verwerking: Messenger component
Caching: Symfony Cache adapters
Testing: PHPUnit integratie met WebTestCase
CI/CD: GitHub Actions voor Symfony
Docker: Symfony CLI Docker-integratie
Programma
Symfony Flex workflow met recipes
Service container configuratie (services.yaml)
Doctrine migrations: make:migration
Entity Relationships: ManyToMany met join tables
Query Builder vs DQL performance
Custom form types en data mappers
Event subscribers/listeners
API Platform resource configuratie
JWT authenticatie met LexikJWTAuthenticationBundle
Async message handling met RabbitMQ
Varnish HTTP cache integratie
Blackfire performance profiling
Behat voor behavior testing
Monolog logging channels
Deployment met Platform.sh
Symfony Encore voor frontend assets
Security voters en access control
Internationalisatie met Translation component
Voorbereiding op: * Symfony Certified Developer * Zend PHP Certification * AWS Certified Developer (associateniveau)
€1.195
Klassikaal
max 12
2 dagen
PLC programmeren 1
Utrecht
di 20 mei 2025
en 7 andere data
Wil je leren hoe je PLC’s programmeert voor industriële automatisering? In deze driedaagse training ontdek je de basis van PLC-hardware, Ladder Diagram en Function Block-programmering. Je leert hoe je logische sturingen bouwt, timers en tellers toepast en PLC’s koppelt aan HMI’s en sensoren.\
Wat leer je in deze training?
PLC-hardware & architectuur – CPU, I/O-modules en geheugenadressering.
Ladder Diagram & Function Blocks – Basisinstructies, logische poorten, timers en counters.
HMI-integratie & communicatie – Data-uitwisseling met Profinet, Modbus en OPC UA.
Troubleshooting & debugging – Watch tables, foutcodes en online monitoring.
Toepassing in industriële processen – Motorsturing, veiligheidscircuits en SCADA-koppeling.
Deze training is ideaal voor technici, onderhoudsmedewerkers en zij-instromers die PLC’s willen programmeren en beheren. Je werkt hands-on met software zoals TIA Portal en RSLogix.
De training bevat Engelstalig lesmateriaal en wordt gegeven door een Nederlandstalige docent.
Deze opleiding is bedoeld voor beginnend technici, elektromonteurs, onderhoudsmedewerkers en operators die willen leren hoe zij PLC’s kunnen programmeren en beheren.
Zij-instromers of engineers met een achtergrond in werktuigbouwkunde of installatietechniek is deze cursus een uitstekende start om kennis te maken met industriële automatisering.Dag 1: Introductie tot PLC-systemen en basisprogrammering
PLC-architectuur: CPU, I/O-modules, geheugentypes (RAM/EEPROM)
IEC 61131-3-standaard: Overzicht van programmeertalen (LD, FBD, ST, CFC)
Ladder Diagram (LD): XIC (XIO), XIO (XIC), OTE, OTL, OTU instructies
VFD-basisbediening: Parametrisatie via digitale I/O (Start/Stop, Richting)
HMI-PLC-koppeling: Tag-configuratie (BOOL, INT, REAL)
Dag 2: Geavanceerde logica en communicatie
Function Block (FB): Timer-blokken (TON, TOF, TP), tellers (CTU, CTD)
Structured Text (ST): Syntax (IF-THEN-ELSE, CASE, FOR-loops), variabeledefinities
Modbus RTU/TCP: Master/slave-configuratie met %MB/MW/MD-adressering
PID-regeling: Tuning van P-, I- en D-parameters via PLC-logica
Safety-circuits: Dual-channel input met SafeLogic-blokken
Dag 3: Projectintegratie en troubleshooting
CFC-programmering: Execution order van blokken, feedback loops
Alarmbeheer: Acknowledge-systemen met ALARM_ACK-bits
SCADA-koppeling: OPC UA-serverconfiguratie (Namespace: ns=3;s=Tag1)
Diagnose tools: Force table, cross-referencing, watch tables
Case study: Ontwerp van een automatisch bandtransportsysteem met encoder-feedback
Programma
PLC-hardware:
Architectuur (CPU, I/O-kaarten, backplane, voeding)
Merkspecifieke platforms (CompactLogix, S7-1200)
Geheugenadressering: Digitaal/Analoog (bijv. I0.1, Q2.3, MW20), symbolische variabelen
Programmeeromgevingen:
Softwaretools (TIA Portal, RSLogix, CODESYS PORT_OPEN(), STEP7)
Cyclische verwerking (bijv. OB1-interrupts)
Projectstructurering (Ladder-netwerken, functieblokken)
I/O-configuratie:
Digitale/Analoge signalen (DI, DO, AI, AO)
Netwerkprotocollen: Profinet (MAC-adres), EtherNet/IP (CIP-messaging)
Programmeerlogica:
Logische operatoren (AND, OR, XOR) en conditionele sturingen (IF-THEN-ELSE)
Timers (TON, TOF, TP) en tellers (CTU, CTD, CTUD)
Geavanceerde functies: PID-regeling, motion control
HMI-integratie:
Basisinstellingen (tag-binding, statusindicatoren)
Elementen: Faceplates, alarmlijsten (ALARM_1.ACK), trendgrafieken
Debugging & Diagnostiek:
Online monitoring (watch tables, cross-referencing)
Debuggingtools: Breakpoints, SFC 14/15 voor data-access
Foutafhandeling (foutcodes, HMI-alarmen)
VFD- en motorsturing:
Parametrisatie (bijv. P1080 (min. frequentie), P1120 (ramptijd))
Praktijkopstellingen (motor/ventielsturing via I/O)
Veiligheid:
Basis safety-circuits (noodstop, veiligheidsvergrendelingen)
Netwerkconfiguratie:
Ethernet-instellingen (remote toegang, subnetmaskers)
Best practices:
Documentatie (back-up, versiebeheer)
Code-archivering (structuur, commentaar)
Voorbereiding op:
Siemens S7-1200-certificering (TIA Portal)
Rockwell Automation Level 1 (Studio 5000)
CODESYS Certified Programmer (IEC 61131-3)
€1.695
Klassikaal
max 12
3 dagen
PLC programmeren 2
Utrecht
di 20 mei 2025
en 7 andere data
Wil je complexe PLC-systemen ontwerpen en programmeren? In deze vervolgtraining verdiep je je in geavanceerde Ladder-logica, analoge signaalverwerking en industriële netwerken zoals PROFINET en Modbus. Je leert hoe je PLC’s integreert met HMI’s, motorsturingen optimaliseert en storingen diagnosticeert met watch tables en real-time debugging.
Wat leer je in deze training?
PLC-programmering – Complexe timers, counters en geavanceerde Ladder-functies.
Analoge signaalverwerking – Configuratie van AI/AO en PID-regeling.
Motorsturing & veiligheid – Ster-driehoek, interlocking en noodstopcircuits.
HMI & netwerkcommunicatie – Tag-binding, alarmbeheer en PROFINET-configuratie.
Praktische case studies – Sensorintegratie en troubleshooting van industriële processen.
Deze training is ideaal voor technici en engineers die al basiskennis van PLC’s hebben en hun expertise willen verdiepen. De training bevat Engelstalig lesmateriaal en wordt gegeven door een Nederlandstalige docent.Deze opleiding is geschikt voor cursisten die de basis van PLC-programmering (bijvoorbeeld uit de opleiding PLC 1) beheersen en meer diepgang willen. Denk aan: * Technici en engineers in elektrotechniek, mechatronica of industriële automatisering * Monteurs en operators die klaar zijn voor een stap naar geavanceerdere PLC-projecten * Iedereen die industriële netwerk-, HMI- en motorregelingen op een hoger niveau wil lerenDag 1: Verfijning Ladder & Analoge Signalering
Herhaling basiselementen (timers, counters) en uitbreiding met complexe timerfuncties
Configuratie van analoge I/O (4-20 mA, 0-10 V) in TIA Portal
PID-regeling en temperatuurmeting (LM35, PT100)
Inleiding tot troubleshooting met watch tables en trace
Dag 2: Complexe Motorsturing & Veiligheid
Overzicht klassieke motorbesturing vs. PLC-sturing (start/stop, ster-driehoek, dahlander)
Vooruit-/achteruit-schakelingen met interlocking in Ladder Diagram
Veiligheidsketen: noodstop, vergrendelingsconcepten
Offline/online diagnostische tools in PLC-software
Dag 3: Praktijkopdrachten en Netwerkcommunicatie
Lab-oefeningen: sorteersysteem met sensoren, temperatuurregeling, start/stop & interlocking
Basale industriële Ethernet (PROFINET) configuratie
Basis HMI-integratie (Siemens KTP-paneel of WinCC Basic)
Presentatie van (mini)projecten, evaluatie en afronding
Programma
Geavanceerde Ladder-instructies (TON, TOF, TOR, TP, set/reset, comparators)
Analoge signaalverwerking (AI, AO, PID, scaling, I/O-configuratie in TIA Portal)
Motorsturingen (start/stop, ster-driehoek, dahlander, forward/reverse)
Interlocking en veiligheidsketen (NO/NC-logica, safety relais, vergrendelingsmechanismen)
Troubleshooting & diagnostische functies (watch tables, trend graphs, real-time debugging)
Basale netwerkconfiguratie (PROFINET, IP-adressering, online/remote toegang)
HMI-koppeling (tag-binding, runtime-simulatie, alarmbehandeling)
Praktijkopdrachten: sorteersysteem met sensoren, temperatuurregeling met PID, interlocking van ventilatoren
Documentatie en projectstructuur (libraries, symbolische adressering, versiebeheer)
Voorbereiding op:
Siemens S7-1200 Advanced Certification
Allen-Bradley Level 2 (Studio 5000)
TÜV-certificering Functionele Veiligheid (SIL2)
€1.695
Klassikaal
max 12
3 dagen
Python
Eindhoven
wo 13 aug. 2025
en 5 andere data
Wil je aan de slag met Python? Deze driedaagse training biedt een complete introductie, van basisconcepten tot geavanceerde onderwerpen zoals objectgeoriënteerd programmeren (OOP), data-analyse met pandas en database-integratie met MySQL. Je leert niet alleen de syntax en logica van Python, maar past deze direct toe in praktijkgerichte scenario’s.
Wat leer je in deze training?
Basisconcepten – Variabelen, datatypes, operatoren en controlestructuren.
Functies en foutafhandeling – Definiëren, return-waarden en error-handling met try/except.
Objectgeoriënteerd programmeren – Klassen, objecten, overerving en encapsulatie.
Data-analyse – Werken met pandas, DataFrames en datavisualisatie.
Database-integratie – SQL-queries uitvoeren met MySQL-connector.
Deze training is perfect voor beginners, developers en IT-professionals die Python willen gebruiken voor automatisering, data science of webontwikkeling.
De training bevat praktijkgerichte opdrachten en Engelstalig lesmateriaal en wordt gegeven door een Nederlandstalige docent.
Beginners zonder programmeerachtergrond.
Data-analisten die Python willen inzetten voor dataverwerking.
Developers die overstappen van andere talen (bijv. Java, C#).
IT-professionals die scripts willen schrijven voor automatisering.
Dag 1: Python Basis en Controlestructuren
Installatie van Python, Jupyter Notebook en een IDE (bijv. VSCode of PyCharm).
Basisconcepten: variabelen, datatypes (strings, integers, floats, booleans), operatoren.
Input/output: print(), input(), eenvoudig bestandslezen/schrijven.
Controlestructuren: if/elif/else, for- en while-loops.
Oefeningen: tekstmanipulatie, lijstbewerkingen en eenvoudige scripts schrijven.
Dag 2: Functies, Foutafhandeling en Introductie OOP
Functies definiëren: parameters, return-waarden en scope.
Foutafhandeling met try/except/finally.
Werken met modules: math, datetime, random.
Introductie OOP: klassen, objecten, methoden en attributen.
Dag 3: Pandas, Databases en Geavanceerde OOP
Data-analyse met pandas: DataFrames, data filteren/sorteren, basisaggregaties.
Database-integratie met MySQL-connector: verbinden, SELECT- en INSERT-queries uitvoeren.
OOP-uitbreiding: overerving, encapsulatie en polymorfisme.
Integratie: CSV-data inladen, verwerken met pandas en opslaan in een MySQL-database.
Tips voor vervolgstappen (data science, webdevelopment).
Programma
Basisconcepten:
Variabelen, datatypes (str, int, float, bool, None).
Operatoren (rekenkundig: +, -, *, /; vergelijkings-: ==, !=, >; logisch: and, or, not).
Typeconversie (int(), str(), float()).
Strings: concatenatie, formattering (f-strings), methoden (lower(), upper(), split()).
Boolean-logica en truthy/falsy-waarden.
Controlestructuren:
Conditionele statements: if/elif/else, geneste voorwaarden.
Loops: for (itereren over lijsten, strings, dictionaries), while met break/continue.
Loop-control: range(), enumerate(), list comprehensions.
Functies en modularisatie:
Functies definiëren met def, parameters (defaults, keyword arguments).
Return-waarden, lambda-functies.
Scope: globale vs. lokale variabelen (global keyword).
Foutafhandeling: try/except/else/finally, specifieke exceptions (ValueError, KeyError).
Datastructuren:
Lijsten: aanmaken, indexeren, methoden (append(), remove(), sort()), slicing.
Tuples: immutable operaties, unpacking.
Dictionaries: keys/values, methoden (get(), keys(), items()).
Sets: unieke elementen, operaties (union(), intersection()).
Modules en libraries:
Standaardmodules: math (sqrt, pow), datetime (datum/tijd-formattering), random (shuffle, choice).
Externe libraries installeren met pip (bv. pandas, mysql-connector-python).
Importeren: import, from … import … as ….
Objectgeoriënteerd programmeren (OOP):
Klassen en objecten: init-methode, instantievariabelen.
Methoden: instance methods, static methods.
Overerving: parent/child-klassen, super().
Encapsulatie: public/private attributen (conventie met _).
Polymorfisme en magic methods (bv. str).
Bestandsafhandeling:
Bestanden openen met open(), modi (r, w, a, r+).
Tekstbestanden lezen/schrijven (read(), readline(), write()).
CSV-afhandeling met pandas (read_csv(), to_csv()).
Data-analyse met pandas:
DataFrame en Series aanmaken.
Data manipulatie: filteren met loc/iloc, groupby(), agg().
Basisvisualisatie: plot() (lijn-/staafdiagrammen).
Database-integratie (MySQL):
Verbinden met mysql.connector.connect().
Cursors: execute(), fetchall(), fetchone().
SQL-operaties: SELECT, INSERT, WHERE-clausules.
Transaction management: commit(), rollback().
Praktische toepassingen:
Scripts schrijven voor bestandsautomatisering.
Data transformeren tussen CSV en databases.
Eenvoudige OOP-applicatie bouwen (bv. inventory management).
Bereidt voor op het PCAP-certificaat (Python Institute Certified Associate in Python Programming).
Basis voor vervolgcursussen zoals Data Science met Python of Python voor Webdevelopment.
Examenafname is extern mogelijk (niet inbegrepen in de cursus).
€1.695
Klassikaal
max 12
3 dagen
Python Django Ontwikkeling
Eindhoven
wo 7 mei 2025
en 9 andere data
Deze opleiding leert je full-stack webapplicaties bouwen met het Django framework. Je leert snel productieve applicaties ontwikkelen met Django’s "batteries included" filosofie, van database-modellering tot template rendering en API-ontwikkeling.
De training behandelt zowel traditionele MVC-architectuur als moderne praktijken zoals REST API’s met Django REST Framework. Speciale aandacht voor security best practices, performante query-optimalisatie en schaalbare applicatiestructuur.
Waarom Python Django?
Rapid development: Automatische admin interface
Veiligheid: Bescherming tegen OWASP top-10 risico’s
Schaalbaar: Geschikt voor high-traffic sites
Extensief ecosysteem: 4000+ packages op PyPI
Multi-purpose: Van CMS tot complexe API backends
Studiebelasting
2 lesdagen (8 uur per dag)
15-20 uur praktijkopdrachten
8 uur aanbevolen zelfstudie
Android-developers die overstappen van Java naar Kotlin.
Backend-developers die Kotlin met Spring of Ktor willen gebruiken.
Java-ontwikkelaars die moderne taalfeatures willen benutten.
Beginners die een productietaal voor meerdere platforms leren.
Dag 1: Kotlin Basis en Functionele Concepten
Installatie van IntelliJ IDEA en Kotlin-plugin configuratie.
Basis syntax: fun main(), val vs var, type inference.
Datatypes: primitief (Int, Double, Boolean), String, Any, Unit.
Controlestructuren: if als expressie, when, for/while-loops.
Functies: default parameters, named arguments, single-expression functies.
Dag 2: OOP, Null Safety en Uitbreidingen
Klassen: primary/secondary constructors, init-blokken.
Data classes: data class User(val name: String), copy(), destructuring.
Null safety: ?, !!, let/also/apply scope functions.
Uitbreidingen: extension functions (fun String.reverse()).
Objecten en companions: object Singleton, companion object.
Dag 3: Geavanceerde Features en Integration
Collecties: List, MutableList, Map, filter/map/groupBy.
Lambdas en hogere-ordefuncties: (Int) → Boolean, fold/reduce.
Coroutines: launch, async/await, suspend functies.
Ktor-basis: eenvoudige REST API bouwen met routing.
Android-integratie (optioneel): Activity, RecyclerView (basis).
Programma:
Basisconcepten:
Variabelen (val, var), type inference, string templates (${var}).
Ranges: 1..10, until, step, downTo.
Type checks en casts: is, as, as?.
Functioneel Programmeren:
Hogere-ordefuncties: functies als parameters retourneren.
Lambda-expressies: syntaxis, it-keyword.
Inline functies: inline fun voor performance-optimalisatie.
OOP en Uitbreidingen:
Overerving: open classes, override, abstracte klassen.
Interfaces: default methoden, properties.
Sealed classes: beperkte class-hiërarchieën.
Null Safety en Scope Functions:
Elvis-operator (?:), safe calls (?.).
run, let, apply, also, with voor contextbeheer.
Coroutines en Asynchroon:
Coroutine-scopes: GlobalScope, CoroutineScope.
Dispatchers: IO, Main, Default.
Job en Deferred voor concurrencybeheer.
Android/Backend Integration:
Room Database: @Entity, @Dao, basisqueries.
Ktor: routing, statuscodes, JSON-serialisatie (kotlinx.serialization).
Tools en Build Systems:
Gradle: Kotlin DSL, dependencies toevoegen.
Debugging: breakpoints, coroutine-inspectie.
Linting: detekt-configuratie voor codekwaliteit.
Voorbereiding op: * Django Software Foundation Certification * Python Institute PCPP-32-1xx
€1.195
Klassikaal
max 12
2 dagen