IJS · KUKA Robot Control
An Angular research platform for Institut Jožef Stefan — a browser-based control and monitoring interface for a KUKA industrial robot arm, built over a purpose-designed REST DataProxy API.
Overview
This was not a typical client project — it was a research collaboration. Institut Jožef Stefan is Slovenia’s largest and most respected research institution, and their automation and robotics group needed a web-based interface for controlling and monitoring a KUKA industrial robot arm. I built the frontend side of that system in 2021.
The platform is called DataProxy — a REST API layer sitting between the browser and the robot controller (KUKA KRC), exposed at IJS’s internal domain over HTTPS. The Swagger-generated TypeScript client divided cleanly into four service domains: ADM (device management and sensor telemetry), PRG (robot programming), DMS (document and connection-scheme storage), and AUTH (JWT session management). I wrote the Angular 12 application on top of that surface.
The robot’s position is tracked as e6pos — KUKA’s native six-axis coordinate type (X, Y, Z, A, B, C). Programs compose into a three-tier hierarchy: Programs contain ordered Routines, which contain ordered Statements — individual KRL instructions. Researchers build sequences in the UI, then either export the raw .src/.dat files or pipe the program through KukaSim for visual simulation before live execution.
Architecture
Reading the diagram: Five UI modules (dashboard, program builder, device panel, cameras, documents) communicate exclusively through the DataProxy REST API — a JWT-authenticated middleware running on IJS infrastructure. The PRG service translates the three-tier program model (Program → Routine → Statement) into KRL and dispatches it to either KukaSim for simulation or the live KUKA KRC controller. The ADM service handles sensor telemetry and device variable readings that flow back up to the browser as ApexCharts time-series. All traffic runs over the IJS internal network via OpenVPN + HTTPS.
Six things shipped,
three hard ones solved.
Key contributions
- Built the Angular 12 frontend for IJS researchers to control and monitor a KUKA industrial robot arm.
- Integrated a Swagger-generated TypeScript client (DataProxy API) across four service domains: device administration, robot programming, document management, and authentication.
- Implemented a structured robot program builder — composing programs from reusable routines and atomic KRL statements, with direct download of
.src/.datfiles. - Wired the KukaSim simulation pipeline so researchers could preview and validate programs before sending them to the physical arm.
- Built device management views with multi-protocol support (Ethernet REST, Serial, Socket) and real-time variable monitoring via ApexCharts time-series graphs.
- Added a camera feed panel (AXIS device type) with zoom control, enabling live visual feedback during experiments.
- Integrated a notifications system with configurable threshold triggers tied to device-type variables — giving researchers alerts on abnormal sensor readings.
Challenges solved
- Bridging the gap between a web-browser UI and a robot controller that speaks its own execution model — routines, statements, executors — required a faithful TypeScript domain model.
- The platform had to work over IJS's internal VPN (OpenVPN + custom hosts entry), adding a layer of network constraint that shaped the proxy architecture.
- Designing the program builder so non-programmers (researchers, not roboticists) could compose KRL programs from reusable statement blocks without touching raw KRL syntax.
The hardest design decision was where to draw the abstraction boundary — low enough that the robot does exactly what the researcher intends, high enough that they never have to read KRL.
What's under the hood.
¿Listo para arreglar, construir
o escalar?
30 minutos, conmigo personalmente. Leo tu sistema como un archivo de logs y te digo qué haría primero. Sin presentaciones, sin embudo de ventas.
— Davor Majc, fundador, Numen