> For the complete documentation index, see [llms.txt](https://selmotech.gitbook.io/selmo-solution/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://selmotech.gitbook.io/selmo-solution/engineering-im-wandel-der-zeit/nc-und-g-code-die-sprache-der-bewegung.md).
# NC und G-Code – Die Sprache der Bewegung
Mit den ersten **NC-Maschinen (Numerical Control)** in den 1950er Jahren entstand der Bedarf nach einer Sprache für **Maschinenbewegungen**.
* Lösung: **G-Code** (DIN 66025, ISO), ab den 1960ern.
* Standardisierte Befehle (G00, G01, M03 …) beschreiben Bewegungen, Werkzeuge und Prozesse eindeutig.
* Aus Zeichnungen und später 3D-Modellen wird **maschinenlesbarer Code**.
👉 G-Code ist ein Erfolgsmodell: eine **formale Sprache**, die bis heute die Grundlage für CNC-Fertigung bildet.
Historischer Verlauf
* **1949–1952**: MIT entwickelt erste numerische Steuerung (US Air Force)
* **1960er**: Standardisierung → G-Code (DIN 66025)
* **1970er–80er**: CNC-Maschinen, Erweiterungen (Zyklen, Makros)
* **1990er**: CAD/CAM-Integration → automatische Generierung von G-Code
* **Heute**: G-Code globaler Standard, Basis aller CNC-Fertigung
## Numeric Control (NC) und G-Code
#### 1. Ursprung
* Erste **numerische Steuerungen (NC)** entstanden Ende der **1940er / Anfang 1950er Jahre** in den USA (MIT, finanziert von der US Air Force).
* Ziel: Werkzeugmaschinen **programmierbar** machen – statt Nocken, Schablonen oder Handbetrieb.
* Erste Steuerungen liefen mit **Lochkarten oder Lochstreifen**, die Positionsdaten enthielten.
***
#### 2. Entwicklung von G-Code
* Ab den **1960er Jahren**: Einführung einer standardisierten Sprache → **G-Code** (DIN 66025 in Deutschland).
* G-Code beschreibt:
* **Geometrie** (Bewegungen: G00 = Eilgang, G01 = Linearinterpolation, G02/G03 = Kreisbögen)
* **Technologie** (M-Befehle: Spindel ein/aus, Kühlschmierstoff, Werkzeugwechsel)
* Damit war G-Code eine **formale Sprache der Fertigung**, vergleichbar mit:
* Technischer Zeichnung (Geometrie → Zielbild)
* Schaltplan (Elektrik → Funktion)
***
#### 3. Bedeutung
* G-Code ist **universell lesbar** für jeden CNC-Techniker.
* Ein Programm ist **standardisiert** und bildet die Bearbeitung eindeutig ab.
* Vorteil: **präzise, formale Sprache** für Maschinenbewegungen.
* Nachteil: **sehr detailnah** – wenig Abstraktion, hohe Fehleranfälligkeit bei komplexen Prozessen.
***
#### 4. Vergleich zu SPS-Programmierung
* **G-Code** ist für CNC-Maschinen, was die **Technische Zeichnung** für Bauteile ist: eine **eindeutige Beschreibung von Soll-Bewegungen**.
* Im Gegensatz dazu ist SPS-Programmierung nie so **einheitlich formalisiert** worden – obwohl sie die „Logik“ beschreibt.
* Das bedeutet:
* Für Bewegungen (NC) → **formale Sprache vorhanden** (G-Code).
* Für Mechanik (Zeichnung) → **formale Sprache vorhanden**.
* Für Elektrik (Schaltplan) → **formale Sprache vorhanden**.
* Für **Logik von Maschinen** (SPS) → **keine weltweit einheitliche Sprache**.
***
### Fazit: Rolle von G-Code
* **Numeric Control / G-Code** ist eine **eindeutige, standardisierte Sprache für Maschinenbewegungen** – seit den 1960er Jahren etabliert.
* Damit hat die Mechanik (über CNC) schon früh einen „Programmieraspekt“ bekommen, der normiert war.
* **Das große Paradox:**
* Während die Logik (SPS) **flexibel, aber unklar** wurde,
* hat sich die Bewegungssteuerung (NC/G-Code) **klar und standardisiert** entwickelt.
👉 Das zeigt: Es ist **möglich**, auch für Maschinenlogik eine formale Sprache zu schaffen – so wie es G-Code für Bewegungen geschafft hat.
## Entwicklung der NC-/CNC-Programmierung (G-Code)
### 1. Die Anfänge (1950er–1960er) – **Numerical Control (NC)**
* Erste NC-Maschinen (Lochstreifen, Lochkarten) → Steuerung durch **reine Zahlenfolgen** (Koordinaten, Vorschübe).
* Alles war **direkt und formal**: Positionen, Wege, Geschwindigkeiten.
* Vorteil: Maschinenbewegungen wurden **exakt beschreibbar**.
* Nachteil: extrem **unflexibel**, mühsam zu programmieren, keine Variablen/Logik.
***
### 2. Standardisierung & G-Code (1960er–1970er)
* Einführung von **G-Code** (z. B. DIN 66025 in Deutschland).
* Klar strukturierte Befehle:
* G00 = Eilgang, G01 = Linearinterpolation, G02/G03 = Kreisbögen
* M-Codes = Maschinenfunktionen (Spindel, Kühlschmierstoff, Werkzeugwechsel)
* Maschinenbewegungen wurden **formalisiert und international standardisiert**.
* Vorteil: **Lesbar und universell verständlich** – ähnlich wie eine Zeichnung.
* Nachteil: Programmiertiefe noch sehr detailorientiert.
***
### 3. CNC und Makroprogrammierung (1980er–1990er)
* Einführung der **CNC-Steuerung** (Computerized NC).
* Erweiterungen:
* Variablen und Parameterprogrammierung
* Unterprogramme und Makros
* Zyklen (Bohren, Fräsen, Gewindeschneiden) → vordefinierte Routinen
* Vorteil: Mehr **Flexibilität und Wiederverwendbarkeit**.
* Nachteil: Programme wurden komplexer, schwerer zu überblicken.
***
### 4. CAM-Integration (2000er)
* Einführung von **CAM-Systemen** (Computer Aided Manufacturing):
* Konstruktion (CAD) → automatische Generierung von G-Code.
* Simulation und Kollisionsprüfung im Voraus.
* Vorteil: **Automatisierung** der Programmierung, hohe Effizienz.
* Nachteil: Bediener verliert das direkte Verständnis für den G-Code → **Black-Box-Effekt**.
***
### 5. Heute (2010er–2020er) – Hybride Welt
* **G-Code lebt weiter**, ist nach wie vor Standard für fast alle CNC-Maschinen.
* Gleichzeitig:
* **CAM-first**: Programme werden zu 90 % automatisch generiert.
* **High-Level-Sprachen**: Einige Hersteller (z. B. Siemens ShopMill, Heidenhain Klartext) bieten vereinfachte Programmiersprachen an.
* **Digitale Zwillinge**: Simulation ersetzt klassische Programmierung.
* Vorteil: enorme **Produktivität** und **Fehlerminimierung**.
* Nachteil:
* **Verlust der Klarheit** – G-Code wird kaum noch direkt gelesen.
* **Abhängigkeit von Softwaretools** und Herstellerdialekten.
***
## Vor- und Nachteile im Überblick
| Epoche | Vorteile | Nachteile |
| ------------------------------- | ----------------------------------------- | ---------------------------------------------------- |
| **NC (50er–60er)** | Formal, eindeutig, direkt | Sehr unflexibel, umständlich |
| **G-Code Standard (60er–70er)** | Klar, international gültig, lesbar | Detailnahe Arbeit, komplex bei großen Teilen |
| **CNC & Makros (80er–90er)** | Flexibler, strukturierter, Zyklen | Steigende Komplexität, schwerer Überblick |
| **CAM-Integration (2000er)** | Automatisiert, effizient, sicher | Black-Box, Verlust der G-Code-Kompetenz |
| **Heute (2010–2020er)** | Simulation, Automatisierung, Digital Twin | Wenig Transparenz, Abhängigkeit von CAM & Hersteller |
***
## Einordnung ins Gesamtbild
* **Mechanik:** Zeichnung → CAD → Simulation (Klarheit nahm ab, Flexibilität stieg).
* **Elektrik:** Schaltplan blieb stabil und klar.
* **Logik:** Früher im Schaltplan sichtbar → durch SPS flexibilisiert, aber intransparent.
* **Bewegungen (NC/G-Code):** Standardisierte Sprache wurde geschaffen, aber durch Automatisierung **aus dem Blick der Anwender verschwunden**.
👉 **Heute stehen wir da:**
* G-Code existiert nach wie vor als **formale Basis-Sprache**.
* Aber die meisten Programmierer arbeiten nur noch indirekt (CAM, Zyklen, Simulation).
* Damit hat auch hier die **ursprüngliche Transparenz** einem **höheren Automatisierungsgrad** Platz gemacht.
***
### Fazit
G-Code ist ein Beweis, dass **formale Programmiersprachen für Maschinen funktionieren** – er hat die Fertigung revolutioniert und über Jahrzehnte standardisiert.\
Heute ist er immer noch Fundament, wird aber im Alltag **versteckt hinter CAM-Systemen**.\
Das zeigt: **Ohne formale Basis-Sprache geht es nicht – aber ohne Modellierung und Abstraktion wird es unübersichtlich.**
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://selmotech.gitbook.io/selmo-solution/engineering-im-wandel-der-zeit/nc-und-g-code-die-sprache-der-bewegung.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.