Schallberts Blog

Schallberts Blog mit Hugo

Schallbert — Sun, 06 Sep 2026 00:00:00 +0000

Was ist geschehen?

Zum fünften Geburtstag 🥳 stelle ich schallbert’s Blog auf eine neue technische Basis!

Ich habe diesen Blog von jekyll nun auf den Webseitengenerator Hugo umgezogen. Das war viel Aufwand: Über etwa vier Monate hinweg habe ich einen Großteil meiner Freizeit hineingesteckt. Dabei ging der Löwenanteil in das Erstellen und Polieren der Formatierung, Anpassung meiner Inhalte an die neue Umgebung, Reparatur defekter Links und die Dokumentation meines Umbaus.

Warum habe ich das gemacht?

Mit Jekyll stand ich immer mehr auf Kriegsfuß: Viele Abhängigkeiten mit immer häufigeren Defekten, die zunehmend lange Bauzeit und die komplexe Umgebung zum Ausrollen auf meinem Server waren die Hauptgründe.

Meine Seite baut nun etwa fünf mal so schnell wie vorher.

Sie lädt weniger Formatierung nach (CSS, JS) und die Bilder sind noch einmal platzsparender.

Außerdem habe ich weder Ruby noch zig Gems auf Stand zu halten.

Bei den Themes habe ich in Hugo Wert darauf gelegt, es nach benötigter Funktion auszuwählen und nicht nur nach gefälligem Aussehen. Somit ist es jetzt viel simpler und performanter.

Was haben die LeserInnen davon?

Der Blog bietet nun einen RSS-Feed. Außerdem sind nun auch meine Projekte in die Schlagwort-Ansicht mit eingebunden. Zu guter Letzt sind durch die Migration zahlreiche Artikel entstanden. Diese sollen einen solchen Umzug für andere leichter machen als ich es hatte, und die Strukturen in Hugo verdeutlichen.

Artikel zum Thema

Was fehlt noch?

Ich bin mit dem Umbau noch nicht ganz fertig:

Es soll möglich sein, Bilder zentriert und in nativer Auflösung anzuzeigen
Der Feed soll Coverbilder meiner Artikel korrekt anzeigen
Ich möchte in CSS einen noch einheitlicheren Look haben
Übersichtsseiten könnten die ganze Bildschirmseite einnehmen und dann größere Bilder anzeigen
Es fehlen einige englische Übersetzungen
Meine aktuellsten Projekte könnten auf der Landing Page mit angezeigt werden
Schlagworte könnten spezifischer und trennschärfer implementiert werden
Schön wäre ein mitscrollendes Inhaltsverzeichnis auf der linken Seite

Auf diesen Seiten wird es in den kommende Wochen in vielen Details noch einmal Verbesserungen geben. Ich freue mich darauf!

schallbert

Umzug von Jekyll zu Hugo

Schallbert — Sun, 06 Sep 2026 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Mittel 3/5
Kosten: 0€
Zeit ~20h

In diesem Projekt beschreibe ich meinen Umzug von Jekyll mit der Optik von Minimal Mistakes zu Hugo (Theme Terminal).

Warum überhaupt wechseln?

Schon seit langem war ich nicht mehr vollständig zufrieden mit dem Bauen meiner Website per Jekyll. Der Auslöser für den Umstieg war, dass ich eines Tages plötzlich wegen eines Kompatibilitätsproblemes nicht mehr lokal bauen konnte. Ein bundle update --conservative oder bundle install wie üblich half nicht. Auch das manuelle Nachinstallieren der verursachenden Pakete per gem install commonmarker-0.23.12 oder gem install posix-spawn -v 0.3.15 -- --with-cflags=\"-Wno-incompatible-function-pointer-types\" brachten keine Abhilfe.

Ein Update von Ruby und Jekyll selbst brachte ebenfalls keinen Erfolg. Und überhaupt: Die Bauzeit mit Jekyll ist inzwischen ziemlich lang geworden. Ich bin durch meinen Umzug der Seite von Github Pages auf einen eigenen Server nicht mehr an Jekyll gebunden, was einen Wechsel attraktiver macht.

Weitere Schwierigkeiten mit Jekyll

CI/CD: Meine Deploy-Pipeline war vor Monaten mit ähnlichen Fehlern ausgefallen, sodass ich auf eine ältere Jekyll-Version zurückgreifen musste. Damit vergrößert sich technische Schuld und Angriffsfläche meiner Actions. Ich müsste auf die Suche nach einer gut gewarteten Containerlösung eines anderen Anbieters wechseln. Suche und Einrichtung würden zusätzliche Zeit erfordern.
RSS-Feed: Ich möchte zu meiner Website gern einen RSS-Feed bereitstellen. Meine Experimente mit Jekyll zeigten jedoch, dass nur “Posts” und keine “Announcements” inkludiert werden. Das wollte ich beheben.
Bildformate: Cover-Bilder (Thumbnails) für Posts werden im RSS-Feed durch Jekyll eigentlich mit gebaut. Durch meinen Umstieg von .jpg auf das platzsparendere .avif funktionierte das nun leider nicht mehr. Eine Lösung habe ich trotz mehrerer Anläufe nicht durch den Pull Request Review bekommen.
Icons: Das von mir verwendete Theme nutzt Font Awesome zur Darstellung von Icons und ist insgesamt für eine statische Website recht groß. Ich wollte aber nichts aus dem Netz nachladen und habe die Bibliothek daher lokal gespeichert. Daher war mein Plan, nur die wirklich benötigten Icons heraussuchen und den Rest zu löschen. Mit dem Umstieg auf Hugo ist dies nicht mehr notwendig.

Die Chancen

Von Hugo verspreche ich mir schnellere Bauzeiten, eine vereinfachte CI/CD ohne Nachinstallieren von Bundler, Ruby etc. und die Behebung der oben beschriebenen Schwierigkeiten. Das Abhängigkeits- und Paketmanagement von Hugo unterscheidet sich grundlegend von Jekyll: Zusätzliche Inhalte werden per Git Submodules eingebunden und das Abhängigkeismanagement nutzt statt der Gemfile schlicht Go modules.

Das Migrationswerkzeug

Die Ordnerstrukturen der Inhalte unterscheidet sich deutlich zwischen Jekyll und Hugo. Ich nutze daher ein in Hugo enthaltenes Importwerkzeug, welches mir zumindest die Artikel unter /posts korrekt importiert.

Alle spezifischen Inhalte wie Übersichtsseiten /tags, /pages/error, /pages/legal und Seiten, wo Projekte und Ankündigungen abgelegt sind /_announcements, /_projects, werden allerdings nicht mit umgezogen und müssen manuell kopiert und modifiziert werden.

Anpassen der Front Matter

Viele von mir gemachten Anpassungen in Jekyll funktionieren in Hugo entweder nicht richtig oder führen zum Abbruch des Bauvorganges - die Front Matter einer jeden Markdown-Datei muss also angepasst und teils bereinigt werden.

---
# Alt: So kann die Front matter einer Übersichtsseite in Jekyll aussehen
lang: de
title: Beitragsarchiv
subtitle: Diese Sammlung enthält alle meine Beiträge
layout: collection
collection: posts
permalink: /posts-archive/
entries_layout: grid
classes: wide
author_profile: false
---

In meinem Falle liegen einige Theme-abhänigen Parameter im Frontmatter vor wie layout, classes, author_profile. Der lang-Parameter aus meiner Internationalisierungserweiterung in Jekyll ist nicht einmal korrekte Hugo-Syntax: es erwartet die angezeigte Sprache entweder als Feld unter params: lang oder Ordnerweit. Auch andere, an den eigenen Geschmack angepasste Parameter können definiert und unter params mitgegeben werden.

Permalinks finden gar keinen Eingang mehr in die Front matter, stattdessen findet die Konfiguration zentral statt.

Eine Hugo-kompatible front matter kann so aussehen:

---
title: Beitragsarchiv
description: Diese Sammlung enthält alle meine Beiträge
layout: collection
---

Konfiguration des Theme

Eine Basis-Konfiguration meines Themes kann ich mit folgendem Kommando installieren:

➜ blog git:(main) ✗ git submodule add https://github.com/panr/hugo-theme-terminal ./themes/terminal

Zum Aktivieren muss ich es in der Hauptkonfiguration bekannt machen:

# /hugo.toml

# Add it only if you keep the theme in the `themes` directory.
# Remove it if you use the theme as a remote Hugo Module.
theme = "terminal"

Und schon baut Hugo für mich im Terminal-Theme und Originalfarben.

Dies ist nun nicht vertikal zentriert und für meinen Geschmack zu schmal ausgelegt, der Text recht klein und “meine” Blog-Farben sollen ebenfalls anders sein .

Daher erstelle ich eine .css-Datei, die einige Eigenschaften des Basis-Themes überschreibt. Sie muss im Ordner /static liegen und den Namen des Themes tragen.

/* /static/terminal.css */

:root{
 --background: #252a34;
 --foreground: #d2eaef;
 --foreground-dimmed: #8b9ea2;
 --accent: #25a679;
 --accent-highlight: #79ae9c;
 --radius: 8px;
 --font-size: 1.35rem;
 --line-height: 1.8em;
}

/* Use system fonts, reduce transferred kB */
body{
 font-family: system-ui, -apple-system, "Segoe UI", Roboto, Arial, sans-serif !important; 
}

/* make content wider */
body .container{
 max-width: 70rem;
 width: 90%;
}

Und schon sieht es fast wie früher aus.

Organisation der Ordnerstruktur

Anders als bei der von mir verwendeten Jekyll-Version verfügt hugo über eingebaute Internationalisierung (i18n). Dafür muss ich meine Ordnerstruktur umbauen und explizit in /de und /en-Ordnerinhalte sortieren. Inhalte werden nun statt auf der höheren Ordner-Ebene direkt unter /_pages, /_announcements, /_posts im Ordner content gehalten, was die Sache übersichtlicher macht.

Vorher

.
├── _announcements
├── assets
│   ├── audio
│   ├── css
│   │   ├── fontawesome
│   │   ├── katex
│   │   ├── main.scss # <-- theme import, customization
│   │   └── webfonts
│   ├── docs
│   ├── images
│   ├── js
│   │   ├── lunr
│   │   ├── _main.js
│   │   ├── main.min.js
│   │   ├── plugins
│   │   └── vendor
│   └── video
├── banner.js
├── CNAME
├── _config.yml
├── _data
│   ├── de
│   │   ├── l10n.yml
│   │   ├── navigation.yml
│   │   └── ui-text.yml
│   └── en
│   ├── l10n.yml
│   ├── navigation.yml
│   └── ui-text.yml
├── en
│   └── index.html
├── Gemfile
├── Gemfile.lock
├── _includes # <-- Layouts (HTML), partials, 3rd-party
├── index.html # <-- Landing page
├── _layouts # <-- Page layouts
│   ├── archive.html
│   ├── archive-taxonomy.html
│   ├── categories.html
│   ├── category.html
│   ├── collection.html
│   ├── compress.html
│   ├── default.html
│   ├── home.html
│   ├── posts.html
│   ├── search.html
│   ├── single.html
│   ├── splash.html
│   ├── tag.html
│   └── tags.html
├── LICENSE
├── package.json
├── package-lock.json
├── _pages
│   ├── 404.md # <-- German version
│   ├── [...]
│   ├── en
│   │   ├── 404.md # <-- English version
│   │   ├── [...]
├── _posts/
│   └── en 
├── _projects/
├── Rakefile
├── README.md
├── _sass
│   ├── minimal-mistakes # <-- Styles (SCSS) for layouts and partials
│   ├── minimal-mistakes.scss
│   └── _video.scss
├── _site/ # <-- Build artifacts
├── staticman.yml
└── tags
 ├── en
 │   └── tags.md
 └── tags.md

Nachher

.
├── archetypes
├── assets
│   └── scss
│   └── landing.scss # <-- custom styling for my landing page
├── content
│   ├── de
│   │   ├── about.md
│   │   ├── announcements/
│   │   ├── posts/
│   │   └── projects/
│   └── en
│   ├── about.md
│   ├── posts/
│   └── projects/
├── data
├── hugo.toml
├── layouts
│   ├── _default
│   │   ├── baseof.html # <-- defines header, add-ons, content, footer structure
│   │   ├── index.html # <-- landing page
│   │   ├── list.html # <-- grid view
│   │   └── single.html # <-- post view
│   ├── _markup
│   │   └── render-link.html # <-- link highlighting and function (referrer, tabs)
│   ├── _partials
│   │   ├── cover.html # <-- cover (thumbnail) image rendering
│   │   └── math.html # <-- math rendering (katex)
│   └── _shortcodes
│   ├── audio.html
│   ├── image.html
│   └── video.html
├── resources
│   └── _gen
│   └── assets/
├── static
│   ├── assets
│   │   ├── audio/
│   │   ├── css/ # <-- contains overrides for custom layouts 
│   │   ├── docs/
│   │   ├── images/
│   │   ├── js/ # <-- math (katex) JS lives here
│   │   └── video/
│   └── terminal.css # <-- Central theme override (colors, formatting, styling)
└── themes
 └── terminal # <-- GIT submodule: Vanilla "Terminal" theme

Bei beiden Lösungen werden Layouts in html und Stil/Format ind CSS definiert. Da ich bei Jekyll mehr Plugins verwenden musste, wird das Setup größer.

Manuelle Anpassungen: Shortcodes

Mit Shortcodes kann man in Hugo nicht-Text-Inhalte (Medien, Links, Formatierung, Stil) definieren, die dann nach definierter Vorschrift gerendert werden. Dafür legt man eine html-Datei an, welche den Dekorator definiert und entsprechende css-Klassen einbindet. Außerdem fügt man die gewünschte Formatierung in der überschreibenden Theme-css-Datei ein.

Da ich hier absolut kein Profi bin, probiere ich anschließend so lange herum, bis mir das Layouting gefällt und ich keine Artefakte/Überlagerungen mehr sehe.

.
├── layouts
│   └── _shortcodes
│   └── my-shortcode.html # <-- Custom shortcode file
├── static
│   └── terminal.css # <-- Central theme override (colors, formatting, styling)

Hugo

Shortcodes werden in der Markdown-Datei mit folgender Syntax angezeigt:

{{< shortcode-html-filename options >}}
{{< image src="/path/to/image.avif" alt="Image: alt text" position="right" >}}

Jekyll

Im Vergleich dazu sehen Shortcode-ähnliche Dekoratoren in Jekyll für Liquid, die in Jekyll benutzte Beschreibungssprache so aus:

### Liquid in interpreter code
{% Liquid bracket syntax %}
### Liquid "shortcode" pendant
{% include gallery id="gallery" caption="Eindrücke von **MobFobAmp**. Zum Vergrößern anklicken." %}
### Liquid decorator for layouting
{:.list-inline}

image

Anwendungsbeispiel zur Bildanzeige. In der nächsten Zeile folgt ein zentriertes Bild.

Der klassische Bild-Dekorator für Markdown [Alt Text](/path/to/image) wird in Hugo standardmäßig als mittig zentriertes Bild ohne Textfluss gerendert. Für ein schönes Layouting benötige ich jedoch ein paar Varianten, welche etwas zusätzlichen Code in cascading style sheets und html erfordern.

Bild zentriert, ohne Textfluss
Bild links , Textfluss rechts
Bild rechts, Textfluss links

Zuerst besorgt sich Hugo Dateipfad und Bildtext. Anschließend liest es die gewünschte Formatierung aus der Markdown-Datei, welche mit der position-Variable angelegt wird. Anschließend wendet sie die image-wrapper Klasse aus der .css-Datei darauf an. Die Ausrichtung der Bilder gilt für bessere Lesbarkeit nur für die Desktop-Variante der Webseite (>768px).

{{- /* /layouts/_shortcodes/image.html */ -}}

{{ $src := .Get "src" }}
{{ $alt := .Get "alt" | default "" }}
{{ $position := .Get "position" | default "center" }}

<div class="image-wrapper {{ $position }}" >
 <img src="{{ $src }}" alt="{{ $alt }}" />
</div>

/* /static/terminal.css */

.image-wrapper.center img,
.image-wrapper.left img,
.image-wrapper.right img{
 max-width: 100%;
 border: 4px solid var(--accent);
 display: block;
 margin-left: auto;
 margin-right: auto;
}

@media (min-width: 768px){
 .image-wrapper.left img{
 float: left;
 margin-right: 1rem;
 max-width: 50%;
 }

 .image-wrapper.right img{
 float: right;
 margin-left: 1rem;
 max-width: 50%;
 }
}

audio

Zur Darstellung des Audio-Players verwende ich die im Browser implementierten Standards.

Your browser does not support the audio element.

Beispielplayer: Melodie auf dem E-Bass

{{- /* /layouts/_shortcodes/audio.html */ -}}

{{ $src := .Get "src" }}
{{ $caption := .Get "caption" | default "" }}

<div class="media-wrapper">
 <div class="media-container">
 <audio controls>
 <source src="{{ $src }}" type="audio/mp3">
 Your browser does not support the audio element.
 </audio>
 {{ with $caption }}
 <div class="media-title">{{ . }}</div>
 {{ end }}
 </div>
</div>

In css verwende ich einen Wrapper und Media-Container, um Titel im Rahmen des Players anzeigen zu können und die Formatierung zu erleichtern. Auch hier habe ich angepasstes Verhalten für ein “responsive layout” bei Mobilgeräten oder Änderungen der Größe des Browser-Fensters.

/* /static/terminal.css */

.media-wrapper{
 width: 100%;
 max-width: 100%;
 margin: var(--line-height) 0;
 display: flex;
 justify-content: center;
}

.media-container{
 width: 100%;
 max-width: 768px;
 display: block;
 border: 4px solid var(--accent);
 background-color: var(--accent);
 border-radius: var(--radius);
 overflow: hidden;
 text-align: center;
}

.media-container audio,
.media-container video{
 width: 100%;
 display: block;
}

.media-container iframe{
 width: 100%;
 min-height: 400px;
 aspect-ratio: 16/9;
 display: block;
}

.media-title{
 word-break: break-word;
 hyphens: auto;
 color: var(--background);
 font-weight: bold;
}

video

Das CSS ist identisch mit audio. Es gibt nur im html geringfügige Unterschiede. Der von mir verwendete Container unterstützt unter src= als Quellen sowohl “embed-Links” von Webseiten wie peertube als auch lokale Quelldateien.

Your browser does not support the video tag.

Video-Beispiel (lokal): Linearführungen mit Kugelumlauf

{{- /* /layouts/_shortcodes/video.html */ -}}

{{- $src := .Get "src" -}}
{{- $title := .Get "title" | default "" -}}
{{- $caption := .Get "caption" | default "" -}}

<div class="media-wrapper">
 <div class="media-container">
 {{- if hasPrefix $src "http" -}}
 <iframe src="{{ $src }}" frameborder="0" allowfullscreen></iframe>
 {{- else -}}
 <video controls>
 <source src="{{ $src }}" type="video/mp4">
 Your browser does not support the video tag.
 </video>
 {{- end -}}

 {{- if or $title $caption -}}
 <div class="media-title">
 {{- if $title -}}{{ $title }}{{- else -}}{{ $caption }}{{- end -}}
 </div>
 {{- end -}}
 </div>
</div>

links

Folgendes Verhalten wünsche ich mir für Links auf meinem Blog:

interne Links sollen im selben Tab geöffnet werden und die Nutzer weiterleiten.
interne Links sollen zu Seiten in derselben Sprache verweisen und nicht auf die Standard-Sprache oder zurück zur Hauptseite führen.
externe Links sollen mit einem Symbol gekennzeichnet werden: ↗
externe Links sollen in einem frischen Tab geöffnet werden: target="_blank"
exterme Links sollen weder auf die ursprünglichen Inhalte zugreifen noch den Quellverweis sehen können rel="noopener noreferrer"

Dafür erstelle ich unter /layouts/_markup die Datei render-link.html. Den Code hierfür und seine Hintergründe stelle ich in einem separaten Post vor: Hugo Multi-language: Interne Permalinks

Der Override für CSS sieht wie folgt aus.

/* /static/terminal.css */

.external-link .external-link-icon{
 display: inline-block;
 font-size: var(--font-size);
 vertical-align: middle;
 transform: translateY(-0.1em);
}

Manuelle Anpassungen: Partials

Partials kann man sich vorstellen wie die Layout-Bausteine für eine Hugo-Website. Sie werden unter /layouts/_partials abgelegt und überschreiben die Standards des verwendeten Themes. Dabei wird die Ursprungsdatei gar nicht mehr geladen, was ein Herüberkopieren der Originaldatei in den Ordner mit anschließender manueller Anpassung empfehlenswert macht.

index

Die Startseite für den Blog ist komplett selbt geschrieben und liegt nicht in Markdown, sondern in html vor. Sie zeigt ihre Inhalte anders an als alle anderen Blog-Seiten und daher lohnte es sich für mich nicht, Templates zu programmieren. In der entsprechenden /layouts/_partials/index.html lade ich dafür notwendige scss und css-Dateien und gebe die Struktur der Seite vor. Die folgende Tabelle gibt einen Überblick über meine Änderungen.

File	Purpose	Customization
cover	thumbnail / cover image for overview pages, lists, and grids	Add custom cover image decorator, alt text
head	Defines Favicon, search console, page parameters, feeds etc.	Custom favicon path
header	Page header containing menu, logo, navigation etc.	Add logo and subtitle to menu, lang selector
logo	Custom page logo, title, subtitle	Full
math	Displays math content with Latex/Katex	None, implement math support

math

Mein Blog soll mathematische Notation unterstützen. Dafür benutze ich Katex

{{- /* /layouts/_partials/math.html */ -}}

<link rel="stylesheet" href="/assets/css/katex.min.css">
<script defer src="/assets/js/katex.min.js"></script>
<script defer src="/assets/js/contrib/auto-render.min.js" onload="renderMathInElement(document.body);"></script>

<script>
 document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(document.body, {
 delimiters: [
 {left: '\\[', right: '\\]', display: true}, // block
 {left: '$$', right: '$$', display: true}, // block
 {left: '\\(', right: '\\)', display: false}, // inline
 ],
 throwOnError : false
 });
 });
</script>

cover image

Unter der Bezeichnung cover verstehe ich ein Titelbild eines Blog-Posts. Es wird in Übersichtsseiten, Artikel- und Tag-Listen etc. angezeigt und soll die Inhalte des Blog-posts unterstützend beschreiben. Auch mein RSS-Feed soll diese Bilder für die Übersicht verschiedener Artikel auf Endgeräten meiner Leserschaft verwenden.

Es ist besonders stark komprimiert und benötigt wenig Übertragungsbandbreite. Daher ist seine Auflösung gering (440x220 oder 640x352). Für einen einheitlichen Look sind sie zudem stets monochrom.

Die Markdown-Syntax zum Einbinden des Covers sehe ich wie folgt vor:

---
cover_alt: 'Image: Hugo console build output. It shows a full build time below 2sec. (~90% reduction over build time with Jekyll)'
cover: /assets/images/migrating-hugo-to-jekyll/hugo-jekyll-build-compare-cover.avif
---

Anschließend erstelle ich unter layouts/_partials die Datei cover.html und schreibe folgenden Code hinein:

{{- /* /layouts/_partials/cover.html */ -}}

{{- /* Handles cover-image generation */ -}}

{{- $cover := false -}}
{{- $autoCover := default $.Site.Params.autoCover false }}

{{- if index .Params "cover" -}}
 {{- if .Resources.GetMatch .Params.Cover }}
 {{- $cover = (.Resources.GetMatch .Params.Cover).RelPermalink -}}
 {{- else -}}
 {{- $cover = absURL .Params.Cover -}}
 {{- end -}}
{{- else if $.Site.Params.AutoCover -}}
 {{- if (not .Params.Cover) -}}
 {{- if .Resources.GetMatch "cover.*" -}}
 {{- $cover = (.Resources.GetMatch "cover.*").RelPermalink -}}
 {{- end -}}
 {{- end -}}
{{- end -}}

{{if $cover -}}
 <!-- Cover image found -->
 <img src="{{ $cover }}"
 class="post-cover"
 alt="{{ .Params.cover_alt | plainify | default (.Description| plainify) }}"
 title="{{ .Params.CoverCredit |plainify|default (.Title | plainify) }}" />
{{- end }}

Der Code sucht und extrahiert den Pfad zum Coverbild. Sollte ein valider Pfad gefunden werden, wird es als post-cover mit entsprechendem CSS angezeigt.

Manuelle Anpassungen: Layouts

Damit sich meine Seite in Hugo weiterhin ganz ähnlich anfüllt wie zuvor in Jekyll muss ich in den Layouts ein paar Änderungen vornehmen. Im Folgenden habe ich sie beschrieben.

baseof.html

Hier werden die Basis-Inhalte definiert. Definitionen für Kopf- und Fußzeile werden importiert und Stylesheets eingebunden. Die allermeisten oben beschriebenen Änderungen werden an dieser Stelle importiert.

{{- /* /layouts/baseof.html */ -}}

<!DOCTYPE html>
<html lang="{{ $.Site.Language }}">
<head>
 {{ if .Param "math" }}
 {{ partialCached "math.html" . }}
 {{ end }}
 {{ block "title" . }}
 <title>{{ if .IsHome }}{{ $.Site.Title }}{{ else }}{{ .Title }} :: {{ $.Site.Title }}{{ end }}</title>
 {{ end }}
 {{ partial "head.html" . }}
 <link rel="stylesheet" href="{{ "/assets/css/gallery.css" | relURL }}"> 
 <link rel="stylesheet" href="{{ "/assets/css/media.css" | relURL }}">
</head>
<body>
{{ $container := cond ($.Site.Params.FullWidthTheme | default false) "container full" (cond ($.Site.Params.CenterTheme | default false) "container center" "container") }}

<div class="{{- $container -}}{{- cond ($.Site.Params.oneHeadingSize | default false) " headings--one-size" "" }}">

 {{ partial "header.html" . }}

 <div class="content">
 {{ block "main" . }}
 {{ end }}
 </div>

 {{ block "footer" . }}
 {{ partial "footer.html" . }}
 {{ end }}
</div>

</body>
</html>

list.html

Für Übersichtsseiten wie Artikel, Tags, Projekte benötige ich eine Listenansicht. Dabei möchte ich je vier Artikel in einer Zeile anzeigen. Jeder Artikel bekommt ein eigenes “Kärtchen” mit Titelbild (cover), Titel, Kurzbeschreibung und - falls Verfügbar - weiteren Details wie Lesezeit. Hugos paginator crawlt den entsprechenden Ordner und stellt die Inhalte zusammen, wärend mein Stylesheet list.css Formatierung und Anzeige übernimmt.

{{- /* /layouts/_default/list.html */ -}}

{{ define "main" }}
 <link rel="stylesheet" href="{{ "/assets/css/list.css" | relURL }}">
 {{ with .Content }}
 <div class="index-content">
 {{ . }}
 </div>
 {{ end }}

 <div class="posts posts-grid">
 {{ range .Paginator.Pages }}
 <article class="post on-list">
 <a href="{{ .Permalink }}" class="post-card" aria-label="{{ .Title }}">
 {{ partial "cover.html" . }}

 <div class="post-card-body">
 <h4 class="post-title">
 {{ .Title | markdownify }}
 </h4>

 <div class="post-excerpt">
 {{ if .Description }}
 <p>{{ .Description }}</p>
 {{ end }}
 </div>

 {{- if and (.Param "readingTime") (eq (.Param "readingTime") true) -}}
 <div class="post-reading-time">
 {{ .ReadingTime }} {{ $.Site.Params.minuteReadingTime | default "min read" }}
 </div>
 {{- end -}}
 </div>
 </a>
 </article>
 {{ end }}

 {{ partial "pagination.html" . }}
 </div>
{{ end }}

single.html

Meine single,html ist fast identisch mit der Standardimplementierung von terminal. Ich habe lediglich die Möglichkeit hinzugefügt, ein zum Titel gehöriges “banner-image” zu haben, und importiere die _partial/cover.html-Vorschrift zum Laden eines Coverbildes.

<article class="post">
 {{ with .Params.banner }}
 <img
 src="{{ . }}"
 class="post-banner"
 alt="{{ $.Params.banner_alt | plainify | default ' ' }}"
 />
 {{ end }}

Bei all den Änderungen könnte man überlegen, ein eigenes Theme zu forken… 🤔

Direkter Vergleich

Dann schauen wir uns jetzt mal an, wie meine Seite mit Jekyll gegenüber Hugo lädt. Hierfür öffne ich die Entwickleroptionen (F12) in meinem Browser, wähle das Network-Tab an und klicke dort auf All. Anschließend lade ich die Seite neu.

Dabei entsteht die folgende Auflistung:

Zu erwähnen ist, dass ich hier eigentlich gar nicht Jekyll mit Hugo vergleiche, sondern lediglich deren Ausgabe und daher die gewählten Themes maßgeblich für Größe und Ladezeit verantwortlich sind. Also vergleiche ich praktisch das minimalmistakes theme in Jekyll mit dem terminal theme in Hugo.

Größe

Ein anderes Diagramm erhalte ich, wenn ich ganz unten links auf die Stoppuhr klicke und damit eine performance analysis ausführe.

Die folgende Tabelle zeigt ein paar meiner Seiten im direkten Vergleich. Allerdings ist die Übersicht mit Vorsicht zu genießen: Die Werte ändern sich schon mal, wenn ich neu lade (auch mit ausgeschaltetem Cache). Gerade bei eingebundenen Inhalten Dritter wie meinen Videos kommen hier teils stark unterschiedliche Werte heraus.

Item	minimal-mistakes	terminal-schallbert		Jekyll	Hugo
	transferred	[kB]	Diff [%]	time	[ms]	Diff [%]
Landing	163.47	98.68	-39	30	30	0
Post	2861	1767	-38	340	270	-20
List page	1507	140	-90	30	30	0

Insgesamt habe ich mit Hugo und Terminal deutliche Optimierungen vorliegen.

Manuell implementiert in Hugo hatte ich das bedingte Laden von Katex (90kB min.css), Größenbeschränkungen für Medien-Vorschaudateien und insgesamt weniger CSS.
Automatisch in Hugo sind Medien-Vorschaudateien von den hochauflösenden Dateien abgeleitet und per Bildprozessor auf die Darstellungsverhältnisse im gebauten Zustand platzoptimiert. Diese Optimierung spart bei vielen, klein dargestellten Bildern eine Menge Bandbreite.
Das Terminal-Theme zeigt anders als minimalmistakes keine Kärtchen für “weitere Posts” an. Dies spart erneut die Übertragung von vier Vorschaubildern. Der Javascript-Inhalt geht außerdem gegen null - eines der Ziele, das ich mir gesteckt hatte.

Komplexität

Ganz klar: Hugo ist hier im Vergleich zu Jekyll unschlagbar.

Da Themes in Hugo steckbare Module sind, benötigen sie keinen Abhängigkeitsbaum in Form von Gems wie bei Jekyll zum Nachladen und installieren. Entsprechend kann hier viel weniger kaputt gehen. Für mich verringert sich die Bauzeit für einen “full build” (zweisprachig) um 75% und auch das automatische Bauen bei Veränderung meiner Markdown-Dateien ist sowohl 80% schneller als auch aussagekräftiger: Wenn ich in Jekyll nämlich “incremental build” einschalte, dann gibt es keine aktualisieren Paginator-Seiten mehr - sprich Listenansichten und Übersichtsseiten werden nicht mit gebaut.

Auf der anderen Seite kann ich in Jekyll sehr flexibel und feingranular selbst eingreifen, eigene Gems entwerfen und recht einfach besondere Gimmicks für meine Seite herstellen wie ein mitscrollendes Inhaltsverzeichnis. Jenes vermisse ich in Hugo etwas.

Für die tagtägliche Benutzbarkeit gefällt mir Hugo ganz klar besser als Jekyll.

Auslieferung/Continuous Deployment

Für Jekyll gestaltete sich Bauen und Ausliefern in Gitea etwas hakelig: erst mit einem Jekyll-Dockerimage war ich in der Lage, ruby richtig aufzusetzen. Damit und weil ich meinen Actions nicht erlaube zu cachen dauert das Bauen ziemlich lang: Erst den aktuellen Docker-Container ziehen, ruby und jekyll updaten, gems installieren, die Quelldateien auschecken, anschließend bauen und ausliefern - hier vergehen gerne einmal 90 Sekunden, bis ein neuer Artikel live ist.

Für Hugo muss ich mal schauen, ob ich am Ende nicht doch einen eigenen Post mache…

htmltest-Konfiguration für Hugo

Schallbert — Mon, 10 Aug 2026 00:00:00 +0000

Nun bin ich mit dem Umzug meiner Website zu Hugo fast fertig. Ich musste mehrere Anpassungen in der Frontmatter jedes Artikel vornehmen, damit sie in Hugo ähnliche Funktionen aufweisen wie zuvor mit Jekyll. Es ergaben sich einige Änderungen in der Ordnerstruktur teils durch die Migration, teils auch durch meine Erfahrungen als Autor, sodass auf dem Weg einige Links in praktisch jedem meiner Artikel zu überarbeiten waren. Inzwischen habe ich fast 340 davon, wenn man die Übersetzungen mitzählt.

Der schieren Masse der Links komme ich ohne weitere Hilfsmittel nicht bei. Also benötige ich Werkzeug.

htmltest

Htmltest ist ein Hilfsprogramm, das HTML-Dateien nach Problemen durchsuchen kann. Unter anderem spürt es defekte Links auf. Ich installiere es per

# Red Hat-based Linux package manager install command
sudo dnf install htmltest

und wende es auf die von Hugo “gebauten” HTMl-Dateien im /public-Verzeichnis an:

htmltest public/
# [...]
✘✘✘ failed in 2.890119823s
2612 errors in 337 documents

Das sind aber ganz schön viele Fehler! Die Darreichungsform erscheint mir außerdem ziemlich unübersichtlich, siehe Bild.

Ausgabe in Datei umleiten

Folglich tue ich mich erstmal ziemlich schwer mit diesem Werkzeug. Ich hatte angenommen, dass mir ein paar Links kaputtgegangen sind und nicht mit tausenden Fehlern gerechnet. Also fiel ich dem typischen not-invented-here Syndrom anheim und programmierte selbst ein Werkzeug in python, welches sich im Nachhinein als nicht gut genug entpuppte. Kurzgesagt:

Htmltest ist ein tolles und unglaublich schnelles Werkzeug. Wenn man dessen Ausgabe leserlich macht und richtig deutet, kann man damit ziemlich glücklich werden. Mit ein bisschen Herumprobieren gelange ich zu folgendem Befehl:

htmltest public/ 2>&1 | ansi2html > htmltest-output.html

Bedeutung: “Führe htmltest im /public/-Ordner aus. Leite Fehler aus stderr in die Ausgabe stdout um. Reiche die Ausgabe an ansi2html¹ weiter. Schreibe dessen Ausgabe in eine Datei namens htmltest-output.html.

Das sieht doch so schon viel besser aus!

Fehlerkategorien

Die mit htmltest gefundene Fehler lassen sich für meine Zwecke in ein paar wenige Kategorien sortieren:

Hugo-intern bedingte Fehler wie durch livereload.js verursachte target does not exist-Meldungen.
Unvollständige Links, die zwar in der Praxis funktionieren, aber href lacks trailing slash-Fehler erzeugen. Diese Art Fehler machen bei mir den Löwenanteil der berichteten Probleme aus.
Lookup-Fehler GET <src> [...] failure in name resolution, bei fehlender Verbindung, unzureichenden Rechten, aktiver Bot-Abwehr oder wenn der Zielserver offline ist
Harte, durch defekte Links erzeugte target does not exist-Fehler. Genau diese wollte ich eigentlich beheben.

Das Log bereinigen

Wie bekomme ich nun nur noch Fehler der vierten Kategorie angezeigt? Durch ein paar Änderungen in den Werkeugen und die Beseitigung der Trailing-Slash-Fehler.

Fehler der Kategorie 1, die durch Hugos nützliche livereload-Funktion hervorgerufen werden, sehen so aus:

 target does not exist --- en/tags/tools/index.html --> /livereload.js?mindelay=10&v=2&port=1313&path=livereload

LiveReload ist diejenige Funktion, die mir ständiges F5-Tippen im Browserfenster erspart, wenn Hugo eine meiner Änderungen nach dem Speichern der Markdown-Datei baut. Für den Test kann ich es jedoch kurz deaktivieren. Die folgende Lösung reduziert die Anzahl erzeugter Fehler um eins pro html-Seite.

hugo server --disableLiveReload

Lookup-Fehler der Kategorie 3 vermeide ich durch einen Fokus auf interne Links worüber ich die vollständige Kontrolle habe. Hierbei hilft mir der Parameter -s, --skip-external in htmltest:

htmltest -s public/ 2>&1 | ansi2html > htmltest-output.html
# [...]
✘✘✘ failed in 494.7678ms
446 errors in 337 documents

Tote externe Links kann ich zu einem späteren Zeitpunkt beheben; nun will ich erstmal die durch die Migration entstandenen Probleme lösen.

“Missing trailing slash”: Fehlerbehebung per Markup

Mit den vielen href lacks trailing slash-Fehlern tue ich mich lange zeit schwer, müsste ich doch an fast jeden Markdown-Link in jedem Artikel ein / anfügen. Zum Glück finde ich eine Lösung in meinem Markup render-link.html:

{{- /* /layouts/_markup/render-link.html */ -}}

{{- $url := .Destination | safeURL -}}
{{- $is_external := or (strings.HasPrefix $url "http://") (strings.HasPrefix $url "https://") -}}
{{- $is_anchor := strings.HasPrefix $url "#" -}}
{{- $is_asset := strings.HasPrefix $url "/assets/" -}}

[...]

{{- /* Add / to internal paths that have no file extension */ -}}
{{- if and (not $is_external) (not $is_anchor) (not $is_asset) -}}
 {{- $parsed := urls.Parse $url -}}
 {{- if and $parsed (not (strings.HasSuffix $parsed.Path "/")) (eq (path.Ext $parsed.Path) "") -}}
 {{- $url = printf "%s/" $url -}}
 {{- end -}}
{{- end -}}

[...]

Bedeutung: Interne Links, die weder auf Überschriften is_anchor noch Mediendateien is_asset verweisen, bekommen genau dann ein / angehangen, wenn sie eine korrekte Syntax aufweisen parsed und noch keinen Slash am Ende der URL vorweisen können.

Dies löst 95% der Fehlermeldungen durch weniger hässliches html. Die restlichen 5% hole ich mir durch Anhängen von ein paar Slashes in der Hugo-Konfiguration. Beispiele:

# hugo.yml
url: "/en/" # /en -> /en/ 
logoHomeLink: "/en/" # /en -> /en/

Fertig! Übrig bleiben nur noch harte, interne Fehler.

htmltest -s public/ 2>&1 | ansi2html > htmltest-output.html
# [...]
✘✘✘ failed in 359.28ms
102 errors in 84 documents

Manuelles Suchen und Beheben

Was nun folgt ist reine Fleißarbeit. Ich öffne das Zieldokument (also jenes, auf welches per Link verwiesen wird) und schaue mir an, ob zum Beispiel Überschriftenlinks zwischen verschiedenen Sprachen uneinheitlich sind. Falls ja, füge ich individuelle Anchor-Links an die Überschrift an.

### Überschrift {#heading3}

Falls in der Zieldatei alles paletti ist, öffne ich zusätzlich alle Quelldateien, die den defekten Link verwenden. Dort korrigiere ich den Link manuell. In den meisten Fällen befindet sich die Zieldatei inzwischen in einem anderen Ordner, oder der Sprachpräfix ist falsch gesetzt.

Das Ergebnis

Nach ein paar Stunden anstrengender und dröger Handrbeit werde ich belohnt:

htmltest public/ -s 2>&1
Skipping the checking of external links.
htmltest started at 10:51:23 on public
========================================================================
✔✔✔ passed in 238.970354ms
tested 338 documents

Bald kann ich mit meiner neuen alten Seite online gehen!

ansi2html bzw. colorized-logs ist ein Hilfsprogramm, welches Konsolenausgabe inkl. Formatierung und Textfarben in html umwandelt. ↩︎

Hugo Multi-Lang: Interne Permalinks

Schallbert — Mon, 27 Jul 2026 00:00:00 +0000

Wer in Hugo wie ich einen mehrsprachigen Blog baut, könnte folgendes Problem kennen:

Interne Links in Artikeln verschiedener Sprachen verweisen nur auf Seiten in der Standard-Sprache.

Konfiguration

Grundlage für das Problem ist die folgende Einstellung:

# hugo.yml

defaultContentLanguage: "de"
defaultContentLanguageInSubdir: false
disableDefaultLanguageRedirect: true

Meine Standardsprache ist Deutsch und zugehörige Artikel werden in das Hauptverzeichnis des Blogs gebaut. Eine Weiterleitung in das Sprachverzeichnis /de findet nicht statt.

Die Verzeichnisstruktur lautet:

├── content
│   ├── de
│   │   ├── about.md
│   │   ├── announcements
│   │   ├── legal.md
│   │   ├── posts
│   │   ├── privacy.md
│   │   └── projects
│   └── en
│   ├── about.md
│   ├── legal.md
│   ├── posts
│   ├── privacy.md
│   └── projects

Das Problem mit der Standardsprache

Ich halte Artikel durch Nutzung von slug in meiner Standardsprache unter Adressen erreichbar wie example.com/my-post, example.com/my-2nd-post/. In der Zweitsprache hingegen erscheinen sie als example.com/en/my-post, example.com/en/my-2nd-post/.

Wenn ich zwei Artikel nun intern verlinken möchte, dann verweist der Link stets auf den Artikel meiner Standardsprache.

# English version of my post
# example.com/en/my-post
---
slug: my-post

---
Post's English content
[2nd](/my-2nd-post)

Ich erreiche damit statt des gewünschten /en/my-2nd-post nur die deutsche Version /my-2nd-post. Das finde ich blöd, denn so müsste ich jeden Link in allen Artikeln manuell anpassen. Leider scheint Hugo dafür keine eingebaute Lösung mitzubringen. Also erstelle ich mir eine Vorschrift, wie Links gerendert werden sollen:

{{- /* /layouts/_markup/render-link.html */ -}}

Lösung: Sprachabhängige Link-Prefixes

Dort soll folgendes passieren: Wenn beim Bauen ein relativer Link innerhalb der Seite gefunden wird, so ist genau dann ein Sprachpräfix wie /en vor diesen Link zu setzen, wenn die Sprache der zu rendernden Seite nicht der Standardsprache entspricht (denn für letztere benötige ich wegen defaultContentLanguageInSubdir: false keinen Sprachpräfix).

Standardsprache auslesen

Nur wie komme ich an die Standardsprache? Die Parameter defaultContentLanguage sind in Templates nicht zugänglich. Nach längerer Recherche finde ich eine passende Lösung für das Problem in der Hugo community: Die Standardsprache ist meist die erste Sprache des gewichtsbasierten Index (welcher die Sprachen nach Reihenfolge erscheinen lässt): index .Page.Site.Home.AllTranslations 0 Wenn ich diesen nun auslese, ist die “erste” meine Standardsprache.

Code für render-link.html

{{- /* /layouts/_markup/render-link.html */ -}}

{{- $url := .Destination | safeURL -}}
{{- $currentLang := .Page.Language.Locale -}}

{{- $is_external := or (strings.HasPrefix $url "http://") (strings.HasPrefix $url "https://") -}}
{{- $is_anchor := strings.HasPrefix $url "#" -}}
{{- $is_asset := strings.HasPrefix $url "/assets/" -}}
{{- $is_lang_prefixed := strings.HasPrefix $url (printf "/%s/" $currentLang) -}}

{{- if $is_anchor -}}
 {{- $url = printf "%s%s" .Page.RelPermalink $url -}}
{{- else -}}
 {{- if not $is_external -}}
 {{- if and (not $is_lang_prefixed) (not $is_asset) (not .Page.Language.IsDefault) -}}
 {{- $url = printf "/%s%s" $currentLang $url -}}
 {{- end -}}
 {{- end -}}
{{- end -}}

{{- /* Add / to internal paths that have no file extension */ -}}
{{- if and (not $is_external) (not $is_anchor) (not $is_asset) -}}
 {{- $parsed := urls.Parse $url -}}
 {{- if and $parsed (not (strings.HasSuffix $parsed.Path "/")) (eq (path.Ext $parsed.Path) "") -}}
 {{- $url = printf "%s/" $url -}}
 {{- end -}}
{{- end -}}

<a href="{{ $url | relURL }}"{{ if $is_external }} target="_blank" rel="noopener noreferrer" class="external-link"{{ end }}>
 {{- .Text | safeHTML -}}
 {{- if $is_external -}}
 <span class="external-link-icon" aria-hidden="true">↗</span>
 {{- end -}}
</a>

Solange die Standardsprache und der Gewichtsindex übereinstimmen, d.h. die Standardsprache ganz oben auftaucht, funktioniert dies prima.

Zusatzfunktionen

Was der Code sonst noch macht:

Prüfung, ob Links nach “extern”, also von meiner Site weg gehen. Jene bekommen dann ein eigenes Fenster und den Indikator ↗.
Prüfung, ob der Link auf eine Überschrift “anchor” führt. Details dazu siehe unten.
Prüfung, ob der Link zu einer (Medien-)Datei “asset” führt. Asset-Links werden nicht modifiziert.

Handelt es sich um einen Überschriftslink, so wird dieser gegebenenfalls auf die vollständige URL ergänzt. Das geschieht nach folgendem Schema: #heading --> /<opt_lang>/<opt_category>/<title>/#heading

Richtig auflösende Permalinks auf Überschriften

Auch für hochspezielle Permalinks innerhalb einer Seite habe ich eine Lösung gefunden. Nehmen wir an, ich habe verschiedensprachige Überschriften :

---
# German
# content/de/posts/yyyy-mm-dd-hugo-create-language-specific-permalinks.md

description: Mit _markup interne Links richtig routen
title: "Hugo Multi-Lang: Interne Permalinks"
slug: hugo-create-language-specific-permalinks
---

## Richtig auflösende Permalinks auf Überschriften {#permalinks}
Lorem Ipsum...

---
# English
# /content/en/posts/yyyy-mm-dd-hugo-create-language-specific-permalinks.md

description: Routing internal links with _markup
title: "Hugo Multi-Lang: Internal Permalinks"
slug: hugo-create-language-specific-permalinks
---

## Correct Permalinks to headings {#permalinks}
Lorem Ipsum...

Dann sollte ein Klick auf diesen Link zurück zur Überschrift #permalinks sprachunabhängig wieder zurück zur Überschrift führen. Schlüssel für diese Lösung ist das Einführen einer Überschriftsdefinition (Heading-ID) in Markdown, in diesem Fall {#permalinks}.

Funktioniert so noch nicht.

Weil #permalinks auf <blog's baseurl>/#permalinks verweist und somit der Link auf die aktuelle Seite fehlt. Doch auch das bekommen wir hin: Ich erweitere den Link-Renderer um ein paar Zeilen Code und gebe die aktuelle Seiten-URL als Präfix hinzu.

Code für render-link.html mit Unterstützung für Überschriften

{{- $is_anchor := strings.HasPrefix $url "#" -}}

{{- if $is_anchor -}}
 {{- $url = printf "%s%s" .Page.RelPermalink $url -}}
{{- end -}}

Nun wird (#permalinks)erweitert zu /hugo-create-language-specific-permalinks/#permalinks, sodass der Link endlich zum Ziel führt.

Scheitern von SSH-Verbindungen

Schallbert — Fri, 12 Jun 2026 00:00:00 +0000

In diesem kurzen Artikel geht es um Fehler beim Aufbau einer SSH-Verbindung. Egal ob andere Rechner, Server oder Dienste wie Versionsverwaltung - die Fehlermeldungen und zugehörige Lösungen sind meist gleich. Weiterlesen lohnt sich allerdings nur, wenn gängige Hilfeseiten wie Githubs troubleshooting-ssh nicht die erwünschte Lösung brachte.

Problem: “No Route To Host”

Die Konsolenausgabe zeigt (im lokalen Netz):

➜ blog git:(article) ✗ ssh 192.168.0.27
ssh: connect to host 192.168.0.27 port 22: No route to host

Oder (in einem entfernten Netz)

➜ blog git:(article) ✗ ssh 1.2.3.4
ssh: connect to host 1.2.3.4 port 22: Network is unreachable

Ursache ist sehr wahrscheinlich eine falsch eingegebene IP oder eine fehlgeschlagene DNS-Namensauflösung. Im lokalen Netz ist ein realistischer Grund, dass der Teilnehmer abgeschaltet ist und der Router ihn daher nicht erreichen kann. Abhilfe schafft meist eine Korrektur der Zieladresse, Einschalten des Ziels oder Update der Routing-Tabelle.

Problem: Connection Refused

Konsolenausgabe:

➜ blog git:(article) ✗ git push gitea
ssh: connect to host git.schallbert.de port 22: Connection refused
fatal: Could not read from remote repository.

Hier kann nicht mal eine Verbindung zum Ziel hergestellt werden. Man ist also “vor” der Authentisierung schon gescheitert. Meiner Erfahrung nach werden solche Fehler aus drei Gründen erzeugt:

Der Host ist noch nicht bereit. Er bootet beispielsweise gerade (Netzwerkkarte ist an) aber der SSH-Dienst ist noch nicht hochgefahren. Hier hilft meist: abwarten.
Eine Firewall, ein Rate Limiter, oder Dienste wie fail2ban weisen die Verbindung ab (REJECT). Die Gründe hierfür sind meist zu viele erfolglose Anmeldeversuche oder eine fehlgeleitete Bot-Erkennung. In seltenen Fällen kann es aber auch sein, dass die eigene IP-Adresse auf einer “deny-list” auftaucht, die von den Zielen eingelesen wurde. Auch hier empfiehlt sich: warten.
Der angesprochene Dienst erwartet einen anderen Port als den SSH-Standard Port 22. Somit stimmen User/Ziel-Adresse/Port nicht überein.

Das Port-Problem lässt sich leicht lösen.

Herausfinden des “Listen Port” auf dem Host (Server Configuration / SSH). Auf dem Bild ist dargestellt, wie die Einstellung auf meiner Gitea-Instanz aussieht. Alternativ genügt meist ein Blick in die Konfigurationsdatei des entsprechenden Services.
Die SSH-Konfiguration unter ~./ssh/config mit einer konkreten Port-Nummer versehen. Beispiel:

# /.ssh/config
 Host gitserver
 Hostname git.schallbert.de
 Port 222
 [...]

Problem: Too Many Authentication Failures

Konsolenausgabe:

➜ blog git:(article) ✗ git pull
Received disconnect from <ipAddress> port <portId>: Too many authentication failures

Wir haben nun also eine Verbindung zum Server 😁, aber der mag uns nicht reinlassen 😨. Immerhin wird mitgeteilt, warum: Er meint, wir hätten zu viele Schlüssel an seiner Haustür ausprobiert.

Server-Anmeldelimit prüfen

Dieser Fehler tritt auf, wenn das Server-Limit der Anmeldeversuche gerissen wird. Der Wert beträgt beim Service sshd beispielsweise standardmäßig MaxAuthTries = 6. Hat man viele Schlüssel für mehrere Verbindungen abgespeichert oder verwendet wie ich neuerdings Hardware Security Keys und legt Zweitschlüssel an (also ssh-keys.count*2), wird dieser Wert schnell überschritten.

Fies bei diesem Fehler ist außerdem, dass er nur bei bestimmten Services “unten” in des Agents Schlüsselbund auftritt: unter den ersten sechs dürfen ja fünf Schlüssel falsch sein. Zudem schützt einen nicht, wenn man die Schlüssel in der ~./ssh/config korrekt hinterlegt hat. Der Agent nimmt stets alle Schlüssel zum Probieren mit, wenn man es ihm nicht explizit verbietet.

Das Verbot erteilen wir per IdentitiesOnly yes. Hiermit wird dem Agent klar gesagt, dass er nur die für diesen Host explizit angegebenen Identities (Also Schlüsseldateien oder Nutzername/Passwort) verwenden soll.

# /.ssh/config
Host gitserver
 Hostname git.schallbert.de
 Port 222
 User <user>
 PreferredAuthentications publickey
 IdentityFile <path_to_private_key1>
 Identityfile <path_to_private_key2>
 IdentitiesOnly yes

Git-Config überprüfen

Diesen Fehler bekommt man auch, wenn die Git-Konfiguration des Repository unter <reponame>/.git/config nicht mit dem in der SSH-Konfiguration ~/.ssh/config hinterlegten Datensatz für Server und Repository übereinstimmt. Ändert man die SSH-Konfiguration, so sind alle auf diesem Server bereitgehaltenen Repo-Konfigurationen ebenfalls zu ändern.

Beispiel:

# <reponame>/.git/config
# [...]
[remote "origin"]
	url = ssh://git@git.schallbert.de:222/schallbert/<reponame>.git
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "main"]
	remote = origin
	merge = refs/heads/main
	vscode-merge-base = origin/main

In diesem Falle wird die gitserver-Konfiguration gar nicht verwendet, sondern sich direkt einwählt. Dies führt dazu, dass der Agent kein IdentitiesOnly yes Flag mitgeliefert bekommt und er Schlüssel durchprobiert, bis der Server abwinkt. Lösung:

[remote "origin"]
 url = git@gitserver:schallbert/<reponame>.git
	fetch = +refs/heads/*:refs/remotes/origin/*

Problem: Permission Denied (publickey,password)

Konsolenausgabe:

➜ blog git:(article) ✗ ssh -T git@gitserver
git@git.schallbert.de: Permission denied (publickey,password).

Dieses Problem kann leider viele verschiedene Ursachen haben. Ein paar räumt Githubs Anleitung bereits aus dem Weg, darunter:

sudo verwendet
Falscher Server
nicht den git-user verwendet
Falschen Schlüssel verwendet (client)
Schlüssel nicht hinterlegt (server)

Die Ausgabe bei falschem Username sieht so aus:

➜ blog git:(article) ✗ ssh -T mit@gitserver
mit@git.schallbert.de: Permission denied (publickey).

Eine weitere Ursache kann eine fehlende Abstimmung zwischen der Konfigurationsdatei ~./ssh/config und dem im git client hinterlegten Remote-Adresse liegen. Sind diese nicht deckungsgleich, wird eine eventuell bestehende Konfiguration gar nicht erst benutzt.

Eine Überprüfung kann man mit git remote -v durchführen.

➜ blog git:(article) ✗ git remote -v
origin	ssh://git@git.schallbert.de:222/schallbert/blog.git (fetch)
origin	ssh://git@git.schallbert.de:222/schallbert/blog.git (push)

Korrekt wäre mit der verbesserten Konfigurationsdatei (Ports eindeutig gesetzt, Identity Files definiert und auf die Angegebenen beschränkt):

# Update link to server's git repository, use host alias from config file
➜ blog git:(article) ✗ git remote update origin git@gitserver:schallbert/blog.git
# Now check if the update was effective
➜ blog git:(article) ✗ git remote -v
origin	git@gitserver:schallbert/blog.git (fetch)
origin	git@gitserver:schallbert/blog.git (push)

Problem: Agent Refused Operation

Konsolenausgabe:

➜ blog git:(local-setup) ✗ git push --set-upstream origin local-setup 
sign_and_send_pubkey: signing failed for ED25519-SK <path-to-private-key> from agent: agent refused operation

Diesen Fehler sehe ich erst, seitdem ich Hardware Security Keys für ssh verwende. Aus meiner Sicht kann er zwei Ursachen haben. Beide sind zum Glück leicht zu beheben:

Der Agent kennt den Schlüssel nicht. Der Befehl ssh-add löst das Problem. Prüfung per ssh-add -l | grep “<your-key’s-comment>”
Der angeforderte Schlüssel ist nicht da. Kann bei HSK und HSM passieren, falls sie nicht eingesteckt sind, nicht richtig auf dem NFC-Lesegerät platziert sind oder das HSM im Netzwerk nicht verfügbar ist. Oder wenn manuell im Verzeichnis ~./ssh/config gearbeitet wurde und der Schlüssel nun umbenannt oder gelöscht ist.

Hardware Security Key: SSH einrichten

Schallbert — Sun, 03 May 2026 00:00:00 +0000

Motivation

In meinem Post über Hardware Security Keys schrieb ich, dass ich möglichst viele meiner Verbindungen passwortlos mit meinem neuen HSK absichern möchte. Ich verwende SSH-Verbindungen für verschiedene Dienste und Zwecke: Ich greife auf meinen VPS zu, benutze Dienste wie Github, Gitea sowie meine eigene Gitea-Instanz und lasse die Erzeugung von Backups im lokalen Netz über scp laufen, welches das SSH-Protokoll verwendet.

SSH-Zugriff für Hardware Security Keys einrichten

HSKs wie mein Yubikey können private Schlüssel für SecureShell-Zugriffe abspeichern. Somit muss man sie nicht mehr lokal auf jedem Endgerät ablegen (das bleibt aber konfigurierbar, siehe unten). Zudem sind sie gegenüber der Verwahrung auf einem Rechner besser gegen unbefugte Zugriffe geschützt.

Also probiere ich aus, meinen Github-SSH-Zugriff auf HSK umzustellen und folge Yubicos Anleitung für passwordlose Authentisierung für Github. Das Verfahren zur Erzeugung von SSH-Schlüsseln nach FIDO unterscheidet sich für verschiedene Schlüsselhersteller nicht. Ich verlinke ebenfalls die Nitrokey-Anleitung als Referenz.

Was so nicht funktioniert

Doch mit den Empfehlungen von Yubico selbst komme ich auf meinem Betriebssystem und der Standardinstallation von openssh nicht zum Ziel. Das aus der Anleitung zusammengebaute Kommando lautet:

schallbert@machine:~# ssh-keygen -t ed25519-sk -O resident -O verify-required -O application=ssh:github -O user=schallbert -C "schallbert@github.com"

Nach Erstellung muss man den öffentliche Schlüssel (Dateiendung .pub) in der Web-Anwendung des jeweiligen Dienstes im Menüpunkt SSH-Zugang hinterlegen.

Bedeutung des Kommandos und der wichtigsten Optionen

Dieser Befehl¹ sagt der Anwendung ssh-keygen, dass sie mir einen Schlüssel des Typs -t ed25519-sk erzeugen soll. Die Endung -sk sagt aus, dass der Schlüssel auf einem Security Key - in meinem Fall dem Yubikey - gespeichert werden soll.

Um das Flag -O resident zu verstehen muss man wissen, dass FIDO Authenticator-Schlüssel wie mit -sk erzeugt aus zwei Teilen bestehen: Ein key handle Teil, welcher auf der Festplatte des Rechners verbleibt und der private Schlüssel selbst, welcher nur auf dem HSK existiert. Nur zusammen können sie Authentisierungsanfragen korrekt beantworten. Das Flag selbst weist jedoch an, beide Schlüsselteile auf den Yubikey zu schreiben. Das erleichtert die Verwendung mehrerer Geräte mit demselben Schlüssel: Der key handle-Teil kann vom Yubikey ausgelesen und auf anderen Endgeräten abgelegt werden. Auf der anderen Seite jedoch genügt nun das Verlorengehen des Yubikey allein, um möglichen Angreifern SSH-Zugriff zu geben.

-f filename legt Namen für die Schlüsseldateien fest. Macht besonders dann Sinn, wenn man mehrere SSH-Verbindungen oder HSM verwalten muss. Ich habe mir eine Konvention erstellt, um nicht durcheinander zu kommen. Diese orientiert sich stark an der Schreibweise des Schlüssel-Auslesens von einem HSK (ssh-keygen -K).

-f <keyType>_<protocol>:<service>_<user>_<device>

Als konkretes Beispiel würde mein Dateiname hier wie folgt lauten:

-f ed25519-sk_ssh:github_schallbert_yubikey-main

⚠️ Obacht bei Nutzung von Windows: Dort ist der Doppelpunkt : nicht als Zeichen in Dateinamen erlaubt. Er wird durch den Unterstrich _ ersetzt, was in der config entsprechend abgebildet werden muss (strg+h -> : ersetzen mit _)

-C schallbert@github.com fügt der Schlüsseldatei selbst einen Kommentar hinzu, zum Beispiel eine Kontaktadresse. Somit bekommt der Schlüssel ein Label, was die Handhabung unter mehreren vereinfacht.

-O application=ssh:github dient nur der sauberen Auflistung im Authenticator-Programm und sorgt dafür, dass ich Schlüssel nicht miteinander verwechseln kann. Ansonsten steht dort nämlich nur ssh:keygen und ich kann nicht sehen, für welche Services ich Schlüssel hinterlegt habe. Außerdem hilfreich bei der Verwendung von -resident, da bei der Extraktion der Schlüssel mit ssh-keygen -K Unterscheidbarkeit gegeben bleibt.

-O user=schallbert hat für mich keinen praktischen Nutzen, da SSH dieses Flag nicht interessiert und der Yubikey Authenticator meinen Nutzernamen anders als erwartet nicht anzeigt.

-O no-touch-required vermeidet, dass der Hardware Security Key bei jeder Verwendung des Schlüssels berührt werden muss. Nützlich bei sehr häufiger Verwendung, allerdings Sicherheitsverlust durch Automatisierbarkeit.

-O verify-required sagt aus, dass die PIN des HSM abzufragen ist, bevor der Schlüssel genutzt werden kann. Eigentlich als zusätzliche Sicherheit gedacht, bekomme ich damit in meiner Shell jedoch Probleme. Und zwar wird die PIN einmal abgefragt, erzeugt aber vom ssh-agent nicht jedes mal eine Abfrage in meiner Konsole. Sobald ich in einer anderen Session versuche mich per SSH zu verbinden, erhalte ich eine Fehlermeldung agent refused operation:

schallbert@machine:~# ssh -T git@github.com
sign_and_send_pubkey: signing failed for ED25519-SK "schallbert@github.com" from agent: agent refused operation
root@opnsense: Permission denied (publickey).

Woran hat es gelegen?

Nach langer, frustrierender Fehlersuche (Was mache ich falsch? Funktioniert es mit dem Zweitschlüssel? Warum geht es beim ersten mal, danach aber nicht mehr? Was ist, wenn ich die Schlüssel erneut erstelle? Was passiert an anderen Rechnern? Was meint “KI” dazu? - Letzteres kostete bestimmt eine Stunde und ließ mich komplett auf der Stelle treten) probiere ich es mit einem anderen Kommando. Das funktioniert auf Anhieb.

Was hingegen funktioniert

schallbert@machine:~# ssh-keygen -t ed25519-sk -O application=ssh:github -C "schallbert@github.com" -f ed25519-sk_ssh:github_schallbert_yubikey-main

Lasse ich verify-required weg, kann ich mich erfolgreich anmelden und der SSH-agent läuft sauber durch.

Was `verify-required` benötigt

Dieser Post im Forum superuser bringt für mein Fehlerbild Licht ins Dunkel. Die Terminal-Session mit der ich das SSH-Schlüsselpaar erstelle speichert die per verify-required Flag erzwungene Pin-Eingabe zwischen. Daher funktioniert der Login erst einmal. Logge ich mich später oder in einem anderen Fenster ein, wie ich es oben getan habe um z.B. git pull in einem meiner Repos zu prüfen, fragt der SSH-Agent meine PIN nicht ab.

Das liegt wohl daran, dass der SSH-Agent selbst keine Prompts an das anfragende Programm ausgeben kann. Abhilfe schafft ein Untermodul von Openssh: openssh-askpass. Dieses kann man dem Agent übergeben, welcher dann die PIN-Abfrage über askpass an den User übermittelt.

Installation von ssh-askpass

Mein Betriebssystem hatte ssh-askpass nicht installiert, daher hole ich das hier nach. Es verwendet den Paketmanager DNF “Dandified YUM” statt apt oder anderer gängiger Manager. Dabei ist die Namensgebung meiner Meinung nach nicht 100% einheitlich, spreche ich den ssh-Programme doch im Terminal mit ssh-agent an, muss jedoch openssh-agent tippen für die Installation.

# verify-required needs openssh subpackage through Fedora's package manager
schallbert@machine:~# sudo dnf install openssh-askpass
Installing:
 openssh-askpass
[...]
Complete!

Nun will ich dem Agent mitteilen, dass er ssh-askpass zum Erfragen der PIN ansprechen kann. Dafür mus ich wissen, in welchem Pfad sich das Submodul befindet.

schallbert@machine:~# which openssh-askpass
/usr/bin/which: no openssh-askpass [...]

Komisch, aber ich hatte es doch installiert! Frage ich mal den Paketmanager:

schallbert@machine:~# dnf repoquery --list openssh-askpass
[...]
/usr/libexec/openssh/ssh-askpass

Aha, openssh versteckt sich im Ordner libexec. Na dann kann ich das Modul jetzt dem Agent bekanntgeben.

schallbert@machine:~# eval "$(ssh-agent -s; SSH_ASKPASS=/usr/libexec/openssh/ssh-askpass)"
Agent pid 16747

Ich prüfe die Verbindung zu Github und bekomme wie gewünscht einen Dialog angezeigt, der meine PIN abfragt. Anschließend muss ich den HSK noch berühren und bekomme dann die Erfolgsmeldung. Damit das alles auch in einem neuen Terminal und nach Neustart des Rechners funktioniert, füge ich eine Referenz auf den Schlüssel in meine Konfigurationsdatei ein.

# ~/.ssh/config
Host github
 User git
 Hostname github.com
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/ed25519-sk_ssh:github_schallbert_yubikey-main

Um auf Nummer sicher zu gehen, den Agenten neustarten und neue Terminalsessions erstellen. Sollten Zugangsdaten im Cache gewesen sein, ist das hiermit zurückgesetzt. Anschließend erneut die SSH-Verbindung testen.

 schallbert@machine:~# eval "$(ssh-agent -k)" && eval "$(ssh-agent -s)"

Einziger Wehrmutstropfen ist, dass ich jetzt beim Verbinden mit SSH ein zusätzliches Popup bekomme. Das wird durch die grafische Nutzeroberfläche gnome ausgelöst. Leider finde ich keine Option, die zugehörige Einstellung permanent speichern. Somit wird es bei jeder Verbindung mit verify-required angezeigt. Bei Gnome wird ist das Problem bereits für andere Anwendungen bekannt, anscheinend aber noch nicht abgestellt.

Übertragung auf Windows-Systeme

Ich habe meine Schlüssel ja mit der Option -O resident erzeugt. Da liegt es nahe, die Extraktion des key-handle mal auf einem komplett anderen System zu testen: Windows.

Ich öffne die Kommandozeile und tippe

schallbert@windows-machine:~# ssh-keygen -K
Enter PIN for authenticator:
You may need to touch your authenticator to authorize key download.
Provider "internal" returned failure -1
Unable to load resident keys: invalid format

Invalid format? Im Netz steht öfters geschrieben, dass die Schlüssel manchmal am Ende noch ein LineFeed-Zeichen benötigen um richtig erkannt zu werden. Ohne Download vom HSK kann ich sie aber nicht modifizieren. Also übertrage ich öffentlichen Schlüssel und key-handle manuell auf den Rechner und probiere testweise das git pull-Kommando aus. Und siehe da: Es klappt!

Möchte man also die Schlüssel mit verschiedenen Betriebssystemfamilien verwenden, nutzt die Option -resident anscheinend nichts. Der Befehl ssh-keygen -K ist nicht granular steuerbar: Er lädt alle auf dem HSK befindlichen resident keys herunter.

VPS: Vorsicht bei Schlüssel-Ersatz

Noch ein Hinweis aus eigener Erfahrung: Hat man bereits SSH-Schlüssel hinterlegt bei einem Dienstanbieter, der selber Ressourcen bereitstellt (In meinem Fall einen Server als VPS) so werden neue SSH-Schlüssel meist nicht über das Web-Frontend an diese Ressource weitergereicht.

Die “alten” Schlüssel werden folglich weiterhin benötigt und die Neuen nicht verwendet, obwohl sie in der Web-App abgelegt sind!

Die neuen Schlüssel müssen dem Ziel manuell bekanntgemacht werden.

Das führe ich der Anleitung von meinem Hoster Hetzner folgend mit dem Befehl ssh-copy-id aus.

Neue Schlüssel manuell auf VPS ablegen

schallbert@machine:~# ssh-copy-id -i ./ed25519-sk_ssh:server_schallbert_yubikey-main.pub server

Dabei ist server der SSH-Alias für meinen VPS. Ich verbinde mittels des bekannten, “alten” Schlüssels lasse den “Neuen” ablegen. Doch irgend etwas funktioniert nicht wie erwartet:

/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: WARNING: All keys were skipped because they already exist on the remote system.
		(if you think this is a mistake, you may want to use -f option)

Schlüssel erfolgreich übertragen?

Ich logge mich also auf meinem Server ein und prüfe, ob der neue Schlüssel tatsächlich in der ~/.ssh/authorized_keys Datei auftaucht. Tut er nicht. Also führe ich das obige Kommando erneut aus, diesmal mit aktivierter -f (Force) Option. Und tatsächlich, die Übertragung klappt!

schallbert@machine:~# ssh-copy-id -f -i ./ed25519-sk_ssh:server_schallbert_yubikey-main.pub server 
Number of key(s) added: 1

Now try logging into the machine, with: "ssh -i <identityFile> 'server'"
and check to make sure that only the key(s) you wanted were added.

Zum Testen wie empfohlen nun mit dem neuen Schlüssel einloggen und… Läuft! Erst jetzt können die alten Schlüssel sicher gelöscht werden: shred -u <path/to/private/key>

Auf direktem Wege ohne ssh-copy-id

Will man den neuen Schlüssel ohne zusätzliche Werkzeuge bekannt machen, so kann man den Inhalt der öffentlichen Schlüsseldatei <key-filename>.pub auch direkt selbst in eine neue Zeile von ~/.ssh/authorized_keys schreiben. Dafür benötigt man lediglich eine offene SSH-Verbindung zum Ziel.

Überlegungen zu Komfort und Bedienbarkeit

Wenn ich mir meine SSH-Verbindungen so ansehe, dann teilen sie sich grob in zwei Kategorien:

Admin-Zugänge (VPS, NAS, Raspberry Pi) und Signaturen
Protokoll-Zugänge (Git etc.)

Erstere erfordern aus meiner Sicht ein höheres Sicherheitsniveau. Zudem nutze ich sie nicht so häufig wie Versionsverwaltungen. Daher empfehle ich für die erste Kategorie verify-required und würde dies bei der Zweiten weglassen. Mit der Option no-touch-required würde ich ebenso verfahren: falls alle paar Minuten ein Commit hochgeladen werden soll, werden ständige Berührungen des Schlüssels schnell irritierend.

Alle Optionen bekommt man bei Aufruf des Handbuchs per man ssh-keygen angezeigt. ↩︎

Hardware Security Keys

Schallbert — Sat, 25 Apr 2026 00:00:00 +0000

Begriffsabgrenzung: TPM und HSK

Akronym	Bezeichnung	Kurzbeschreibung
TPM	Trusted Platform Module	Fest verbaut. Schützt das Gerät selbst
HSK	Hardware Security Key	Mobil. Schützt Konten, Zertifikate, private Schlüssel

Das Trusted Platform Module ist ein Sicherheitschip, der kryptografische Schlüssel sicher speichert und Funktionen wie Secure Boot, BitLocker-Verschlüsselung und Geräteidentität bereitstellt. Er ist fest auf der Hauptplatine eines Computers oder Smartphones verlötet.

Ein Hardware Security Key HSK, Hardware-Sicherheitsschlüssel hingegen ist meist mobil und kann mit verschiedenen Geräten verbunden werden. Es kann Schlüssel nicht nur speichern, sondern meist auch kryptografische Operationen (Schlüsselgenerierung, Signatur, Verschlüsselung) ausführen. HSKs sind hochsicher und manipulationsgeschützt konstruiert. Sie können extern zertifiziert bzw. auditiert sein, sodass auch hochsensible Vorgänge wie Zahlungstransaktionen ausgeführt werden können.

Was bisher geschah

Ich hörte einen Podcast vom Bundesamt für Sicherheit in der Informationstechnik (BSI) zum Thema “Passkey statt Passwort”. Den Empfehlungen folgend habe ich mir ein mobiles Hardware-Sicherheitsmodul (HSM) gekauft, um in Zukunft Passkeys für meine Dienste zu verwenden. Schon lange bin ich nicht mehr glücklich mit meiner fragmentierten Geheimnisverwaltung aus Zetteln, Browser-Plugins, offline-Passwortmanagern wie KeePass, auf Festplatte abgelegten SSH-Schlüsseln, Backup-Keys und Notfallcodes diverser Anbieter.

Ich möchte endlich mal Ordnung in die Landschaft bringen, ohne mich an einen kommerziellen Anbieter so fest zu binden, dass ich von ihm abhängig werde.

Zielvorstellung

Keine Passwörter oder Login-Daten mehr merken müssen
Möglichst einfache, dabei sichere Verwaltung von Passwörtern aufbauen
Ordnung in den Accountwust bringen
Digitalen Nachlass regeln
Anderen ermöglichen, es mir gleichzutun

Welche Erwartung ich jetzt schon einmal nehmen kann: Ganz ohne Passwörter oder Pins geht es auch mit dem HSK nicht. Ein Yubikey ist kein Passwortmanager. Er kann zwar Zertifikate, Passkeys und Secrets für OTPs halten, gibt diese Geheimnisse dann aber nicht mehr preis. Mit seiner Hilfe kann man signieren (Authentizität beweisen), Verschlüsseln und abgeleitete Schlüssel erstellen.

Vielmehr lässt sich die Passwortverwaltung mit Hilfe eines Hardware-Sicherheitsschlüssels aber zentralisieren und vereinfachen, da gängige Passwortmanager z.B. Passkeys unterstützen und so kein “Masterpasswort” mehr nötig ist.

Yubikey

Als HSK nutze ich zwei Yubikey Schlüsselanhänger. Einen zum immer dabeihaben und einen als Zweitschlüssel, welcher an einem sicheren Ort verwahrt wird. Es gibt noch andere Anbieter mobiler Hardware Security Keys wie Nitrokey. Die kannte ich vor Verfassen dieses Artikels noch nicht. Das ist bedauerlich, ist ihr Produkt doch quelloffen und damit idealer Testkandidat für mein Blog 😥.

Yubico Authenticator

Das GUI-Programm “Yubikey Authenticator” ist nützlich zum Einrichten, Belegen der Funktionstaste (z.B. Bestätigung oder Passwortausgabe als Tastatursimulation) und falls man 2FA-Einmalkennwörter z.B. als TOTP erzeugen will. Außerdem unterstützt mein Yubikey PKI, sodass man dort unter anderem auch SSL-Zertifikate und private Schlüssel geschützt ablegen kann.

Konzept des HSK

Dabei gehört es zum Konzept, dass private Schlüssel entweder direkt auf dem Hardware-Schlüssel erzeugt werden oder - ohne sie lokal dauerhaft zu speichern - zwar auf einem Endgerät erstellt, aber auf dem Yubikey abgelegt werden. Diese verbleiben auf dem Schlüssel und sind nicht exportierbar. Er unterstützt gängige asymmetrische Verfahren wie RSA und ECDH. Für Details siehe z.B. diese BSI-Publikation über kryptografische Verfahren. Außerdem wird der Schlüssel die meiste Zeit offline, also ohne Energieversorgung herumliegen und dadurch kaum angreifbar sein. Eine zusätzliche Pin als Schutzmaßnahme bei Verlust des Schlüssels ist ein weiterer Sicherheitsfaktor.

Zweitschlüssel

Dennoch sollte man sich notieren, welche Zugänge man mit welchem Verfahren schützt, damit die richtigen Accounts im Falle des Verlustes gesperrt werden können. Ein “Zweitschlüssel” sollte vorhanden und belegt sein, was fast genauso zeitaufwändig ist wie den Hauptschlüssel zu konfigurieren.

NFC

Von der NFC-Unterstützung meines Schlüssels hatte ich mir erhofft, Logins noch schneller und leichter hinter mich bringen zu können. Zwei Dinge hier stören mich jedoch: Meinen Laptop kriege ich partout nicht dazu, den Yubikey per NFC zu erkennen. Und auf dem Handy funktioniert die NFC-Erkennung höchstens mittelmäßig. Halte ich den Schlüssel dran, startet die App und bittet mich um Eingabe der Pin. Tue ich dies, muss ich den Schlüssel wieder entfernen und erneut an den Sensor halten “Schlüssel nicht bewegen!”. Das funktioniert längst nicht jedes mal und wirkt insgesamt ziemlich störanfällig. Schade.

Was mir beim Umgang mit Yubikey fehlt

Insgesamt vermisse ich ein paar Komfort-Funktionen beim alltäglichen Umgang mit dem Yubikey. Bei Klick auf die gewünschten Schlüssel oder Accounts passiert nämlich nichts. Und konfigurieren kann ich da anscheinend auch nichts.

Bei der Verwendung von Passkeys würde ich mir eine Verknüpfung wünschen. Ein Klick auf den entsprechenden Schlüssel im Authenticator sollte die entsprechende App bzw. das Browserfenster mit der Zielwebsite aufrufen. Da ich das HSK zu diesem Zeitpunkt bereits mit der PIN entsperrt habe, kann sogar der Anmeldevorgang nach Berührung des Schlüssels vollautomatisch stattfinden.

Ähnliches wünsche ich mir beim Umgang mit Accounts. Warum heißt das Modul “Accounts”, wenn ich meine Konten nicht direkt darüber aufrufen kann? Auch hier muss ich die entsprechenden WebApps etc. selbst öffnen, den Passwortmanager am Start haben und dann noch die 2FA-Codes vom Authenticator herauskopieren. Das geht bestimmt einfacher.

Touch, password, PIN, PUK, management key, passphrase

Je nach Modul gibt es auch bei der Verwendung des Yubikey zumeist eine Mehr-Faktor-Authentisierung. Das unkomplizierteste Verfahren ist eine Anwesenheitserkennung über eine Berührung des Sticks. Damit kann sichergestellt werden, dass eine Person das HSK aktiv bedient und nicht etwa automatisch eingeloggt werden kann. Touch kann modulübergreifend angewendet werden; zur Detailkonfiguration komme ich in meinem Artikel über SSH.

Das Accounts-Modul kann optional mittels Passwort, das Passkeys-Modul per PIN gesichert werden. Manche Anbieter verlangen die Einrichtung einer PIN als zweiten Faktor sogar.

Das Certificates-Modul muss mit PIN, und PUK und Management Key vor unbefugtem Zugriff gesperrt werden. Private Schlüssel oder Zertifikate können optional zusätzlich mit einer Passphrase ausgestattet werden, was die Schlüssel selbst schützt (und aus meiner Sicht für den Yubikey keinen Sinn macht, da die privaten Schlüssel ohnehin nicht auslesbar sind).

Funktionsumfang und kryptographische Landschaft

Da das HSK einen so großen Sicherheitsgewinn verspricht, möchte ich natürlich möglichst viele seiner Fähigkeiten nutzen. Ich habe jetzt ein paar Wochen mit den verschiedenen Modulen herumgespielt und muss feststellen, dass man sich ganz schön hineindenken und viel lernen muss, um alle gut nutzen zu können. Immerhin versteht man danach ungefähr was die Module tun und bekommt einen guten Überblick zu den Themen Internet-Sicherheit, Verschlüsselungsverfahren und -Protokolle.

“Accounts” und “Passkeys” sind für Eingabemasken (Plattformen, Webseiten, Shops) und Apps (Mailer, Passwortmanager, Messenger) einfach einzurichten: Absolut empfehlenswert! - schallbert

Yubikey-Modul	Beschreibung
Accounts	Verwaltung von Konten/Anmeldungen, unterstützt TOTP
Passkeys	Passwortloses Anmeldeverfahren durch FIDO/WebAuthn (Public-Key-Credential)
Certificates	Speicherung und Nutzung von Zertifikaten; unterstützt OpenPGP (PGP) und X.509 (PIV)
Slots	Zwei programmierbare Slots zur Ausgabe statischer Passworte oder Einmalkennwörter

Kompliziert und aufwändig wird es meiner Meinung nach mit Public/Private Keys und Zertifikaten. Erzeugungs- und Validierungsverfahren hängen vom Betriebssystem oder darauf verfügbaren Programmen ab und Anleitungen greifen teils zu kurz oder widersprechen sich: Nur für Nerds oder Profis. - schallbert

Gehen wir die Module mal durch.

2-Faktor-Authentisierung “Yubikey: Accounts”

Der Yubikey kann als Generator für zeitbasierte Einmalkennwörter dienen. Dafür legt man wie in jeder anderen Authenticator-App auch pro Dienst ein Konto an und übergibt einen Sicherheitsschlüssel (Geheimnis, Secret) an den Yubikey. Auf Basis dieses Geheimnisses können bei angestecktem HSK nun Einmalcodes erzeugt werden.

Da es keine Möglichkeit gibt, diese “Secrets” vom Yubikey zu exportieren, muss der Vorgang für Zweitschlüssel wiederholt werden. Doch nicht jeder Anbieter sieht die Nutzung mehrerer Authentikatoren vor. Also kann es sinnvoll sein, das Geheimnis in der Zwischenablage¹ zu halten und ihn bei der Konfiguration des/der Zweitschlüssel wiederzuverwenden.

Passkeys “Yubikey: Passkeys”

Das Passkey-Modul meines Yubikey funktioniert recht gut. Viele Services² unterstützen die passwortlose Anmeldung leider noch nicht oder akzeptieren Passkeys nur als zweiten Faktor. Bei anderen Services³ kann ich das Passwort nicht deaktivieren, sodass ich kaum einen Sicherheitsgewinn sehe oder mir werden Backup-Codes ausgegeben, die im Notfall als zweiter Faktor dienen sollen⁴. Immerhin, ich kann durch den Passkey jetzt bei einigen Diensten die Passwort-TOTP-Anmeldung umgehen und bin schneller eingeloggt.

“Die wohl größten Vorteile der Technologie für Nutzerinnen und Nutzer liegen darin, dass Sie in Zukunft zum einen keine Passwörter mehr erstellen und verwalten müssen. Zum anderen sind Passkeys immun gegen die breite Masse bekannter Phishing-Angriffe.” - BSI-Website, Oktober 2025

Die Authenticator-App braucht man nicht zur Konfiguration von Passkeys. Dies läuft komplett im Browser oder der Kommandokonsole ab. Beide müssen das Handling von Passkeys unterstützen.

Keys & Certificates “Yubikey: Certificates”

Um hier etwas Licht hineinzubringen, müssen wir uns erst einmal den Unterschied zwischen Schlüsselpaar und Zertifikat im Kontext der Authentisierung vor Augen führen. In beiden Fallen geht es darum, die Identität des Client zu verifizieren. Vor einem Server (z.B. per SSH), einer Institution (z.B. einer Certificate Authority) oder einem anderen Client (z.B. per PGP). Somit wird für das Ziel feststellbar, dass es sich tatsächlich um den zur Verbindung berechtigten Client handelt.

Public/Private Key Pair

Das reine Schlüsselpaar (also kein Zertifikat) wird üblicherweise dann verwendet, wenn das Ziel der Kommunikation im Besitz desjenigen ist, der auch über den Client verfügt. Dann nämlich kann der Client zum Aufsetzen der Verbindung den öffentlichen Schlüssel auf dem Host platzieren. Dieses Verfahren wird z.B. bei Einrichten von SSH-Verbindungen und für einige APIs wie bei der Search Console verschiedener Suchmaschinenanbieter angewendet.

Der Host kann dem Client mit dem öffentlichen Schlüssel verschlüsselte Testnachricht schicken, welche nur mit dem zugehörigen privaten Schlüssel wieder in Klartext umgewandelt werden kann. Schickt der Client den korrekten Klartext zum Host zurück, ist für den Host bewiesen, dass der Verbindungspartner authentisch ist.

Certificates / PIV

Doch was, wenn der Host nicht unter der Kontrolle des Clients steht? Wie soll dann sichergestellt werden, dass sich weder Client noch Server für jemand anders ausgibt und einen gefälschten öffentlichen Schlüssel hinterlegt? Genau da kommen Zertifikate zum Einsatz.

Vereinfacht gesagt enthält das Zertifikat nicht nur den öffentlichen Schlüsselteil, sondern zusätzliche Informationen über den Netzteilnehmer und die gewünschte Verbindung. Nun kommt eine vertrauenswürdige, an der Kommunikation zwischen Client und Server unbeteiligte dritte Partei ins Spiel. In der Private Key Infrastructure PKI nennt man sie Certificate Authority CA.

Der Netzteilnehmer sendet nun den öffentlichen Schlüssel samt Metadaten über sich selbst an die CA und stellt einen sogenannten CSR, einen Certificate Signing Request. Die CA prüft nun, ob der Kanal des Teilnehmers auch wirklich diesem gehört.

Bei einer E-Mail (Stichwort PGP/GPG) kann die CA beispielsweise einen aus dem Public Key errechneten Hash-Link an die angegebene Mailadresse versenden. Wird der Link geklickt, beweist dies der CA gegenüber, dass die Mailadresse tatsächlich dem Client gehört und sie kann das Zertifikat ausstellen, den CSR also mit ihrem privaten Schlüssel signieren.

Bei Domains (Stichwort SSL/TLS) kann die CA beim Domain Name Service DNS-Anbieter prüfen, ob die Angaben zur Anfrage des Servers passen.

Clients haben die Signaturen gängiger Certificate Authorities eingespeichert (z.B. im Browser). Wird das Zertifikat auf dem Rückweg zwischen Server und Client manipuliert, verändert sich der Hashwert und der Client spuckt eine Zertifikatswarnung aus: “invalid certificate”. Jetzt muss man jedoch den Certificate Authorities vertrauen⁵ 🙃

Der Rechner sollte dafür offline sein. Wenn man supersicher sein will, macht man das Anlernen auf einem Live-Betriebssystem. Das bootet üblicherweise von einem USB-Stick und hat nach dem Herunterfahren alles vergessen. ↩︎
Z.B. Gar nicht: Mailbox, 2FA: Discord und Kraken, zum Zeitpunkt Apr-26. Vielleicht habe ich aber auch nicht die richtigen Einstellungen gefunden? ↩︎
Z.B. Google, Github und Hetzner, zum Zeitpunkt Apr-26. ↩︎
Auch diese Backup-Codes müssen sicher abgelegt werden. Idealerweise wieder offline, unbedingt aber unabhängig vom HSK. ↩︎
Es gibt Alternativen zu Institutionen wie CAs, siehe Web of Trust. So kann die Verifikation der Identität beispielsweise auch peer-to-peer von unbeteiligten Dritten stattfinden. ↩︎

Giteas act_runner rootless: Startprobleme

Schallbert — Sat, 28 Mar 2026 00:00:00 +0000

Das Fehlerbild

Mein docker-in-docker (DinD) act_runner stürzt kurz nach dem Start mit folgender Fehlermeldung ab:

Issue-Ticket bei Gitea

In der Gitea-Community (issue #721) habe ich ein Ticket für das Problem angelegt. Im Folgenden gehe ich auf eigene Erkenntnisse ein und fasse die Diskussion etwas zusammen.

Problem mit Kernel-Berechtigungen?

Der act_runner muss bei der Docker-in-Docker Konfiguration selbst einen eigenen Docker Daemon betreiben. Nur so kann der Runner für die Actions eigene Container erstellen. Dies ist aus Sicherheitsgründen erst einmal nicht erlaubt.

Warum Container keine Container starten dürfen

Im Kontext des act_runner führt eine Action Code aus, der selbst Teil des Repository ist. Wird unbemerkt Schadcode in die Action eingeschleust, z.B. von einem “Collaborator”, so kann dieser bei einer Docker-Installation ohne DinD über den unter Umständen mit root-Rechten ausgestatteten Docker-Daemon dockerd direkt auf das Hostsystem durchgreifen.

Auswirkungen, falls trotz DinD etwas schief geht

Bei Anwendung des DinD-Konzeptes kann dies bei einem Angriff lediglich zum Zugriff auf den dockerd innerhalb des act_runner Containers führen - und das nur, wenn die Action nicht sauber gekapselt ist. Immer noch nicht gut, aber vertretbar: Bei Neustart des Containers ist der Status quo ante wiederhergestellt. Durchgriff auf das Hostsystem besteht allenfalls indirekt dadurch, dass der Container selbst mit sämtlichen Kernel-Features ausgestattet ist.

Einfache Lösung: DinD-Container `privileged` starten

Um dem DinD-Container jetzt die Möglichkeit zu geben eigene Actions aufzusetzen, kann in der Konfiguration privileged: true gesetzt werden. Damit werden dem Container alle Kernel-Fähigkeiten eingeräumt. Dies ist laut (dem hervorragend gemachten) OWASP Security Cheat Sheet möglichst zu vermeiden. Sollte act_runner nun selbst angegriffen werden oder kritische Sicherheitslücken offenbaren, hätte der Eindringling auf diese Weise bereits alle Möglichkeiten, der Kapselung vor dem Host-System zu entgehen.

Will man den einfachen Weg gehen, sieht die entsprechende docker-compose.yml wie folgt aus.

# docker-compose.yml
# section ACT_RUNNER
runner:
 image: gitea/act_runner:latest-dind-rootless
 container_name: gitea-runner
 privileged: true
# [...]

“And remember: Do not run containers with the –privileged flag!!!” - OWASP’s Docker Security Cheat Sheet, 2026 License

Sackgasse: Nur unbedingt benötigte Rechte vergeben

Nach kurzer Recherche finde ich einen Artikel auf CodeStudy.net¹, welcher sich mit dem Thema DinD beschäftigt. Hieraus bastele ich Änderungen in meiner docker-compose.yml zusammen.

Meine Vorgehensweise:

Änderungen in docker-compose.yml vornehmen
Service neu starten docker compose restart <service>
Logs anschauen docker logs --tail 100 <container-name>
Falls gestartet: Programm laufen lassen web-app->repo->jobs->rerun_all-jobs
Bei Fehlschlag: Wiederholen

Ich beginne mit wenigen, aber sehr mächtigen Rechten. Nach ein paar Iterationen erhalte ich:

# docker-compose.yml
# section act_runner DinD-rootless
runner:
 image: gitea/act_runner:latest-dind-rootless
 container_name: gitea-runner
 privileged: false
 cap_add:
 - SYS_ADMIN
 security_opt:
 - no-new-privileges:true
 - apparmor:unconfined 
 - systempaths=unconfined
 - writable-cgroups=true
# [...]

Aber noch immer fehlen mir Rechte, die außerhalb von Kernel-Privilegien und Sicherheitszonen liegen: Der Docker-Daemon möchte auf sysfs und proc, also Systemdateiverzeichnisse und -Prozesse zugreifen können.

level=warning msg="[rootlesskit:child ] failed to mount sysfs, falling back to read-only mount: operation not permitted"

Das kann ich selbst mit cap_add: ALL nicht ausgleichen. Zudem wird die Quellenlage im Internet auf dieser technischen Ebene echt dünn (und ich bin kein Docker-Spezialist). Ein Re-Mount der Dateisysteme könnte hier noch helfen; das erscheint mir aber zu experimentell und fehleranfällig.

Nach weiteren Stunden Recherche und Trial-and-Error auf meinem Server muss ich @tianon in einer Diskussion auf Github zustimmen: Der Docker Daemon benötigt so viele Rechte und Fähigkeiten, dass man gleich bei privileged: true bleiben kann und sich nicht mit einer Armada an CAP_ADD und System-bind-mounts herumschlagen muss.

Zukünftige Lösung: Virtualisierung oder Daemonless

Doch es gibt möglicherweise bessere Lösungen: Eigene Container-Laufzeitumgebungen wie Sysbox. Die Box hat selbst auf dem Hostsystem keine besonderen Rechte, ähnlich wie in einer virtuellen Maschine scheint sie in ihr laufenden Applikationen aber alle Rechte und Fähigkeiten zur Verfügung stellen zu können.

Installation und Inbetriebnahme bis hin zu funktionierenden Job-Containern führt für diesen Post zu weit. Daher muss ich vorerst auf andere Quellen verweisen.

Auch das Umschwenken von Docker auf Podman ist eine mögliche Lösung: Podman ist Daemonless, rootless und bietet ähnlichen Funktionsumfang wie Docker. Ein Umzug nach Podman wäre für mich ein eigenes Projekt und passt nicht in den Kontext dieses Posts.

Linux Security Modules (seccomp, AppArmor, SELinux)

Begriffsklärung: LSM ermöglichen verschiedene Sicherheitsprüfungen und -Sperren auf Kernelebene. Durch “Mandatory Access Control” können Sicherheitserweiterungen wie AppArmor Kernel-Fähigkeiten für einzelne Anwendungen steuern und Zugriffe falls nötig sperren.

Apparmor

Ich betreibe meinen Server (VPS) mit Ubuntu. Dieses Betriebssystem hat in den aktuelleren Versionen “user namespace creation restrictions” in AppArmor integriert, was das Betreiben von appimages, WebApps und eben auch Containers mit höheren Rechten verhindert.

“Unprivileged user namespaces are a feature in the Linux kernel […]; it enables unprivileged users to gain administrator (root) permissions within a confined environment […]” - mbelair, Ubuntu Discourse, as of May-2026, Ubuntu Discourse Website

Kurzgesagt wurde dieses Werkzeug als security-hardening-Maßnahme entwickelt, um Angriffsfläche auf dem Host-System bei Ausführung von Programmen zu reduzieren, die höhere Rechte erfordern.

Einfache Lösung: Komplett abstellen

Die Dampfhammermethode stellt das Feature für Benutzernamensräume komplett kalt. Wir teilen AppAmor mit, dass Drittprogramme wie in alten Betriebssystemversionen auch ohne Einschränkungen Kernel-Features oder höhere Rechte nutzen dürfen. Den zugehörigen Befehl habe ich aus dem askubuntu-Forum entliehen.

Er schaltet die Einschränkung von Nicht-Admin-Benutzernamensräumen (die Übertragung ins Deutsche tut schon fast weh) für diese Sitzung ab, indem er die Kernelparameter zur Laufzeit umschreibt (-w).

schallbertTestsThis@machine:~# sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0

Ich halte den Befehl zur Fehlersuche für sehr hilfreich. Möchte man herausfinden, ob das gewünschte Programm wegen AppArmor nicht startet:

Obiges Kommando eingeben
das Drittprogramm, den Container etc. testen
durchbooten. Oder den Befehl mit =1 eingeben. Danach ist der Ursprungszustand wiederhergestellt.

Möchte man diese Verwundbarkeit permanent erhalten, so gibt man ein:

makeVulnerability@machine:~# echo 'kernel.apparmor_restrict_unprivileged_userns = 0' | sudo tee /etc/sysctl.d/20-apparmor-donotrestrict.conf
makeVulnerability@machine:~# sudo shutdown -r now

Dies alleine stellt noch keine Sicherheitslücke dar. Es ist jetzt nur prinzipiell einfacher geworden, eventuelle Schwächen im Kernel auszunutzen und der “Sandbox” des Containers zu entrinnen.

Richtige Lösung: Für jede Anwendung justieren

Es gibt Anwendungen (wie meine DinD-Version von act_runner), die benötigen zwingend erweiterte Rechte um ordnungsgemäß zu funktionieren. Und nur diese sollten die Möglichkeit erhalten, Nicht-Admin-Benutzernamensräume zu erhalten.

Docker selbst hat AppAmor einen Abschnitt in der Dokumentation gewidmet. Um zur Lösung für den DinD-Runner zu gelangen, benötigt es eine Transferleistung (danke, @thespad). Zur Wiederholung nochmal die Fehlermeldung von oben:

gitea-runner | [rootlesskit:parent] error: failed to start the child: fork/exec /proc/self/exe: operation not permitted
gitea-runner | s6-svwait: fatal: some services reported permanent failure or their supervisor died

Das Logfile sagt aus, dass der parent (Docker-Daemon im Container) sein child (Runner-Container) nicht starten kann, weil er für andere Teilnehmer (fork) selbst keine Prozesse (/proc/self) erstellen kann. Wer ist der User dieses Daemons? rootlesskit. Genau hier hakt unsere Lösung ein: Wir müssen in der docker-compose.yml das AppArmor-Profil für rootlesskit im DinD-Container des act_runner freigeben.

# docker-compose.yml
# section act_runner DinD-rootless
runner:
 image: gitea/act_runner:latest-dind-rootless
 container_name: gitea-runner
 privileged: true
 security_opt:
 - apparmor=rootlesskit
 # [...]

Entsprechend gut sieht jetzt auch das Logfile aus. Fertig!

Ich habe das Gefühl, dass jener Post mit “KI” geschrieben wurde. Wenn es konkret wird und es um “critical volume mounts” geht, stehen dort nämlich keine echten System-Pfade mehr und der Artikel wird insgesamt so vage, dass ich den Ratschlägen folgend gar nicht bis zum Ziel komme. ↩︎

Edelstahl V2a bzw. AISI304 gravieren

Schallbert — Sun, 08 Mar 2026 00:00:00 +0000

Warum dieser Versuch?

Ich wurde gefragt, ob ich einen Hilfsanker für eine Segelyacht gravieren könne. Dieser Anker ist aus 10mm starkem Edelstahlblech gefertigt und passt mit Maßen von 389x630mm auf meine Maschine.

Ich habe noch nie mit dem Material gearbeitet und bin so neugierig, dass ich den Auftrag annehme.

Das Material

Der Anker besteht aus Edelstahl der Sorte AISI304. Andere Namen für diese Legierung sind 18/10, 18/8 bezogen auf ihren Chrom/Nickel-Gehalt oder V2A/A2 nach ihrer Entwicklung aus der Versuchsschmelze bzw. ihre Herstellung “Air hardened” und der Legierungsgruppe. Sie ist verhältnismäßig gut formbar und wird daher häufig in industriellen Anwendungen genutzt.

Dieser Edelstahl hat für die spanende Bearbeitung jedoch ein paar Nachteile: Seine Wärmeleitfähigkeit ist recht gering. Daher geht wenig Wärme ins Material, was den Fräser umso heißer werden lässt. Dazu ist das Material zäh. Der Span löst sich nicht gut vom Werkzeug, es entsteht leicht eine Aufbauschneide. Das erzeugt Unsauberkeiten in der Fräsbahn. Schiebt der Fräser Späne vor sich her, wird das Material nicht vollständig geschnitten und es neigt zur Gratbildung. Außerdem ist der Edelstahl kaltverfestigend: Reibt oder Steht der Fräser am Material, verändert der von ihm ausgehende Druck die Materialoberfläche. Sie wird härter als das Werkzeug selbst.

All diese Eigenschaften zusammengenommen sorgen für hohen Werkzeugverschleiß und großen Kühlbedarf. Die Schnittparameter müssen außerdem in einem engen Korridor gehalten werden.

Das Werkzeug

Ich wähle einen Gravierfräser von vhf speziell für die Bearbeitung von Edelstahl. Mit 6mm Schaftdurchmesser, jedoch nur 4mm Schneidendurchmesser, einer kurzen geraden Schneide, 60° Gravurwinkel und 0.4mm Spitzendurchmesser wirkt das Werkzeug gedrungen und stabil. Der Fräser ist mit einer AlTiN-Beschichtung versehen.

Ob die dünne Spitze den Fräskräften und der Wärmeentwicklung standhält?

Diskussion um Fräsparameter

Im Forum cnczone.nl frage ich nach Erfahrungswerten für Tiefenzustellung, Vorschub und Drehzahl für meinen Vollhartmetallfräser.

Die Internetrecherche¹ liefert mir eine Ziel-Schnittgeschwindigkeit für AISI304 von etwa 60m/min und einen Zahnvorschub zwischen 0.02mm und 0.05mm.

Außerdem rufe ich den Fräserhersteller an und frage nach Empfehlungen für optimalen Einsatz auf einer weichen Maschine wie meiner. Der Hersteller sagt, ich müsse unbedingt kühlen. Idealerweise mit reichlich Emulsion auf dem Material. Seine Empfehlung lautet für den ersten Versuch und mit dem Fräser:

S15000 F600 Z-0.1 (vhf-Beratung)

Bei Gravuren seien häufige Richtungswechsel zu erwarten, und Ziel solle es sein, die Maschine möglichst gleichmäßig und mit kurzen Beschleunigungswegen zu führen. Das würde Rattermarken weitestgehend vermeiden.

Aus dem Forum erhalte ich Werte zwischen F240 und F800 bei maximaler Spindeldrehzahl.

Meine Erfahrungen bei der Verarbeitung von Stahl aus vorherigen Artikeln SECC fräsen und Stahl bearbeiten lasse ich einfließen und stelle einen Zahnvorschub von 0.04mm ein. Ich passe die Drehzahl der Schnittgeschwindigkeit von 60m/min an. Ich fahre gern zügig durch das Material, stelle in der Tiefe aber nur sehr vorsichtig zu. Dies ergibt für die vorliegende Schneidengeometrie folgende Werte:

S30000 F1200 Z-0.1 (Schallbert)

Damit liege ich mit Drehzahl und Vorschub genau beim Doppelten der Empfehlung von vhf. Ich wähle den Vorschub so zügig, damit ich weniger Reibungshitze am Fräser erzeuge und mehr Wärme in den Span geht. Die Tiefenzustellung halte ich gering, weil die auf die Konstruktion wirkenden Kräfte so niedriger sind. Davon verspreche ich mir eine höhere Gravurgenauigkeit und bessere Details.

Die Gesamttiefe der Gravur lege ich auf 0.2mm fest.

Einfluss der Maschinenkinematik

Wie oben beschrieben werden Drehzahl und Vorschub aufeinander eingestellt. Dabei ist es wichtig zu prüfen, ob der eingestellte Vorschub überhaupt erreicht werden kann. In Abhängigkeit von der Beschleunigungsfähigkeit der Maschine sowie Größe und Form der Gravur kann es nämlich sein, dass die Maschine durch die vielen Richtungswechsel im Schnitt mit viel geringerem Vorschub unterwegs ist.

Daher sind Drehzahl und Vorschub an die real erzielbaren Werte anzupassen. Diese können mit der Maschine im Simulationsmodus beobachtet werden. In meinem Falle ist die Maschinenbeschleunigung im Verhältnis zur Größe der Gravur so hoch, dass ich fast immer in Zielgeschwindigkeit operieren kann. Beispielrechnung gefällig?

Die Maschine benötigt folgende Zeitspanne, um vom Stillstand auf den eingestellten Vorschub von F1200 zu kommen:

$$a_{machine} = 400\frac{mm}{s^2}, v_{feedrate} = 1200\frac{mm}{min} = 20\frac{mm}{s}$$$$t = \frac{20}{400} = 50ms$$

Ich habe also nur sehr kurze Zeiten, in denen die Maschine mehr am Material reibt als schneidet.

Vorbereitung des Gravurvorganges

Ich verarbeite nur ganz selten Metall. Ich habe also keine fertige Schneid- oder Kühlemulsion vorliegen. Als Ersatz nehme ich Ballistol-Spray und etwas Wasser zur Hand. Das Öl reibe ich in die Oberfläche ein. Hinzu füge ich für die Fläche von 10x15cm etwa ein Esslöffel Wasser. Beides bildet zu meinem Erstaunen von selbst eine Emulsion.

Ich habe vor, den Anker per Vakuum zu spannen und bringe ihn mittels Passstiften auf dem Frästisch mittig in Position. Die Aussparungen für Griff und Stieleinsatz schließe ich mit beschichtetem Butterbrotpapier (Pro-Tipp! Günstig, super reißfest, umweltschonend, fast luftdicht, gut zu verarbeiten).

Nach Einschalten der Vakuumpumpe muss ich leider feststelen, dass der Anker auf einer Seite nicht ganz plan aufliegt. Ich bekomme statt -0.7bar nur knapp -0.4bar hin. Das ist für die bei der Gravur wirkenden, geringen Kräfte nicht dramatisch. Die Linienbreite allerdings wird so kaum konstant zu halten sein.

Meine Lösung ist nun, das Fräsmotiv herunter zu skalieren. Durch die geringere Größe wirken sich Unterschiede in der Linienbreite kaum noch aus.

Durchführung

Bevor ich die Gravur durchführe lasse ich die Maschine im Simulationsmodus laufen. Dabei entdecke ich noch zwei sehr langsame Eintauchvorgänge. Das CAM erstellt sie vermutlich wegen der von mir eingestellten Eintauchrampe, welche auf sehr kurzen Linienzügen erfolgt. Dies korrigiere ich mit manuell vorgegebenen Eintauchpunkten.

Nun lasse ich den Fräsjob durchlaufen. Die Emulsion bleibt trotz Spindelgebläse an Ort und Stelle. Die Geräuschentwicklung ist bei der ersten Tiefenzustellung weit geringer als bei der Zweiten - wird jedoch nie unangenehm. Vibrationen treten kaum auf. Der Fräsvorgang dauert auch bei dem aufwändigeren Logo kaum fünf Minuten.

Ergebnis

Ich bin hochzufrieden. So ein gutes Ergebnis hatte ich auf meiner Hobbymaschine auf Basis meiner Beobachtungen in den Foren nicht erwartet. Praktisch keine Rattermarken, saubere Fräskanäle und nur an den Stopp- und Austauchpunkten leichte Gratbildung. Das Material bleibt jedoch im Fräskanal und erzeugt keine fühlbaren Kanten. Auch im Detail ist das Fräsbild noch ziemlich ansehnlich.

Das folgende Video zeigt ein paar Details des Fräsvorganges. Meine letzte offene Frage: Ist das leicht raue Geräusch des Fräsers bei der zweiten Tiefenzustellung ein Hinweis auf größeren Werkzeugverschleiß durch Materialverfestigung?

Engraving Stainless Steel

Quelle1: VNT Hardware Quelle2: Machiningdoctor Quelle3: CNC Optimization ↩︎

HudL - Datenbank veröffentlicht

Schallbert — Sat, 28 Feb 2026 00:00:00 +0000

Der Song

Unser Song “Datenbank” entstand im Jahr 2024 aus einer Jam-Session in Bremen. Von unseren Hörern nach mehreren Live-Auftritten als “Smash Hit” bezeichnet, haben wir uns 2025 ins Studio begeben und “Datenbank” eingespielt.

Nun, Anfang 2026, wagen wir das Abenteuer und veröffentlichen “Datenbank” über den Berliner Distributor RecordJet. Wir hoffen, es gefällt!

Wo kann ich “Datenbank” anhören?

Praktisch überall, wo man streamen kann! Beispiele:

Wer ist HudL eigentlich?

Hannes und die Luken - kurz HudL - ist ein Bandprojekt aus Spaß, gegründet im Jahr 2024.
Die drei Musiker aus Bremerhaven und Bremen in der klassischen Rockbesetzung Gitarre, Schlagzeug und Bass verweben Texte aus dem Alltag mit eingängigen Melodien.

Nicht wenige HörerInnen erwischen sich dabei, dass ihre Finger unwillkürlich die Dauerschleife anwählen. Das bereuen sie keineswegs!

Besetzung

Lucas Freund - Gitarre und Lead-Vocals
Hannes Christen - Schlagzeug und Backing-Vocals
Lukas Preußer - Bass und Backing-Vocals

Danke für die Hilfe

Im Hintergrund hatten wir helfende Hände, ohne die wir niemals so schnell und in dieser Qualität hätten veröffentlichen können. Vielen Dank daher an Lennert Röthemeyer für die Studioaufnahme des Schlagzeuges sowie an Feliks Weber und seine Nocturn Studios für Bass-Recording, Mixing und Mastering!

Werkzeugvermessung automatisieren

Schallbert — Tue, 10 Feb 2026 00:00:00 +0000

Mich erreichen immer wieder Fragen zu meinem Post über CNC-Makros. In diesem Beitrag möchte ich ein paar Antworten geben und Details zur Vermessung und Kompensation verschiedener Werkzeuglängen teilen.

Frage: Wie berechnet das Makro die Werkzeuglänge?

Im Abschnitt Werkzeuglänge Vermessen steht folgender Code:

1 G53 G00 Z[zSafety] ; # Go to safety height (machine coordinates)
2 G53 G00 X[xPosTls] Y[xPosTls] ; # Go to tool length sensor
3 G53 G00 Z[zSpindleTip + toolLengthEst + 10] ;# Move Z down to 10mm above estimated tool tip

Was passiert in den Zeilen 1-3? Wenn Z=0 im Maschinenkoordinatensystem (G53) die höchste Position ist, sind zSpindleTip und toolLengthEst dann negative Werte?

Antwort:

Diese Zeile fährt die Maschine zum in Variable #4506 hinterlegten Wert. Bei mir ist er 0, also maximale Z-Höhe. Dieser Wert bleibt permanent gespeichert (siehe hier) und man muss ihn vorher im Makro-Setup-Dialog festlegen.
Führt eine Bewegung zum Werkzeuglängensensor (WZLS) im Maschinenkoordinatensystem aus. Dafür habe ich meinen Sensor an einem festen Punkt auf der Maschine platziert.
Mit zSpindleTip (Variable #4509) ist die Höhe auf der Z-Achse gemeint, in der die Spindelnase den Werkzeuglängensensor freitastet. Dieser Wert ist negativ. Weshalb? Der größte Wert der Z-Achse ist Null, wenn sie sich ganz am oberen Anschlag der Maschine befindet. Senkt man dia Achse von hier aus zum WZLS ab, bewegt man sie in negative Z-Richtung. Addiert man die geschätzte Werkzeuglänge toolLengthEst sowie eine Sicherheitshöhe von 10mm dazu (falls man sich bei der Werkzeuglängenschätzung vertan hat), bleibt aber unter dem mechanischen Anschlag der Z-Achse, so ist der Wert noch immer negativ. Die Spindelnase hat nun aber genügend Luft zum WZLS, weil jetzt virtuell Werkzeug und Sicherheitshöhe hinzuaddiert wurden.

Pro Tipp: Im “Variables” Tab von EdingCNC kann man sich Werte von Variablengruppen anzeigen lassen. Man gibt eine Gruppe ein, z.B. #4500 und erhält die Live-Werte aller zehn Variablen.

Um das gut nachvollziehen zu können bietet sich an, die CNC-Software zum Ausprobieren nebenbei im Simulationsmodus laufen zu lassen. Konkretes Beispiel:

zSafety = 0 ;# machine coordinates, Z-axis at top notch
zSpindleTip = -86.43 ;# machine coordinates, where empty spindle collet touches TLS
toolLengthEst = 35 ;# the length the tool is protruding from spindle collet

G53 G00 Z[-86.43 + 35 +10] # = -41.32mm, so below max Z height

Die Benennung der Variablen habe ich in meinem Makro-Repository auf Github abgelegt.

Frage: Wie berechne ich die Werkstückhöhe nach einer Werkzeugvermessung?

Folgendes Szenario: Man vermisst das Werkzeug und bestimmt anschließend per Makro die Werkstückhöhe. Wenn ich nun die Werkzeuglänge verändere ohne das Werkzeugwechselmakro aufzurufen, stimmt der Werkstücknullpunkt ja nicht mehr. Mit einem kürzeren Werkzeug liegt der Nullpunkt “zu tief”, bei einem Längeren “zu hoch”.

Wie kann man dieses Problem lösen?

Antwort: Mehrere Lösungswege

Aus meiner Sicht gibt es hier drei Lösungswege.

Werkzeuglängenänderung immer über das Werkzeugwechselmakro laufen lassen. Man kann dort ja dieselbe Werkzeugnummer erneut eingeben.
Den Z-Nullpunkt über die Werkstückvermessung neu setzen (nicht empfohlen¹)
Ohne Makro: Per Kommando G92 das Z-Koordinatensystem verschieben. Beispiel folgt.

Lösung #3: Koordinatensystem verschieben

Man kann das Werkstückkoordinatensystem mit den Befehl G92 Coordinate System Offset verschieben. Führt man ihn aus, so wird die ihm übergebene Zahl der angewählten Achse als neuer Wert im Koordinatensystem übernommen.

In diesem Fall wollen wir ja nur die relative Position verschieben und damit den Unterschied der Werkzeuglängen zueinander ausgleichen. Machen wir es mal konkret:

Nehmen wir an, das alte Werkzeug T17 hat eine freie Länge von 32mm und das neue Werkzeug (wieder T17, denn wir spannen in diesem Beispiel nur um oder setzen ein Schlichtwerkzeug mit gleichen Schnittdaten ein) eine freie Länge von 24mm. Der neue Wert ist kürzer, und daher muss der Nullpunkt um 8mm nach unten wandern. “Nach unten” ist im Koordinatensystem der Z-Achse ein negativer Wert.

;# Pseudocode
;# (CamelCaseWord steht für eine Variablennummer wie #5003):
G92 Z[AktuelleZPosition + (AlteWerkzeuglänge - NeueWerkzeuglänge)]
;# 20mm + (32mm - 24mm ) = 20mm + 8mm = 28mm

Verschiebung Werkstücknullpunkt vs. Werkstückkoordinatensystem

Diese Rechnung mag erst einmal verwirren, versetzt sie das Koordinatensystem doch nach oben. Aber genau das ist erforderlich, damit der Werkstücknullpunkt relativ zur Werkzeugspitze erhalten bleibt: Das Werkzeug ist 8mm kürzer. Da wir den Werkstücknullpunkt nicht nach unten schieben, muss das Koordinatensystem halt nach oben versetzt werden. So wird die nun längere Strecke zwischen Werkzeugspitze und Werkstück kompensiert.

Coordinate System	Tool tip position Z [mm]	Workpiece position Z [mm]	Tool top position Z [mm]	Workpiece position Z [mm]
	Before shift	Before shift	After shift	After shift
Workpiece	20	0	28	0
Machine	-41.42	-61,42	-41.42	-69,42

Man sieht hier, dass sich durch das Versetzen des Koordinatensystems die Position der Werkzeugspitze im Werkstückkoordinatensystem verändert. Die Z-Achse wird dabei nicht bewegt. Das Maschinenkoordinatensystem bleibt von dieser Änderung unberührt. Da die Z-Achse nun aber einen weiteren Weg zum Werkstück zurücklegen muss, liegt seine Position im Maschinenkoordinatensystem jetzt um -8mm unter dem vorigen Wert.

Rahmenbedingungen

Die Makros funktionieren nur unter bestimmten Voraussetzungen:

Die Werkzeuglänge wurde zuvor gemessen bzw. Werkzeugwechsel werden stets per Makro gesteuert und nicht ohne “Wissen” der Maschine
Der Werkstücknullpunkt wird bei bereits bekannter Werkzeuglänge ermittelt.
Es gab keinen Not-Aus oder einen anderen kritischen Fehler. Dies würde den flüchtigen Speicher für die relevanten Variablen löschen.

Nach einem Werkzeugwechsel die Werkstückhöhe in Z erneut einzumessen verschiebt meiner Ansicht nach den falschen Parameter. In Wirklichkeit hat sich doch nicht die Höhe des Werkstückes geändert, sondern die Position der Werkzeugspitze. Daher würde ich stets vorziehen, den sich ändernden Parameter anzupassen. ↩︎

Vortrag: Software-defined vehicle

Schallbert — Sun, 25 Jan 2026 00:00:00 +0000

— Dezember 2025 — Neuer Vortrag veröffentlicht

Ich habe vor kurzem einen Vortrag zum Thema software-defined vehicle gehalten. Die Folien sind jetzt zur Ansicht auf meiner Hauptseite unter Vorträge verfügbar.

Die Rückmeldungen waren überwältigend positiv. Der Vortrag gewährt tiefe Einblicke in die aktuelle Lage der Automobilindustrie und hilft dabei zu verstehen, warum sich die “klassischen” Autobauer so schwer tun, mit den modernen Fahrzeugen aus Fernost mitzuhalten.

Stahlblech (SECC) bearbeiten

Schallbert — Mon, 22 Dec 2025 00:00:00 +0000

Das Werkstück

Es handelt sich um ein PC-Gehäuse aus 0.8mm starkem, verzinktem Stahlblech “SECC”. Es stammt aus den frühen 2000ern und wurde kürzlich mit neuem Innenleben ausgestattet.

Die Aufgabe

Durch die nun viel leistungsfähigere Grafikkarte (TDP 200W) und das beengte Design als HTPC war die entstehende Verlustwärme nicht im gewünschten Maße abzutransportieren, sodass im Gehäuse unter Last Temperaturen um 50°C vorherrschten. Das ist mir viel zu hoch.

Die Gegebenheiten

Die Grafikkarte folgt gängigen aktuellen Designs: Ein metallener Radiator bedeckt die komplette Oberfläche der Platine. Seine Rippen sind in Querrichtung zum Sockel ausgerichtet und die darauf montierten, flachen Lüfter (3x80mm) drücken die Luft durch die Leitbleche in Richtung Moainboard und Gehäusedeckel.

Zwischen Grafikkarte und Gehäusedeckel sind leider nur wenige Millimeter Platz. Nun möchte ich also genau an dieser Stelle zusätzliche Löcher in die Abdeckung einbringen. Das Gehäuse besitzt bereits Belüftungsbohrungen mit 3mm Durchmesser in einem 10x19mm 45°-Raster an den Seiten. Ich versuche nun, dieses Muster auch auf die Bohrungen für die Grafikkartenentlüftung anzuwenden. So komme ich auf eine Gesamtzahl von 133 Stück, welche ich der Bequemlichkeit wegen ungern anzeichnen, körnen und von Hand fertigen möchte.

Also erstelle ich mir eine Zeichnung im CAD und schließlich ein Bohrzyklus-Programm für meine Fräse.

Werkzeug1: 3mm-Bohrer

Ich habe zwar noch ein paar Baumarkt-Stahlbohrer aus üblichem Hochgeschwindigkeits-Schnellarbeitsstahl (HSS) herumliegen, diese befinden sich jedoch in teils schlechtem Zustand. Also nehme ich einen noch unbenutzten Stahlbohrer aus meinem Dremel-Sortiment.

Bohrparameter

Er hat eine hellgraue, metallene Färbung und sieht unbeschichteten Werkzeugen aus Vollhartmetall so ähnlich, dass ich (fälschlicherweise) annehme, er sei aus Wolframcarbid. Daher wählte ich folgende Parameter:

3mm VHM-Bohrer für Stahl, 2 Schneiden: S17000 F470 Z-0.2 Rückzug 0.5mm

Ich arbeite wie üblich komplett trocken, setze also keine Kühlschmierstoffe ein.

Bohrvorbereitung

Zur Vorbereitung des Werkstücks bringe ich auf den Abschnitt des Gehäuses Klebeband an, wo später die Löcher sein sollen. Mit der maximalen Bohrtiefe durchstoße ich das Material nur minimal. Da das Klebeband auf diese Weise intakt bleibt, verliere ich keinen Unterdruck durch offenliegende Löcher im Vakuumtisch.

Ich lege den Gehäusedeckel mit der Außenseite auf das Maschinenbett und decke freie Löcher meines Vakuumtisches mit einer Gummimatte ab. Anschließend bringe ich das Portal in eine Position nahe der Löcher, damit die Spindel im Pfadverlauf nicht mit der Gehäusewand kollidiert. Außerdem entferne ich das Anfahren der Parkposition G28 aus der Fräsdatei, denn nun liegt der Gehäusedeckel im Weg. Nach Hochziehen der Z-Achse von der letzten Bohrung endet das Programm mit M30 (Stop und zurückspulen).

Das Ergebnis

Um es vorwegzunehmen: Der Bohrer hält nicht durch. Dass etwas nicht in Ordnung ist, merke ich nach wenigen Sekunden am Geräusch der Maschine: Sie ist plötzlich viel leiser als vorher.

Ich schaffe auf diese Weise schlappe 3 von 133 Löchern. Danach befindet sich die Spitze des Bohrers in einem der halb fertiggestellten Löcher und scheint mit diesem verschweißt.

Problemanalyse

Anscheinend war der Bohrer gar nicht aus Vollhartmetall, und damit bin ich mit völlig ungeeigneten Parametern unterwegs gewesen. Ich habe die Symptome in zwei Foren gegeben (Hobbyline sowie cnczone) und ich erhalte die Information, dass ich besser mit S1000 F30 (!) unterwegs sein sollte, wenn ich ein paar mehr Löcher mit dem Bohrer hätte schaffen wollen.

Die Lösung

Ich wechsle also auf Hartmetallfräser. Ich habe nur einen in meiner Sammlung, der für Stahl gemacht wurde. Dieser hat allerdings einen größeren Durchmesser, sodass ich mein Design anpassen muss.

Nun erzeuge ich mir im CAD Langlöcher, welche mit 6mm Breite und 22mm Länge im 45°-Winkel über dem Radiator der Grafikkarte platziert sind.

Werkzeug2: 6mm VHM-Fräser

Ich wende meine bereits bewährte Frästechnik für SECC-Stahl an und verfeinere sie weiter: Hohe Spindeldrehzahl, großer Vorschub, geringe Tiefenzustellung.

6mm VHM-Fräser, AlTiN-beschichtet, 2 Schneiden, 0.2mm 45°-Fase: S10600 F880 Z-0.18

Bearbeitungsvorgang

Die Maschine arbeitet ruhig und das Werkzeug ist nach Fertigstellung, die knapp zehn Minuten benötigt, nur handwarm. Beim Eintauchen wird sie kurz lauter. Das nächste mal werde ich die Eintauchrampe noch flacher einstellen - etwa auf 5°. Damit verspreche ich mir, die untere Schneidfläche zu schonen.

Cutting SECC steel of my PC case

Schnittqualität

Die Schnittkanten sind gratfrei, hochglänzend und messerscharf. Daher ist eine Fase anzubringen. Dies mache ich von Hand mit Ziehklinge und Cuttermesser, was ich schnell bereue: Ich bekomme das nicht so sauber und gleichmäßig hin wie gewünscht.

Nicht so schlimm: Ich erhalte ein ordentlich gearbeitetes Gehäuse mit deutlich verbesserter Kühlung praktisch zum Nulltarif (Wenn man vom Lehrgeld absieht). In der Abbildung oben ist der Radiator der Grafikkarte klar durch die neuen Schlitze im Gehäuse zu erkennen.

Jekyll-dockerimage: Bundler und Gemfile

Schallbert — Fri, 14 Nov 2025 00:00:00 +0000

Was ist bundler?

Bundler ist ein Werkzeug, mit dem Abhängigkeiten zwischen Modulen und Bibliotheken in der Programmiersprache Ruby verwaltet und versioniert werden können. Ich benutze Bundler-Kommandos regelmäßig, z.B. um meinen Blog zu bauen und auf dem Server live zu stellen.

Will ich lokal bauen, so tippe ich beispielsweise

bundle exec jekyll serve --incremental --future

in die Konsole. Dieser Befehl sagt Bundler, es soll die Applikation jekyll im Server-Modus ausführen und ihr Parameter mitgeben, welche jekyll nicht bei jeder Dateiänderung komplett neu bauen lässt und noch nicht veröffentlichte Seiten dennoch mit erstellt.

bundler in der CI-Pipeline

Auch für die Veröffentlichung meiner Seite nutze ich Bundler als Teil eines Jekyll-Dockerimages, wie bereits öfters auf meiner Seite verlinkt, z.B. bei der Umstellung auf self-hosted. Seit ich auf eine neue Version der Blog-Software umgestiegen bin, sehe ich in meiner CI-Pipeline rätselhafte Fehler. Lokal baut das System jedoch einwandfrei. Wie man solche Fehler angeht und behebt, habe ich hier festgehalten.

“There was an error while trying to write to /path/to/Gemfile.lock” - CI console output

Keine Schreibrechte

Bundler selbst kann auf meiner CI wie der Jekyll-user auch nur Dateien lesen und nicht schreiben. Was ich für den Jekyll output mit chown beheben kann, möchte ich bundler aber gar nicht erlauben: Ich will ja gerade, dass Gemfile.lock zwischen meiner lokalen Bauumgebung und der CI identisch bleibt, damit ich mögliche Fehler schon vorab beheben kann.

Spezifikationsdatei für bundler

In der Datei Gemfile.lock stehen alle Abhängigkeiten der verwendeten Applikation drin, inkl. Versionsnummer und Bezugsquelle. Wird nur der Quellcode der Anwendung plus diese Datei geliefert, so kann bundler eine konkrete Version aller Abhängigkeiten beim Bauen ziehen, sodass unabhängig von Maschine und Version mit ähnlichen Voraussetzungen gearbeitet werden kann.

Fehlerbehebung

Ein erster Versuch der Behebung durch Angleichung sämtlicher Versionen zwischen lokal und CI schlug fehl. Der zweite Versuch, dem Jekyll-user Schreibrechte auf die Gemfile.lock zu geben, schlug ebenfalls fehl. Der dritte Versuch führte mich zur Bundler-Website, wo ich die Parameter genauer unter die Lupe nahm, Stichwort “frozen”.

Es ist nämlich so, dass man bundler verbieten kann, die Gemfile.lock umzuschreiben. Dafür verwendet man das Kommando

bundle config set frozen true

Laut Dokumentation wird die Verarbeitung abgebrochen, sobald die Datei umgeschrieben werden müsste.

Obwohl ich diesen Befehl meiner yaml-Datei in der CI hinzugefügt hatte, schlug das Bauen erneut fehl. Auslöser war dieselbe Bibliothek nokogiri wie vorher, nur war die Fehlermeldung nun viel hilfreicher:

`Gemfile.lock` für verschiedene Umgebungen optimieren

Also befolge ich den Vorschlag und führe das gewünschte Kommando auf meinem lokalen Rechner aus:

bundle lock --add-platform x86_64_musl # my CI runner's environment

Randnotiz: musl ist eine libc-Implementierung für Linux, sprich mit ihrer Hilfe laufen viele in C geschriebene Programme.

In meiner Lockfile taucht daraufhin folgender Eintrag auf:

nokogiri (1.18.10-x86_64-linux-musl)

Nun läuft meine CI wieder sauber durch und nebenbei habe ich die Portabilität meines Jekll-Setups verbessert.

fail2ban: Update zerstört Konfiguration

Schallbert — Thu, 23 Oct 2025 00:00:00 +0000

Alle paar Wochen sehe ich auf meinem Server üblicherweise nach dem Rechten:

Ist bei Docker alles ok? docker ps
Werden die Backups korrekt erzeugt? borgmatic repo-info
Funktionieren meine Abwehrmaßnahmen? iptables -n -L
Laufen meine Daemons zur Update-Automation? htop -F /server-config

Dieses mal allerdings zeigte iptables mir gähnende Leere. Das ist ungewöhnlich und deutet darauf hin, dass mit fail2ban etwas nicht stimmt.

schallbert@machine:~# iptables -n -L

Chain FORWARD (policy DROP)
target prot opt source destination 
DOCKER-USER all -- 0.0.0.0/0 0.0.0.0/0 
DOCKER-FORWARD all -- 0.0.0.0/0 0.0.0.0/0 

Chain DOCKER-USER (1 references)
target port opt source destination

Übersetzt lautet die Ausgabe etwa in etwa

“Die FORWARD-Chain leitet wie von Docker benötigt an die für Container relevante DOCKER-USER-Chain weiter. Unter dieser sind allerdings keine Anwendungen gelistet, die Pakete zurückweisen oder deren Weiterleitung verbieten (REJECT/DROP) können.”

An dieser Stelle müssten zwei Einträge für caddy-server und caddy-ratelimit auftauchen.

“fail2ban ERROR Failed during configuration”

Also schaue ich zuerst mal bei Docker nach:

docker logs -t fail2ban # Logs für den Container mit Namen fail2ban mit Zeitempel ausgeben

Statt wie üblich nach dem Durchscrollen mit <timestamp> Server ready belohnt zu werden, bekomme eine nicht enden wollende Flut an Logmeldungen angezeigt. Sie wiederholen sich und zeigen, dass fail2ban mit Exit with code 255 aussteigt. Einen besseren Überblick liefert mir das Log, wenn ich nur die letzten 100 Zeilen ausgebe:

docker logs -t --tail 100 fail2ban # Nur die letzten 100 Zeilen des Logs ausgeben, mit Zeitstempel

Die Fehlermeldung

<timestamp, ID> ERROR Failed during configuration: Bad value substitution: 
option 'action' in section 'caddy-ratelimit' contains an interpolation key 'banaction' which is not a valid option name. 
Raw value: '%(action_)s'

Die Meldung ist interessant, weil ich genau an dieser Stelle auch schon beim Erstellen im Zuge des Artikels Fail2ban mit Caddy Probleme mit der jail.local hatte. Damals musste ich action = iptables-multiport aus der Konfiguration nehmen, weil die auslösenden IP-Adressen auf der falschen CHAIN (INPUT) gelandet waren.

Nun scheint also die default-action auf der DOCKER-USER chain nicht mehr zu funktionieren. Also gehe ich ins Netz und suche nach ein paar Quellen für eine mögliche Lösung. Ich finde aber weder in der Update-Historie von fail2ban noch in der von mir benutzten Distribution von linuxserver.io Hinweise auf Updates, die hier große Änderungen im action.d Ordner veranlassen würden.

Lösung per `banaction = iptables[type=multiport]`

Also bemühe ich die Websuche und finde einen Kommentar eines Maintainers von fail2ban:

“[…] With action = iptables[type=multiport, protocol=tcp, chain=DOCKER-USER] you overwrote the default action […] [Solution:] simply set the chain variable only in the jail […]: port = http, https banaction = iptables[type=multiport] chain = DOCKER-USER”

Die Grundlage dieser Aussage kann man in den Docker Docs nachlesen. Nebenbemerkung: An allen Stellen wird empfohlen, für zukünftige Anwendungen das modernere nftables statt iptables zu verwenden. Hier gibt es einen Artikel zum Thema.

Somit kann ich das bisher in meiner jail.local vorhandene action-Feld komplett löschen und stattdessen banaction verwenden. Sie sieht nun wie folgt aus:

# jail.local update Oct-2025

# Server/Client errors: 401 403 404 500
[caddy-status]
enabled = true
chain = DOCKER-USER
port = http,https
filter = caddy-status
logpath = <path/to/logfiles>
findtime = 10min
maxretry = 5
bantime = 1d
banaction = iptables[type=multiport]

Mit dieser Konfiguration fährt fail2ban normal hoch und gibt Server ready aus.

Überprüfen der Lösung mittels iptables

Ich erzeuge mir wie oben beschrieben Einträge in den Test-Logfiles, welche die Aktionen von caddy-status und caddy-ratelimit auslösen sollen. Wie erwartet erhalte ich in der “blocklist”:

schallbert@machine:~# iptables -n -L

Chain DOCKER-USER (1 references)
target prot opt source destination 
f2b-caddy-ratelimit tcp -- 0.0.0.0/0 0.0.0.0/0 multiport dports 80,443
f2b-caddy-status tcp -- 0.0.0.0/0 0.0.0.0/0 multiport dports 80,443

Albasia-Holz fräsen

Schallbert — Mon, 06 Oct 2025 00:00:00 +0000

Was ist Albasia?

Albasia (Falcataria falcata) ist ein sehr leichtes Weichholz. Es kommt hauptsächlich in Südostasien vor und wächst schnell, was sein Nachhaltigkeitsrating verbessert. Seine Farbe variiert zwischen weißlich-gelb und pastelligem braun-rosa, ist im Vergleich zu Buche oder Eiche aber deutlich heller.

Hierzulande ist es meist als Multiplexplatte im Handel. Dadurch werden Nachteile wie die starke Neigung zum Schwinden und Quellen abgemildert.

Die Dichte von Albasia ist nochmal etwa 15% geringer als die des ohnehin schon sehr leichten Pappelholzes. Es bildet im Wuchs lange Fasern, was die Zerspanbarkeit beeinträchtigt. Da es durch seine vielen Lufteinschlüsse zudem gut dämmt, wird es häufig im Fahrzeugausbau (Camper, Boote etc.) verwendet. Um die geringere Festigkeit auszugleichen, wird Albasia-Multiplex oft nicht roh, sondern als Sandwich-Platte angeboten.

Mit Sandwichtechnik zu guten Materialeigenschaften

Mein Testmaterial verfügt über eine beidseitig aufgebrachte, 0.8mm starke Schicht aus Hochdrucklaminat (HPL). Die Oberfläche ist in farbigen Melamindekoren erhältlich und kann als Extra gehärtet bestellt werden, was sie mattiert sowie unempfindlich gegenüber Kratzern macht.

Sind Albasia-Verbundplatten für den Außenbereich geeignet?

“Unsere Platten sind übrigens nicht für den Außenbereich vorgesehen.” - EpicPLY, Händler

Auch wenn das Material für den Innenausbau entwickelt wurde: Ich teste die Wetterfestigkeit der Platten momentan mit einem Experiment. Dafür verschraube ich die Verbundplatte im rechten Winkel auf Stoß miteinander, sodass einmal die Beschichtung und einmal die Holzkante der Witterung direkt ausgesetzt sind. Ich habe eine offene Kante mit Hartöl versiegelt und eine unbehandelt belassen. Nun hänge ich die Konstruktion ein Jahr draußen auf den Balkon und sehe dann, wie sich das Material verhält - Update dann in einem gesonderten Post!

Versuchsaufbau für Bewetterungs- und Schraubentest.

Vorbereitung für den Schraubentest

Der zusammengesetzte Testaufbau ist zur Bewitterung angebracht.

Am Tag 0: Beide Oberflächen sehen noch frisch aus.

Meine Erwartung: anders als bei Birkensperrholz und ähnlich wie Pappelholz wird Albasia nicht für den Außenbereich taugen. Ich nehme an, dass sich die Fasern im Kantenbereich mit Wasser vollsaugen und das Material zum Quellen bringen. Dies würde es schnell verrotten lassen. Außerdem schätze ich die Gefahr für Insektenbefall als hoch ein, weil die Fasern echt weich sind und sich leicht abschälen lassen. Daher würde ich es nur in Innenräumen einsetzen.

Verschraubungen

Trotz seines leichten Kerns sei die Albasia-Verbundplatte gut zu verschrauben und würde mit einer “Schraubenauszugsfestigkeit von 120kg” bei einer 4mm-Holzschraube in einem “sehr stabilen Bereich” liegen, meint mein Händler.

Als Laie kann ich mit solchen Werten nicht viel anfangen und führe ein kleines Experiment durch. Ich nehme eine 4x35 Holzschraube her und schaue mir die vorgesehenen Anzugsmomente an. Hier gilt für meinen Hersteller etwa:

Parameter	Wert
Auszugsparameter $ f_{ax,k} $	14 N/mm²
Torsionsfestigkeit $ f_{tor,k} $	3 Nm
Einschraubdrehmoment $ R_{tor,mean} $	$ \frac{f_{tor,k}}{R_{tor,mean}} $ ≥ 1,5
Vorbohren in Nadelholz	2.5 mm
Vorbohren in Laubholz	3 mm

Quelle

Nun schaue ich, ob ich zwei Bretter auf Stoß mit dem vorgesehenen Anzugsmoment verbinden kann. Dafür nehme ich einen Drehmomentschraubendreher zur Hand. Doch ich komme gar nicht bis zum Auslösen der Mechanik: Bereits vorher beginnt die Schraube, sich in die Deckschicht zu ziehen. Das maxinale Drehmoment, bevor die Schraube im Material “verschwindet”, schätze ich auf lediglich 0.8Nm.

Your browser does not support the video tag.

Video: Ich versuche, eine Schraube auf Drehmoment im Holz festzuziehen.

Somit lassen sich durchaus stabile Schraubverbindungen herstellen, jedoch würde ich beim Anziehen stets vorsichtig vorgehen, großzügig mit der Menge an Schrauben sein und zusätzlich Dübel- oder formschlüssige Verbindungsarten wählen.

Albasia auf der CNC-Fräse

Albasia kann wie jedes andere Weichholz auch mit der CNC-Fräse verarbeitet werden. Für Weichhölzer typische Probleme wie Ausrisse oder Fasernester sind auch hier zu erwarten. Hinzu kommt die harte Beschichtung, welche die Bearbeitung wegen anderer Anforderungen an die Parameterwahl noch einmal schwieriger macht.

Mit welchen Fräsern gelingt die Bearbeitung?

Für den Fräser ist der Materialmix herausfordernd. Beim Fräsen in HPL hatte ich im Artikel zur Überlastung meines Fräsmotors ja bereits schlechte Erfahrungen gesammelt. Das Material damals besaß im Vergleich zu Albasia-Verbund jedoch einen viel höheren Hartpapierfaseranteil (Späne sind hellbraun und mit vielen “Punkten” durchzogen), was den Fräser in Rekordzeit stumpf werden ließ.

Ich setze Vollhartmetallfräser VHM mit Spanbrecher und kaum Drall (15°) ein, um die langen Holzfasern zu brechen. Sie verstopfen sonst sehr schnell die Absaugung und sammeln sich um den Fräser an, was zu Brandgefahr führen kann.

Für die Kantenbearbeitung habe ich mit komprimierenden Fräsern wie dem Viertelstab gute Erfahrungen gemacht. Taucht man nur leicht in das Material ein, so eignet sich aber auch ein V-Cut. Bei größerer Eintauchtiefe erreichen Halbrundfräser “Ball-nose” ein schönes Fräsbild.

Auf dem Bild ist ein Vergleich dargestellt. Rechts mit grün-grauer Beschichtung das Rohmaterial, geschnitten an einer Formatkreissäge. Links in violett ist das von mir CNC-gefräste Werkstück zu sehen. Das Schnittbild unterscheidet sich deutlich voneinander und die mit dem Fräser bearbeitete Fläche ist viel sauberer und ohne Ausrisse.

Geht man in der Vollnut mit spanbrechenden Fräsern vor, lohnt sich ein Schlichtgang mit gerade gezahntem Fräser und großen Vorschüben bei nur geringer Abnahme von 0.2mm.

Allen Fräsern gemein sein muss

eine möglichst scharfe Schneide (keine Beschichtung!)
eine große Schnittgeschwindigkeit (keine zu kleinen Durchmesser verwenden)
ein verhältnismäßig großer Vorschub.

Mit Einschneidern habe ich eine hohe Oberflächengüte erzielen können. Der große Spankanal sorgt für gute Abfuhr, allerdings sind Ausrisse bei der Arbeit im Vollen mitunter problematisch. Die Schneidlast ist recht hoch, und die Schneiden sind im harten Obermaterial nicht dauerhaltbar. Für Schlichtgänge allerdings ideal.

Welche Parameter?

Albasia ist so weich, dass es den Achsantrieben der Fräse kaum Widerstand bietet. Die Schnittgeschwindigkeit ist hoch anzusetzen, Quellen im Internet empfehlen etwa 500m/min als Richtwert. Als Vorschub habe ich Werte bis 6000mmm/min ausprobiert. Ich habe aber auch nur kleine Werkstücke bearbeitet, weswegen noch höhere Vorschübe wegen der ständigen Richtungswechsel kaum einen Zeitvorteil böten. Ein zusätzlicher Schlichtgang ist wegen der Marken des Spanbrechers Pflicht.

Einen guten Kompromiss zwischen Fräszeit und Oberflächenqualität habe ich für verschiedene Fräser unten festgehalten. Die Gravierfräser lasse ich allerdings ausschließlich in der HPL-Schicht arbeiten, weswegen ich Vorschub und Drehzahl etwas reduziere.

Werkzeug (s= Anzahl Schneiden)	Vorschub `F` [mm/min]	Drehzahl `S` [U/min]	Zustellung Z [mm]	Zustellung XY [mm]
VHM-2s spanbrechend 15° 6mm	4200	24000	12	2.7
VHM-2s gerade 6mm	3700	26500	21	0.2
VHM V-cut 3s 90° 10mm	3000	21000	0.27	0.1
VHM Radienfräser 2s 6mm	3000	21000	0.27	0.1
VHM Viertelstab 4s r2 6mm	3600	15000	2	2

Schlichtgang

Das folgende Video zeigt die den Schlichtvorgang nach dem Schruppen eines 145x145mm großen Werkstückes. Durch die geringe seitliche Zustellung bilden sich kaum Fasern aus und der geringe Vorschub sorgt trotz leichtem Drall des Fräsers für eine sehr hohe Oberflächengüte.

Your browser does not support the video tag.

CNC-Schlichten von Albasia Verbundmaterial

Gravuren

Bei beschichteten Albasiaplatten finden Gravuren idealerweise in der Deckschicht statt. Wird nicht in das Trägermaterial eingetaucht, so können keine Probleme mit Ausrissen und losen Fasern entstehen. Da die Deckschicht nicht sehr stark ist, fällt die Wahl schnell auf V-Fräser mit stumpfem Winkel oder mit abgeflachter Spitze.

Alternativ hierzu können Bereiche mit Schaftfräsern vorgeräumt werden, falls das CAM-Programm eine solche Option bereitstellt. So entstehen komplett glatte “Böden” innerhalb der Taschen. Oder man verwendet Halbrundfräser wegen ihrer nur sanft ansteigenden Geometrie im unteren Bereich. Unterstützt das CAM-Programm die 3D-Gravur hiermit nicht, so kann die Fräsergeometrie wie im Artikel Halbtonbilder auf Dibond beschrieben angenähert werden.

Zwei Beispiele habe ich im untenstehenden Bild vorbereitet: Der CR-Code in der oberen Hälfte entstand mit einem 6mm-Radienfräser bei 0.2mm Eintauchtiefe. Die entstehenden Punkte und Linien fühlen sich durch die sanften Übergänge weich und angenehm an. Der Schriftzug in der unteren Bildhälfte ist mit einem Gravierfräser und bis zu 7mm Tiefenzustellung gefräst. Hierdurch kommt der natürliche Holzton zwar schön zur Geltung, bei kleinen Schrithöhen wie dieser (max. 30mm) entstehen aber leicht Ausbrüche bei Buchstaben mit “Inseln” (a, e, b, o, etc.).

Mit Farbe arbeiten

Die Kontraste der Gravuren sind zwar in Ordnung, die Lesbarkeit ist aber längst nicht perfekt. Da liegt es nahe, Gravuren mit Farbe auszulegen. Ich habe mit ein paar Farbtönen experimentiert; ein paar Impressionen finden sich im Bild unten.

Welcher Lack?

Die Platte wird mit einer Schutzfolie ausgeliefert, um die farbige Beschichtung zu schützen. Das macht das Auslegen mit Farbspray total einfach, wenn ich die Schutzfolie für die Gravurbearbeitung auf dem Werkstück belasse. Ich habe mit handelsüblichem Acryllack auf Wasserbasis (oben rechts), Farbspray mit Metallpartikeln (unten) und mit lösemittelbasiertem Permanent Marker (oben links) gearbeitet.

Dabei ging die Lackierung stets leicht von der Hand. Die Abriebfestigkeit ist bei den in HPL gravierten Flächen hoch. Graviert man bis hindurch zum Holz, so stellen sich die Fasern durch das Lackieren etwas auf, was später nur sehr zeitaufwendig korrigiert werden kann und dem Gesamteindruck nicht zuträglich ist.

Zu beachten: Schutzfolie

Der Lackiervorgang sollte möglichst direkt nach dem Gravieren gestartet werden und nicht erst Tage oder gar Wochen später. Ansonsten nämlich neigt die Schutzfolie zum Ablösen bzw. zur Blasenbildung an den Rändern der Gravur und die Farbe wird durch Kapillarkräfte in Bereiche gezogen, wo sie nicht hingehört. Dies hat mir die gold-blaue Version meiner Testreihe leider deutlich sichtbar ruiniert.

Fazit: Albasia für was?

Alles in Allem würde ich Albasia zu den eher gutmütigen Materialien zur CNC-Bearbeitung zählen, die einen weiten Parameterbereich von Vorschüben bei hoher Schnittqualität akzeptiert. Herausfordernd sind die Neigung zum Bilden langer Fasern und die sehr unterschiedliche Härte zwischen Deckschicht und Kernmaterial; Geht man mit zu hohen Vorschüben vor, so nutzt der Fräser in den Bereichen mir HPL-Deckschicht sehr schnell ab.

Als Gravurmaterial eignet es sich ebenfalls, wofür aber die Beschichtung allein bereits genügen würde und durch die kleinen Gravurtiefen enge Grenzen für die Strichbreite gesetzt sind. Die Gravur kann also allenfalls nettes Beiwerk zum eigentlichen Einsatz der Platten sein.

Die Beschichtung macht das Material absolut möbelbaufähig. Arbeitet man mit verdeckten Kanten, so kann ich mir sogar den Einsatz in der Küche vorstellen. Da es eine hohe Biegestabilität besitzt und die Beschichtung mit hoher Härte besticht, ist es sogar als Oberfläche für den täglichen Gebrauch verwendbar. Das Plattenmaterial ist federleicht und eignet sich daher auch prima für mobile Anwendungen im Sichtbereich.

An die Robustheit von Birke Multiplex reicht es jedoch nicht heran. Belastete Verbindungen traue ich dem Material ohne Weiteres nicht zu; bei Verschraubungen würde ich Oberflächen maximieren und stets Möbelbauverbindungen einsetzen (also keine Holzschrauben nehmen).

passtdas auf Github

Schallbert — Sun, 14 Sep 2025 00:00:00 +0000

— September 2025 — passtdas zum Download verfügbar

Das Werkzeug passtdas liest eine G-Code Datei für die Bearbeitung mit einer CNC-Fräsmaschine und ermittelt die Werkstückgrenzen (Extremwerte) in X und Y. Anschließend schreibt es ein weiteres CNC-Programm mit diesen Punkten und ermöglicht so, dass die Werkstückgrenzen direkt an der Maschine angefahren werden können.

So kann stets sichergestellt werden, dass der Rohling korrekt ausgerichtet ist und das Werkstück drauf passt.

Link zum Projekt auf Github

Ich habe vor, das Projekt demnächst in eine Browser-Lösung zu portieren und will es auf diese Weise einfacher zugänglich machen.

Schallbert

passtdas - ein Hilfsprogramm für die CNC

Schallbert — Mon, 08 Sep 2025 00:00:00 +0000

Das Problem

Ein Bekannter von mir schrieb mich an. Er betreibt eine CNC-Portalfräsmaschine als Hobby so wie ich und fertigt oft Einzelstücke. Die dabei entstehenden Reste sind aber teils zu schade zum Wegwerfen. Für eine bestmögliche Materialausnutzung probiert er, diese Reste als Rohlinge für weitere Projekte zu verwenden.

“Weißt du, wie ich an der Maschine herausfinden kann, ob mein Frästeil auf den Rohling passt?” - Anonym

Schnell ist es passiert: Den Maßen zufolge passt das Werkstück so gerade auf den Rohling. Setzt man den Nullpunkt nur leicht falsch, so fährt der Fräser über die Werkstückgrenzen hinaus und man kann das Werkstück wegwerfen.

Die Lösung

Es wäre doch toll, wenn die Maschine vor Beginn des Fräsvorganges die Kontur des Werkstückes abfahren würde, oder? So könnte man unkompliziert herausfinden, ob sich der Rohling wirklich komplett innerhalb der Werkstückgrenze befindet.

Da ich auf Anhieb keine schnelle Lösung online finden kann, denke ich an selbstgeschriebene Software für die Umsetzung. Daher mache ich mich an die Arbeit.

TODO: ADD VIDEO LINK

Die Software

Für einen schnellen Prototypen wähle ich die Hochsprache python. Warum? Ich beherrsche python recht gut, Bibliotheken für die erforderlichen geometrischen Berechnungen sind verfügbar, und das geschriebene Programm lässt sich leicht in eine all-in-one-Datei kompilieren.

Das Programm soll Maschineninstruktionen (G-Code) lesen und die Fräspfade analysieren. Die Stellen, an denen im Fräsprogramm die maximalen und minimalen X- und Y-Werte angefahren werden, sollen abgespeichert und selbst als Bewegungskommando in einer Pfaddatei ausgegeben werden.

Lädt man dieses Programm auf die Maschine, so wird ein so ermittelter “Extremwert” angefahren und die Z-Achse von Sicherheits- auf Messhöhe abgesenkt. Anschließend wird das Programm pausiert, sodass der Bediener Anpassungen der Werkstückposition vornehmen kann. Erst durch Einabe eines weiteren Startbefehls wird der nächste Extremwert angefahren usw.

Dieses Programm wird passtdas heißen.

Programmart

Ich entscheide mich für ein Konsolenprogramm mit wenigen Parametern:

Shortcut	Parameter name	Description
`-f`	`--file`	The source file to be analyzed. Required.
`-s`	`--zsafety`	Safety height the machine will do flyovers with. Optional.
`-p`	`--zprobe`	Probe height the machine will pinpoint to. Optional.

Die beiden Höhenparameter bekommen Default-Werte, sodass sie nicht immer mit angegeben werden müssen.

Eingabe

passtdas liest Dateien ein und durchsucht sie zeilenweise nach Bewegungsbefehlen G00, G01, G02, G03. Während die Auswertung für lineare Bewegungen wie G00, G01 einfach ist - Lineare Bewegungen lassen sich durch Punkt-zu-Punkt-Verbindungen ausdrücken, deren Extremwerte nicht zwischen den Punkten liegen können - kann das für Kreissegmente durchaus herausfordernd sein.

Die Höheninformation auf der Z-Achse wird ebenfalls mitgelesen und gespeichert. So kann die Zerspanungstechnikerin schnell prüfen, ob die maximale Frästiefe mit der Gewünschten übereinstimmt.

Befinden sich in der G-Code-Datei keine oder falsch formulierte Anweisungen, so gibt das passtdas entsprechende Fehlermeldungen aus und bricht die Analyse ab.

Definition Kreissegmente

Zum Hintergrund: Im G-Code können Kreissegmente auf zwei Arten definiert werden.

[...]
G00 X5.660 Y-0.000 Z10.000
G02 X-5.660 Y0.000 R5.660 F1600
[...]

Kommando:

“Fahre einen Kreisbogen im Uhrzeigersinn ab dem Punkt X5.66 Y0 mit Radius 5.66mm bis zum Punkt X-5.66 Y0 mit Vorschub 1600mm/min auf Höhe 10mm.”

Zeichnet man diese Kommandos, entsteht ein hängender Halbkreis. Kreise können mittels dreier Punkte definiert werden. Doch nur zwei Punkte sind gegeben. Der dritte Punkt muss mit Hilfe von Anfangs- und Endpunkt aus dem ebenfalls angegebenen Kreisradius berechnet werden.

Aufgabe: Finde heraus, wo dieser Kreis seine Extremwerte in XY hat.

Aber auch so kann ein Kreissegment definiert sein:

[...]
G00 X-2.5696 Y5.0431
G03 X-4.6258 Y3.2616 Z-0.5000 I2.5696 J-5.0431
[...]

Kommando:

“Fahre einen Kreisbogen gegen den Uhrzeigersinn ab dem Punkt X-2.56 Y5.04 mit Mittelpunktkoordinaten I2.56 J-5.04 bis zum Punkt X-4.62 Y3.26.”

Zeichnet man diese Kommandos, entsteht ein kurzes Kreissegment im oberen linken Quadranten. Hier sind zwar drei Punkte (Start- und Endpunkt sowie Kreismittelpunkt) gegeben. Doch auch hier kann es mitunter schwierig werden, herauszufinden, ob irgendwo auf dem Kreisbogen ein Extremwert angefahren wird.

Aufgabe: Finde heraus, wo dieser Kreis seine Extremwerte in XY hat.

Extremwerte von Kreissegmenten berechnen

Ein Kreissegment kann je nach Spanne bis zu vier zusätzliche Extremwerte haben: X+, Y+, X-, Y-. Bei einem Vollkreis sind dies stets die Koordinatenschnittpunkte vom Radius aus gesehen.

def get_extremes_from_arc(arc, coordinates):
 # [...]
 x_plus_radius = [center_x + radius, center_y, xyz[2]]
 y_plus_radius = [center_x, center_y + radius, xyz[2]]
 x_minus_radius = [center_x - radius, center_y, xyz[2]]
 y_minus_radius = [center_x, center_y - radius, xyz[2]]
 extremevalue_order = [x_plus_radius, y_plus_radius, x_minus_radius, y_minus_radius]
 if (arc[1] - arc[0]) < 0:
 # crossing the 0° line (x-axis), handle overflow with nested if below
 arc[1] += 360
 result = []
 for crossing_angle in range(0, 721, 90):
 if crossing_angle in range(int(arc[0]), int(arc[1] + 1)):
 i = int(crossing_angle / 90)
 if i > 3:
 i -= 4
 result.append(extremevalue_order[i])
 # [...]

Sind Kreismittelpunkt sowie Kreisradius bekannt, kann aus den Anfangs- und Endpunkten der überstrichene Winkel bestimmt werden. Hierdurch wird nun klar, ob Kreisanfangspunkt und/oder -Endpunkt selbst Extremwerte darstellen, oder ob durch Überstreichen eines Koordinatennullpunktes zusätzliche Extremwerte entstehen. Genau dies tut das obige Codebeispiel.

Datentabelle

Alle möglichen Extremwerte (zwei bei einer Linie, bis zu vier bei einem Kreissegment) werden nun in einer Datentabelle gesammelt. Sobald jede G-Codezeile ausgewertet und die Liste damit komplett ist, werden die Maximal- und Minimalwerte für jede Achse aus dieser Liste bestimmt.

So entstehen schließlich vier XYZ-Koordinaten, welche für jede Raumrichtung die maximale Ausdehnung des Werkstückes beschreibt.

Parallel durchsucht das Programm alle Befehle an die Z-Achse und merkt sich die maximale Eintauchtiefe.

Ausgabe

Das Kommandozeilenprogramm verfügt über keine visuelle Ausgabe. Daher beschränke ich mich auf die Erstellung eines Simulationsprogramms für die Fräsmaschine, in dem die Werkstückausdehnung angefahren wird und bei jedem Punkt pausiert:

G90

# Go to coordinate zero
MSG "Zmin of this job: -1.0"
G00 Z40
G00 X0 Y0
G01 Z15 F1200

MSG "PathPreview: Hit START to go to Ymin: ['0.0', '-5.66']"
M00
G00 Z40
G00 X0.0 Y-5.66
G01 Z15 F1200

MSG "PathPreview: Hit START to go to Xmin: ['-5.66', '0.0']"
M00
G00 Z40
G00 X-5.66 Y0.0
G01 Z15 F1200

MSG "PathPreview: Hit START to go to Ymax: ['0.0', '5.66']"
M00
G00 Z40
G00 X0.0 Y5.66
G01 Z15 F1200

MSG "PathPreview: Hit START to go to Xmax: ['5.66', '0.0']"
M00
G00 Z40
G00 X5.66 Y0.0
G01 Z15 F1200
# [...]

Obiges Beispiel fährt die Extremwerte eines Kreises mit r=5.66mm ab. Dabei fährt es stets eine Sicherheitshöhe von Z40 zum Überstreichen der Punkte an und bewegt die Z-Achse bei Ankunft langsam mit F1200 auf die Zielhöhe von Z15. Wichtig dabei ist, dass der Nullpunkt in Z vorher korrekt vermessen wurde - sonst kommt es möglicherweise zur Kollision mit dem Werkstück.

Test und Verifikation

Um zu sehen ob das Programm auch wie erwartet funktioniert habe ich drei Testdateien erstellt:

Unit tests: Prüft einzelne Funktionen im Programm, z.B. ob Linien- und Kreissegmente korrekt erkannt werden
integration tests: Testen, ob Funktionen im Verbund korrekt funktionieren, z.B. die richtige Berechnung von Extremwerten anhand von Eingabewerten
End to end tests: Diese Tests prüfen über die gesamte Funktionskette, z.B. ob falsch formatierte Eingabedateien erkannt werden

Zum Schluss erstelle ich mehrere Testdateien mit dem Programm und fahre die daraus erzeugten Extremwerte mit meiner CNC an.

Open-source software

Der Quellcode für passtdas steht kostenlos auf GitHub zur Verfügung, muss allerdings durch Python interpretiert werden.

Ich baue ein Endanwenderfreundliches und leicht zu bedienendes Programm daraus, sobald genügend Leute den Wunsch dafür geäußert haben.

Giteas act_runner rootless ausführen

Schallbert — Sun, 10 Aug 2025 00:00:00 +0000

In diesem Artikel zeige ich, wie ich den act_runner meiner Gitea-Instanz von gitea/act_runner auf gitea/act_runner:latest-dind-rootless umstelle.

Warum dieser Aufwand? Weil act_runner in Docker läuft und Zugriff auf den Daemon per /var/run/docker.sock als sogenanntes Volume (gemeint im Sinne von Datenträger) bzw. Bind-Mount benötigt, um zu funktionieren. Der Besitzer dieses Sockets ist root, wodurch der Container praktisch Vollzugriff auf das Hostsystem erhält.

“RULE #1 - Do not expose the Docker daemon socket (even to the containers)” - OWASP / Docker Security Cheat Sheet

Dies ist hoch riskant, denn es liegt im Prinzip des Runners, von Dritten erzeugten Job-Code auszuführen. Ein offenes Einfallstor. In Verbindung mit direktem Durchgriff auf das Hostsystem kann das im Falle eines erfolgreichen Angriffes einen Totalausfall bzw. die “feindliche Übernahme” meiner Infrastruktur bedeuten.

Gefahr durch `docker.sock`

Ich richte mich in dieser Anleitung nach der Empfehlung von OWASP zum Thema Docker-Sicherheit und wende deren Regel(n) in der Praxis an. OWASP steht für “Open Web Application Security Project”. Es ist eine Organisation, die sich für höhere Sicherheit von Webanwendungen einsetzt und dabei Anwender wie mich mit kostenfreien Artikeln, Dokumentation und Technologie unterstützt.

Die unter Regel 1 beschriebenen Maßnahmen lauten:

Dockers tcp Socket abgeschaltet lassen

Sollte der Zugang zum Docker Daemon per tcp eingeschaltet sein, kann sich mit diesem - sofern keine weiteren Vorkehrungen getroffen wurden - über eine ungesicherte Verbindung und ohne Authentisierung verbunden werden. Der Daemon ist dann durch praktisch jeden Internetnutzer zugänglich und damit angreifbar.

Wie stelle ich also sicher, dass der tcp Socket abgeschaltet ist? Die Anleitung hierzu findet sich in den Docker Docs und muss quasi verkehrt herum angewandt werden. Auch dort wird ausdrücklich vor ungeschützter Verfügbarmachung des tcp-Sockets gewarnt.

Nach Ausführen aller erforderlichen Schritte lasse ich netstat einmal durchlaufen. Es listet mir offene Sockets, Netzwerkschnittstellen und Routing-Tabellen auf:

# check if Docker Daemon's "dockerd" tcp socket is exposed
schallbert@machine:~# netstat -lntp | grep dockerd
# test is a pass if this command does not return anything.

Bei mir findet sich kein Eintrag mit dockerd. Mein Server ist an dieser Stelle schon einmal nicht verwundbar.

Den Docker Socket `/var/run/docker.sock` nicht in andere Container einbinden

Hier wird es schon etwas schwieriger: act_runner benötigt den Socket, um Job-Container zu erzeugen, zu verwalten und schließlich wieder zu entsorgen. Ohne Zugriff auf den Docker Daemon über den Socket funktioniert die Build-Pipeline schlicht und einfach nicht - es sei denn, man möchte komplett auf Docker verzichten und sowohl den Runner als auch die Build-Jobs direkt auf der Host-Maschine laufen lassen. Damit gingen aber viele Nachteile einher: Verlust der Kapselung, keine Portabilität, schlechte Skalierbarkeit, geringere Sicherheit…

Aber auch für die Option mit Docker gibt es eine Lösung: act_runner Docker-in-Docker aufsetzen. Mit diesem Setup erhält act_runner einen eigenen Docker Daemon, jedoch mit eingeschränkten Rechten und ohne Zugriff auf den des Host-Systems. Dieser übernimmt dann den Lebenszyklus von Job-Containern, sodass sie komplett unabhängig vom Host-System laufen.

Docker in Docker

Folgendes Schaubild verdeutlicht den Unterschied:

Act_runner “rootless” starten

Also folge ich der Anleitung und kopiere mir eine passende docker-compose.yml zusammen. Wichtig hier:

Es muss privileged: true gesetzt werden. Ansonsten kann der Docker Daemon im act_runner-Container nicht richtig starten, da ihm Kernel-Funktionen fehlen. Somit schmiert der ganze Container wieder und wieder ab, ohne dabei hilfreiche Fehlermeldungen zu erzeugen.
Die Umgebungsvariable DOCKER_HOST=unix:///var/run/user/1000/docker.sock muss gesetzt sein. Hier wird der Docker Socket über einen nicht-privilegierten User gesteuert und steht dem Runner für die Verwaltung von Job Containern zur Verfügung. Der Daemon läuft gekapselt im Container und steht nicht in Verbindung mit der Host-Maschine.

Volume-Verwirrung

Prima! Da der Runner nun läuft, lasse ich ihn direkt mal auf einen Job los. Leider schlägt das Bauen bereits nach Sekundenbruchteilen mit dieser Meldung fehl:

# Runner step: Set up job
failed to start container: Error response from daemon: error while creating mount source path '<volumeSourceFullPath>': mkdir <volumeSourcePath>: permission denied

Hier habe ich stundenlang recherchieren müssen und war lange der falschen Überzeugung, dass es an fehlenden Berechtigungen bei Ordnern auf der Host-Maschine liegt. Später erst verstand ich wirklich, dass Docker-in-Docker genau so gemeint ist, wie es heißt: Nicht nur werden Container durch Container erzeugt, sondern innerhalb des Containers läuft ein separater Docker Daemon!

Damit funktioniert nämlich der klassische Weg nicht mehr, Volumes in Job Containern direkt vom Host-System per -v /a/b:/x/y verfügbar zu machen. Stattdessen müssen Volumes nun durchgereicht werden. Beispiel:

host directory /opt/server/www/blog-artifacts -> act_runner volume /tmp/blog-artifacts –> job container volume /tmp/blog-artifacts

Das :z im Volume vom act_runner wird jetzt wichtig. Es zeigt Docker gegenüber an, dass dieses Volume zwischen Containern geteilt wird. Diese Volumes müssen nicht nur in der docker-compose.yml von act_runner angegeben werden, sondern auch die Job-Skripte im Ordner .gitea/workflows/ sind jetzt entsprechend anzupassen. Hier wird das :z auf der “rechten Seite” hingegen nicht benötigt.

“is not a valid volume”

Allem Aufwand zum Trotz laufen meine Jobs noch immer nicht durch. Dieses Mal wegen einer Fehlermeldung, die mir bereits bekannt vorkam:

# Runner step: Set up job
[/tmp/blog-artifacts] is not a valid volume, will be ignored

Also rein in die config.yml von act_runner und die Volume-Namen hinzufügen:

# /gitea/runner/config.yml
# [...]
 valid_volumes: ["/tmp/blog-artifacts", "/tmp/lectures-artifacts"]
# [...]

In dieser Datei kann ich privileged: false stehen lassen, denn der Job Container selbst benötigt anders als act_runner keine Kernel-Features.

Berechtigungen korrekt setzen

Nun erhalte ich erneut Permission Denied Fehlermeldungen beim Ausführen meiner Jobs, wenn auch nicht direkt im ersten Schritt der Aktionen. Da ich die Volume-Pfade jetzt bis ins Kleinste geprüft habe, kann es eigentlich nur noch an den Ordnerberechtigungen auf der Host-Maschine liegen.

Damit die vom Job-Container erzeugten Artefakte durch die Volumes auf meinem Host abgelegt werden können, muss ich das zu schreibende Verzeichnis und alle Unterordner -R an den vorher definierten, nicht-privilegierten User ID=1000 übergeben:

schallbert@machine:~# chown -R 1000:1000 /target/path/to/artifact/

Endlich funkioniert alles reibungslos und ich habe der (unwahrscheinlichen, aber möglichen) Übernahme meines Host-Systems durch bösartige Job-Container einen Riegel vorgeschoben.

Rate limiter für Gitea

Schallbert — Fri, 25 Jul 2025 00:00:00 +0000

Hier halte ich eine Schritt-für-Schritt Anleitung fest, die das Problem meiner Gitea-Abstürze lösen soll. Die Erfahrung aus der Erstanwendung eines Rate Limiters für meinen Blog lasse ich hier einfließen mit dem Ziel, dass die Anwendung robuster läuft und gegen ungerichtete Denial of Service Attacken geschützt wird.

Schritt 1: Log-Quelle für rate limiter festlegen

Gitea erzeugt natürlich selbst Logs, theoretisch bis herunter auf Zugriffsebene durch externe Clients. Doch schaffte ich es in der Vergangenheit nicht, Giteas Access-Logs aus Docker auszuleiten. Daher geben wir jetzt dem als Reverse Proxy angeflanschten Caddyserver die Anweisung, Logs stellvertretend zu erstellen. In ihnen tauchen dann Zugriffe auf das Webinterface von Gitea auf.

In der Caddyfile sieht das Log-Modul total unspektakulär aus.

# /caddy/Caddyfile

#[...]
log {
 output file /log/gitea/access.log
 }

Internen Traffic vom Log ausschließen

Nun schaue ich die Logs mal an und sehe Einträge, die ich gar nicht haben will. So erzeugt act_runner zum Beispiel alle zwei Sekunden einen Fetch Task POST nach Gitea und alle zehn Sekunden einen GET Request mit demselben Ziel als Health check. Diese brauchen für mich im Log gar nicht erst aufzutauchen. Mein erster Gedanke hier war, einfach Anfragen von internen IP-Adressen nicht zu loggen. Da Caddy allerdings als Reverse Proxy fungiert, laufen ausnahmslos alle IP-Adressen “intern”.

Also muss ich act_runner spezifische Logs anders erkennen:

# /caddy/Caddyfile

#[...]
git.schallbert.de {
 reverse_proxy * http://gitea:3000

 # Enable logging for fail2ban, don't log for runner
 log_skip /api/actions*
 log {
 output file /log/gitea/access.log
 }
}

Die log_skip Direktive weist caddy nun an, keine Logs für Zugriffe auf /api/actions* mehr anzulegen.

Reverse-Proxy: Remote IPs anzeigen

Dennoch habe ich noch immer ein Problem: Wenn im Log alle externen Anfragen auf einer internen IP-Adresse hereinkommen, wie soll ich “böse” Anfragen dann wegblocken? Eine Websuche zeigt, dass dies für Reverse Proxy in Docker ein üblicher Stolperstein ist. Leider helfen mir viele Lösungen nicht, da sie andere Serversoftware wie nginx verwenden oder andere Services hinter ihren Proxies laufen haben als Gitea.

Doch tatsächlich ist es ganz einfach: Nur eine Zeile muss an der richtigen Stelle in die Caddyfile eingefügt werden und schon kommen die remote IP-Adressen unverfälscht rein.

# /caddy/Caddyfile

#[...]
git.schallbert.de {
 reverse_proxy * http://gitea:3000 {
 trusted_proxies 172.16.0.0/12 # Docker-internal netwock traffic runs with these IPs
 }
#[...]

Die Direktive trusted_proxies teilt Caddy mit, dass dem von Docker bereitgestelltem Netzwerk vertraut werden kann. Somit wird die eigentliche Quell-IP angezeigt statt der internen Schnittstelladresse des Containers. Genau das brauche ich, um die Adressen später mit fail2ban analysieren zu können.

Schritt 2: Anwendungsfall bestimmen

Schauen wir uns an, wie viele HTTP 200 ok Anfragen im Grenzfall zwischen Normalnutzung und “abuse” kommen. Dazu surfe ich auf Gitea herum und klicke einen Haufen Dinge an, wie ich das als Mensch sonst nie in der Geschwindigkeit tun würde. Danach mache ich eine Auswertung der Logs.

Damit haben wir erste Richtwerte für den Rate Limiter.

# rate limiter tests
findtime = 10s
maxretry = 10
bantime = 6h

Schritt 3: Fail2ban konfigurieren

Anschließend konfigurieren wir Filter und Jail-Datei von fail2ban so, dass sie die oben definierten Logs analysieren.

Filter

Ich verwende hier schlicht denselben Filter für meinen Rate-Limiter aus dem vorherigen Artikel wieder. Uns interessieren nur erfolgreiche Anfragen, die wir innerhalb eines Zeitfensters zählen.

Jail

Ich verwende die Werte aus den rate limiter Tests 1:1 hier in der Jail-Datei weiter. Als Filter verweise ich auf caddy-ratelimit (Link oben).

# /fail2ban/config/fail2ban/jail.local
# [...]

[gitea-ratelimit]
enabled = true
chain = DOCKER-USER
port = http,https
filter = caddy-ratelimit
logpath = /var/log/caddy2/gitea/access.log
findtime = 10s
maxretry = 10
bantime = 6h

Mit einem Neustart von fail2ban schalte ich den Schutz scharf.

Schritt 4: Rate limiter testen

Hier gehe ich genauso vor wie in meinem Artikel fail2ban with caddy und komme zum selben Ergebnis. Es funktionert!

⚠️ Update Oktober 2025

Wird fail2ban auf Services in Docker-Containern angewendet, kann mit der oben genannten Konfiguration des jails Gein Fehler auftreten. Die Behebung habe ich im folgenden Artikel dokumentiert: fail2ban-Fehler “Bad value substitution” for ‘action’

Rate limiter mit Caddy und fail2ban

Schallbert — Thu, 10 Jul 2025 00:00:00 +0000

Hier beschreibe ich, wie man das meist zur Abwehr unerlaubter Zugriffsversuche eingesetze Werkzeug fail2ban auch zur Begrenzung der Anzahl von erfolgreichen Zugriffen innerhalb eines definierten Zeitfensters verwenden kann. Dies nennt man “rate limiting” und soll denial of service Attacken vereiteln, bei denen mein Server überlastet wird.

Caddy-Logs einschalten

Zuerst müssen wir den Logger des Webservers einschalten. Bei Caddy geht das mit wenigen Zeilen Code, die ich meiner bestehenden Konfiguration hinzufüge:

# caddy2/config/Caddyfile

blog.schallbert.de {
# Define webserver
root * /www/blog
encode gzip
file_server

# Enable logging for fail2ban
log {
output file /log/blog/access.log
}

# [...]

Ab jetzt werden im angegebenen Pfad Logs angelegt, die ich mit einer logrotate-Konfiguration verwalte.

Fail2ban als Rate Limiter konfigurieren

Nochmal kurz zur Wiederholung: fail2ban greift auf die Paketfilter-Regeln der Maschine zu und modifiziert sozusagen ihre Firewall, um dynamische Angriffe abzuwehren. Damit dies funktioniert, müssen fail2ban Logdateien zur Verfügung gestellt werden, die eine Host-Applikation wie beispielsweise ein Webserver erzeugt und IP-Adressen der Client-Rechner enthalten.

Vorüberlegung: “http 200 OK” als Filter?

Auch normale, zulässige Zugriffe 200 OK müssen für meinen Rate Limiter zählen.

Um ein Gefühl zu bekommen wie der Logger Zugriffe aufzeichnet, werfe ich einen Blick in die Logs. Ich lasse mir die Anzahl Einträge zurückgeben, die einen Status 200 OK enthalten. Dazu führe ich mit grep eine Suche durch und lasse mir die Anzahl Treffer zeilenweise per wc -l ausrechnen.

schallbert@machine:/var/log/caddy2/blog# grep -o '"status":200' access.log | wc -l
847

Gut, es hat heute also bereits 847 Zugriffe gegeben, die 200 OK zurückgemeldet bekommen haben. Nun rufe ich selbst mal die Landing page meiner Blogseite auf und lasse mir dann die Artikelübersicht anzeigen.

schallbert@machine:/var/log/caddy2/blog# grep -o '"status":200' access.log | wc -l
858 // after calling blog.schallbert.de
rschallbert@machine:/var/log/caddy2/blog# grep -o '"status":200' access.log | wc -l
882 // page loaded after clicking "Posts" button

Whow, das waren 35 Einträge für zwei Klicks! Wenn ich mir das Log so ansehe, dann erklären sich die vielen Zeilen mit Assets - sprich Bildern und Logos, die geladen werden.

Damit ist leider klar, dass das Filterkriterium status:200 für meinen Rate Limiter nicht ohne Weiteres funktionieren kann. Denn die Anzahl Meldungen hängen maßgeblich von dem jeweiligen Artikel ab. Ich müsste also eine Grenze definieren, über der kein normaler Mensch Zugriffe auf mein Blog erzeugt.

Um nur “echte” Zugriffe auf meine Seiten zu zählen, muss ich die Assets in den Logs irgendwie ausschließen. Glücklicherweise gibt es dafür eine einfache Direktive in Caddy.

# caddy2/config/Caddyfile

 # Enable logging for fail2ban
 log_skip /assets*
 log {
 output file /log/blog/access.log
 }

log_skip sorgt nun dafür, dass alle Zugriffe auf Dateien im assets/-Ordner und darunter nicht mitgeloggt werden.
Das Verhalten von Fail2ban wird mittels zweier Konfigurationsdateien festgelegt:

Ordner `filter.d`

filter.d/<filter-name>.conf beinhaltet die Definition eines zu betrachtenden Ereignisses. So kann die failregex ein “Seite nicht gefunden” http 404 Statuscode ebenso zum Auslösen des Paketfilters verwendet werden wie der erfolgreiche Zugriff für den Aufbau meines Rate Limiter, welcher auf 200 OK reagiert. Abgeschrieben habe ich für die Regex bei Rafael Kassner.

# /opt/fail2ban/config/filter.d/caddy-ratelimit.conf

[Definition]
failregex = "client_ip":"<HOST>"(.*)"status":200
datepattern = \d+
ignoreregex =

Außerdem werden in der Datei weitere Randbedingungen bestimmt, z.B. das Datumsformat datepattern an den Log-Output des zu schützenden Systems angepasst.

Datei `jail.local`

jail.local bestimmt die Bedingungen, bei deren Eintritt der Paketfilter für die Client-IP aktiv wird und weitere Zugriffsversuche blockt. Für den Einsatz als Rate Limiter benötige ich folgende Felder:

findtime - das Zeitfenster, in welchem Angriffe gezählt werden, maxretry ist die Anzahl zulässiger Versuche im Zeitfenster und bantime ist die Zeit, für die geblockt wird. ignoreip ist meist per Werkseinstellung auf die relevanten internen IP-Adressen vorkonfiguriert. In meinem Falle funkt act_runner zum Beispiel an intern gitea zur Abfrage, ob neue Automatisierungsaufgaben anliegen. Diese Zugriffe will ich auf keinen Fall behindern.

Das im Folgenden verwendete Beispiel für fail2ban zeigt den Rate Limiter auf meinem Blog. Am Ende sind Dateien und Log-Einträge für gitea im Wesentlichen gleich. Nur Filternamen und Parameter unterscheiden sich voneinander durch die unterschiedlichen Anforderungen an Webseite und DevOps-Platform.

# /opt/fail2ban/jail.local
# ...

[caddy-ratelimit]
enabled = true
chain = DOCKER-USER
action = iptables-multiport
port = http,https
filter = caddy-ratelimit
logpath = /var/log/caddy2/blog/access.log
findtime = 10s
maxretry = 10
bantime = 6h

Sind diese beiden Dateien konfiguriert, kann man fail2ban neu starten und sich die Logs anschauen. Wenn man noch Fehler in den Dateien hat, gibt fail2ban folgendes aus:

ERROR Errors in jail 'caddy-ratelimit'. Skipping...

Tritt dies auf, kann z.B. das Jail nicht dem Filter (muss gleichnamig sein!) nicht zugeordnet werden, eine Feld-Definition wie maxretry ist falsch getippt oder ein Zahlenformat kann nicht gelesen werden. Wenn alles gut läuft, lautet der Eintrag:

Reading config files: /etc/fail2ban/filter.d/caddy-ratelimit.conf

Rate Limiter testen

Nun möchte ich prüfen, ob alles wie erwartet funktioniert.

Filter-Regex überprüfen

Als ersten Schritt schaue ich auf den Filterbegriff und prüfe, ob er in den Logs zuverlässig gefunden wird. Praktischerweise hat fail2ban hierfür ein passendes Werkzeug eingebaut: fail2ban-regex <logfile> <filter>. Ich kann also schlicht die Filterdatei und ein Test-Logfile eingeben und sehe dann, ob ich Treffer bekomme.

fail2ban-regex ./access.log /etc/fail2ban/filter.d/caddy-ratelimit.conf 

Running tests
=============

Use filter file : caddy-ratelimit, basedir: /etc/fail2ban
Use datepattern : \d+ : \d+
Use log file : ./access.log.2
Use encoding : UTF-8

Results
=======

Failregex: 2009 total
|- #) [# of hits] regular expression
| 1) [2009] "client_ip":"<HOST>"(.*)"status":200
`-

Ignoreregex: 0 total

Date template hits:
|- [# of hits] date format
| [2685] \d+
`-

Lines: 2685 lines, 0 ignored, 2009 matched, 676 missed
[processed in 0.12 sec]

Quantitativ bekomme ich, was ich erwarte: das oben beschriebene Suchverfahren per grep liefert mir exakt dieselben Ergebnisse.

Jail überprüfen

Als nächsten Schritt muss ich testen, ob der Rate Limiter auch greift. Dafür simuliere ich mir Logeinträge. Die Jail-Regeln nehme ich für diesen Test stark zurück, sonst muss ich zu viele Eingaben in kurzer Zeit erzeugen.

# /opt/fail2ban/jail.local TEST
# ...

[...]
findtime = 10s
maxretry = 2
bantime = 100s

Nach einem Neustart von fail2ban erzeuge ich mir eine zweite Konsole, wo ich Log-Einträge simulieren kann. Dabei müssen mindestens Zeitpunkt, IP-Adresse des Aufrufenden und Status enthalten sein; ich gehe aber auf Nummer sicher und nehme vollständige Einträge.

echo '{"ts":1751246139,"remote_ip":"1.1.1.1","status":200,[superLongIrrelevantOtherStuffForFiltering]}' >> /var/log/caddy/blog/access.log

Dies gebe ich mehrfach ein, um über mein Limit von 2 retries zu kommen.

In der ersten Konsoleninstanz prüfe ich anschließend den fail2ban-Status für den entsprechenden Filter.

fail2ban-client status caddy-ratelimit
Status for the jail: caddy-ratelimit
|- Filter
| |- Currently failed:	0
| |- Total failed:	0
| `- File list:	/var/log/caddy2/blog/access.log
`- Actions
 |- Currently banned:	0
 |- Total banned:	0
 `- Banned IP list:

Das war nichts. Warum offenbart die fail2ban-Logdatei:

# /fail2ban/config/log/fail2ban/fail2ban.log
WARN [caddy-ratelimit] Ignoring all log entries older than 20s; # probably messages generated within a fail2ban restart period

Also nochmal mit passenden Zeitstempeln. Diese muss ich aus der aktuellen Systemzeit ($(date +%s.%N)) ziehen, wenn ich sie ständig anpassen muss. Daher nehme ich eine vollständige Logzeile her, modifiziere sie auf die IP-Adresse 1.1.1.1 und füge passende Zeitstempel ein:

 echo "{\"level\":\"info\",\"ts\":$(date +%s.%N),\"logger\":\"http.log.access.log0\",\"msg\":\"handled request\",\"request\":{\"remote_ip\":\"1.1.1.1\",\"remote_port\":\"38229\",\"client_ip\":\"1.1.1.1\",\"proto\":\"HTTP/1.1\",\"method\":\"GET\",\"host\":\"blog.schallbert.de\",\"uri\":\"/vacuum-clamping/\",\"headers\":{\"Accept-Encoding\":[\"gzip, deflate, br\"],\"Connection\":[\"keep-alive\"],\"User-Agent\":[\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0\"],\"Accept\":[\"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\"],\"Accept-Language\":[\"en-US,en;q=0.5\"]},\"tls\":{\"resumed\":false,\"version\":772,\"cipher_suite\":4865,\"proto\":\"http/1.1\",\"server_name\":\"blog.schallbert.de\"}},\"bytes_read\":0,\"user_id\":\"\",\"duration\":0.001207354,\"size\":12290,\"status\":200,\"resp_headers\":{\"Last-Modified\":[\"Tue, 10 Jun 2025 19:33:01 GMT\"],\"Content-Encoding\":[\"gzip\"],\"Server\":[\"Caddy\"],\"Alt-Svc\":[\"h3=\\\":443\\\"; ma=2592000\"],\"Vary\":[\"Accept-Encoding\"],\"Etag\":[\"\\\"gzip\\\"\"],\"Content-Type\":[\"text/html; charset=utf-8\"]}}" >> access.log

Nach mehrmaligem Aufruf dieses gebastelten Kommandos erhalte ich nun

fail2ban-client status caddy-ratelimit
Status for the jail: caddy-ratelimit
|- Filter
| |- Currently failed:	1
| |- Total failed:	11
| `- File list:	/var/log/caddy2/blog/access.log
`- Actions
 |- Currently banned:	1
 |- Total banned:	4
 `- Banned IP list:	1.1.1.1

Das sieht super aus. Auf zum letzten Schritt.

Paketfilter überprüfen

Wenn wir nun einmal in die Logs schauen, müsste unser [caddy-ratelimit] Jail nun bei jeder “normalen” Anfrage triggern.

schallbert@machine: nano fail2ban/config/log/fail2ban/fail2ban.log

 <timestamp> <id> INFO [caddy-ratelimit] Found <IP a>
 <timestamp> <id> INFO [caddy-status] Found <IP b>
 <timestamp> <id> INFO [caddy-ratelimit] Ignore 172.18.0.1 by ip
 <timestamp> <id> INFO [caddy-status] Ignore 172.18.0.1 by ip
 <timestamp> <id> INFO [caddy-ratelimit] Found <IP c>
 <timestamp> <id> INFO [caddy-ratelimit] Found <IP c>
 <timestamp> <id> INFO [caddy-status] Found <IP c>
 <timestamp> <id> INFO [caddy-status] Found <IP c>
 <timestamp> <id> INFO [caddy-ratelimit] Found <IP d>
 <timestamp> <id> INFO [caddy-status] Found <IP d>
 <timestamp> <id> INFO [caddy-status] Found <IP e>
 <timestamp> <id> INFO [caddy-ratelimit] Found <IP e>
 <timestamp> <id> INFO [caddy-ratelimit] Found <IP f>

Um die ganze Kette getestet zu haben müssen wir jetzt noch prüfen, ob die entsprechende IP-Adresse auch wirklich in der Hardware geblockt ist. Dafür gebe ich ein:

schallbert@machine:~# iptables -n -L | grep "1.1.1.1"
REJECT all -- 1.1.1.1 0.0.0.0/0 reject-with icmp-port-unreachable

Scheint ja alles in Ordnung zu sein. Für einen letzten Test von einer externen IP-Adresse rufe ich im Browser einen Link Checker auf, der meine Webseite crawlen und damit den Rate Limiter auslösen soll. Obwohl dieser 44 Links in kürzester Zeit durchläuft, wird der Test als “bestanden” angezeigt. Sehr merkwürdig, [caddy-ratelimit] hätte anschlagen müssen!

iptable-chain INPUT statt FORWARD

Verwirrt schaue ich mir mal die ganze iptable an. Parallel suche ich mir die IP-Adresse des Link Checker heraus. Sie taucht in den iptables auf. Und trotzdem wird offensichtlich nicht geblockt. Woran das liegt? Ein genauer Blick zeigt:

Chain INPUT (policy ACCEPT)
target prot opt source destination 
f2b-caddy-ratelimit tcp -- 0.0.0.0/0 0.0.0.0/0 multiport dports 22

Problem hier ist, dass mein Jail auf der INPUT-Chain liegt. Die Anfragen gehen aber doch nicht direkt an meine Server-Hardware, sondern werden über Docker an Caddyserver weitergeleitet. Um zu funktionieren, muss ich auf der FORWARD-Chain landen, wo DOCKER-USER bereits ist. Sehr merkwürdig, hatte ich doch in der jail.local extra chain = DOCKER-USER angegeben. Irgend etwas muss diese Definition überschreiben.

Ein unscheinbarer Forenpost zusammen mit dem Kommentar multiport im iptables-Print bringt mich auf die Lösung: Die action = iptables-multiport Direktive überschreibt mein chain = DOCKER-USER Statement, denn in der zugehörigen Konfigurationsdatei iptables.conf wird folgendes gesetzt: chain = INPUT.

Also lösche ich den action Eintrag einfach, sodass fail2ban auf den Default für DOCKER-USER zurückfällt: multiport dports 80,443. Nun taucht der Jail-Name auch korrekt in iptables auf.

schallbert@machine:~# iptables -n -L
Chain DOCKER-USER (1 references)
target prot opt source destination 
f2b-caddy-ratelimit tcp -- 0.0.0.0/0 0.0.0.0/0 multiport dports 80,443

Erfolg genießen

Endlich zeigt ein weiterer Link Check, dass mein Rate Limiter funktioniert.

⚠️ Update Oktober 2025

In Verbindung mit diesem Artikel gibt es ein wichtiges Update, welches den fail2ban Fehler “Bad value substitution” for ‘action’ behebt. Dieses Problem kann auftauchen, wenn fail2ban Services prüfen soll, die in Docker-Containern laufen.

Gitea stürzt ab: Zu viele Anfragen

Schallbert — Mon, 30 Jun 2025 00:00:00 +0000

Hier möchte ich kurz darstellen, wie ein Absturz eines Dienstes meinen Server über Stunden wiederholt lahmgelegt hat. Und dies so gründlich, dass ich nur aus der Konsole des Anbieters überhaupt einen Neustart durchführen konnte. Ich erkläre, wie es dazu kam und wie ich dieses und ähnliche Probleme in Zukunft vermeiden möchte.

Ich wurde angegriffen. Oder?

Ich saß gerade an einem Artikel, den ich später posten wollte. Zur Sicherheit erstellte ich wie üblich einen Commit und wollte ihn auf meine Gitea-Instanz schieben. Doch mein git push Befehl lief einfach nicht durch.

Verwundert versuchte ich, meine Webseite aufzurufen. Zurück kam:

Merkwürdig. Anschließend wollte ich mich auf meinem Server einloggen, um nach dem Rechten zu sehen: ssh <servername>. Wieder blieb das Terminal ohne Reaktion. Mist!

Timeout. Als letzte Rettung meldete ich mich bei meinem Hoster an und schaute auf die Graphen des Servers:

Oh, was ist denn da los? Nun versuche ich über die Weboberfläche, den Server herunterzufahren. Klappt auch nicht. Erst ein harter Neustart ist erfolgreich. Ich kann mich wieder per SSH einloggen und sehe, dass auch alle Docker-Container wieder ganz normal hochfahren.

Was war passiert?

Gut, dass ich eine Woche lang alle Logs aufbewahre. So und über die Auslastung der Maschine über Zeit kann ich einigermaßen rekonstruieren, was passiert ist.

Welche Logs helfen?

Crash lokalisieren! Auslösende Anwendung finden im kern.log, Zeitstempel notieren.
Gibt es systemweite Auswirkungen oder andere Dienste, die beeinträchtigt werden? Im syslog nachsehen.
Falls der Verdacht aufkommt, das System sei möglicherweise gehackt worden: auth.log hat die Details.
Sollte die betroffene Anwendung im Container laufen, helfen entsprechende Logs dort möglicherweise weiter.
Logs der Anwendung selbst sichten. Besonders die Zeit kurz vor dem Crash ist interessant.

Und hier nochmal im Detail die Logs, die ich mir für meine Verhalten angesehen habe und wo sie zu finden sind.

log name	purpose	relevant content for this issue
/var/log/syslog	System-wide (bare metal) messages	(docker) warning: “health check for container `<ID>` timeout” (containerd) error: “ttrpc: received message on inactive stream”
/var/log/auth.log	Contains authentication messages from external hosts, in my case mostly SSH	None
/var/log/kern.log	Logs all app, service, daemon and system crashes	Out of memory: Killed process `<ID>` (`<serviceName>`)
[.]/gitea/log/gitea.log	Protocol for requests, actions on Gitea’s web interface, repo changes etc.	`GET` requests, crash/restart indications
docker container logs `<containerID>`	Docker’s logs for the container in question	Received signal 15; terminating. (SIGTERM)

kern.log/syslog

Hier sehe ich neben dem Stack trace, was genau passiert ist. Die am besten verständlichste Meldung ist folgende:

Out of memory: Killed process `<ID>` (gitea)

Gitea ist also der Stecker gezogen worden, weil es praktisch alle Systemressourcen gezogen hatte. Wenn ich im Log nach oben scrolle, sehe ich ein paar Minuten vorher:

<timestamp> <machineName> dockerd[716]: level=warning msg="Health check for container <ID>"
<timestamp> <machineName> dockerd[716]: level=error msg="stream copy error: reading from a closed fifo"

Bereits hier sehe ich Warnungen, dass der gitea-Container nicht sauber arbeitet. Ein weiterer Vorteil, den das Einbauen von “Healthchecks” in der docker-compose.yml Datei hat. Über Zweck und Einbau von Healthchecks in docker hatte ich aus anderen Gründen bereits einen Artikel verfasst.

gitea.log

Folgender Log-Eintrag zeigt wegen eines Bugs in einem Submodul indirekt an, dass Gitea gerade neu gestartet ist:

cmd/web.go:205:serveInstalled() [W] Table system_setting Column version db default is , struct default is 1

Und weiter oben im Log nun:

Sehr interessant. Die highlight.css liegt in meinem öffentlichen Repo. Auf ihrer Grundlage erhält die Seite lectures.schallbert.de ihr Aussehen. Diese Datei ist ziemlich groß, fast 1MiB. Und sie wird hier gleich zig male geladen, und das praktisch für jeden Commit.

Nun schaue ich mir weitere Crashes in der Vergangenheit an. Immer sind es bursts von GET-Befehlen auf große Dateien oder die Anforderung von compares zwischen zwei Branches des Repository, die einem Aufhängen meines Servers vorausgehen.

Wer steckt dahinter?

Alle crash-auslösenden Requests kommen aus dem selben IP-Adressraum. Die Abstürze starteten bereits vor ein paar Wochen. Zumeist aber zu Tageszeiten, die ich (und anscheinend auch viele meiner LeserInnen) nicht mitbekamen. Und nach ein paar Minuten war der Server stets wieder im Normalbetrieb.

Oha, die Spur führt zu Google’s Cloud Platform (GCP).

Aber ich hatte doch Robots ausgesperrt?

In der Tat hatte ich die Suchmaschinenindexierung für Gitea gestoppt. Merkwürdig. Oder habe ich es hier gar nicht mit einer der Google-spiders oder “KI”-Scraper, sondern mit einem fiesen Hacker zu tun, der sich bei “Google Cloud” eine virtuelle Maschine gemietet hat?

Log-Recherche: Wie häufig wird die Datei angefragt?

Ein Spider würde ja höchstens einmal alle paar Wochen alle meine Seiten durchsuchen, richtig? Und sich hoffentlich nicht über meine robots.txt hinwegsetzen. Erst recht nicht würde ein Crawler mehrfach und in kurzen Abständen denselben Request stellen, oder?

Zum dies zu prüfen, suche ich in den *Gitea Logs nach Einträgen von GET-Anfragen auf einer der großen und damit ressourcenintensiv zu übertragenen Dateien:

gunzip gitea.log.<date.rotateID>
grep "<filename>" gitea.log.<date.rotateID>

In der Liste sehe ich, dass dieselbe Anfrage auf dieselbe Zieldatei von derselben IP-Adresse mehrfach und binnen Sekunden gestellt wird. Kurz vor dem Crash benötigt mein Server schon fast 4sec, um die Anfrage zu bedienen.

Auch sehe ich, dass sich die IP-Adresse alle paar Stunden ändert.

Einen DoS-Angriff parieren

Zusammenfassend muss ich zum Schluss kommen, dass ich aus dem Adressraum des GCP per Denial-of-service angegriffen werde.

Um ein bisschen mehr Hintergrundwissen zu sammeln, besuche ich ein paar Websites zum Thema. Dort lerne ich, dass gitea auf meinem Server unter einer Application Layer Attack zusammenbricht. Jetzt da ich weiß, was passiert und wie das Problem heißt, fällt das Finden von Lösungen gleich viel leichter 😅

Ich will mich natürlich nicht kampflos ergeben, indem ich meine Gitea-Instanz dauerhaft vom Netz nehme. Also, welche Optionen habe ich?

Mehr Ressourcen bereitstellen

Zugegeben, meine Maschine hat nur 40GB Speicher und 2GB VRAM sowie eine mickrige 2-Kern CPU aus 2009. Ich könnte einen leistungsfähigeren Server buchen, um Lastspitzen besser abreiten zu können. Doch dies würde den Angriff nicht verhindern, sondern nur seine Auswirkungen abmildern.

Rate limiting direkt im Webserver

Rate limiter begrenzen die Anzahl Anfragen eines Clients innerhalb eines Zeitfensters. Dadurch werden die Ressourcen des Servers geschont. Dies ist eine “weiche” Abwehr von Dos-Attacken, denn auslösende IP-Adressen werden mit einer Fehlermeldung kurzzeitig und sanft abgewehrt. Üblicherweise wird HTTP status code 429 “Too Many Requests” zurückgegeben, wenn der Limiter eingreift.

Gitea verfügt über keinen Rate Limiter. In meinem Setup läuft Gitea hinter einem reverse proxy, der von meinem Caddyserver bereitgestellt wird. Hier also müsste ich ansetzen. Für Caddy gibt es Rate limiter nur als externe Module, welche manuell in xcaddy nachinstalliert und eingerichtet werden müssen.

Blocken mit IP-table Regeln

Hier könnte man sich erneut fail2ban hernehmen und mehrfache Anfragen derselben Ressource von einer IP-Adresse schlicht blocken. Gitea hat in der Dokumentation eine Beschreibung der Einrichtung. In meinem Falle müsste ich für die Umsetzung dort weitermachen, wo ich bereits einmal aufgegeben hatte und damit nicht nur SSH, sondern auch normale Seitenaufrufe überwachen.

Für mich klingt diese Lösung am Sinnvollsten, denn sie trennt klar Funktionen in verschiedene Anwendungen auf. Ich nutze ausschließlich bei mir bereits verfügbare Applikationen: Caddy würde die Zugriffslogs bereitstellen und fail2ban müsste sie lesen und Filter in der Konfoguration jail.local so setzen, dass es sich wie ein Rate Limiter verhält.

Jetzt schaue ich mal, wie ich Caddy entsprechend mit fail2ban verbinden kann. Den weiterführenden Artikel Fail2ban mit Caddy einrichten verlinke ich direkt mal 🙂

Webshop selber aufsetzen - Teil3

Schallbert — Sun, 15 Jun 2025 00:00:00 +0000

Die Auswahl anhand von Leitfragen

Welche Lösung ist einfach gestrickt und mit wenig Zeitaufwand zu installieren?
Welche Lösung ist leichter zu pflegen?
Bei welchem System kann ich als Betreiber am einfachsten nachvollziehen, wie was funktioniert (Transparenz, Abhängigkeiten)?
Wo ist die Angriffsoberfläche geringer?

Hier fehlt noch einiges!

In den letzten Wochen ist mir die Lust nach einem eigenen Webshop etwas vergangen, da ich mich erst um die Sicherheit meines Servers und die Einarbeitung alter, fast fertiger Projekte kümmern wollte. Ich werde diese Serie vervollständigen, sobald mich das ich-will-was-Neues-machen-Fieber erneut packt.

Haltet durch! Schallbert

Webshop selber aufsetzen - Teil2

Schallbert — Thu, 15 May 2025 00:00:00 +0000

Ein paar Optionen für die Webshop-Software

Gehen wir mal davon aus, dass in der Vorauswahl nur Software landet, die meine Anforderungen zumindest teilweise erfüllt. Im Folgenden möchte ich ein paar mögliche Ecommerce-Lösungen vorstellen.

Shopify

Shopify ist eine alles-inklusive-Paketlösung für den Onlinehandel. Shopify Inc. hat ihren Hauptsitz in Kanada und wickelt das europäische Geschäft über Irland ab. Die auf der Website zu findenden Bereiche Rechtliches sowie die Komplexität der Informationsdarstellung zum Thema Datenschutz lassen mich vermuten, dass Shopify ein multinationaler Konzern ist - und nicht nur die Onlineshops selbigen zur Verfügung stellt.

Aber zurück zum Thema.

Die Domain sowie das Hosting sind bei Shopify im Preis inbegriffen und der eigene Shop kann ohne Programmierkenntnisse per Weboberfläche, Auswählen eines Themes und Einstellen von ein paar Parametern in kurzer Zeit erstellt werden. Shopify besitzt eine ausführliche Dokumentation und bietet Fortbildungen und allerlei weitere Dienstleistungen für ihre Abonnenten an.

Doch wo bleibt da der Spaß? Schließlich betreibe ich ein Techblog und bin kein Geschäftsmann im eigentlichen Sinne. Ein bisschen Programmieren muss da schon drin sein. Außerdem gefällt mir als Open-Source-Fan das Konzerngehabe (man schaue sich ihre moderne, mit automatisch abspielenden Videos ausgestattete, auf Marketing-Zwecke durchoptimierte Website an) nicht so besonders gut. Die Konfigurierbarkeit ist bestenfalls mittelmäßig und die Optimierung auf Suchmaschinenergebnisse muss ich wie bei den meisten anderen Lösungen auch selbst erledigen. Was Datenschutz und Sicherheit angeht, betreiben sie die übliche Compliance- und Stand-der-Technik-Kommunikation; ich kann also nicht dahinter schauen und muss davon ausgehen, dass sie ihre Kunden auch im eigenen Interesse gut schützen.

Shopify bezeichnet sich selbst als closed-source SaaS platform.

Daher streiche ich diese Plattform von meiner Liste präferierter Webshoplösungen, weil ich mich nicht ohne Not von Wohl und Wehe Dritter abhängig machen möchte. Bei Shopify hätte nämlich nicht ich die Kontrolle über Abokosten oder “meinen” Anteil an der Cloud, sondern Shopify. Nicht ich kann bestimmen, wie viele Transaktionen im “Plan” inklusive sind, sondern Shopify. Nicht meine Kunden blieben Herren ihrer Daten, sondern Shopify oder ein von ihnen mit der Abwicklung beauftragtes Drittunternehmen.

Wordpress / WooCommerce

Ich kenne Wordpress nur als Moloch. Die Eierlegende Wollmilchsau, die durch eine unübersichtlich gewordene Anzahl an Plugins, Erweiterungen und Funktionen alles kann, was man sich nur wünschen kann. Und vieles mehr, was man nicht braucht.

Aber es ist quelloffen, kostenfrei und wird laut eigener Darstellung von sehr, sehr vielen Shopbetreibern genutzt. Schauen wir uns also mal die bekannteste Ecommerce-Erweiterung zu Wordpress an: WooCommerce.

Ich fand auf Anhieb zig Anleitungen zum Aufsetzen eines WooCommerce-Shops (Beispielsweise von GeeksForGeeks oder Themeisle), also verzichte ich im Folgenden auf eine eigene Darstellung.

Nach dem Querlesen einiger Anleitungen fasse ich zusammen:

Ein WooCommerce-Shop lässt sich einfach per Assistent aufsetzen und konfigurieren
Es stehen sehr viele Themes zur Verfügung und einfach einzubindende Shopdesigns bieten für jeden Geschmack eine passende Optik
Es hilft, bereits eine Wordpress-Seite zu haben und etwas Basiswissen bezüglich Domains, DNS und Hostern zu besitzen
Viele Zahlungsdienstleister und einige Versandabwickler sind vorkonfiguriert auswählbar
Es gibt eine Menge YouTube-Lehrvideos zum Thema und eine ausführliche Dokumentation liegt ebenfalls vor
Zahllose Plugins erlauben die Optimierung des Shops auch auf sehr spezialisierte Gebiete und Einsatzzwecke
Allerdings steht dieser Optionsvielfalt gegenüber, dass die Auswahl der “besten Lösung” schwer fallen kann und dass Optimierungen der Seite hinsichtlich Geschwindigkeit und Auffindbarkeit komplex werden können

Alles in allem wirkt WooCommerce auf mich wie eine ausgewogene Mischung aus “Ich will schnell etwas Brauchbares zusammen klicken” und “Ich möchte alles konfigurieren und umbauen können”.

Snipcart

Snipcart würde ich als “Shopping-Plugin” für eine beliebige Website verstehen. Auch statische Websites, die eigentlich nur einen Warenkatalog darstellen können, werden mit Snipcart zu einer vollwertigen eCommerce-Lösung. Kernelement ist hier der Warenkorb “cart”, über den der Kaufvorgang abgewickelt wird.

Die Schnittstelle ist das HTML Markup der Webseite. Snipcart wird als JavaScript-Blob eingebunden und per HTML referenziert. Gestaltung und Aussehen läuft über cascading style sheets. In meinem Fall also könnte ich das vorhandene “Tech Stack” bestehend aus einer statischen Jekyll-site mit CD-Pipeline in Gitea auf einer Caddyserver-Instanz auch für den Shop nutzen und mit minimalen Anpassungen eine Optik aus einem Guss für Blog und Shop zaubern. Klingt doch schon einmal prima.

Snipcart wird von einer kanadischen Firma in Québec entwickelt. Es bezeichnet sich als “Shopping Cart Platform”. Für die Installation wird ein Account benötigt und man muss die eigene Shopping-Domain ähnlich wie bei der Google Search Console oder Google Analytics im Web-Frontend von Snipcart angeben, um einen sogenannten API-Key zu erhalten. Nur mit diesem wird der JavaScript-Blob später auch korrekt funktionieren.

Und damit kommt das erste größere Problem: Snipcart schränkt meine Freiheit ein.

<link rel="preconnect" href="<https://app.snipcart.com>" />
<link rel="preconnect" href="<https://cdn.snipcart.com>" />

Mir zeigt dies, dass Snipcart die Daten gern bei sich haben will. Ich muss deren content delivery network für die Abwicklung des Bestellprozesses verwenden und bei mir einbinden. Es ist also mitnichten so, dass alle Verbindungen bei mir bleiben und ich den JS-Code von Snipcart “kaufe” und im Browser des Kunden bzw. eine dahinter liegende Datenbanklösung auf meinem Server betreibe.

Wenn einem also volle Autonomie und Kontrolle über die eigene Site nicht super wichtig ist, kann Snipcart eine sehr elegante Shopsystem-Lösung sein. Dies lohnt sich vor allem für bereits bestehende Seiten. Für mich jedoch ist sie damit raus.

OpenCart

OpenCart bietet eine PHP-basiertes Shopmodul kostenlos und quelloffen an. Es kann sowohl als “Software as a Service” über Drittanbieter gebucht wie auch per Github heruntergeladen und auf eigenen Servern bereitgestellt werden.

Installation und Administration geschehen über eine Weboberfläche und ist meines Ermessens nach unkompliziert möglich. Auch im DockerHub findet man ein paar Images, mit welchen man direkt loslegen kann.

OpenCart ist vollständig an die eigenen Bedürfnisse anpassbar. Auch vorgefertigte Themes können eingebunden werden. Aus Neugier habe ich mal ein paar Webseiten angeschaut, die OpenCart einsetzen: Das Shopsystem ist aus meiner Sicht gut strukturiert und einfach zu bedienen. Jedoch ist die Ladegeschwindigkeit der von mir besuchten Beispielseiten nicht immer super schnell.

Im Gesamtpaket halte ich OpenCart mit seiner anpassbaren, leichtgewichtigen Shoplösung in PHP auch durch die immer noch aktive Community (13+ Jahre!) für eine gute Lösung.

Django

Django ist ein Webframework für Python. Es bietet viele Funktionen, ermöglicht Erweiterungen durch schlichtes Einbinden von Python-Modulen und man kann auch als Programmier-Einsteiger schnell funktionierende Lösungen erzeugen. Obwohl es eine Menge Bibliotheken beispielsweise für Websites, Shops wie z.B. django-SHOP, Datenbankeinbindungen, Einbindung von Zahlsystemen usw. gibt, muss alles noch selbst zusammen gesteckt und konfiguriert werden.

Dadurch erhält man zwar volle Kontrolle und eine perfekt an die eigenen Bedürfnisse anpassbare Lösung - doch es gibt auch einen gewichtigen Nachteil: Lernzeit. Die Sicherheit der Datenbank muss selbst hergestellt werden, Validierung von User inputs muss selbst programmiert oder zumindest korrekt konfiguriert werden. Das Abspeichern von Kundenstammdaten passiert standardmäßig erst einmal im Klartext. Zugriffs- und Löschkonzepte müssen selbst erstellt und implementiert werden bzw. man sollte Zeit einplanen, passende Module ausfindig zu machen und zu integrieren.

Sollen Frameworks verwendet werden, empfiehlt es sich vorab eine aktive Wartung durch die Community zu prüfen. Für mich sieht es beispielsweise so aus, als wäre bei django-SHOP bereits seit dem Jahre 2021 keine große Bewegung mehr auf dem Github-Repo. Eine kurze Suche hingegen offenbart eine Menge Alternativen - hier gilt es nun, etwas Passendes ins Auge zu fassen oder gleich selbst das Rad neu zu erfinden 😃

Die Alternative für Anfänger wie mich: ohne Shopsystem

Was ist mit “Ohne Shopsystem” gemeint? Ein formularbasierter Ansatz. Hier schaut sich der User eine statische Website an, die Katalog- und Produktseiten enthält. Zusätzlich sind ein paar Elemente eingeblendet wie ein Dropdown-Menü für Variante und ein Feld für die Stückzahl. Daneben ein schlichter Button. Wird dieser geklickt, so öffnet sich ein Formular, welches automatisch die geklickten Inhalte überträgt und nach Kontaktdaten des Users fragt.

Wird alles ordnungsgemäß ausgefüllt, so erzeugt das Formular beim Absenden eine PGP-verschlüsselte Mail an mich. Ich kann dann die Order analog zu manuell erstellten Bestell-Mails sichten, eine Bestellbestätigung senden und die Zahlung anfordern.

So lässt sich mit wenigen Produkten bei wenigen Kunden ohne großen Aufwand ein Shop-Äquivalent datensparsam umsetzen. Natürlich nicht so bequem wie mit einer Ecommerce-Lösung. Aber für den Anfang reicht das vielleicht trotzdem.

Im nächsten Artikel

Auswahl und Implementierung

Webshop selber aufsetzen - Teil1

Schallbert — Tue, 15 Apr 2025 00:00:00 +0000

Dies ist Teil eins der Artikelserie über den Aufbau meines eigenen Webshops. Ich liste Anforderungen und Wünsche für meine Ecommerce-Lösung auf und grenze mich damit auf ein paar passende Software-Lösungen ein, die ich dann für meinen Webshop verwenden könnte.

Was mein Webshop können muss

Für mich als Betreiber soll der Webshop möglichst schlank, transparent und automatisiert operieren. Ich möchte nur wenig Zeit mit Betrieb, Wartung und Pflege verbringen. Zahlungsabwicklung, Verwaltung des Bestellstatus, Kundenregistrierung, Versenden von Kundeninformation sowie eine große Anzahl Schritte im Versandprozess wie Frankieren und Einpflegen von Versandbestätigungen soll automatisiert stattfinden oder zumindest für die Automatisierung vorbereitet werden.

Aber auch für Kunden muss der Webshop verständlich aufgebaut sein: Simpel und mit wenigen Klicks von der Startseite bis zum Checkout, leicht zu bedienen, ähnlich zu anderen gängigen Webshops, mit unkomplizierter Zahlungsabwicklung. Dabei sollen so wenige Daten vom Kunden wie möglich erhoben werden.

Der Webshop muss nur wenige Produkte darstellen. Daher kann die Navigation sehr einfach gehalten werden. Durch die geringe Anzahl Produktkategorien kan möglicherweise komplett auf ein Baumsystem verzichtet werden.

Schauen wir uns mal schnell im Detail an, welche Funktionen der Webshop am Ende bereitstellen muss.

Funktionen für Admins

Produkt anlegen

Titel
Tags
Kurzbeschreibung
Beschreibung
Bilder
Videos
Preis
Steckbrief / Datenblatt / Anleitung

Produkt editieren
Produkt entfernen
Bestellungen verwalten

Schritt quittieren
Schritt erneut starten
Prozess stornieren

Kunden verwalten
- anlegen (sandbox)
- löschen (Datenschutz)

Funktionen für Käufer

Webshop durchstöbern
Produkt(e) konfigurieren oder Produktvariante auswählen (z.B. Farbe, Qualität)
Produkt(e) in einen Warenkorb legen
Warenkorb verwalten
Registrierung vornehmen (optional, nur zur Kundendatenablage und Bestellverwaltung)
Versand wählen
Zahlung vornehmen

Automatische Funktionen

Zahlungsregistrierung
Rechnungserstellung und -Versand
Inventarverwaltung
Versandbenachrichtigung

Nichtfunktionale Anforderungen

Hier liste ich auf, was der Webshop “nebenbei” noch so alles können soll. Alles, was nicht unmittelbar zur Auftragsabwicklung benötigt oder für Kunden sichtbar wird.

Usability Betreiberseite

Der Shop soll mit möglichst geringen Abhängigkeiten zu Software Dritter auskommen und nur diejenigen Module einbinden, die unbedingt benötigt werden. Beispiele:
- Zahlungsabwicklung
- Warenkorb
- Kundenkonto / Adressdaten
- Lagerbestände
- Bestellabwicklung (Mailer) für Käufer
- Rechnungsstellung.
Der Shop soll nur so viele dynamisch erzeugte Elemente enthalten wie unbedingt nötig.

Usability Käuferseite

Der Webshop soll sich wie aktuelle übliche ECommerce-Lösungen anfühlen: Flink, übersichtlich, einfach.
Kein Zwang zum Kundenkonto.
Der Shop soll gängige Zahlungsmöglichkeiten unterstützen (Debit, Kredit, PayPal, Apple/GooglePay etc.). Dabei sind nur lokale (in Deutschland ansässige) Zahlungsdienstleister akzeptabel.
Für den User sollen Lagerbestände bzw. Fertigungszeiten transparent angezeigt werden.

Datenschutz

Der Shop soll nur für die Geschäftsabwicklung notwendige Daten erfassen.
Falls technisch und rechtlich möglich soll der Shop ohne Cookie-Banner auskommen können.
Kundenkonten sollen automatisch nach 2 Jahren der Nicht-Nutzung (mit Ankündigung 2 Wochen vorher) gelöscht werden.

Look & Feel

Hier einige Beispiele für Shopdesigns:

Davon abgeleitete Anforderungen:

Der Webshop soll von Aufbau und Farbgebung her an meine Blogseite erinnern und eine einheitliche Optik bieten.
Es sollen nur statische Fonts ohne Nachladen verwendet werden.
Produktbeschreibungen sollen als Markdown-Dokumente (oder Ähnlich) hochgeladen werden können.

Datenbank- oder Dateilösung?

Es muss nicht immer gleich eine Datenbank sein. Für viele Anwendungen werden nur Bruchteile der Funktionalität gängiger Datenbanklösungen benötigt, doch erhöht sich die Komplexität des Gesamtsystems erheblich. Sollte z.B. gleichzeitiges Schreiben selten oder nie vorkommen und keine starke Verkettung von Daten vorliegen, so kann eine Dateilösung einfacher, schneller und effizienter sein Link zu einer passenden Engineering Kiosk Podcast-Episode.

Andererseits kommen viele Shopsysteme “with batteries included”, verfügen also schon von sich aus über eingebaute und für die Programmierer nahezu transparente Datenverwaltung.

Dateilösung (statische Website)

Auf Betreiberseite soll sich der Webshop so anfühlen wie ein Git-Projekt (everything is a file).
Änderungen im Angebot, Artikelbeschreibung, Preise etc. sollen per git push auf den Server gespielt werden können - wie bei einer statischen Webseite.
Wird ein Pull Request nach main gemerged, so soll der Webshop neu bauen (CD-Pipeline) und die Änderungen auf dem Server veröffentlichen.
Für Inventarverwaltung, Warenkorb, Kundeninteraktion und automatisierte Funktionen sind dynamische Elemente erforderlich. Hier gilt zu entscheiden, was direkt in Javascript und welche Elemente besser per Automatisierungspipeline gelöst werden sollen.

Datenbanklösung (dynamische Website)

Produkte werden in der Datenbank gehalten.
Die Verwaltung des Webshops geschieht per Web-Oberfläche.
Die Datenbankverwaltung soll teilautomatisiert erfolgen, dabei sind Backups und Verschlüsselung für Kundendaten vorzusehen.
Die Datenbank ist transparent für den Admin: Alle Einträge hier erfolgen über eine Web-Schnittstelle.

Im nächsten Artikel

Vergleich verschiedener Ecommerce-Lösungen für meinen Webshop

PeerTube im Fediverse

Schallbert — Tue, 01 Apr 2025 00:00:00 +0000

Kurze Begriffsklärung

Fediverse?

Das Fediverse nennt etwas Fediverse, wenn mehrere durchaus unterschiedliche Anbieter dasselbe Protokoll nutzen, um Nutzer dieser Anbieter frei miteinander interagieren zu lassen - und das in Bezug auf digitale Medien. Somit entsteht stark vernetzte aber dabei stets dezentrale Dienste, bei dem freie Anbieterwahl zum Konzept gehört. The Verge geht hier einmal ins Detail und gibt einen Ausblick.

PeerTube?

PeerTube ist eine dezentrale Videoplattform, bei der sich mehrere Server die Last teilen und auch Zuschauer beim Verbreiten von Videos helfen können. Grob gesagt steht PeerTube zu YouTube wie Mastodon zum Kurznachrichtendienst X.

Der Anlass

Dieser Artikel beginnt mit einer E-Mail.

“You’re receiving this non-automated email because you’re one of the handful of people who has a video hosted on this PeerTube instance. I have decided to shut down this service […]” - Tom, scitech.video administrator

Es tue ihm wirklich leid, aber der Weiterbetrieb der Instanz koste zu viel Zeit, Wartungsaufwand und Geld. Zudem sei die Plattform im Moment nur wenig genutzt, sodass der Aufwand unverhältnismäßig erscheine.

So weit, so verständlich.

Toms Geschichte: scitech.video

Da ich dort allerdings alle meine Videos hochgeladen und verlinkt hatte, war ich sehr an den Hintergründen interessiert. Also hakte ich nach. Meine Nachfrage wurde ausführlich und prompt beantwortet.

Die Anfänge

Tom setzte seine PeerTube-Instanz im Jahr 2019 auf. Ursprünglich, um eigene Inhalte zu teilen. Bereits wenig später öffnete er das Hosting-Angebot, wenn auch mit leichtem Unwohlsein, für andere.

Aus der Admin-Perspektive wirke so eine Videoplattform wie der “wilde Westen”. Seinem Angebot ein gesundes Wachstum angedeihen zu lassen, stellte sich als recht schwierig heraus - vor allem, weil viele Bots und Werbetreibende unterwegs sind.

“Growing the service turned out to be challenging. Every time I opened registrations spambots started creating accounts easily and uploading videos with advertisements in the video descriptions […]” - Tom, scitech.video administrator, via E-Mail

Viele Bots und unerwünschte User unterwegs

Diese unerwünschten Spammer, Scammer, Advertiser konnte er zwar stets davon abhalten, scitech.video zu verseuchen. Dennoch bedeutete dies ständige Arbeit und manuelle Überwachung der automatischen Tools zum Ablehnen und Moderieren.

An dieser Stelle möchte ich Tom beipflichten. Ich habe im Schnitt etwa 340 fehlgeschlagene und dann von mir weggeblockte Verbindungen externer IP-Adressen auf meinen Server pro Tag. Allein auf dem ssh-Port. Und mein Server ist weder besonders groß, bekannt oder kann als lohnenswertes Ziel durchgehen. Ganz zu schweigen von zahllosen Versuchen, auf meine Gitea-Nutzeroberfläche zu kommen, die Website nach verborgenen Links zu crawlen und vieles mehr.

Für Betreiber eines Portals, welches auch externen Usern Schreibzugriff gibt (Videos, Beschreibungen, Tags, Kommentare), potenziert sich das Problem natürlich nochmal. Hier gehört anders als bei meiner Seite ja zum Konzept, sich zu beteiligen.

Copyright?

Genau, grundsätzlich fällt aus Sicht des Plattformbetreibers erst einmal jedes Video unter das Urheberrecht oder verwandte Schutzrechte. Aber ist der Nutzer, der gerade dieses Video veröffentlichen will auch der Urheber? Oder hat dieser Jemand Nutzungsrechte erworben?

Je nach Land und zugehöriger Rechtslage müssen sich Admins mit diesem Thema sehr genau auseinandersetzen. Es können hohe Strafen sowohl für die Betreiber als auch für die User fällig werden, sollte eine Urheberrechtsverletzung vorliegen.

Ersteres ist zumindest in Deutschland einem Urteil des Bundesgerichtshofes vom 23.10.2024, wie folgt aufzulösen: “[… sind] nach einem klaren Hinweis auf eine Rechtsverletzung die dort eingestellten Angebote im Rahmen des technisch und wirtschaftlich Zumutbaren auf gleichartige Verletzungen zu überprüfen und rechtsverletzende Inhalte zu sperren oder zu löschen”.

Durch die starke Fokussierung der Instanzen auf bestimmte Themenbereiche fallen Verletzungen jedoch meist schnell auf - denn auch User können Beiträge “reporten”.

Die Rechtslage für soziale Netzwerke

Einige Länder bereiten im Moment Gesetze vor, die Kinder und Jugendliche vor der Nutzung sozialer Netzwerke und damit verbundenen Gefahren schützen soll. Als Referenz hier ein Link zur Bundeszentrale für Jugend- und Medienschutz. Auch hier sind die Admins gefragt, diese Regeln umzusetzen - doch wie?

Dies jedenfalls fragt sich Tom angesichts der zunehmend vielfältiger werdenden Rechtsauffassungen unterschiedlicher Länder.

Updates und Wartung

“PeerTube upgrades were a bit of a drag because everything was tightly coupled with their specific nginx configuration, with breaking changes that had to be adjusted every couple of minor versions.” - Tom, scitech.video administrator, via E-Mail

Die Arbeiten seien nicht besonders schwierig auszuführen, dennoch kosten sie eine Menge Zeit. Wie bei anderer Software auch könne es passieren, dass ein PeerTube-Server zum Beispiel nach Betriebssystemupdates sich nicht mehr hochfahren lässt oder es zu Inkompatibilitäten verschiedener Softwarestände oder Modulen untereinander kommt.

Aus Leistungsgründen stellt sich das Testen als schwierig heraus, sodass oft direkt in “Prod” gearbeitet wird. Im Fehlerfalle leidet der Livebetrieb.

Die Konfiguration sei relativ aufwändig und müsse auf die Hardware angepasst werden. Größere PeerTube-Updates erfordern auch hier Änderungen.

Fazit

“I’m also disillusioned about the fediverse generally as a communication medium. A constant battle against spam/LLMs, so much anger, so much focus on follows, likes and boosts.” - Tom, scitech.video administrator, via E-Mail

Tom ist frustriert, dass auch hier die Aufmerksamkeitsökonomie durchschlägt. Obwohl werbefrei gedacht und als kleine Graswurzelbewegung ausgerollt, werden aus Idealismus heraus erstellte Instanzen schnell für Werbung und Selbstdarstellung missbraucht. Die Kosten beliefen sich zudem auf mehrere hundert Dollar im Jahr, was die Kosten-Nutzen-Bilanz weiter verschlechtere.

Eine Lösung könne hier “die Rückkehr zu Web1.0 oder geschlossene Gemeinschaften” darstellen, wie es sie zum Beispiel bei Meatspace, Matrix, Discord etc. bereits gebe.

Auch alle anderen Faktoren machen Tom den Weiterbetrieb seiner Instanz schwer: Die Nutzerbasis ist nie besonders groß geworden und es gibt nur wenige Menschen, die ihre Inhalte hier noch hochladen. Als Vater hat er nun viel weniger Zeit zur Verfügung und muss Projekte priorisieren. Somit beendet er nun seine immerhin sechs Jahre betriebene Reise als Anbieter im Fediverse.

Ich wünsche Tom für die Zukunft weiterhin viel Kraft, Idealismus und Enthusiasmus.

Jans Geschichte: makertube.net

Da ich nun nach einer neuen Hosting-Plattform für meine Videos Ausschau halten musste, bemühte ich die Suche für “video-maker” auf der PeerTube-Website. Da meine Inhalte einen klaren Tech-Fokus haben und von Forschung, Produktentwicklung bis in den Vorserienbau reichen, war es nicht schwer, schnell passende Kandidaten ausfindig zu machen.

So kam ich dann zu meinem Kanal auf MakerTube.

Nach erfolgreicher Anmeldung schrieb ich eine Mail an die Admins mit ähnlichen Fragen, die ich Tom bereits gestellt hatte.

Motivation - warum MakerTube?

“Ich habe einen kleinen Youtube-Kanal und die permanente Werbung und der Fokus auf die großen Kanäle, Klickbait etc. und wie die Leute gezwungen werden sich der Content-Maschine anzupassen ging mir auf die Nerven. […]” - Jan, MakerTube administrator, via E-Mail

Jan war bereits im Fediverse unterwegs und beschäftigt sich auch beruflich mit Webdiensten, die stark skalieren müssen. Daher erschien es für ihn logisch, selbst eine Instanz aufzusetzen - dann aber natürlich mit den wirklich interessanten Themen dieser Welt. Es sei ja nicht als Konkurrenz zu YouTube gedacht und fokussiere sich daher auf Maker, Musikerinnen, Künstler etc.

Ist der Einstieg leicht?

Es bedeute schon einiges an Aufwand, so eine Instanz hochzuziehen und performant zu halten. Framasoft, welche die PeerTube-Software entwickeln, machten einen Superjob und unterstützen die Hoster-Community wo sie können.

Ich persönlich kann bestätigen, dass sich PeerTube in den neueren Versionen ganz anders anfühlt als noch vor ein paar Jahren und sich mit praktischen Features wie automatisch generierten Untertiteln immer näher an den Funktionsumfang von YouTube heranrobbt.

Das Fediverse, so Jan, sei nach wie vor eine Nische. Daher falle das Wachstum seiner Instanz eher moderat und sehr organisch aus. PeerTube sei im Moment noch etwas für enthusiastische Videomacher; am normalen Publikum laufen die Inhalte größtenteils ungesehen vorbei.

Wie groß ist der Zeitaufwand?

Jan legte den Fokus auf niedrige laufende Kosten bei gleichzeitiger Skalierbarkeit, falls die Sache plötzlich doch groß werden sollte. Jetzt, da das System reibungsfrei läuft, liege der Aufwand bei ein paar Stunden pro Woche für Moderation von Usern, Inhalten und Support.

Ausnahmen: Größere Updates, Upgrades und technische Probleme.

Was sagen die Leute?

“Es gibt positive Rückmeldungen und die Leute sind dankbar, dass ich die Seite betreibe und ich mir die Arbeit mache, aber ich würde sagen nicht sehr viele.” - Jan, MakerTube administrator, via E-Mail

Aber natürlich gebe es auch immer mal wieder Entrüstung darüber, dass das halt nicht YouTube wäre und nicht jeder sofort einen Account aufmachen könne.

Wie erkennt ihr Urheberrechtsverletzungen?

“Bezüglich Copyright gibt es da keine direkten Hilfsmittel. Es gibt die Report-Funktion an den Videos, um auf Verstöße gegen Copyright oder Instanzregeln hinzuweisen. Das wird auch von Benutzern genutzt.” - Jan, MakerTube administrator, via E-Mail

Verantwortung und Haftung lägen bei so kleinen Anbietern wie MakerTube in erster Linie beim User. Wenn allerdings auf Verstöße hingewiesen wird, müssen die Admins tätig werden und Inhalte löschen. Auf MakerTube sei dies allerdings im Alltag kein Problem: Die Registrierungen neuer User wird genau geprüft und im Zweifel werde nachgefragt, um welche Inhalte es gehe. Bei den meisten Verletzungen gehe es um Hintergrundmusik der Videos, da gebe es scheinbar weniger Bewusstsein für Urheberrecht wie bei Uploads von Videokopien.

Und wie finanziert sich das Ganze?

MakerTube finanziert sich über Spenden. Gerade zu Anfang ging laut Jan viel Zeit dafür drauf, dies den Leuten klar zu machen und genügend Budget für einen flüssigen Betrieb zu erhalten. Eine Videoplattform sei ressourcenintensiv: Viel CPU-Power für Transkodierung und Streaming, einen Haufen Plattenplatz für die ganzen Assets bei gleichzeitig hohen Anforderungen an die Bandbreite, gerade in “Stoßzeiten”.

Fazit

Ich bin mit MakerTube bis jetzt zufrieden: Transkodierungen gehen flott, Videos laufen flüssig. Sogar der Heise-Verlag hat nun ein erstes Video auf die Instanz hochgeladen. Es ist allerdings deutlich schwieriger, ohne “Fanbase” auf die Landing Page zu kommen, was bei scitech.video für mich nie ein Problem darstellte 😅.

Lasst mich mit einem weiteren Zitat von der Site selbst schließen:

“MakerTube is here to stay.” - MakerTube, March 2025, about MakerTube.

Danke, Jan. Auf die Zukunft!

MakerTube

Schallbert — Mon, 17 Mar 2025 00:00:00 +0000

Ich bekam eine Mail mit dem Hinweis, dass die von mir genutzte PeerTube-Instanz scitech.video Mitte April 2025 ihren Betrieb einstellen würde. Als Begründung nannte der Host unter anderem den hohen Zeit- und Kostenaufwand für den Betrieb sowie die geringe Anzahl Nutzer. Dazu gibt es inzwischen sogar einen eigenen Artikel, der sich mit den Vor- und Nachteilen als Betreiber im Fediverse beschäftigt.

Als Nachfolgeportal für meine Videos habe ich MakerTube ausgewählt. Dorthin migriere ich nun sämtliches Material. Stück für Stück in den kommenden Wochen.

MakerTube wird in Deutschland über Hetzner gehostet und hat viel, viel mehr Rechenpower als scitech. Daher laufen die Videos deutlich reibungsloser als vorher.

Abschließend werde ich alle Videolinks auf dieser Site umbiegen müssen, damit sie auch weiterhin funktionieren.

Für Nutzende von schallbert.de ändert sich nichts 😀

Schallbert

Gitea: Suchmaschinenindexierung stoppen

Schallbert — Wed, 12 Mar 2025 00:00:00 +0000

Nach ewigen Zeiten habe ich nur zum Spaß mal wieder einen Ausflug auf die Google Search Console gemacht. Normalerweise interessiert die mich überhaupt nicht, weil ich selbst Google gar nicht nutze und davon ausging, dass die Suchmaschinen ihre Arbeit aus Eigeninteresse schon gut machen würden.

Ich war etwas irritiert, als ich feststellte, dass es das Gros meiner Seiten nicht mal durch den Indexer geschafft hat.

Das Problem

Wie sollen denn Leute meine Webpräsenz finden? Selbst wenn sie die korrekten Suchbegriffe wüssten, würden sie über Google kaum etwas angezeigt bekommen. Immerhin stand klar drin, dass keiner meiner Blogartikel im Indexer vorkam. Auf meiner Gitea-Instanz hingegen waren mehrere tausend Seiten dem Indexer bekannt. Ein klares Missverhältnis. Wieso überhaupt erzeugt Gitea ein so hohes Dateiaufkommen?

Googles crawler (ein Programm, welches das Netz nach Inhalten durchsucht und für die Suche indexierbar macht) findet anscheinend jeden noch so kleinen Commit in öffentlichen Repositories sowie die dahinter liegenden Dateien. Auch Automationsläufe und andere Metadaten werden indexiert.

Das ist natürlich vollkommen unnötig und verbraucht mir an einer Stelle Energie, die ich viel lieber in der Präsentation meines Blogs hätte. Also muss eine Lösung her.

Lösungsansätze

Mir fielen direkt ein paar Möglichkeiten ein:

Den Crawler für jedes Repository so konfigurieren, dass nur die oberste Ordnerebene durchsucht wird.
Suchindexierung für git.schallbert.de komplett abschalten.
Per Search Console so lange Korrekturen fahren, bis der Indexer auf meinen Blogbeiträgen korrekte Zuordnungen anzeigt.

Die naheliegendste Lösung für mich war, den Indexer für meine Gitea-Instanz komplett abzuschalten. Korrekturschleifen greifen bei Googles Crawler erst Tage oder Wochen später und waren mir zu langwierig. Eine eigene robots.txt für jedes Repository hielt ich für zu aufwändig.

Meine Umsetzung

Hierfür nahm ich die Gitea-Dokumentation zur Hand. Der Vorschlag mit einer robots.txt leuchtete mir sofort ein, ebenso ihr Inhalt:

User-agent: *
Disallow: /

Hiermit wird Crawlern von jedem Anbieter * gesagt, dass ab dem Stammverzeichnis / überhaupt nicht indexiert werden soll.

Leider nur war mir überhaupt nicht klar, wie Gitea diese Datei in seiner Instanz bereitstellt:

To make Gitea serve a custom robots.txt (default: empty 404) for top level installations, create a file with path public/robots.txt in the custom folder or CustomPath.

Giteas Konfigurationsverzeichnis

Also probierte ich ein Wenig herum. Erstellte mal einen public-Ordner mit entsprechender Datei, dann einen custom-Ordner auf verschiedenen Ebenen innerhalb der Gitea-Ordnerstruktur. Jedes mal startete ich den Container neu und schaute nach, ob die robots-Datei auch auf dem Server erschien.

Nichts.

Doch dann löste ich mich von den Ordnernamen und packte die Datei schlicht in das Konfigurationsverzeichnis von Gitea - die niedrigste Ebene, auf der gitea als Ordnername schon gar nicht mehr vorkommt. Und dies war die Lösung.

Test

Nach Neustart konnte ich die Datei im Browser erfolgreich anzeigen.

Inzwischen beginnt auch Google, die unerwünschten Seiten aus dem Indexer zu entfernen. Meine Blogartikel werden über die nächsten Wochen hoffentlich auch in der Google-Suche verfügbar.

Graustufenbilder auf Dibond

Schallbert — Tue, 25 Feb 2025 00:00:00 +0000

Im letzten Artikel hatte ich Dibond (Aluminium-Sandwichplatte) als Material zum Zerspanen wiederentdeckt. Ich setze es aus Umweltgründen - Verbundmaterialien sind nichts, was ich für besonders nachhaltig oder recyclebar halte - immer seltener ein. Dennoch üben die wunderschönen Oberflächen immer wieder eine gewisse Anziehungskraft auf mich aus. Nun denn - zur Sache!

Bloglogo als Punktwolke

Inzwischen war ich in der Lage, ein von Stipplegen erzeugtes Bild mal auf die Fräse zu werfen. Dafür musste ich ein im Vorgängerartikel Graustufenbilder mit der CNC fräsen noch vorhandenes Problem lösen: In meinem meistgenutzten CAM-Werkzeug nämlich können Fräspfade für punktebasierte Halbtonbilder kaum erstellt werden, da jeder der über 2200 Punkte einzeln mit einer Fräsoperation versehen werden müsste.

CADasCAM hingegen ermöglicht es, ganze Gruppen von Elementen ein- und derselben Fräsaktion hinzuzufügen. Nun fragte ich mich, mit welchem Fräser ich in Dibond am besten arbeiten solle, denn ich habe ja nur eine sehr dünne Deckschicht zur Verfügung.

Simulation Radienfräser

Ich entschied mich für einen Radienfräser mit Halbrundkopf. Für diesen hat das CAM allerdings keine Berechnungsvorschrift, sodass er sich nicht ohne Weiteres auswählen lässt. Nach Rücksprache mit dem Hersteller kam die Idee auf, den Radienfräser durch einen V-cut mit Abflachung an der Spitze für das CAM zu simulieren, tatsächlich auf der Fräse aber den Kugelkopf einzusetzen.

Um hier passende Werte zu erhalten, fertigte ich ein paar Zeichnungen an. In der Tabelle unten sind Näherungswerte festgehalten für den Falle, dass die Eintauchtiefe 0.3mm nicht überschreitet. Nun konnte ich die Pfadberechnung im CAM durchführen und sogar eine Tiefenbegrenzung von 0.22mm einhalten. Die flachsten Bereiche haben eine Gravurtiefe von lediglich 0.10mm.

Bei der Pfadberechnung ist zu beachten, dass die Rückzugshöhen möglichst gering ausfallen sollten. Dann muss die Z-Achse der Maschinen nicht für jeden Punkt so weit hochfahren. Ich halte einen Wert von 0.5mm für angemessen.

Radienfräser	Simulation durch V-Cut
r=3mm	140°, 1.0mm Abflachung
r=2mm	140°, 0.5mm Abflachung

Fräsvorgang

Die Motivgröße für die Gravur beträgt 180x180mm und ich fräse mit folgenden Werten: Radienfräser 2s r3 6mm, S20000, F1800. Ich durchsteche die Schutzfolie der Dibondplatte, deren Dicke ich nicht kompensiere. Ich verwende eine geringe Menge Schmiermittel zur Verbesserung der Schnittqualität. Nach knapp 11 Minuten ist der Fräsvorgang beendet.

Beobachtungen

Das Motiv ist in diesem Versuch schon einmal viel deutlicher zu erkennen. Leider habe ich dennoch klar ein Problem mit der Oberflächenebenheit. So ist im mittleren Bereich rechts beispielsweise zu tief graviert (Aufbauschneide - siehe Video - dort ist die Fräse zum Schluss unterwegs), während die Graviertiefe ganz oben rechts und oben mittig nicht ausreichend erscheint.

Fräse und Fräser haben überhaupt kein Problem mit dem Material. Der Gravurvorgang klingt ein wenig wie die Arbeit mit der Ständerbohrmaschine, unterbrochen von Positioniergeräuschen der Schrittmotoren.
Die für Dibond verwendete Aluminiumsorte AlMg1 ist weich und zäh. Sie eignet sich nicht gut zum Zerspanen.
Fräser tendieren hier zum Erzeugen von Aufbauschneiden, welche den Fräserradius vergrößern und die Schnittqualität verschlechtern.
Die Schutzfolie verhindert Ausrisse und Spanränder.
Aufbringen von etwas Schmiermittel ist eine gute Idee.
Selbst auf einem Vakuumtisch ruiniert jedes Staubkorn unter dem Werkstück die Fräsarbeit. Wenige hundertstel Millimeter Höhendifferenz haben große Auswirkung auf die Punktgröße und führen zu Verfälschungen.
Das Maschinenbett muss absolut eben sein oder die Maschine muss über eine hochwertige, aktive Höhenkompensation verfügen; z.B. mittels vorheriger Oberflächenvermessung durch einen Kantenfinder. Meine Steuersoftware unterstützt das Verfahren sogar unter dem Namen ZheightComp.

Fazit

Ich mag Dibond als Material sehr, aber es scheint meine Zuneigung nicht zu erwidern.
Mit meinen technischen Mitteln bekomme ich Gravuren nicht mit wiederholbar in guter Qualität hin.
Vielleicht sollte ich stattdessen Plastik oder Holz verarbeiten. Oder einen Laser verwenden…

Zum Abschluss noch ein kurzes Zeitraffer-Video des Fräsvorganges.

Graustufenbilder mit der CNC herstellen - Teil2

Saturn als ASCII-Art

Halbtonbilder kann man statt mit Linien, Wellen, Punkten natürlich auch mit Mustern herstellen. Als Beispiel habe ich mal das Bild des Planeten Saturn von Christopher Johnsons ASCII Art für die Fräse aufbereitet.

CAD/CAM

Für das richtige Größenverhältnis wird eine Schriftart benötigt, bei der jedes Zeichen dieselbe Setzbreite besitzt. Ich wähle die TrueType-Schriftart Courier New und passe Schriftgröße und Zeilenabstand so an, dass das Motiv auf mein Material passt und die Gravur nicht die Deckschicht perforiert.

Dies zwingt mich zur Verwendung eines 1/8" Gravurstichel mit 36° Spitzenwinkel und 0.1mm Abflachung. Ich hätte hier einen Radienfräser bevorzugt: Im weichen Dibond kommt es bei spitzwinkligen Sticheln zu Materialaufwurf und -Verschmierung. Dies führt zu unsauberen Linien und einer rauen Oberfläche. Da das Werkstück sehr klein ist, würde die Schrift jedoch viel zu breit ausfallen.

Die Pfadberechnung zeigt, dass ich auf dem nur 80x80mm großen Werkstück Fettdruck wählen muss, um meine Mindesttiefe von 0.08mm überhaupt zu erreichen.

Fertigung

Ich habe das Bild vom Saturn zweimal gefertigt: Auf 80x80mm, um die maximale Auflösung im Material zu testen und auf 180x180mm (Abbildung unten) zum Prüfen der Kontrastwirkung.

Ich bin zufrieden mit dem Ergebnis. Der Kontrast ist hoch und die silberweiße Oberfläche des Aluminium(oxyds) sieht auf der mattschwarzen Lackierung richtig edel aus.

Graustufenbilder mit der CNC fertigen: Teil3

QR-Codes

Wenn ich schon einmal mit Dibond arbeite: Ich probiere gleich noch aus, ein paar QR-Codes mit einem Radienfräser einzubringen. Dieses Mal verwende ich verschiedene Maschinen.

Auf der Hobbyline

In schwarz graviere ich auf der mir zur Verfügung gestellten Hobbyline im übertakteten Gravurmodus. Ich fixiere das Werkstück mit einigen Punkten Doppelklebeband. Ich fräse trocken ohne Schmiermittel. Beobachtungen:

Die Gravurtiefe scheint mit zunehmender Linienlänge zuzunehmen (Aufbauschneide, Fräser schmiert ins Material)
Teilweise wölbt sich die Lackoberfläche am Fräsrand nach oben
Sehr unsaubere Fräskanäle, starke Richtungsabhängigkeit

Auf der Basicline

Hier nutze ich natürlich meinen Vakuumtisch und profitiere vom viel stabileren Aufbau. Ich verwende eine geringe Menge Schmiermittel. War gespannt, ob die das weiße Material trotzdem ausreichende Kontraste zulässt. Beobachtungen:

Auch meine QR-codeengrave Software muss richtig bedient werden. Ansonsten verschieben sich wie hier Nullpunkte und Größenverhältnisse. Folge: Mein Handy erkennt den QR-Code nicht 😐
Die viel bessere Niederhaltung verhindert starke Unterschiede in der Fräskanalbreite.
Dennoch sieht man die Austauchpunkte der Maschine und manchmal auch mitgeschleifte Späne.
Die Fräsqualität ist noch immer nicht befriedigend.

Fazit

In Zukunft muss ich Dibond ähnlich behandeln wie Acrylglas: Sehr scharf geschliffene Fräser verwenden, die das Material ordentlich schneiden. Idealerweise Einschneider mit Habichtschnabel und Eckenfase (weiche Kanten), zentrumsschneidend, dazu ordentlich Drall. Z.B. diese hier (Link zu vhf). So wird - glaube ich - eine Materialverdrängung in das noch weichere Kernmaterial vermieden und Späne außerdem im Spankanal nach oben gefördert, sodass sie nicht anhaften können oder ein zweites Mal unter den Fräser geraten.

Zudem sollte ich mit zügigen Vorschubwerten arbeiten. Dann heizt sich das Material nicht zu stark auf. Die Verwendung von ein wenig Schmiermittel sowie das Aufbringen von Schutzfolie trägt zu besserem Fräsergebnis bei. Weitere Verarbeitungshinweise gibt es beispielsweise im CNC-aus-Holz-Forum. Stöbern kann sich lohnen.

Graustufenbilder mit der CNC fräsen

Schallbert — Mon, 27 Jan 2025 00:00:00 +0000

Bis jetzt habe ich Bilder stets als Gravuren in Volltonfarben erstellt. Damit lassen sich Texte wie diesen hier, aber auch Zeichnungen und Bilder kontrastreich und hübsch fertigen.

Das Ziel

Bei der Volltondarstellung können viele Details nicht abgebildet werden. Nun möchte ich aber ein echtes Foto ins Material bringen. Idealerweise soll dies zügig, ohne manuelle Nacharbeit und mit hoher Bildqualität passieren.

Mein CAM-Werkzeug stellt hierfür eine “Halbtonbild”-Funktion zur Verfügung, mit der ich im Folgenden herumexperimentiere. Auch hier ist es wieder so, dass selten direkt gute Ergebnisse aus der Maschine fallen. Außerdem sind die Erzeugung solcher Abbildungen sehr zeitintensiv, und Fehlversuche folglich “teuer”.

Daher gebe ich am Ende des Artikels ein paar Tipps und Tricks, mit deren Hilfe recht schnell gute Ergebnisse erzielt werden können.

Ein wenig Farbwissen: Rasterverfahren

Das Problem, einen ganzen Farbraum mit nur wenigen verfügbaren Farben abbilden zu wollen, ist schon hunderte Jahre alt. Während Farbverläufe durch Mischen von Farben in der analogen Welt und auch am Bildschirm mittels unterschiedlicher Luminanzwerte der drei Farbkanäle in Pixeln hervorragend dargestellt werden können, stehen bei längst nicht jeder Anwendung eine große Anzahl Farben zur Verfügung.

Drucker zum Beispiel¹. Sie haben meist nur die drei Grundfarben cyan (C) - ein Türkiston, magenta (M) - ein Pinkton, yellow (Y) - gelb sowie key (K) - meist Schwarz - zur Verfügung. Hieraus müssen sie dann die Illusion aller möglicher Farben erzeugen, denn sie können die Pigmente wegen ihrer hohen Deckkraft nicht mischen. Ansonsten würde der zuletzt aufgebrachte Farbton dominieren oder die Farbe würde schlicht verlaufen. Hieraus ergibt sich die Notwendigkeit, Rasterverfahren einzusetzen.

Halftones (Halbtonbild)

Eines dieser Rasterverfahren heißt halftone. Hierbei wird durch Farbpunkte oder -Muster unterschiedlicher Strichstärke ein Farbton simuliert, welchen das Auge ab einem gewissen Abstand nicht mehr auflösen kann und daher gemeinsam mit dem umgebenen Freiraum und gegebenenfalls anderen Farbpunkten zu einem Tonwert “mittelt”.

Dieses Verfahren eignet sich für die Fertigung mittels CNC-Fräse, sofern die Oberfläche des zu bearbeitenden Werkstücks eine andere Farbe besitzt als das Kernmaterial.

Für Halftones existieren viele verschiedene Erzeugungsverfahren, bei denen sich Anordnung der Punkte, Striche, Musterform usw. teils stark unterscheiden. Auf der CNC bestimmen das verwendete Gravurmaterial, die benötigte Auflösung und das gewünschte Werkzeug das Verfahren, da sich nicht mit jeder Kombination eine gute Qualität erreichen lässt.

Dithering

Dithering wird eher bei der Darstellung auf Bildschirmen verwendet. Hierbei variiert nicht wie beim Halbtonverfahren Stärke bzw. Größe von Farbpunkten oder Mustern, sondern die räumliche Verteilung andersfarbiger Punkte, welche in die Grundfarbe gesprenkelt werden. Dadurch entsteht der Eindruck einer Mischfarbe.

Auch hier gibt es wieder verschiedene Erzeugungsverfahren: Diffusion, Rauschen, Muster, Floyd-Steinberg-Algorithmus…

Materialauswahl

Hier habe ich eine Menge ausprobiert. Am Besten eignen sich Materialien mit homogener Zusammensetzung und hohem Kontrast zwischen Oberflächen- und Kernfarbe. Zudem sollte die Schichtdicke des Oberflächenmaterials nicht zu groß ausfallen, da sie komplett durchstochen werden muss und dann schnell sehr große Einzelpunkte erforderlich werden. Die Oberfläche ist idealerweise mattiert, denn Seiden- Metall- oder Hochglanz erzeugen eine Blickwinkelabhängigkeit, bei der die Erkennbarkeit des Motivs leidet.

Außerdem sollte das Material komplett plan zur Fräsfläche sein, da die Punktgröße sonst unerwünscht stark variiert.

Geeignete Materialien 👍

Kernmaterial	Beschichtung	Besonderheit
Mitteldichte Faserplatte	Grundierung + Lack	Fräsbahn nicht überlappen
Aluverbundmaterial	Lack oder Folie	Max. 0.18mm tief fräsen
Acrylglas (PMMA)	Lack oder Folie	XT verwenden (Dickentoleranz)

Am wenigsten Aufwand macht mir die Verarbeitung von fertig lackiertem Aluverbundmaterial. Hier ist praktisch keine Vor- und Nacharbeit erforderlich. Es ist aber darauf zu achten, die Frästiefe auf 0.18mm zu begrenzen. Sonst wird der PU-Kern deformiert oder es entstehen Ausrisse.

Das Aufbringen einer Folie kann eine gute Lösung sein, wenn man den Zeitaufwand eines Farbauftrags scheut. Ich selbst bin leider nicht besonders geschickt im Umgang mit Folie. Ständig erzeuge ich Luftblasen oder Einschlüsse kleinster Staubkörnchen. Nach dem Fräsvorgang sind die dadurch entstandenen Defekte im Höhenprofil deutlich anhand zu großer Löcher im Material zu erkennen.

Ungeeignete Materialien 👎

Die hier aufgelisteten Materialien eignen sich meiner Meinung nach so nicht gut zum Erzeugen von Halbtonbildern. Ich habe ein paar Bilder misslungener Versuche hier abgelegt. Oft liegt ein Grund für Fehlschläge in einer für das Material zu hoch gewählten Bildauflösung.

Kernmaterial	Beschichtung	Grund
Mitteldichte Faserplatte	Furnier	Zu hohe Schichtdicke
Mitteldichte Faserplatte	Metallfolie	Papierkern der Metallfolie ist weiß
Aluverbundmaterial	Metall, gebürstet	Material “matscht”, Auflösung schlecht
Aluverbundmaterial	Keine, PU-Kern	Alu in Kern gedrückt, Auflösung mies
Weiche Alu-Legierungen	Lack oder Folie	Aluminium verschmiert, Auflösung mies

Hier experimentiere ich mit der Bildpunktdichte. Im unteren Bereich habe ich sie zu eng angeordnet, sodass sich die Beschichtung beim Fräsen löst. Auf meiner Gravur-CNC benötigt ein solches Bild auf einer Platte mit den Maßen15x10cm trotz Übertaktung etwa 15 Minuten. Das Material ist wegen des Metallglanzes, der Ausrissgefahr, einer kaum erreichbaren Flächenverleimung und der hohen Schichtdicke nicht gut für solch hohe Auflösungen geeignet.

Halbtonbilder: Anforderungen an die CNC

Das Problem hängt hier ausnahmsweise mal nicht mit Haltekräften, Fräskräften oder Schwierigkeiten beim Niederhalten zusammen. Im Gegenteil, beim Fräsen von Bildern werden außerordentlich geringe Kräfte aufgebracht, und die zumeist in Z-Richtung, wo die Maschinen eine Stabilitätsreserve besitzen.

Die Komplexität der Jobs stellt das Problem dar. Das Portal muss große Strecken zurücklegen und auf dem Weg ständig bremsen und beschleunigen. Endstufen, Schrittmotoren und Lager der Linearspindeln sind hierdurch stark belastet.

Wellen/Striche/Linien

Im Linienverfahren fährt die Maschine ein Bild zeilenweise ab. Helligkeitsinformationen werden dabei üblicherweise per Frästiefe übertragen. Damit ergeben z.B. besonders dunkle Bereiche breitere Schnitte, welche dann im Schatten liegen. Dieses Verfahren eignet sich prima bei Fräsungen in Schaumstoffen, MDF und Acrylglas. Sie lassen sich außerdem recht zügig durchführen, da die Maschine im Materialeingriff bleibt und lediglich für Zeilensprünge Positioniervorgänge erforderlich sind.

Punktverfahren

Hier wird die Größe von Punkten verändert, sodass mal größere und mal kleinere Vertiefungen im Material entstehen.

Halbtonbilder im Punktverfahren benötigen verhältnismäßig viel Zeit auf der Maschine. Was mit einem Hobbylaser in einer halben Stunde vonstatten gehen kann, dauert mit einer CNC-Maschine bei gleicher Größe und Auflösung locker mal zwei Stunden (auch hier gibt es Optimierungsmöglichkeiten).

Zur Fertigung solcher Bilder muss die Maschine extrem oft die Z-Achse bewegen. Beim Fräsen von Punkten muss sie für jeden “Pixel” einmal zwischen Sicherheitshöhe und Materialeingriff wechseln.

Beispiel: Werden 400x400 Punkte gefräst (Das wäre im Pixelmaßstab ein ziemlich mies aufgelöstes Bild), so muss die Maschine 32000x ihre Z-Achse in Gang setzen!

Daher sollte die Sicherheitshöhe nur ein paar Zehntel über der Werkstückoberfläche liegen, z.B. 0.5mm. Um die schwere Y-Achse zu schonen, macht es Sinn, das Bild per CAM zeilenweise auf der X-Achse abzuarbeiten. So wird die Y-Achse nur für Zeilensprünge bewegt.

Vorteilhaft ist hier eine leichte Portalfräsmaschine mit wenig Masse auf der Z-Achse. Sie sollte gut geschmiert und die Achsführungen gereinigt sein. Gleichzeitig sollte sie nicht zu steif sein, damit sie sich nicht durch die vielen abrupten Bewegungen aufschwingt.

Für Schrittmotoren und -Treiber sind diese Jobs Marathonrennen. Ihre Temperaturen sollten stets gut im Auge behalten werden. Ich empfehle, die Maschine nicht mit Halbtonbildern im Dauerbetrieb zu fahren. Die Achs- und Portalbelastungen hingegen sind vernachlässigbar: Die Maschine ist kaum Last in X- und Y-Richtung ausgesetzt, da sie zumeist nach unten im Materialeingriff steht und dies auch nur minimal zum Erzeugen kegelförmiger Vertiefungen.

Labyrinth/Liniensegmente

Soll das gesamte Bild in nur einem Zug abgefahren werden, so muss erst ein “Problem des Handlungsreisenden” (TSP) gelöst werden, wie es zum Beispiel die von EvilMadScientist vorgestellte Software Stipplegen2 vermag. Bei diesem Verfahren wird die Dichte der Liniensegmente pro Flächeneinheit erhöht, wenn ein Bereich besonders dunkel erscheinen soll. Auf der CNC-Maschine sind solche Bilder recht zügig fertiggestellt, da sie die Z-Achse nur einmal eintauchen lassen.

Nachteilig bei diesem Verfahren sind die geringe erreichbare Auflösung (Es werden sehr viele Punkte benötigt) und der geringe Kontrast, denn alle Linien sind gleich dick.

CNC-Werkzeuge

Die Erzeugung von Halbtonbildern sind Gravurarbeiten. Daher empfiehlt sich die Verwendung von Gravierfräsern mit 60° oder 90° Spitzenwinkel sowie einer Abflachung von 0-0.5mm.

Ist das Motiv klein, so sollte gar keine Abflachung verwendet werden. Der Spitzenwinkel sollte groß sein, wenn nicht tief gefräst werden soll oder kann oder falls die “helle Farbe” die Kernfarbe des Materials ist. So werden tiefe Schatten vermieden, die das Bild zusätzlich abdunkeln.

Wird lackierte Aluminium-Verbundplatte bearbeitet, so kann ich Halbrundfräser mit r<2mm bei sehr geringer Eintauchtiefe von maximal 0.18mm empfehlen. Hierbei wird allerdings vorausgesetzt, dass das Maschinenbett überplant und damit sehr eben ausgerichtet ist.

Herstellung

Bild: Versuch, mein Bloglogo als TSP-Pfad mit 9600 Kanten auf schwarz lackiertes Aluminiumverbundmaterial zu gravieren. Verwendet habe ich einen 1/8" 36°-Stichel mit 0.1mm Abflachung. Am unteren Bildrand ist zu erkennen, dass das Material etwas tiefer liegt und daher nicht mehr vom Stichel erreicht werden kann.

Bildvorbereitung

Das Bild sollte eine hohe Auflösung besitzen und in Graustufen vorliegen. Idealerweise besitzt es hohe Kontraste und nutzt das gesamte Grautonspektrum.

Nun wird das Bild entweder in ein CAM-Tool geladen, welche die Anfertigung von Halbtonbildern unterstützt - z.B. von Vectric, Estlcam - oder aber in ein Bearbeitungswerkzeug, welches Punktewolken oder Pfade erzeugen kann, z.B. Stipplegen2 oder Inkscape.

Dort probiere ich stets ein paar verschiedene Einstellungen durch in Abhängigkeit vom verwendeten Material, dem gewünschten Fräser und der Bildwirkung. Oft sieht man bereits dort, ob das Foto wirken kann und erlaubt eine Einschätzung, ob die Auflösung für das verwendete Material geeignet ist.

Wie man zu guten Ergebnissen kommt

Große Abmessungen bevorzugen: Je größer das Bild gewählt wird, desto weniger fallen Materialinhomogenitäten und ausgebrochene Bereiche auf.
Große Beobachtungsdistanz ermöglichen: Je weiter das Bild vom Betrachter entfernt positioniert wird, desto schärfer wird die Auflösung wahrgenommen. Bevor es dann irgendwann zu klein erscheint 😆
Lichteinfallwinkel berücksichtigen: Hat das Material Seidenglanz, metallischen Glanz oder ist sogar hochglänzend, so hängt die Abbildungsqualität sehr vom Blickwinkel und der Distanz zur Lichtquelle ab. Je glänzender das Material, desto kleiner wird der Bereich, in dem die Abbildung gut zu erkennen ist.
Homogene, nicht schmierende Materialien verwenden. Ich habe mit Acrylglas die besten Ergebnisse erzielen können.

CNC-Durchlauf

Hier ist vor allem eines mitzubringen: Zeit. Im Folgenden ein paar Videoausschnitte meiner Versuche (Zeitraffer).

Graustufenbilder mit der CNC fertigen: Teil1

Ausnahmen bestätigen die Regel. Natürlich gibt es sowohl bei Bildschirmen als auch bei Druckern Ausführungen, welche dieses Problem umgehen: Sie setzen etwa zusätzliche Subpixel mit zusätzlichen Farben ein und können so größere Farbräume abdecken oder - wie im Tiefdruck (Magazine, Verpackungen etc.) üblich - verwenden eine höhere Anzahl Farben beziehungsweise Farbmischungen, deren Tonwerte näher an den benötigten Halbtönen liegen. ↩︎

Mehrfarbige Gravuren

Schallbert — Mon, 30 Dec 2024 00:00:00 +0000

Die Projektidee

Vor ein paar Wochen war ich im Wald unterwegs. Dort sah ich ein wunderschönes, altes Schild mit dem Aufdruck “Helft Waldbrände verhüten”. Ein Zeichenstil wie in Tinte aus vergangenen Zeiten. Kurzerhand fotografierte ich es.

Leider ist das Schild ziemlich verblichen und wirkt als Foto wenig plastisch. Daher beschloss ich, mit etwas Zeitaufwand aber ohne große Kosten mit Hilfe meiner CNC-Gravurmaschine eine dreidimensionale Kopie des Schildes anzufertigen.

Vom `.jpg` nach `.svg`

Bevor ich einen Job für die CNC erstellen kann, muss ich das Bild aufbereiten und in Vektorform bringen. Mein CAM-Programm kann mit Pixelgrafiken nämlich wenig anfangen. Ich möchte das Bild gern als “Carve” erstellen, also mit einem spitzen Gravierfräser diejenigen Bildbereiche schnitzen, die später farbig erscheinen sollen. Hierfür benötige ich zudem eine Farbtontrennung, da das Bild auch in der gefrästen Fassung später weiße, rote und schwarze Anteile haben soll.

Bildaufbereitung

Hierfür nutze ich gängige Bildbearbeitungsprogramme wie gimp und paint.net. Ich verwende das curves-Werkzeug, um den Kontrast zu erhöhen, richte die Perspektive mittels 3D-Drehung gerade und hole mir anschließend mit dem Zuschneiden-Werkzeug den gewünschten Bildausschnitt. Anschließend radiere ich Bilddefekte, Schmutz oder durch die Kontrasterhöhung entstandene Artefakte weg. Zum Schluss noch ein wenig Schärfe hineindrehen und eine Tontrennung vornehmen, sodass ich keine Rottöne oder Graustufen, sondern reine Farben erhalte.

Nun exportiere ich das Bild als .jpg und importiere es in Inkscape.

Pfadkonversion

Hier skaliere ich das Bild zuerst, sodass es auf eine A4-Seite passt. Außerdem erstelle ich ganz unten links im Bild ein 1mm x 1mm kleines Quadrat, was mir für die beiden Farbschichtbilder später im CAM als Nullpunkt dienen soll, selbst aber nicht gefräst wird.

Wie bereits in einem früheren Artikel zur Pfadkonversion beschrieben, nutze ich die Trace-Funktion und kann so die roten und schwarzen Bereiche mittels unterschiedlicher Helligkeitsgrenzwerte in je eigene Layers freistellen. Die “rote” Layer enthält erst einmal auch die schwarzen Bildbereiche. Ich kann jedoch Layers voneinander subtrahieren, sodass nach dieser Aktion nur noch die roten Bildanteile übrig bleiben.

Anschließend lasse ich die Pfade noch vereinfachen und entferne fälschlicherweise erstellte Pfadartefakte. Ich exportiere die “rote” und die “schwarze” Layer jeweils als .svg-Datei.

Pfadplanung im CAM

Im CAM muss ich zwei Jobs planen - je einen für jede Farbe. Die unbearbeiteten Bildbereiche sollen weiß erscheinen. Die Gravur des ersten Jobs wird mit roter Farbe ausgelegt werden, und die zweite Gravur soll später tiefschwarz erscheinen.

Ich importiere also zuerst die “rote” SVG-Datei, wähle die für DIN A4 passende Skalierung, setze den Nullpunkt unten links und mache mich anschließend an die Erstellung der Carve-Pfade.

Job1: “rote” Bereiche

Ich setze eine Tiefenbegrenzung von 2mm und wähle für die Gravur einen 6mm 90° Stichel mit einer Schneide und 0.5mm Abflachung an der Spitze. Für die Räumarbeiten größerer gravierter Bereiche suche ich einen 3mm Zweischneider für Holz heraus und fräse mit 60% seitlicher Zustellung. Die Drehzahl stelle ich für beide Fräser bei 24000U/min, den Vorschub auf 3000mm/min ein.

Job2: “schwarze” Bereiche

Bei den schwarzen Bereichen erlaube ich für Job2 eine höhere Tiefenzustellung von 2.8mm und spare mir den Räumfräser, da hier weniger zusammenhängende Flächen abgenommen werden müssen. Durch die größere Tiefe soll das Schwarz noch dunkler und das Motiv plastischer wirken.

Durchführung

Für das Projekt nehme ich eine schwarz durchgefärbte Faserplatte (MDF) zur Hand. Mit weißem Acryllack streiche ich sie mehrfach an, bis ich eine homogene und gut deckende Oberfläche habe. Nachdem alles getrocknet ist, bringe ich eine selbstklebende Folie auf. Profis nehmen Schablonenfolien (Maskierfolien) z.B. von Orafol, ich behelfe mir jedoch mit einer viel einfacheren Einschlagfolie für Bücher. Nicht perfekt, da ihre Haftung für kleine Flächen nicht ausreicht - aber gut genug für mich.

Rote Flammen

Nun lasse ich den ersten Job auf der Fräse durchlaufen. Dafür klebe ich das Werkstück mit Doppelklebeband im Arbeitsbereich der Fräse fest und richte sie ordentlich aus, sodass der Nullpunkt einfach gesetzt werden kann.

Sobald die Fräse durchgelaufen ist, setze ich Schrauben in die T-Nuten des Grundplatte an den Rändern des Werkstücks. So kann ich es nachher wiederholgenau positionieren. Anschließend löse ich es vom Maschinenbett, reinige es mit Bürste und Pinsel und bringe rote Sprühfarbe auf. Dummerweise zieht diese sofort in das MDF ein (siehe Video unten). Die Flammen bleiben somit schwarz. Ich probiere es erneut, wieder ohne Erfolg. Also muss ich nochmal ins Geschäft und einen viel viskoseren Lack zum Aufbringen per Pinsel kaufen.

Soll MDF lackiert werden, eignet sich Sprühfarbe wegen ihrer geringen Viskosität nicht: Sie zieht ein und hinterlässt kaum Pigmente auf der Oberfläche.

Nachdem ich auch hier wieder gewartet habe bis die ausgelegten Flammen getrocknet sind, montiere ich das Werkstück erneut auf dem Maschinenbett.

Schwarze Tannen

Nun lasse ich den zweiten Job durchlaufen. Dies geht trotz Verzicht auf den Räumfräser bedeutend schneller, da der Werkzeugwechsel entfällt.

Anschließend ziehe ich die Schutzfolie vom Werkstück ab und reinige es gründlich. Wie schön das Schild geworden ist!

Video der 3D-Gravur

Zu diesem Projekt gibt es mal wieder ein Zeitraffer-Video, bereitgestellt auf meinem PeerTube-Kanal.

multicolorEngrave

Was noch besser werden könnte

Im Nachhinein betrachtet gibt es bei meinen Projekten oft Dinge, die noch besser gemacht werden können. Wenn ich so auf das Video gucke, fallen mir zwei Sachen auf:

1. Pfadqualität bestimmt Fräsqualität

Ich wollte möglichst schnell zum Ergebnis kommen und habe daher bei der Umwandlung vom Pixelbild zur Vektorgrafik nicht alle Pfadartefakte ausgeräumt. Diese äußern sich am fertigen Produkt als kleine Inseln und Punkte, die weniger tief gefräst wurden als der Rest. Am besten ist dies in den roten Bildbereichen zu erkennen. In Natura fällt das kaum auf. Im Video erkennt man aber, dass Fräse zum Ausarbeiten dieser Stellen zusätzliche Zeit benötigt.

2. CAM-Strategie kostet Zeit

Mein Programm für die Fräsplanung läuft Fräspfade für Räumung, Umrisse und Ausspitzungen von oben nach unten jeweils zeilenweise ab. Dies hat zur Konsequenz, dass unglaublich viele Positioniervorgänge für nicht zusammenhängende Pfade erforderlich werden. Zudem wird jeder Punkt im ungünstigsten Falle drei mal angefahren.

G00-Kommandos sind hier schlecht, weil sie eine Menge Zeit kosten und die Maschine unnötige Wege verfährt. Dieses Problem ließe sich nur mit einem professionellerem CAM-Werkzeug beheben.

Repo-Lookout: Sicherheitslücke beheben

Schallbert — Fri, 20 Dec 2024 00:00:00 +0000

Repo-Informationen öffentlich zugänglich

Eines schönen Tages bekam ich eine E-Mail von Repo Lookout. Darin stand, dass eines meiner Repositories für Zugriffe aus dem Internet freigegeben sei. Dies stelle ein potentielles Sicherheitsrisiko dar, da möglicherweise geheime Quelldateien, versteckte Funktionen oder sogar Passwörter enthalten sein könnten.

Zuerst hielt ich diese “Ihr-Repo-ist-nicht-sicher”-Warnung für einen Phishing-Versuch. Doch durch einfaches Eingeben der darin enthaltenen Links wurde klar, dass Repo Lookout Recht hatte und mein Lectures-Repo nicht nur wie von mir gewünscht öffentlich war, sondern dass auch die Metadaten zur Versionskontrolle offen auf dem Webserver lagen.

Ist das schlimm?

Normalerweise sollen innere Struktur und Konfiguration (Actions, Diskussionen, Wiki etc.) hinter einem Repository nicht öffentlich bleiben. Erst recht nicht, wenn das Repository als private angelegt ist. Doch auch bei öffentlichen Repos sollte niemand auf die Struktur dahinter zugreifen können.

Daher die Mission von Repo-Lookout:

“Find source code repositories that have been inadvertently exposed to the public and report them to the domain’s technical contact.” - Repo Lookout /about (Crissy Field GmbH)

In diesem Falle unkritisch, aber unerwartet und unschön.

Schadet mir nicht, weil mein Webserver die Dateien lediglich zum Abruf dort liegen hat und sie selbst bei Manipulation keine Rückwirkung auf mein Repository gehabt hätten. Außerdem hatte ich alle Secrets wie in diesem Artikel beschrieben in eigens angelegte Dateien ausgelagert, sodass sie nicht mehr in den Konfigurationsdateien auftauchen. Das Repository liegt zudem getrennt auf der Gitea-Server-Instanz. Dennoch sollte nur am Internet hängen, was ich bewusst freigeben möchte.

Der Bildausschnitt von Gitea zeigt denselben Commit wie die Warnung von Repo Lookout.

Wie es dazu kam

In der Deploy-Pipeline für meine Subdomain lectures.schallbert.de und Landing Page schallbert.de habe ich einen direkt-Checkout von der Gitea-Instanz zum Webserver Caddy. Dieser läuft automatisch an, sobald die main-Branches ein Update erhalten. Der Runner startet eine Checkout-Action, welche das Repository ins entsprechende Verzeichnis des Webservers kopiert.

Checkout-Action kopiert auch den `.git`-Ordner

Dabei wird der .git-Ordner einfach mit aufgesetzt. Dort drin liegen alle von der Versionskontrollsoftware benötigten Daten zur Zustandsverwaltung des Repos. Den Kopiervorgang selbst kann ich auf Gitea nicht sehen, denn dort taucht der versteckte .git-Ordner gar nicht erst im Verzeichnis auf. Verständlich, denn auf Basis dieses Ordners findet die gesamte Darstellung auf Gitea statt.

So blieb das unerwünschte Verhalten unter meinem Radar - und laut Repo Lookout bin ich bei Weitem nicht der Einzige, dem es so geht.

Option 1: Fix auf dem Webserver

Die naheliegendste Lösung ist, den Zugriff auf die Datei serverseitig zu blockieren. Dies kostet nur wenige Ressourcen und ist leicht einzurichten.

Dieser Foreneintrag zeigt, wie das geht: hide-entire-folder-caddyfile. Für meine zu schützenden Dateien füge ich also folgende Einträge der Caddyfile hinzu:

# /caddy2/Caddyfile

# [...]
respond /.git/* "Access denied" 403
respond /.gitea/* "Access denied" 403

Damit sage ich Caddy, dass es bei Aufruf einer beliebigen Datei /* im Ordner /.git mit dem Fehlercode 403 “Forbidden” antworten soll. Dabei ist die Wildcard (*) unbedingt erforderlich, denn sonst wird lediglich der Ordner selbst und nicht die enthaltenen Dateien gesperrt.

Zur Kontrolle prüfe ich was passiert, wenn ich die Git Logs anfrage:

# Terminal
curl <lectures.schallbert.de>/.git/logs/HEAD
Access denied

Funktioniert prima!

Option 2: Fix in der Checkout-Action

Es gibt allerdings eine noch viel elegantere Lösung: bereits vorher in der Pipeline dafür sorgen, dass der Ordner gar nicht erst auf dem Server auftaucht.

Variante 1: Mit Hilfe von `sparse-checkout`

sparse-checkout ermöglicht die Auswahl von Ordnern und Dateien, die zum Checkout gehören sollen. Alle anderen Dateien im Repository bleiben unberührt und tauchen im Branch nicht auf. Dies spart vor allem bei großen Repositories Zeit und Speicherplatz. Macht aber natürlich nur Sinn wenn bereits vorher bekannt ist, dass nicht alle Dateien angefasst werden müssen.

Negativliste für `sparse-checkout`

In meinem Falle will ich die oben erwähnten Ordner gerade nicht per Checkout auf den Server kopieren, den ganzen Rest aber schon. Wie ich das hinbekomme? Mit Hilfe der Negation im no-cone mode.

“The user has explicitly said ‘I want these directories and not those directories.’” - Derrick Stolee, Microsoft, auf Github

In der Anleitung zu Checkout-Action steht, dass sparse-checkout auch für die vom Runner automatisierte Aktion unterstützt wird.

Nun programmiere ich mit Hilfe des Github Actions Cheet Sheet:

# /.gitea/workflows/deploy-lectures.yml

# [...]
steps:
 - name: --- CHECKOUT ---
 uses: actions/checkout@v4
 with:
 path: ./tmp
 sparse-checkout: |
 /*
 !.git
 !.gitea
 sparse-checkout-cone-mode: false
 # [...]

Zur Erläuterung: Das Skript zum Veröffentlichen auf meinem Webserver verwendet die Aktion checkout, Unterfunktion sparse-checkout und bezieht sämtliche Dateien im Ordner im Stammverzeichnis tmp und darunter ein bis auf .git und .gitea.

Was ist der `No-Cone Mode`?

Standardmäßig erwartet sparse-checkout eine Liste von Ordnern, die für den Checkout erfasst werden sollen. Im no-cone Modus wird stattdessen eine Liste von Patterns erwartet. Hier sind sämtliche Operatoren möglich, die auch in der .gitignore zum Spezifizieren von Dateien, Ordnern, Auslassungen etc. verwendet werden können. Dies ermöglicht mir den Ausschluss bestimmter Ordner, hat aber einige gewichige Nachteile. Durch viel höhere Komplexität der Pattern-Befehle, die damit einhergehende Fehleranfälligkeit sowie die deutlich rechenintensivere Auswertung bei größeren Repositories wird die Verwendung des no-cone Mode nicht empfohlen und ist in der Dokumentation als “deprecated” (überholt) angegeben. Dennoch, probieren geht über Studieren!

Test mit `sparse-checkout`

Nun lade ich die Action auf meine Gitea-Instanz hoch und lass meinen runner einmal drüber laufen. Anschließend logge ich mich auf dem Webserver ein und schaue, ob der .git-Ordner erstellt wurde oder nicht:

lectures# ls -la
[...]
drwxr-xr-x 8 root root 4096 Dec 20 10:41 .git
[...]

Mist, der Ordner ist ja immer noch da. Ich schaue in den Logs der Action auf meiner Gitea-Instanz nach:

[...]
hint: 	git branch -m <name>
Initialized empty Git repository in /workspace/schallbert/lectures/tmp/.git/
[...]
::group::Setting up sparse checkout
[command]/usr/bin/git config core.sparseCheckout true

An sparse-checkout liegt es also nicht. Dafür aber an der Art und Weise, wie checkout funktioniert: Offensichtlich wird für ein ordentliches Aufsetzen des Repository auf meinem Webserver der .git-Ordner zwingend benötigt. Also bleibt mir nur übrig, ihn nach dem Auschecken automatisch zu löschen.

Variante 2: `rm -rf`

Und so probiere ich es mit Gewalt:

# /.gitea/workflows/deploy-lectures.yml

# [...]
steps:
 - name: --- CHECKOUT ---
 uses: actions/checkout@v4
 with:
 path: ./tmp
 - name: --- REMOVE TEMPORARY FILES ---
 run: |
 rm -rfv ./tmp/.git ./tmp/.gitea
# [...]

Nun endlich taucht der .git-Ordner auf meinem Webserver nicht mehr auf und mein “Repo-Leak” ist geflickt. Nochmal danke an Repo Lookout!

Fazit

Ich hatte hier das Problem, dass der versteckte .git-Ordner, wo Konfiguration und Struktur von Repositories gespeichert werden, unbeabsichtigt und ohne mein Wissen auf meinem Webserver veröffentlicht waren.

Ich habe hier zwei funktionierende Optionen zur Lösung des Problems vorgestellt:

Ein Zugriffsverbot auf dem Webserver einrichten
Die Pipeline so umbauen, dass sie den .git-Ordner nach erfolgtem Ausrollen selbstständig löscht.

Die zweite Option ist zwar etwas aufwendiger einzubauen, doch packt sie das Problem bei der Wurzel, anstatt lediglich die Symptome zu beheben. Außerdem entspricht sie dem ersten Grundsatz aus dem Datenschutz: Datenminimierung geht vor Schutzmaßnahmen.

“Was nicht existiert, kann nicht verloren gehen” - Schallbert

Logrotate-Rekursion

Schallbert — Mon, 18 Nov 2024 00:00:00 +0000

Was funktioniert nicht?

Eigentlich wollte ich logrotate nutzen, um meine Logs täglich zu bereinigen und so Datensparsamkeit umzusetzen: So können IP-Adressen, die ich für’s Banning brauche, einheitlich und automatisiert nach kurzer Zeit gelöscht werden. Die Server-Logs interessieren mich ansonsten überhaupt nicht und stehlen mir nur Speicherplatz.

Mit meiner aktuellen Konfiguration erstellt logrotate zwar eine Logdatei am Tag, nennt sie aber xyz.log.1, xyz.log.1.1, xyz.log.1.1.1 anstatt der erwarteten xyz.log.1, xyz.log.2, xyz.log.3. Somit funktioniert die Löschroutine nicht mehr und die Anzahl der Logs wächst stetig.

Und warum?

Ich vermute, dass meine logrotate-Konfiguration fehlerhaft ist. Im Moment sieht sie wie folgt aus:

## LOGROTATE file named 'blog'
blog/* {
# it's ok if the file doesn't already exist
missingok
# Sets the logs to rotate in intervals
daily
# Tells the system to remove old logs and only keep the most recent rotated logs
rotate 7
# Rotated logs will be compressed and kept on disk if they are 10 MB or less.
size 10M
# compress and delaycompress: These two options are used together and indicate that 
# rotated logs should be compressed (gzip) except for the most recent one.
compress

delaycompress
}

Wie üblich nehme ich als Erstes die Bedienungsanleitung zur Hilfe, die ich mittels man logrotate in der Konsole aufrufe. Dort steht, dass die zu rotierende Datei direkt angegeben (und nicht nur per “Wildcard” gewählt *) werden kann. Außerdem kann ein Logverhalten auch auf mehrere Dateipfade angewendet werden, indem sie durch Leerzeichen getrennt vor die geschweifte Klammer gesetzt werden.

Das Sternchen scheint genau mein Problem mit den kaskadierenden Logs zu erzeugen: Dadurch wird nicht nur die eigentliche Zieldatei access.log rotiert sondern auch alle bereits rotierten Dateien nochmal angefasst.

Die Lösung

Entsprechend der Bedienungsanleitung schreibe ich die Bearbeitungsvorschrift für Logrotate so um, dass ich statt fünf eigenen Vorschriften für die jeweiligen Logs nur zwei Dateien erzeuge. Diese sind zudem einfacher und kürzer als die obige Ausgangsversion.

Beispiel:

# rotate webserver log files.
gitea/access.log
blog/access.log
landing/access.log
lectures/access.log
{
 # Sets the logs to rotate in intervals
 daily
 # Tells the system to remove old logs and only keep the most recent rotated logs
 rotate 7
 # compress and delaycompress: These two options are used together and indicate that 
 # rotated logs should be compressed (gzip) except for the most recent one.
 compress
 delaycompress
}

Konfigurations-Update

Dies kann ich durch meine vorhandene Server-Konfigurations-Pipeline durch einfachen Push ins Repository auf dem Server ausrollen. Nun muss ich die Dateien dort nur noch händisch nach /etc/logrotate.d kopieren.

Logrotate testen

Jetzt wäre es noch schön, wenn ich ausprobieren könnte, ob die von mir vorgenommenen Änderungen auch tatsächlich funktionieren. Dafür nehme ich erneut die Bedienungsanleitung von logrotate zur Hilfe und tippe:

logrotate -d -v <LOGROTATE-DESCRIPTOR-FILE>

Mit aktivierten debug und verbose Flags wird logrotate die in der Konfigurationsdatei angegebene Rotationsvorschrift anwenden und Rückmeldung geben, tatsächlich auf dem Dateisystem aber keine Änderungen oder Rotationen durchführen. Bei mir sieht das Ergebnis des Tests dann etwa so aus:

lectures/access.log 
 after 1 days (7 rotations)
empty log files are rotated, old logs are removed
considering log gitea/access.log
 Now: 2024-11-28 17:19
 Last rotated at 2024-11-27 00:00
 log needs rotating
considering log blog/access.log
 Now: 2024-11-28 17:19
 Last rotated at 2024-11-16 00:00
 log needs rotating
considering log landing/access.log
 Now: 2024-11-28 17:19
 Last rotated at 2024-11-07 00:00
 log needs rotating
considering log lectures/access.log
 Now: 2024-11-28 17:19
 Last rotated at 2024-09-21 00:00
 log needs rotating
rotating log gitea/access.log, log->rotateCount is 7
[...]
renaming lectures/access.log.7.gz to lectures/access.log.8.gz (rotatecount 7, logstart 1, i 7), 
renaming lectures/access.log.6.gz to lectures/access.log.7.gz (rotatecount 7, logstart 1, i 6), 
renaming lectures/access.log.5.gz to lectures/access.log.6.gz (rotatecount 7, logstart 1, i 5), 
renaming lectures/access.log.4.gz to lectures/access.log.5.gz (rotatecount 7, logstart 1, i 4), 
renaming lectures/access.log.3.gz to lectures/access.log.4.gz (rotatecount 7, logstart 1, i 3), 
renaming lectures/access.log.2.gz to lectures/access.log.3.gz (rotatecount 7, logstart 1, i 2), 
renaming lectures/access.log.1.gz to lectures/access.log.2.gz (rotatecount 7, logstart 1, i 1), 
renaming lectures/access.log.0.gz to lectures/access.log.1.gz (rotatecount 7, logstart 1, i 0)
[...]

Die Ausgabe zeigt mir, dass sowohl alle gewünschten Logdateien von logrotate berücksichtigt werden und auch, dass die Rotation korrekt und täglich durchgeführt wird.

Wieder etwas gelernt 😃

Klingenbutler

Schallbert — Mon, 14 Oct 2024 00:00:00 +0000

Warum Klingenbutler?

Nachdem das Problem der fehlenden Ablage für feste Shampoos in meiner Dusche gelöst hatte - daraus entstand der Seifenbutler - fielen mir dort herumfliegende Rasierer mehr und mehr störend auf.

Liegen sie unten auf dem Rand der Dusche, bildet sich um sie herum eine Lache. Dort entstehen dann besonders viele Kalkflecken und die Reinigung geht schlechter von der Hand. Legt man die auf die Armaturen, fallen sie früher oder später herunter und werden beschädigt. Selbiges gilt für die wackelige Ablage auf dem Rand der Duschkabine.

Es liegt nahe, die Klemmmechanik des Seifenbutler wiederzuverwenden. Somit muss nur der “vordere Teil” neu designt werden und schon erhalte ich eine formschöne Ablage für Rasierer - den Klingenbutler.

Das Design

Ich mag die runde Formgebung des Seifenbutler und möchte den Klingenbutler ähnlich gestalten. Die Rasierer sollen allerdings nicht allzu leicht versehentlich berührt werden können. Daher entschließe ich mich, sie möglichst “innen” anzubringen. Hierfür erstelle ich einen Ring mit Öffnung, der wiederum drei Einkerbungen für Rasierer besitzt. Die Radien der Einkerbungen gestalte ich so, dass alle mir zur Verfügung stehenden Nassrasierer dort hineinpassen und sogar Zahnbürsten sich ohne Kontakt der Borsten zum Klingenbutler einhängen lassen.

Die Öffnung (in der Zeichnung links) gestalte ich für Ober- und Unterschale so, dass die Oberschale in allen möglichen geschlossenen Positionen stets die Unterschale überdeckt. Damit vermeide ich überstehende Kanten bei besonders großen oder kleinen Duschstangendurchmessern.

Einrasten der Rasierer

Schwieriger war schon die Planung von Rasthilfen, sodass die Rasierer sich nicht von allein lösen können. Hier entschied ich mich beim ersten Entwurf für eine Kerbe in Form eines Doppeltetraeders. Im Bild oben ist die Kerbe mit “drain” beschriftet. Sie besitzt auf ca. 15mm Länge ein Gefälle von 3mm, lässt Spritzwasser ablaufen und ermöglicht eine schnelle Trocknung der Rasierer.

G2-Kurven

Als ich einen meiner Entwürfe kurz vor Einstieg in die Fertigung einem Bekannten von mir zeigte - er ist 3D-Designer von Beruf - fiel ihm sofort auf, dass ich keinen fließenden Übergang zweier Kurvenradien vorgesehen hatte. Er meinte, dass in solchen Fällen “G2-Kurven” im CAD eingesetzt werden und das Modell so viel harmonischere Übergänge bekäme.

Im Fachjargon scheint man dabei von geometrischer Stetigkeit zu sprechen. Sogleich fragte ich die Softwarefirma hinter meinem CAD-Werkzeug, ob sie so etwas ebenfalls unterstütze und siehe da - es gibt das Werkzeug tangentenstetige Verbindung erzeugen. Von nun an werde ich dieses Werkzeug verwenden, wenn ich Radien miteinander verbinde.

Das Werkzeug erzeugt eine Bezier-Kurve, deren Endpunkte tangential an die beiden Kreissegmente anschließen und die Knickstelle auf diese Weise beseitigen.

Diese Herangehensweise hat außer der gefälligeren Optik sogar noch einen Vorteil in der Fertigung: Beim Abfahren von Knickstellen muss die CNC-Maschine plötzliche Richtungsänderungen durchführen, ähnlich wie bei verbundenen Liniensegmenten, die in einem Winkel aufeinandertreffen. Somit muss abgebremst und im neuen Kurvenradius beschleunigt werden. Durch Verwendung tangentenstetiger Verbindungen hingegen werden Beschleunigungsspitzen deutlich abgemildert und die Maschine läuft mit gleichmäßigerer Geschwindigkeit durch.

Hat man wie mit dem Klingenbutler Projekte mit vielen “Knickstellen” in der Zeichnung, so kommen hier schnell ein paar Sekunden Fertigungszeit pro Teil zusammen, die leicht einzusparen sind - dazu vielleicht später mal mehr.

Erster Prototyp - Version 1.0

Die Fertigung trat ich mit meinem “klassischen” Prototypenmaterial an: gegossenes PMMA (Acrylglas) mit 5mm Stärke in opak weiß. Verwendet man einigermaßen passende Parameter, so verhält sich das Material äußerst gutmütig. Gleichzeitig legt das Material schonungslos alle Fehler offen: Hier eine Fase etwas zu weit, dort leichte Rattermarken durch Herausbeschleunigen der Maschine aus einer Ecke, im Boden des Gewindes gefangene Späne - All das tritt die etwas lichtdurchlässige Materialkomposition und starke Reflexionen an Materialkanten stark hervor. Daher ist dieses Material hervorragend geeignet, Design- und Fertigung von Produkten zu verbessern.

Durch meine Erfahrungen mit dem Seifenbutler gingen Niederhalten während der Fertigung und Zusammenbau des Klingenbutler problemlos vonstatten. Zahnbürsten und Rasierer sind von nun an an einem festen Platz in der Dusche zu finden 🙂.

Version 1.1 - Fertigung in Bambus

Eigentlich will ich ja weg von Kunststoff. Die Produktion meiner Seifenbutler habe ich im Laufe des Jahres zwar bereits auf “greencast” Acrylglas umgestellt - also PMMA, das selbst aus 100% recycelter Ware besteht - aber besser wäre ja noch, gar keinen Kunststoff einzusetzen.

Dafür ließ ich mir ein paar Muster “Moso-Bambus” kommen: Stäbchen-Leimholz in drei Schichten kreuzverleimt, ähnlich wie Sperrholz, knapp 7.5mm stark. Für die Fertigung in Bambus legte ich die Passtoleranzen etwas großzügiger aus (0.1mm Untermaß )und wandelte metrische Gewinde im Plan schlicht in einfache Bohrungen für Holzschrauben um.

Unnötiges weglassen

Beim Zusammenbau des ersten Prototypen wurde mir klar, dass das dritte Bajonett überflüssig geworden war. Zusammen mit ein paar kleineren, weiteren Änderungen entwickelte ich Version 1.1:

Dritte Verschraubung im Rastkreis weglassen
Rastnasen/Ablaufrinne: Durchgängige Gravur ohne Stoppen bei “Schlüsselloch”
Bajonett: Innenseiten auf Rückseite anfasen und so die Oberfläche durchbrechen

Drehzahl und Vorschub

Für das Vollnutfräsen nutze ich einen DLC-beschichteten (Diamond-like-carbon) 4mm Zweizahnfräser ohne Drall mit 12mm Schneidenlänge. Ich betreibe ihn bei S30000U/min mit einem Vorschub vonF3000mm/min. Ich gehe direkt in die volle Materialtiefe mit Z+ 7.5mm und fahre Bohrungen und Materialrampen mit 20°.

Fasen bringe ich mittels eines 90° Gravurfräser, dreischneidig, Durchmesser 10mm an. Ihn betreibe ich mit F5000mm/min bei S15000U/min und einem Mittenabstand von 2mm, was bei einer glatten Kante mit 0.5mm Breite schon bedeutet, dass er 2.5mm Luft “nach unten” in Z-Richtung benötigt.

Für Bohrungen, Taschen und kleine Aussparungen verwende ich einen hinterschliffenen 2mm Zweischneider Fischschwanz mit 15° Drall und 20mm Schneidenlänge. Ihn betreibe ich mit vorsichtigen 1700mm/min bei S30000U/min und einer Tiefenzustellung von nur Z+1.5mm. Auch hier tauche ich mit 20° ins Material ein.

Fertigung

Das Arbeiten im mir bis Dato noch völlig unbekannten Material “Bambus” ging überraschend leicht von der Hand. Dank meiner noch neuen und sehr scharfen Fräser waren keinerlei Ausrisse zu beklagen und das Material selbst hatte ebenfalls kaum Defekte oder Schadstellen.

Klingenbutler CNC-fräsen

Bei der Bearbeitung entstanden recht feine Späne, die ein wenig an Staub von der Verarbeitung von MDF-Platten erinnern. Ich bin mir noch nicht sicher, ob ich mit der Drehzahl weiter heruntergehen sollte oder ob dies an den geraden Schneiden des Fräsers liegt. Dieser muss Späne beim Fräsen in der Vollnut unter Umständen mehrere Umdrehungen lang mit sich führen, bevor er sie in der Nut hinter sich lassen kann.

Bohrungen jedenfalls sind mit diesem Fräser und unveränderten Parametern nicht zu empfehlen. Sämtliche Bohrlöcher haben verkohlte Ränder, was auf viel zu hohe Drehzahlen schließen lässt. Zudem habe in einem Stück gebohrt, anstatt den Fräser mehrfach zurückzuziehen. Nehmen wir den Dreisatz zur Hilfe: Beim Vorschub von FZ+2000mm/min, S30000/U/min und Z7.5mm führt der Fräser 112.5 Umdrehungen im Bohrloch aus, reiben die Schneiden also 225 mal sinnlos an der Wand des Bohrloches entlang - abtragen tut ja nur die Zentrumsschneide unten. Zudem werden die Späne ja nicht ausgeworfen sondern die ganze Zeit über mitgeführt.

Für den nächsten Prototypen werde ich Bohrlöcher also entweder mit Rückzügen und drastisch reduzierter Drehzahl fertigen oder schlicht einen kleineren Fräser verwenden.

Ergebnis

Das kann sich sehen lassen. Ich habe die Fase zum Kantenbrechen aus der Fertigung in Acrylglas übernommen. Sie fällt mit 0.5mm sehr schmal aus. Trotzdem zeigt sich auch im Detail ein sehr sauberes Bild. Ober- und Unterschale des Klingenbutler lassen sich weich gegeneinander verschieben und auch der Klemmer, mein Sorgenkind noch aus diesem Video ließ sich ohne Ausrisse fräsen.

Der Zusammenbau geht problemlos vonstatten und auch die Holzschrauben lassen sich leicht in die vorgebohrten Löcher eindrehen. Der Klingenbutler aus Bambus hält an der Duschstange sogar noch besser als sein Pendant aus Acrylglas - der raueren Oberfläche und höheren Materialstärke sei dank.

Bleibt abzuwarten, ob das Material auch im Feuchtraum langlebig genug ist. Für Schneidbretter in der Küche wird es ja noch immer gern verwendet.

Ausblick

Die Verwendung von Bambus hat mich sehr motiviert hinterlassen: Ein toller Werkstoff. Hart und fest aber dabei leicht, gut maschinell zu bearbeiten, formstabil und kaum Materialdefekte: So wünscht man sich das Arbeiten mit Naturmaterialien!

Dieser Prototyp landet nun zum Dauertest bei uns in der Dusche. In der Zwischenzeit verfeinere ich das Design weiter.

Version 1.2

Für V1.2 habe ich folgende kleine Verbesserungen in Planung:

Bohrungen: Kleineren Fräser wählen (zu Lasten der Zykluszeit)
Befestigung: Ausschnitt fräsen, sodass das Rändelrad nicht mehr übersteht
Aussparung innen an der Oberschale ist überflüssig
Unterschiedliche Radien mit G2-Kurven übergehen lassen
Rastnasen durch harmonischere, runde Ablaufrinne ersetzen
Maserung ausrichten: Alle Teile “senkrecht” fertigen
Die Klemmer nun in der ersten Aufspannung fräsen und um 0.04mm aufdicken

Auch hier ist das Ziel, mittels stetiger Verbesserung hin zu einem guten Produkt zu kommen.

Neue Startseite

Schallbert — Tue, 01 Oct 2024 00:00:00 +0000

Oktober-2024 — Neues Website-Design —

schallbert.de hat jetzt endlich die “Baustellenphase” überwunden. Ab jetzt steht nicht nur dieser Blog zur Verfügung, sondern auch die zusätzlichen Kategorien Shop und Vorträge.

Shop

Dieser Bereich befindet sich noch in einer frühen Planungsphase. Ich überlege hier, meinen Seifenbutler, Rohlinge für CNC-Gravuren und ein paar meiner Software-Projekte wie zum Beispiel QR-Codengrave als App zum Kauf anzubieten.

Ich habe mich bis jetzt weder auf ein Webshop-Framework festgelegt, noch bin ich momentan in der Lage, viel Zeit in den Aufbau der Seite oder die Fertigung von Produkten zu stecken. Von daher stellt der Shop ein Langfristiges Ziel dar. Als Bezugsquelle für Seifenbutler steht weiterhin Mopemasters Onlineshop zur Verfügung.

Vorträge

Diese Subdomain habe ich erstellt, um meine Vorträge zu sammeln. Sie nutzen ein anderes Framework als mein Blog und sind daher besser separat untergebracht.

Schallbert

NVME-Festplatte kaputt?

Schallbert — Tue, 10 Sep 2024 00:00:00 +0000

Das Ereignis

Mitte April 2024:

Nach einem Systemupdate fährt mein Laptop plötzlich nicht mehr hoch. Der Bootloader grub-core meldet, er habe Probleme beim Schreiben von Sektoren.

error: ../grub-core/efi/efidisk.c:638: failure writing sector 0xXXXXXXXX

Beim Reboot bleibt mir der Bildschirm nach Anzeige des Firmenlogos mit blinkendem Cursor schwarz. Wenn ich hinter die Maske schaue, dann schlägt das Laden diverser Services fehl:

Your browser does not support the video tag.

Boot errors due to read-only nvme

Erste Analyse

Ich vermutete ein Problem beim Update des Rechners und führte aus dem UEFI von Lenovo heraus einen Festplattentest durch. Ergebnis:

The media check is complete, the result is: FAIL

Eher kein Problem mit dem Betriebssystem sondern eines mit der Platte. Mist. Muss ich um meine Daten bangen? Ich habe zwar Backups herumliegen, das letzte ist aber drei Wochen alt und somit sind einige Stunden Arbeit auf der Kippe. Zudem kostet mich ein Wiederaufsetzen einiges an Zeit. Daher probiere ich erst einmal, ob sich noch etwas retten lässt.

Selbsttest

Ich lasse also die SMART Tests für die Platte mit smartctl -x /dev/nvm0 durchlaufen und weiß nun, dass sie etwa 7600 Betriebsstunden hinter sich und 240GB nutzbare Kapazität hat. Die unter dem Namen nvme0n1 eingesetzte Disk meint, sie sei nun “read-only”. Und zwar sämtliche Partitionen inklusive Kernel. Na klasse. Das Ergebnis meiner Online-Suche war in etwa:

Die Platte ist irreparabel beschädigt. Es muss eine Neue her.

Reparaturversuch

Man muss ja nicht alles glauben, was im Netz steht. Also nehme ich das Lenovo-eigene Reparaturwerkzeug für Festplatten zur Hand. Es lässt sich aus dem UEFI heraus aufrufen und firmiert unter dem Namen Bad Block Recovery Tool. Das Programm scannt die Platte auf defekte Sektoren und versucht, betroffene Blöcke wiederherzustellen. Der Durchlauf benötigt für die letzten 10% fast eine halbe Stunde.

Ergebnis: Wiederherstellung fehlgeschlagen. Ich führe das Werkzeug erneut aus. Und noch ein drittes Mal im langsamen pedantic-Modus. Immer wieder ohne Erfolg. Ständig bekomme ich critical medium error angezeigt.

Ob dies alles nicht klappt, weil sich die Platte in den Read-only mode gesetzt hat?

Da ich nicht mehr booten kann und keine Konsole zur Verfügung habe, sind meine Möglichkeiten mit Bordmitteln nun erschöpft.

Einwurf: Der Read-only mode bei SSDs

Laut Internet (DiskTuna) ist der read only mode zur Schadensbegrenzung vorhanden. Stellt der Controller des Speichergerätes einen schwerwiegenden Fehler fest, versetzt er die Platte in Nur-Lesezugriff. Somit wird das Risiko minimiert, dass weitere Blöcke korrumpiert oder mit in den Tod gerissen werden.

Im Forum Superuser beschreibt jemand einen identischen Fehler zu meinem, und tatsächlich ist da wohl nichts mehr zu machen.

Datenrettung per Boot-Stick

Weiter geht’s mit einem USB-Stick, den ich von einem anderen Rechner aus zum Linux-Boot-Stick mache. Ich stopfe ihn an meinen Laptop und kann ihn endlich wieder hochfahren. Als Medium zur Datenrettung schließe ich eine externe Festplatte an.

Übersicht verschaffen mit fdisk

Zuerst schaue ich, ob alle Platten und Partitionen auftauchen. Dafür tippe ich das Kommando sudo fdisk -l in die Konsole.

Glück gehabt, alles ist noch da! Vielleicht kann ich die Dateien ja einfach von der defekten Festplatte herunter kopieren?

Kopieren mit cp

Probieren wir’s aus.

sudo cp -r -v /mnt/nvme0n1p3/Documents/my/important/files /mnt/externalHdd/save

Ein paar Sekunden denke ich, dass alles glatt geht. Doch dann bricht cp mit Fehlermeldung ab, das Volume sei nicht verfügbar. Tatsächlich ist die Platte nicht mehr gemountet. Ich kann sie allerdings direkt wieder finden und mounten. Ein paar Versuche später habe ich meine wirklich wichtigen Daten gesichert, der Kopiervorgang bricht aber stets nach ein paar Sekunden ab. Für die ganze Platte würde mir dieses Vorgehen viel zu lange dauern.

Genau dieses Verhalten - mounten, ein paar Sekunden kopieren, Platte verschwindet - habe ich online in ein paar Foreneinträgen bestätigt bekommen.

Also muss eine andere Lösung her.

Daten retten mit ddrescue

Nach kurzer Online-Suche installiere ich das Programm ddrescue.

In der zugehörigen Dokumentation stehen einige Dinge sehr klar drin. Dass man z.B. verstanden haben sollte was es genau tut, bevor man es verwendet. Oder das Folgende:

“Never try to repair a file system on a drive with I/O errors; you will probably lose even more data. " - ddrescue Manual

Jetzt stellt sich für mich die Frage, ob ich oben mit dem Block-Reparaturversuch genau so einen Fehler begangen habe. Oder bin ich mit der Bad Block Recovery auf der sicheren Seite, da hier von Datenblöcken auf der Platte und nicht vom “darüber liegenden” Dateisystem die Rede ist? Hier steht auch, dass die sogenannte Mapfile eine Kernfunktion des Programmes ist. Nach Abbruch, Neustart, für die Zusammenführung von Backups und zum Verkürzen der Datenrettung bietet sie einen großen Zeitvorteil. Daher sei es keine schlechte Idee, sich die Mapfile schon bei Erstellung einer Offlinhe-Sicherheitskopie zu erzeugen und gut wegzulegen. Insgesamt fand ich das Tool extrem hilfreich, effektiv und leicht zu bedienen und kann es an dieser Stelle nur weiterempfehlen.

Zurück zur Sache: Ich finde einen ganz einfachen Befehl, die komplette Datenpartition meines beschädigten NVME-Speichers auf eine externe Festplatte zu kopieren:

ddrescue --sparse /dev/nvme0n1p3 /run/media/liveuser/myExternalHDD/datapartition

Die --sparse-Option überspringt mit Nullen belegte Bereiche der Quellplatte und kann so eine Menge Platz auf dem Zieldatenträger einsparen. Das Programm benötigt eine Viertelstunde für den kompletten Durchlauf. Es kann wie oben im Bild zu erkennen tatsächlich 99.6% der Daten retten und auch mehrere Monate später habe ich die restlichen 0.4% noch nicht vermisst. Glück gehabt.

Überprüfung: Output von ddrescue ansehen

Jedenfalls legt das Programm am Ende eine einzige Datei auf meiner externen Platte ab: datapartition.img Dieses Image kann ich mit fdisk -l anschauen:

datapartition.img: 236.89 GiB, 254356226048 bytes, 496789504 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

Alles da, das ist ja schon einmal gut. Ob denn nun auch alles drin ist?

Dafür mounte ich die Partition mal und schaue mich per cd und ls -l darin um:

sudo mkdir /mnt/olddisk # Mount point of the rescued data image
sudo mount /run/media/liveuser/myExternalHDD/datapartition.img /mnt/olddisk

Zum Glück war alles drin, was drin sein sollte. Nun konnte ich das Image unmounten, den Rechner herunterfahren und eine neue Festplatte einbauen lassen.

Die neue Festplatte

Auch hier habe ich noch einmal Glück gehabt: Auf meinem Gebrauchtlaptop war noch Garantie und so bekam ich ihn binnen einer Woche mit einer neuen (und doppelt so großen) Festplatte zurück gesendet. Da ich so große Angst vor Datenklau bekam, hatte ich meine alte Platte vor dem Versenden ausgebaut. Dabei kam ich mir ganz schön paranoid vor.

Diese Arbeit hätte ich mir aber vielleicht sparen können, denn ddrescue hat auch für paranoide Leute wie mich eine Software-Lösung parat: Die Option --fill-mode. Hiermit können nach erfolgter Rettung die “noch guten” Blöcke und Sektoren gelöscht werden. Nur die ohnehin defekten Sektoren bleiben erhalten. Aus der Online-Dokumentation:

ddrescue --fill-mode=+ --force /dev/zero bad_drive mapfile

Ob dies allerdings auch einer Platte wie meiner funktioniert hätte, die der On-Board-Controller auf “read-only” gesetzt hat, ist mir nicht klar. Egal.

Ich kann jetzt jedenfalls mit einem voll funktionsfähigen Laptop weiter Blog-Einträge verfassen ☺️.

Giteas act_runner: Startprobleme

Schallbert — Fri, 30 Aug 2024 00:00:00 +0000

Das Problem

Seitdem ich diese Seite in Eigenregie betreibe, habe ich nach Neustart des Gitea-Containers das Problem, dass der aktivierte act_runner manchmal nicht mit hochfährt. Er bricht dann unter Angabe von Status Code -1 ab und meine Workflows werden nicht abgearbeitet, sodass ich z.B. keine Artikel bauen oder veröffentlichen kann.

Die Fehlermeldung ist immer dieselbe:

[...]
runner-1 | time="2024-08-26T10:09:46Z" level=info msg="Starting runner daemon"
runner-1 | time="2024-08-26T10:09:46Z" level=error msg="fail to invoke Declare" error="unavailable: 502 Bad Gateway"
runner-1 | Error: unavailable: 502 Bad Gateway
runner-1 exited with code 1
gitea | 2024/08/26 10:09:46 cmd/web.go:242:runWeb() [I] Starting Gitea on PID: 16

Der Runner kann sich also nicht bei Gitea einklinken. Wenn ich alle Services über Docker per docker restart erneut starte, meint der Container für act_runner, ihm fehle dafür ein Netzwerk mit ID <ellenlanger Hexcode hier>.

Die kurzfristige Lösung

Ich hatte die letzten Monate keine Zeit dem nachzugehen. Daher half ich mir stets damit, folgendes doppelt auszuführen:

# schallbert server-console
docker compose -f /path/to/giteas/composefile up -d

Beim zweiten Anlauf dann lief der Runner wiederholbar erfolgreich an (Gitea war ja schon betriebsbereit):

gitea | 2024/08/26 10:38:17 routers/init.go:116:InitWebInstalled() [I] Git version: 2.45.2 (home: /data/gitea/home)
runner-1 | time="2024-08-26T10:38:22Z" level=info msg="Starting runner daemon"
runner-1 | time="2024-08-26T10:38:22Z" level=info msg="runner: action-runner, with version: v0.2.10, with labels: [ubuntu-latest], declare successfully"
runner-1 exited with code 0
runner-1 | time="2024-08-26T10:40:32Z" level=info msg="Started runner daemon"

Dies ist natürlich nicht so schön und muss händisch von mir gemacht werden. Doch was ist die Ursache?

Ursachenforschung

Zuerst hatte ich den Reverse Proxy von Caddy im Verdacht, da er Gitea an das Internet anbindet. Doch tatsächlich ist Gitea selbst das Problem: Es ist zum Zeitpunkt, zu dem Docker den runner Container startet, noch gar nicht fertig hochgefahren. Also lese ich nach, wie ich Abhängigkeiten in Docker besser darstellen kann.

Lösung: Abhängigkeiten abbilden

Zuerst versuche ich es mit dem Einbinden der Änderung in docker compose.

depends_on

# gitea/docker-compose.yml
 ## service: runner
 ## [...]
 depends_on:
 gitea:
 condition: service_started

Doch noch immer startet der act_runner wohl zu früh. Docker stellt hier nämlich lediglich sicher, dass Gitea gestartet wurde, nicht aber, dass es hochgefahren ist und stabil läuft.

Healthcheck

Ich muss folglich sicherstellen, dass Gitea betriebsbereit ist. Dies geht prima mit der Bedingung service_healthy. Ich passe also die Instruktionen für den Runner wie folgt an:

# gitea/docker-compose.yml
 ## service: runner
 ## [...]
 depends_on:
 gitea:
 condition: service_healthy # required so runner can attach to gitea
 restart: true

Der service_healthy Qualifier ist ein Rückgabewert der healthcheck Funktion. Diese besteht aus einem sogenannten test und ein paar Begleitparametern, in welchem Intervall wie oft und nach welcher Zeit geprüft werden soll, ob der Dienst nun betriebsbereit ist.

Ich habe als Test ein einfaches Kommando gewählt mit der Annahme, dass Gitea (und damit implizit auch Caddy) fertig hochgefahren ist, sobald curl seine Webseite aufrufen kann.

# gitea/docker-compose.yml
## service: gitea
## [...]
 healthcheck:
 test: ["CMD", "curl", "-f", "https://git.schallbert.de/"] # checks if gitea is available
 interval: 10s
 retries: 3
 start_period: 30s
 timeout: 10s

Mit diesen Zeilen prüft Docker, ob Gitea “healthy” ist und startet den act_runner entsprechend später. Das oben dargestellte Problem ist auf meinem Server seitdem komplett behoben und Gitea sowie runner verhalten sich zuverlässig und stabil.

Fehler-Logdateien versenden

Schallbert — Tue, 20 Aug 2024 00:00:00 +0000

In diesem Artikel schaue ich mir an, wie ich “Monitoring” für meinen Server einrichte. Anwendungen und Dienste sollen mir im Fehlerfalle Benachrichtigungen senden können.

Worum geht es hier?

Sendemechaniken kennenlernen und auswählen
Testnachrichten verfassen und die Automation verifizieren
Fehlerbericht von Borgmatic automatisch senden
Senden von Runner-logs durch Gitea
Benachrichtigung bei Login auf meinem Server per ssh
Erstellen und Senden eigener Logs zu Server-Update / Server-Fehlern

Verifikation und Überwachung

Ich möchte nach dem Ausführen einer Automation wissen, ob sie erfolgreich durchgeführt wurde und alle Programme und Dienste ihre Arbeit erwartungsgemäß aufgenommen haben. Dies soll für jegliche Automation gelten - ob es sich konkret um das Senden eines Updates, die Anfertigung automatischer Backups oder eine Action von Gitea handelt, muss egal sein.

Normalerweise würde ich für so etwas Berichtsmechanismen von act_runner verwenden. Im Falle eines Server-Updates steht der Runner durch den bereits im Artikel Serverkonfiguration ausrollen erwähnten Zirkelbezug nicht zur Verfügung, da zeitweise alle Anwendungen heruntergefahren werden müssen.

Zudem kann es sein, dass Anwendungen eigene Vorgehensweisen haben, Monitoring zu betreiben. Also muss ich mir Mechanismen anschauen, mit denen ich leicht an die Informationen herankomme.

Was zeichnet ein gutes Monitoring für mich aus?

Es ist unaufdringlich, meldet sich also nur im Fehlerfall oder bei ungewöhnlichen Vorgängen.
Es liefert spezifische Informationen und gut zu verstehende Fehlermeldungen.
Es nutzt einen Nachrichtenkanal, der auch bei Absturz des zu überwachenden Systems funktioniert.
Es stellt Berichte und Fehlermeldungen isoliert von anderen Themen dar und vermischt nichts.
Es fasst sich kurz.

Methoden automatischer Berichterstattung

Diesen Abschnitt gliedere ich ich auf. Im Allgemeinen Teil gehe ich auf das mir auf dem Ubuntu-Server zur Verfügung stehende Bordwerkzeug zum asynchronen Monitoring ein. Danach schaue ich mir die bei meinen Diensten teils eingebauten Lösungen bzw. mit ihnen kompatible Anwendungen an. Dabei möchte ich mich nicht auf das klassische Instrument der E-Mail beschränken, sondern auch kurz “modernere” Kommunikationskanäle wie Messengerprogramme oder RSS-Feed beleuchten.

Mail per Konsole - curl

Versand von Mails als Benachrichtigungen sind in vielen Firmen üblich. Dies geht mit Linux meist sogar ganz ohne zusätzliche Programme: Das standardmäßig vorhandene curl kann hier bereits weiterhelfen. curl it ein Programm zum Datentransfer von oder zu einem Server. Gebe ich meinen Blog als Ziel ein, bekomme ich die HTML-Seite als Textdatei auf die Konsole ausgegeben:

curl https://blog.schallbert.de

Bei der Gelegenheit fällt mir auf, wie viel unnötige Daten meine Blogsoftware erzeugt. Da werde ich später mal aufräumen müssen. Zurück zum Thema: Man kann curl allerdings auch nutzen, um ein beliebiges Webbackend anzusprechen - Zum Beispiel einen Mailserver:

# copied from https://stackoverflow.com/questions/8260858/how-to-send-email-from-terminal
curl --url 'smtps://smtp.gmail.com:465' --ssl-reqd \
 --mail-from 'from-email@gmail.com' \
 --mail-rcpt 'to-email@gmail.com' \
 --user 'from-email@gmail.com:YourPassword' \
 -T <(echo -e 'From: from-email@gmail.com\nTo: to-email@gmail.com\nSubject: Curl Test\n\nHello')

Dies funktioniert nur dann auch für meinen Mail-Provider, wenn ich Logins durch externe Clients zulasse. Google nennt diese z.B. “weniger sichere Apps”. Ich bin wie in meinem Beitrag Server-Konfiguration mit Git beschrieben kein Fan davon, Secrets irgendwo hart hineinzuschreiben - daher würde ich den direkten Weg über curl eher nicht nutzen.

Mail per Konsole - mail, mailx, mailutils, swaks

Wer all die Konfigurationsinformationen für den Server und Secrets nicht immer mitgeben möchte, dem stehen diverse handliche Werkzeuge für die Konsole wie mailutils oder swaks zur Verfügung. Hier wird die Verbindung zum Mailserver über das Werkzeug einmalig konfiguriert und kann in z.B. in Umgebungsvariablen abgelegt werden. Die Syntax variiert von Programm zu Programm, hinten kommt aber stets eine Mail heraus.

An sich eine simple Lösung. Der einzige große Nachteil dabei für mich ist, dass sich hier Informationsdomänen vermischen. Ich hätte nur ungern noch einen “Berichtsthread” in meinen Mails, nach dem ich im Wust der Nachrichten irgendwann würde suchen müssen. Bei Benachrichtigungen auf anderen Kanälen kann ich zudem ein automatisches Verfallsdatum einstellen, sodass sie nach eingestellter Zeit aus meiner Liste verschwinden.

RSS Feed erzeugen

Ungewöhnlich aber möglich: Ich könnte das Monitoring als RSS-Feed wie meinen Blog auch (schallberts-blog-feed) z.B. per Jekyll-Instanz erzeugen und als Website online stellen. Dieser wäre leicht zu abonnieren, mit praktisch jedem Reader zu lesen und ich könnte ihn sogar für jede Applikation ganz einfach getrennt vorsehen. Doch es gibt offensichtliche Nachteile:

Hoher Aufwand: Gitea runner mit Jekyll-Instanz, Webserver und Subdomain erforderlich.
Öffentlich verfügbar: Plötzlich werden Bauvorgänge, Updates, Upgrades und Fehlermeldungen für jedermann zugänglich.
Fehleranfällig: Schmiert Gitea, der Runner, mein Proxy oder der Webserver ab, bekomme ich keine Berichte.

Spätestens mit dem letzten Punkt ist diese Option für mich raus. Ich möchte ja gerade dann einen Bericht bekommen, wenn meine Applikationen nicht das tun, was sie sollen.

Werfen wir nun mal einen Blick auf die von mir bereits betriebenen Anwendungen und schauen, wie sie dieses Problem angehen.

borgmatic

Borgmatic bringt von Haus aus Kompabitilität zu einer Menge Monitoring-Optionen mit. Darunter befinden sich apprise, ntfy, healthchecks, cronitor, pagerduty, cronhub und grafana.

Apprise ist eine Bibliothek. Sie ist quelloffen und kann von einer bestehenden Anwendung als Abhängigkeit eingebunden werden. Wie ein Adapter ermöglicht sie die asynchrone Kommunikation der Anwendung mit diversen verschiedenen Kommunikationsdiensten wie SMS, Mail, Messenger (z.B. Signal), diverse Heimautomation oder den Benachrichtigungssystemen diverser Betriebssysteme. Letzteres funktioniert allerdings nur auf der lokalen Maschine. Der Trigger für die Kommunikation muss dabei stets von der Anwendung ausgehen.
ntfy ist ein Push-Benachrichtigungsdienst. Er ist quelloffen und kann sowohl selbst gehostet als auch über eine Webanwendung als Dienstleistung in Anspruch genommen werden. Apprise z.B. unterstützt ntfy als Kommunikationsdienst. Der Aufbau ist recht einfach und funktioniert wie bei MQTT auch über einen Publication-Subscription bzw. Broker-Client Mechanismus, allerdings HTTP-basiert.
Healthchecks ist ein Dienst. Er ist quelloffen und kann selbst gehostet werden. Der Dienst ist dazu da, regelmäßige Aktivitäten zu überwachen und kann als Totmannschalter fungieren: Erfolgt anders als erwartet keine Rückmeldung vom überwachten Programm, so kann er selbst eine Fehlermeldung absetzen. Diese kann wiederum an diverse Kommunikationsdienste gesendet werden.
Cronitor ist eine Monitoringlösung und Webanwendung, die neben den von mir benötigten Benachrichtigungen eine Menge Analysetools, Leistungsmessungen und Metriken - zumeist gegen Geld - bereitstellt. Es gibt zwar einen kostenfreien “Hacker”-Account mit begrenztem Funktionsumfang, jedoch ist auch dieses Werkzeug mir entschieden zu groß und zu komplex.
PagerDuty sieht sich als kommerzielle “Operations” Plattform, die sowohl “Incident Management”, Automation, “Business Operations”, “AIOps” etc. bereitstellt. Ist für mich direkt raus. Spätestens beim Wort “AIOps” 😅
cronhub sieht mir wie eine kommerzielle Webanwendung aus, die ähnlich wie Healthchecks Cron-Jobs erstellen, überwachen und bei Fehlern melden kann. Sie ist für mich uninteressant, denn sie scheint weder open source zu sein noch könnte ich sie selbst hosten.
Grafana ist eine Open-Source-Webanwendung, die entweder selbst gehostet oder als Cloud-Dienst verwendet werden kann. Obwohl viele größere Unternehmen und Projekte die Anwendung nutzen, ist sie für meine Zwecke um Größenordnungen zu umfang- und funktionsreich.

fail2ban

Fail2ban hat keine Automationslösung wie borgmatic. Es erzeugt schlicht Logdateien die ausgewertet werden müssten, um Inhalte für Benachrichtigungen zu gewinnen. Mir fällt im Moment nichts ein, was ich unbedingt von Fail2ban wissen müsste. Daher erstelle ich mir hierfür erst einmal keine Berichte.

Gitea

Bei Gitea lassen sich die Logdateien sehr feingliedrig konfigurieren. So können Access Logs getrennt von Service Logs, Repository Logs oder Action Logs herausgeschrieben und dann weiterverarbeitet werden. Als Benachrichtigungssystem bietet Gitea nach meiner Recherche ausschließlich einen mailer an. Dieser ist meiner Ansicht nach vor Allem für Repository- und Action Logs gedacht.

Auch hier würde es mir am meisten bringen, die Logs zu analysieren und bei Bedarf einen Bericht selbst zu erstellen.

Server

Das Ausrollen meiner Server-Konfigurationsdateien übernehme ich per Skript ja sowieso schon selber. Also könnte ich auch hier im Fehlerfalle die Logs in eine Datei umleiten und sie dann einem Bericht in einen beliebigen Kanal anhängen.

Außerdem wären erfolgreiche Logins auf dem Server selbst eine Nachricht an mich wert. Dann kann ich sofort feststellen, ob ich das selbst war oder nicht.

Die Auswahl des Berichtsprogramms

Ich muss nicht nur ein Monitoring-Programm heraussuchen, sondern auch einen Kommunikationsdienst wählen über den die Berichte versendet werden.

Berichtsprogramm

Programm	Vorteil	Nachteil
curl	simpel	Konfiguration muss mitgegeben werden
	funktioniert super einfach mit ntfy¹	Keine Überwachung bei Absturz des Servers
	Bordwerkzeug
	kein Service erforderlich
Apprise	ermöglicht Einbindung der Signal-Api²	Komplex im Zusammenspiel mit externen Diensten³
	kein Service erforderlich
Healthchecks	Kann als Watchdog/Totmannschalter agieren	Registrierung erforderlich
	Kann lokal gehostet⁴ werden	Lokales Hosting widerspricht Watchdog-Konzept

Ich habe ja nur einen kleinen Server mit ein paar wenigen Anwendungen. Daher halte ich es hier so einfach wie möglich und wähle Apprise für Dienste wie borgmatic, die diese Bibliothek sowieso mitbringen und curl für jene, deren Berichtsmechanik ich selbst programmieren muss.

Kommunikationsweg

Programm	Vorteil	Nachteil
SMS	Hohe Zuverlässigkeit	Registrierung erforderlich
		Beschränkung auf wenige Zeichen
		Keine Anhänge möglich
		Keine Topics, Domänenvermischung
Mail	einfach einzurichten	Schlechte Durchsuchbarkeit
RSS-Feed	Gute Sortierbarkeit	Kompliziert einzurichten, fehleranfällig
	Client sehr leichtgewichtig	Lokales Hosting widerspricht Watchdog-Konzept
		Inhalte öffentlich verfügbar
ntfy	Simpel und leichtgewichtig	Registrierung optional bei Web-Nutzung
	Client zweckorientiert	Unsicher: Keine Verschlüsselung ohne Registrierung
	Kostenlos für Kleinanwender
	Unabhängig von der eigenen Maschine
Signal	“Note to self” einfach einzurichten	Einrichtung und Konfiguration der Signal-API komplex
	Unabhängig von der eigenen Maschine	Topics etwas schwierig umzusetzen
		Nutzlos bei Absturz des Servers

SMS, Mail und RSS-Feed sind durch teils oben bereits erläuterte Nachteile für mich bereits raus. Bleiben also ntfy und Signal. ntfy besticht durch seine Einfachheit: HTTP PUSH-request auf ein selbst definiertes “Topic” senden und selbiges auf dem Handy abonnieren - fertig. Es ist auch gut erweiterbar, denn durch self-hosting kann ich später bei Bedarf die Sicherheit erhöhen (Verschlüsselung) und das Sendeverhalten steuern. Signal hingegen macht einen eigenen Client mit verhältnismäßig aufwändiger Konfiguration erforderlich. Außerdem müssten die Geräte Server-Handy verbunden werden, sodass nicht einfach neue Abonnenten hinzuzufügen sind. Dafür ist die Übertragung bestens Ende-zu-Ende gesichert, ich muss mich nicht registrieren und kostenlos ist es auch noch.

Vorerst entscheide ich mich auch hier für die weniger komplexe Lösung mit ntfy.

Logging

Gut. Nun ist geklärt, dass ich per curl und apprise über den ntfy-Dienst nach Hause telefoniere. Nun schaue ich mal, welcher Inhalt zu übermitteln ist und wie ich möglichst unaufdringlich, dabei aber kurz und prägnant bleibe.

Wann sollen Logs gesendet werden?

borgmatic: Wenn ein Backup fehlschlägt
Bei erfolgreichem Login auf meinen Server oder Gitea
Nach Ausrollen eines Updates der Server-Konfiguration
docker: Falls eine Applikation ausfällt oder nicht hochfährt
gitea: Fehlgeschlagener Durchlauf von act_runner

Was gehört für mich in einen Bericht?

Ich möchte die klassischen “W-Fragen” beantwortet bekommen.

Wann ist es passiert (Zeitstempel)?
Welche Anwendung berichtet?
Was ist passiert?
Wo (Modul, Codezeile) etc. ist das passiert?
Wie viele Verletzte (Schweregrad, Recovery)?

Eine Benachrichtigung sieht dann etwa so aus:

TIMESTAMP APPLICATION PRIORITY MESSAGE EFFECT DETAIL

Rohfassung eines Berichts

Eine ntfy-Nachricht könnte ungefähr so aussehen:

curl \
 -H "Title: Fehler Borgmatic" \
 -H "Priority: urgent" \
 -H "Tags: warning" \
 -d "YYYY-MM-DD HH:MM:SS Backup-Erstellung abgebrochen. Zugriff auf Repository blockiert" \
 ntfy.sh/schallberts-topic

Ich installiere die entsprechende App auf meinem Handy, registriere mich auf das “Topic” und sende die Nachricht ab. Es ist schön, wenn Dinge einfach funktionieren! Aha, die App zeigt den Zeitpunkt des Einganges an. Das ist mir genau genug.

Durchführung

Ich nehme mir hier nacheinander alle Dienste vor, für die ich gern Benachrichtigungen einrichten möchte.

borgmatic

Starten wir mit einem Pilotversuch wieder in kleinen Schritten. Als Erstes konfiguriere ich Borgmatic zum Senden einer Nachricht über Apprise an ntfy bei Fehlschlag der Backup-Erstellung:

# /borgmatic.d/config.yml
on_error:
 - echo "Error while creating a backup."
 - apprise -vv --title "Borgmatic Error"
 --body "Could not run {output}. Aborted {error}."
 ntfy://schallberts-topic

Dann teste ich das Kommando, indem ich innerhalb des Borgmatic-Containers apprise anspreche. Und tatsächlich, es funktioniert. Aber der Weg hierhin hat mich locker eine Stunde gekostet, da die yml mit ihren Syntaxregeln sogar innerhalb von Strings interpretiert und borgmatic aufgrund von : sowie - Zeichen ständig die Konfigurationsdatei nicht lesen wollte. Wenn ihr einen Fehler sieht ähnlich diesem hier:

At 'on_error[1]': {'apprise -vv --title "Borgmatic Error" --body "Could not run {output}': 'Aborted {error}." ntfy://schallberts-topic'} is not of type 'string'

Daran ist zu erkennen, dass die Interpretation von Zeichen oder Einrückungen schiefgelaufen ist und die Zeichensetzung zu prüfen ist. Alternativ kann auch der Pipe-Operator | verwendet werden, um ein Kommando zu kombinieren. Referenz: yml-Spezifikation

Server

Eine Anwendung von ntfy zur Überwachung von Logins auf einem Server findet sich bereits in der Dokumentation von ntfy selbst. Die Beschreibung zeigt, dass so etwas leicht selbst umzusetzen ist und gibt unter Verwendung von Pluggable Authentication Modules (PAM-Bibliothek) ein tolles Beispiel.

Am Ende der Datei sshd im Verzeichnis etc/pam.d folgenden Code einfügen:

session optional pam_exec.so /usr/bin/ntfy-ssh-login.sh

Diese Zeile sagt PAM, dass sie bei Öffnen einer session per ssh das ausführende Modul pam_exec aufrufen soll, welches dann das hernach angegebene Skript abspult. Der Wert optional bedeutet, dass die Konfigurationsdatei auch bei Fehlschlag der Aktion weiter durchlaufen werden soll. Mehr Details zum Umgang mit PAM gibt es z.B. auf Baeldung.

Anschließend ist im Skript ntfy-ssh-login.sh schlicht der ntfy-Aufruf zu hinterlegen, wenn das Skript feststellt, dass PAM ein open_session Event festgestellt hat.

Genau so habe ich es bei mir umgesetzt und es funktioniert auf Anhieb. Klasse! Der einzige Nachteil: Diese Modifikation habe ich direkt auf dem Server gemacht. Ohne Container und außerhalb meiner Konfigurations-Sicherung. Wenn ich den Server jetzt aus irgendeinem Grund neu aufsetzen muss, ist die Änderung im PAM futsch und ich bekomme keine Benachrichtigungen mehr, bis ich die Änderung manuell erneut einpflege.

Server-Konfiguration

Für das Senden eines Berichts nach Ausführen der Konfigurationsautomation muss ich eigentlich nur das im Rahmen des letzten Artikel verfasste server-config-action Skript anpassen.

Zunächst möchte ich informiert werden, wenn das Skript fehlerfrei durchlief. Dafür füge ich am Ende der Datei einen curl-Befehl ein.

# server-config-action.sh

# action commands...
# [...]
# send success notification
curl \
 -H "Title: server-config-action" \
 -H "Priority: low" \
 -H "Tags: white_check_mark" \
 -d "Rollout successful" \
 ntfy.sh/schallbert-server-config-push-topic

Sollte das Skript allerdings nicht fehlerfrei durchlaufen, so möchte ich folgendes tun:

Aktionen nach Auftreten des Fehlers abbrechen
Ein Fehler-Log erstellen
Dieses Log versenden

Den ersten Punkt kann ich durch Hinzufügen einer Falle (Englisch “Trap”) für Fehler erreichen:

# server-config-action.sh
trap 'handle_error $LINENO' ERR

# action commands...

Hiermit wird die Funktion handle_error aufgerufen. Ihr wird die Zeilennummer mitgegeben, an der der Fehler ERR auftrat. Damit decke ich auch Fehler ab, die beim Neustart der Container entstehen können. Das Fehler-Log erstelle ich mir durch Wegschreiben der Ausgabe der einzelnen Skriptbefehle. Dies erreiche ich mit der folgenden Zeile:

# server-config-action.sh

exec 3>&1 1>server-config-action.log 2>&1

# action commands ...

Jeglicher Standard-Output stdout soll mit diesem Befehl an den Dateideskriptor 3, hier angegeben mit der Logdatai server-config-action-log, überschreibend weitergereicht werden. Für “Anhängen” müssten es zwei Umleitungsoperatoren >>⁵ sein. Somit ersetzt die Logdatei die Konsolenausgabe, welche ich im vorigen Artikel noch an dieser Stelle hatte.

Um das Log zugesandt zu bekommen, definiere ich nun folgende Funktion am Anfang des Bash-Skripts:

# server-config-action.sh
# on error, send a notification
handle_error() {
 # stop redirecting to file
 exec 1>&3 1>&2
 curl \
 -H "Title: server-config-action FAILED" \
 -H "Priority: high" \
 -H "Tags: x" \
 -T server-config-action.log \
 -H "Filename: server-config-action.log" \
 ntfy.sh/schallbert-server-config-push-topic
 exit 1
}

# set error trap
# redirect stdout and stderr to file
# action commands...

Gitea

Für Berichte von Github Actions gibt es bereits ein existierendes Beispiel auf ntfy_examples/#github-actions. Und das Beste: Da der act_runner von Gitea an den wesentlichen Stellen in den Umgebungsparametern kompatibel ist, funktioniert das Senden an ntfy bei mir auf Anhieb. In der Workflow-Datei des runners muss nur der auf der Website angegebene curl-Befehl angegeben werden und fertig.

Ergebnis

Hiermit sind jetzt fünf Benachrichtigungen über die wichtigsten Vorgänge auf meinem Server eingerichtet. Ich habe die zugrundeliegenden Mechaniken verstanden und kann jederzeit weitere Benachrichtigungen erstellen, wenn ich sie benötige. Löse ich alle Benachrichtigungen testweise aus, zeigt mein Handy das dargestellte Bild.

Eine Unabhängigkeit vom zu überwachenden System habe ich noch nicht erreicht. Die Benachrichtigungen gehen sämtlich von der betroffenen Maschine aus und es bestehen zum Teil sogar Abhängigkeiten zwischen Docker-Containern. Der act_runner muss sich zum Beispiel über Websockets mit Gitea verbinden. Und das funktioniert nur, wenn Caddy den Reverse Proxy bereitstellt.

Stelle ich in den nächsten Monaten fest, dass ein Dienst “unter meinem Radar” nicht mehr arbeitsfähig ist, werde ich diese Unabhängigkeit herstellen müssen und entsprechend darüber berichten.

Kontext zum Setup mit ntfy ↩︎
Kontext zur Signal-API ↩︎
Bericht von asad-awadia zur Einrichtung der Signal-API ↩︎
Healthchecks ist direkt verfügbar als Docker-Image. ↩︎
Übrigens sind die Operatoren << und >> für mich nicht schwer zu merken, denn früher habe ich viel mit der Programmiersprache C zu tun gehabt. Dort - und in vielen anderen Programmiersprachen auch - sind dies Shift-Operatoren, die einen Wert bitweise “verschieben” bzw. ein Feld auf ein anderes schieben können. Bei den RISC Architekturen, die ich damals verwendet habe, war die Schiebe-Operation “billig”, also sehr schnell und speicherplatzschonend umgesetzt. ↩︎

Server-Konfiguration ausrollen

Schallbert — Wed, 31 Jul 2024 00:00:00 +0000

Im vorigen Artikel habe ich meine Konfigurationsdateien unter Versionskontrolle gebracht. Nun will ich die auf dem Server bereitgestellten Updates automatisiert einspielen.

Worum geht es hier?

Schreiben eines Skripts zur automatischen Erkennung des Update-Triggers
Server-Anwendungen sollen heruntergefahren und eine Sicherungskopie erstellt werden
Das Skript soll die Konfiguration auf dem System verteilen
Anschließend sollen alle Anwendungen neu gestartet werden

Wege und Möglichkeiten

Auch hier habe ich wieder mehrere Stunden mit Recherche verbracht. Bei größeren Projekten verwenden Infrastrukturexperten anscheinend spezialisierte Automatisierungswerkzeuge. Dazu zählen Ansible, einfachere Tools wie cdist oder gar Kubernetes für stark skalierende Dienste.

Automatisierungsdienste Ansible, cdist, Kubernetes

Ansible und cdist scheinen dabei ein ähnliches Konzept zu verfolgen: Auf der Quellmaschine (in diesem Beispiel meinem Laptop) erstelle ich die Konfiguration für meinen Server und lege diese sowie die Vorschrift zur Konfiguration meiner Dienste in einem “Playbook” (Ansible) bzw. in “types” (cdist) ab.

Vereinfacht gesagt - so wie ich das verstanden habe - kümmert sich das Werkzeug anschließend auf Knopfdruck darum, die Konfiguration zu bauen, sich per ssh auf dem Zielhost einzuwählen, sie dort hinüberzuschieben und anschließend zu starten. Für Ansible existieren sogar für mein Szenario mit docker-compose Tutorials wie dieses, was den Einstieg nochmal erleichtert.

Einen anderen Weg geht Kubernetes, was sich als eher als Containermanager, Loadbalancer und Skalierungsagent versteht, aber für meine Zwecke Ähnliches leisten kann.

Mein Weg

Ich hingegen brauche von den Fähigkeiten dieser Programme nur einen Bruchteil. Zudem schrecken mich der “zusätzliche” ssh-Kanal, der Konfigurationsaufwand, die teils auf dem Zielsystem erforderlichen, zusätzlichen Programme sowie das erforderliche Einlesen und Auswählen des für mich besten Werkzeuges ab. Denn dank meiner sehr einfachen Pipeline aus dem letzten Artikel befindet sich die Konfiguration bereits auf meinem Server. Sie muss “nur noch” an die richtigen Stellen kopiert und betroffene Services einem Neustart unterzogen werden.

Daher versuche ich, dieses Problem mit Bordwerkzeug, meinem Gehirn in Betriebsbereitschaft und ein paar Suchanfragen bei Einschlägigen Foren zu den Themen “Ausführen eines Skriptes bei Dateiänderung, “Kopieren von Ordnerstrukturen unter Linux” zu lösen.

Risiko Zirkelbezug

Ein Risiko gehe ich dabei jedoch ein: Da das Deployment über Gitea läuft, die Konfiguration aber Gitea selbst betrifft, kann ich bei einem Fehler in diesem Modul nichts mehr um- oder zurückstellen: Der Gitea-Service ist dann ja kaputt. In diesem Szenario müsste ich also händisch mit auf dem Server die Konfiguration wieder ans Laufen bekommen.

Ich probiere es jetzt trotzdem aus und schaue, ob ich tatsächlich mit so einem Problem konfrontiert werde. Falls ja, steige ich halt auf cdist um und dokumentiere dies in einem eigenen Artikel! 🤗

Vorbereitung: Ordnersystem und Skripte erstellen

Ich überlege kurz und erstelle ein paar Ordner im Server-Dateisystem:

# /opt/server-config
mkdir automation-hooks-trigger
mkdir automation-hooks-handler

Diese Ordner sollen die zwei Seiten der Automation abbilden. trigger enthält Textdateien, die von der (Web)-Serviceseite aus manipuliert werden können. So soll act_runner beispielsweise die Datei server-config-update schreiben, sobald ein Update vorliegt.

service –> writes to trigger file ||| server_handler() –> trigger_file.changed ? run_action() : loop()

Im Handler-Ordner wiederum befinden sich Skriptdateien, die die erforderlichen Änderungen auf dem Server-Dateisystem vornehmen.

Durchführung: Shell-Script zum Abhandeln des Updates

Im vorigen Artikel habe ich im Container act_runner zum Signalisieren des Vorhandenseins einer neuen Serverkonfiguration das Kommando touch server-config-update.txt ausgeführt. Auf dem Server prüfe ich nun mit folgendem Code periodisch ab, ob sich diese Datei geändert hat.

### set directories
actionfile=/opt/server-config/automation-hooks-handler/server-config-action.sh
triggerfile=/opt/server-config/automation-hooks-trigger/server-config-update.txt

### Set initial time of file
LTIME=`stat -c %Z ${triggerfile}`

while true
do
 ATIME=`stat -c %Z ${triggerfile}`

 if [[ "$ATIME" != "$LTIME" ]]
 then
 ${actionfile} 2>&1
 LTIME=$ATIME
 fi
 sleep 10
done

Per #!/bin/bash wird dem Betriebssystem der Interpreter genannt, mit dem das Skript auszuführen ist. Der Befehl stat -c %Z fragt ab, wann die Datei zuletzt geändert wurde und gibt den Zeitpunkt im Epoch-Format zurück. Schließlich wird die zu Anfang des Skriptes mit der in der Schleife genommenen Zeit verglichen und bei Veränderung kann dann die noch zu schreibende Deploy-Routine ablaufen. Anschließend wird der Referenzzeitpunkt aktualisiert. Zum Schluss pausiert das Skript (sleep 10) für zehn Sekunden, bevor die Abfrage erneut losläuft. Ich verwende absolute Pfade, da ich das Skript sowohl für Tests von der Konsole aus als auch automatisch per cron oder systemd starten können will.

Erster Test und Einhängen in den “Autostart”

Nun müssen wir die Datei für einen ersten Test ausführbar machen:

# change file mode bits: add "executable" flag to server-config-handler script
chmod +x /opt/server-config/automation-hooks-handler/server-config-handler.sh

Dann erstelle ich die Datei server-config-action.sh und gebe ihr als einziges Kommando ein echo. Schauen wir mal, ob bis hierhin alles funktioniert. Dafür erstelle ich lokal meine Update-Triggerdatei und starte das Skript. Anschließend modifiziere ich sie in einer anderen Shell-Instanz per touch server-config-update.txt und prompt erscheint in der Konsole --- CONFIG UPDATE TRIGGER detected ---. Super!

Auf dem Server später muss ich das Skript automatisch nach einem Neustart ausführen lassen. Dafür nehme ich das Werkzeug cron zur Hilfe und erstelle einen neuen Eintrag per crontab -e:

# cron can automatically execute recurring tasks
# in this case, we're running server-config-handler script on reboot
@reboot sh /opt/server-config/automation-hooks-handler/server-config-handler.sh

Mit dem Befehl ps aux kann ich nun prüfen, ob das Skript auch wirklich ausgeführt wird:

schallbert@server: ps aux
[...]
8:15 0:00 /bin/bash ./server-config-handler.sh
8:15 0:00 sleep 10
[...]

Sicherungskopie

Eine Sicherungskopie meiner Anwendungen und Dateien anzufertigen bevor ich das Update ausrolle macht total Sinn. Also teile ich Borg mit, dass ich jetzt ein Backup anlegen möchte. Vorher muss ich natürlich alle Services stoppen. Somit sind alle Daten zugriffsfrei, kohärent und statisch.

Zustand und Daten einfrieren

Hierfür lege ich in automation-hooks-handler ein Skript an, welches alle Container bis auf borg selbst beendet.

#! /bin/bash
# /opt/automation-hooks-handler/backup-pre-action.sh
# this shell script shuts down all docker containers prior to backup

echo "Shutting down containers for backup:"
echo "watchtower..."
cd /opt/watchtower
docker compose down 2>&1
# [...]

Der Ausdruck 2>&1 bedeutet, dass eventuelle Ausgabe von Fehlern in die Konsole umgeleitet wird. Die Zahl 1 stellt nämlich den Filedescriptor für stdout dar, während 2 stderr meint. Der Operator >& funktioniert als redirect merger, also als Umleitung und Zusammenführung. Später können wir an diesem Punkt hingehen und die Ausgabe in ein Logfile schreiben - das lasse ich aber der Einfachheit halber erst einmal aus.

Borgmatic: Trigger-Handler Mechanismus #2 und #3

Das Skript kann ich nun auf zwei Arten ausführen lassen:

Als Aufruf durch das weiter oben beschriebene Skript server-config-handler
Durch die vor borg geschaltete Automatisierungslösung borgmatic

Ich entscheide mich für die zweite Option und schreibe daher in die borgmatic.d/config.yml die folgenden Befehle:

# borgmatic.d/config.yml
# List of one or more shell commands or scripts to execute before
# creating a backup, run once per repository.
before_backup:
 - echo "Triggering container shutdown for backup."
 - touch /etc/automation-hooks-trigger/backup-pre.txt
 - sleep 20
 - echo "Assuming container shutdown complete. Creating the backup now."
# [...]
after_backup:
 - echo "Triggering container restart after backup."
 - touch /etc/automation-hooks-trigger/backup-post.txt
 - sleep 10
 - echo "Assuming container restart complete. Exiting."
# [...]

Damit dies richtig funktioniert, muss ich in der zugehörigen docker-compose.yml natürlich ein Volume anlegen und auf den Pfad im Dateisystem des Servers zeigen lassen: ${VOLUME_UPDATE_TRIGGER}:/etc/automation-hooks-trigger

Nun muss ich die Gegenseite dieser Trigger einrichten: Handler überwachen die Triggerdateien auf Änderungen und rufen entsprechend Action-Skripte auf. Sie sind bis auf die Pfade von triggerfile und actionfile identisch mit dem oben erläuterten Handler.

Das Backup anlegen

Würde ich borg direkt ansprechen, so ließe sich das Backup über create erstellen. Dazu müsste ich angeben, in welchem Repository die Sicherungskopie abgelegt werden soll und unter welchem Namen. Im Beispiel unten wird das mit dem Scope-Operator vorgegeben: ::config-update. Anschließend werden die zu sichernden Ordner angegeben.

borg create /path/to/repo::config-update ~/opt

Ich verwende ja borgmatic, was mir über die Konfigurationsdatei einiges abnimmt. Dafür muss ich den Befehl allerdings im Container ausführen. Um besser prüfen zu können, ob auch alles funktioniert, lasse ich mir Statistiken “verbose” auf die Konsole ausgeben (--stats -v 1) sowie die kopierten Dateien anzeigen --files.

docker exec borgmatic sh -c "cd && borgmatic --stats -v 1 --files 2>&1"

Diese Zeile füge ich dem Automationsskript hinzu.

Zweiter Test zum Anlegen des Backups

Wenn jetzt alles funktioniert, sieht der komplette Ablauf wie folgt aus:

Nach Eingang der geänderten Dateien durch Giteas Automation legt act_runner (im Docker-Container) die Dateien auf dem Server ab und setzt anschließend den server-config-update Trigger.
Binnen 10sec wird der Trigger von server-config-handler.sh erkannt, welches anschließend server-config-action.sh aufruft.
borgmatic (im Docker-Container) wird darin beauftragt, ein Backup anzufertigen. Dieses wiederum schreibt den pre-backup Trigger.
Erneut binnen 10sec wird durch diesen pre-backup-handler.sh das backup-pre-action.sh Skript aufgerufen und alle Container bis auf borgmatic gestoppt.
Durch die eingebaute Verzögerung wartet borgmatic dies ab und erstellt nun das Backup.
Nach dem Backup schreibt borgmatic den backup-post-action.sh Trigger.
Binnen weiterer 10sec erkennt post-backup-handler.sh die geänderte Datei und fährt alle Container über post-backup-actions.sh wieder hoch.
borgmatic teilt server-config-update.sh mit, ob irgendwo im Prozess bis jetzt Fehler auftraten. Falls nicht, wird fortgefahren.
Alle Docker-Container werden gestoppt.
Die Server-Konfiguration wird auf die entsprechenden Stellen ausgerollt.
Es findet ein Neustart aller Docker-Container mit neuer Konfiguration statt.

Ein erster Erfolg: Bis Punkt 6 laufen diese Skripte sogar auf meinem Laptop bereits durch:

schallbert@laptop: touch server-config-update.txt
server-config-handler@laptop: --- RUN backup ---
borgmatic@docker: /etc/borgmatic.d/config.yml: Running 4 commands for pre-backup hook
 Triggering container shutdown for backup. 
backup-pre-handler.sh@laptop: --- RUN backup-pre-action.sh ---
 Shutting down containers for backup:
 watchtower...
 [...]
 complete.
borgmatic@docker: Assuming container shutdown complete. Creating the backup now.
 local: Creating archive
 Failed to create/acquire the lock /mnt/repository/lock.exclusive

Fehlerbehebung für “failed to acquire the lock”

Dieses Problem taucht bei mir dann auf, wenn borg beim Erstellen eines Backups einen Fehler meldet, der das Programm zum Abbruch bringt. In diesem Falle wird das Repository anscheinend nicht korrekt freigegeben, sodass es nach Neustart des Containers für den alten, nun nicht mehr existierenden Container reserviert bleibt. Das folgende Kommando löst dieses Problem:

docker exec borgmatic sh -c "cd && borg break-lock /mnt/repository

Übertragen der Konfiguration

Nun müssen die Konfigurationsdateien noch an die jeweils richtige Stelle auf dem Server kopiert werden. Glücklicherweise hatte ich die Ziel-Ordnerstruktur bereits beim Erstellen des Repository geklont, sodass ich das mit einem einzigen Kopierbefehl ohne “hardcoding” hinbekommen sollte. Nach ein paar Netzrecherchen und einem Blick in die Bedienungsanleitung für den Kopierbefehl man cp habe ich mein Kommando:

# copy recursively contents of folder "server-config" to "/opt"
sudo cp -r -v /opt/server-config/. /opt 2>&1

Somit sage ich dem Betriebssystem, es solle den Inhalt (/.) des Ordners server-config rekursiv (-r), also inklusive aller Unterordner, in den Ordner opt befördern, welcher sich im Stammverzeichnis / befindet. cp arbeitet hierbei überschreibend-ergänzend, wird also noch nicht vorhandene Dateien erstellen und vorhandene überschreiben, sie also nicht unter gleichem Namen “daneben kopieren”. Mit der Option -v lasse ich zusätzliche Details ausgeben, und mit 2>&1 leite ich die Fehlerausgabe in die Konsole um.

Alle Ordnerindikatoren müssen sich genau dort befinden, wo sie im Befehl stehen: Ein Slash hinter /opt/ würde Ordner nicht-überschreibend redundant kopieren, Dateien aber überschreiben. Ohne . würde der Ordner server-config am Zielpfad erstellt.

Umstieg auf rsync

Der cp-Befehl kopiert leider auch ein paar Dateien, die ich gar nicht kopiert haben möchte: Repository-spezifische Ordner wie .gitea, oder auch die Ordner für Trigger und Handler. Diese benötige ich nur unter server-config, nicht aber auch direkt in opt. Um dies zu beheben nutze ich stattdessen das Kommando rsync. Dort kann ich mit -u einstellen, dass nur neuere Dateien überschrieben werden sollen und über eine --exclude-Option nicht zu kopierende Dateien und Ordner ausschließen. Dies sieht dann so aus:

rsync -r -u -v --exclude '.*' --exclude 'README.md' --exclude '<otherFolders>' /opt/server-config/. /opt 2>&1

Doch plötzlich startet gitea nicht mehr. Fehlermeldung:

docker@server: [...] failed to load config file "app.ini": open: permission denied

Nach längerem Grübeln und diversen Neustarts des Docker-Clients sehe ich, dass rsync die Berechtigungen der Quelldatei auf die Zieldatei geschrieben hat, was bei cp vorher nicht der Fall war: -rw-------. Nun ändere ich dies, indem ich chmod +r app.ini ausführe. Schon fährt alles wieder wie gewohnt hoch! 🎉

Alle Anwendungen neu starten

Da ich alles auf meinem Server in Docker betreibe, genügen hierfür zwei einfache Befehle:

docker stop $(docker ps -a -q) 2>&1
# [...roll out config changes...]
docker restart $(docker ps -a -q) 2>&1

Die fertige Automation

Mein Skript ist nun fertig und ruft lediglich das Action-Skript auf.

#! /bin/bash
#/opt/automation-hooks-handler/server-config-handler.sh
#[...]
 if [[ "$ATIME" != "$LTIME" ]]
 then 
 echo "--- CONFIG UPDATE TRIGGER detected ---"
 ./server-config-action.sh 2>&1
 LTIME=$ATIME
 fi
 sleep 10
done

Das Skript server-config-action führt dann die oben beschriebenen Aktionen aus:

#! /bin/bash
#/opt/automation-hooks-handler/server-config-action.sh

echo "--- RUN backup ---"
docker exec borgmatic sh -c "cd && borgmatic --stats -v 1 --files 2>&1"
echo "--- STOP all containers ---"
docker stop $(docker ps -a -q) 2>&1
echo "--- DEPLOY config ---"
cp -r -v /opt/server-config/. /opt 2>&1
echo "--- RESTART all containers ---"
docker restart $(docker ps -a -q) 2>&1

Damit das Ganze nun zuverlässig funktioniert, müssen die drei Handler-Skripte im Hintergrund laufen:

server-config-handler.sh
backup-pre-handler.sh
backup-post-handler.sh

Sie reagieren auf die jeweiligen Trigger, ausgelöst durch act_runner von Gitea bzw. durch borgmatic. Ich erweitere das crontab jetzt entsprechend und bin dann mit der Aufgabe vorerst fertig. Die Konsolenausgabe des gesamten Vorgangs sieht so aus:

--- RUN backup ---
/etc/borgmatic.d/config.yml: Running 4 commands for pre-backup hook
Triggering container shutdown for backup.
--- RUN backup-pre-action.sh ---
Shutting down containers for backup:
gitea... 
fail2ban...
complete.
Assuming container shutdown complete. Creating the backup now.
local: Creating archive
<borg archive stats>
/etc/borgmatic.d/config.yml: Running 4 commands for post-backup hook
Triggering container restart after backup.
--- RUN backup-post-action.sh ---
Restarting containers after backup:
fail2ban...
gitea... 
watchtower...
complete.
Assuming container restart complete. Exiting.
local: Pruning archives
local: Compacting segments
compaction freed about 1.82 MB repository space.
local: Running consistency checks
summary:
/etc/borgmatic.d/config.yml: Successfully ran configuration file
--- STOP all containers ---
<container ids>
--- DEPLOY config ---
sending incremental file list
<files that are copied>
sent 206,558 bytes received 3,463 bytes 420,042.00 bytes/sec
total size is 193,167 speedup is 0.92
--- RESTART all containers ---
<container ids>

Prima! Nun fehlt mir nur noch, dass diese Ausgabe mir zugestellt wird, falls etwas bei diesem Vorgang schief geht.

Server-Konfiguration mit Git

Schallbert — Mon, 15 Jul 2024 00:00:00 +0000

Worum geht es?

Ich wünsche eine Versionskontrolle für die Konfiguration von Serverapplikationen
Diskussion technischer Lösungen zur Umsetzung
Tutorial: Docker/Gitea/andere “Secrets” von der Versionskontrolle ausnehmen
Tutorial: Deploy-Pipeline erstellen
Automationstrigger für nachgelagertes Ausrollen der Dateien auf dem Server programmieren
Nächster Artikel: Automation auf dem Server integrieren und Upgrades einspielen

Hintergrund

Ich habe auf meinem Server ja Watchtower laufen, um die Installierten Distributionen automatisch auf Stand und frisch gepatcht zu halten. Vor Kurzem hatte ich nun den Fall, dass sich mein Gitea Action Runner nicht mehr automatisch starten lassen wollte und auch bei manuellem Start eine Fehlermeldung ausgab.

Anscheinend hatte sich Docker ohne meine Aufsicht auf Stand gebracht und warf nun beim Hochfahren des Runner-Containers einen Volumefehler, die ich so vorher noch nicht gesehen hatte. Die Fehlermeldung war eindeutig und ließ sich mittels kleiner Änderungen in einer Konfigurationsdatei für Gitea leicht beheben. Dennoch hatte ich nun das Gefühl, dass eine Versionskontrolle für meine Konfiguration sinnvoll wäre, um Änderungen, Updates und ihre Beweggründe später besser nachvollziehen zu können.

Vorüberlegungen

Klingt nun für mich nach einem Zirkelbezug: Ich nehme die Konfigurationsdateien für meinen Server in Gitea auf, welches selbst auf meinem Server läuft. Das könnte beim Auto-Deploy noch spannend werden. Aber mehr dazu später.

Spontan fallen mir zwei Möglichkeiten ein, eine Versionskontrolle mit automatischer Synchronisation zu bekommen:

1. Hardlink

Diese Lösung würde die auf meinem Server in vielen Ordnern verstreuten Konfigurationdateien per Hardlink in einen zum Repository erklärten Ordner ablegen. Warum per Hardlink? Weil jeder Service auf meinem Server in sich gekapselt läuft und dafür jeweils eigene Konfigurationsdateien und Umgebungsvariablen gemeinsam mit dem Service abgelegt bekommt. Ohne Hardlinks müsste ich den gesamten Service-Ordner versionieren und meine .gitignore entsprechend komplex aufblasen.

Mit Git würde ich die per Hardlink abgebildeten Dateien versionieren und ihre Inhalte auf diese Weise auf Gitea verfügbar machen.

schallbert@server:/server-config-files –> hardlinks –> repository –> Gitea

Ich bekäme also eine nachgelagerte “Versionsbeobachtung” mit Sicherungskopie in dem Sinne, dass die Dateien nun mehrfach herumliegen.

2. Repo und auto-deploy auf den Server

In diesem Szenario halte ich die Konfigurationsdateien lokal auf meinem Laptop und kann sie wie üblich mit Git versionieren. Auf Gitea würde ich das Repository abbilden, und am Ende der Kette müsste mein Runner bei jeder Änderung der Konfiguration ein Auto-Deploy auf dem Server ausführen und die betroffenen Container anschließend neu starten.

schallbert@laptop:/server-config-files –> repository –> Gitea –> act-runner –> server:/<service1...ServiceN>/config-files

Ich bekäme in diesem Falle den Verwaltungs-“Main” auf meinen Laptop, und der Server würde der Abbildung auf Gitea folgen.

Probleme

In beiden Fällen habe ich noch keine Möglichkeit, geänderte Konfigurationen vorab zu testen. Alles, was ich tue geht direkt nach “Prod” und wäre live. Schlimmstenfalls kann ich mir so recht leicht mein Setup zerschießen.

Ändert nun den Status Quo ante nicht, bei dem ich die Dateien direkt auf dem Server verändere. Also ein neues Problem nur in der Hinsicht, dass ich beim Aufsetzen damals noch keinen Prod-Betrieb hatte und so kein Ausfallrisiko bestand.

Lösung Zwei scheint mir komplexer umzusetzen zu sein, denn ich benötige hierfür eine Deployment-Pipeline, welche die Dateien im Repository auf meinem Server ausrollt. Zumal sich der Runner in einem Docker-Container aufhält, während die Konfigurationsdateien direkt im Dateisystem des Servers befinden.

Ein direkter Durchgriff auf das Serverdateisystem ist zwar technisch möglich, würde aber meinem beschränkten Verständnis nach eine große Angriffsfläche für alle meine Dienste bedeuten, deren Konfigurationsdateien nun über das Repository in Gitea direkt manipulierbar würden.

Auswahl meiner Lösung

Lösung Zwei lagert mir das Sofort-Live-Problem zumindest auf meinen Laptop vor, sodass ich in einem ersten Schritt nicht direkt am Prod-System herumfuhrwerken muss. Hier ließe sich, denke ich, leichter eine Integrationsumgebung aufsetzen, mit der ich meine Konfigurationsänderungen vorab prüfen kann. Da ich alle meine Dienste im Docker laufen habe, könnte sich das vielleicht ganz bequem lösen lassen.

Frisch ans Werk

Konfigurations-Repo anlegen

Gut, dann ziehe ich mir in einem ersten Schritt die Konfigurationsdateien vom Server. Dafür nutze ich das Dateitransferkommando scp: scp server:/path/to/source path/to/target etwa ein Dutzend mal, bis ich alle Konfigurationsdateien auf meinem Server erwischt habe.

Ich setze die Ordnerstruktur in diesem Repo direkt so auf, wie die Dateien auf dem Server liegen. So, hoffe ich, mache ich mir das Leben später etwas leichter.

Secrets in `docker-compose.yml`

Nur - was tue ich mit “secrets” in den Konfigurationsdateien? Also privaten Schlüsseln, registration tokens, hashes? Die möchte ich lieber nicht mehr oder minder offen im Repository herumliegen haben. Bei Verwendung von docker-compose ist das das recht einfach: Ich kann geheime Werte in versteckte Dateien für Umgebungsvariablen auslagern und vom Git-Tracking ausnehmen. Im einfachsten Falle heißen solche Dateien schlicht .env und beinhalten eine Aufzählung an Umgebungsvariablen im Stil von

BORG_PASSPHRASE="<redacted>"

In der entsprechenden docker-compose.yml ziehe ich die Variable aus der Datei .env wie folgt an:

- BORG_PASSPHRASE=${BORG_PASSPHRASE}

Diese Änderungen nehme ich direkt mal lokal auf meinem Laptop vor. Über die .gitignore teile ich mittels .* mit, dass versteckte Dateien und damit .env nicht ins Repository aufgenommen werden sollen. Doch woher weiß ich nun, ob die Container noch korrekt hochfahren?

Secrets in Giteas `app.ini`

Bei Gitea habe ich mich schon deutlich schwerer damit getan, Secrets in Dateien auszulagern. Die app.ini wird auch von Gitea dynamisch geschrieben, sodass die Datei bei jedem Neustart des Services ein wenig anders aussieht. Nach langer Recherche fand ich dieses Issue, in welchem eine Lösung für das separate Speichern von Secrets gesucht und gefunden wurde.

Sinnvoll erscheint mir nur das separate Speichern der Werte INTERNAL_TOKEN sowie SECRET_KEY.
Die anderen beiden Properties LFS_JWT_SECRET und JWT_SECRET werden ohnehin automatisch generiert und regelmäßig überschrieben.

In meiner Konfiguration verwende ich lediglich INTERNAL_TOKEN. Also werde jenes im Klartext und ohne Anführungszeichen in eine versteckte Datei kopieren (.INTERNAL_TOKEN) und sie per Docker-Volume dem Container zur Verfügung stellen:

# Gitea's docker-compose.yml
# [...]
 volumes:
 - ./.INTERNAL_TOKEN:/run/secrets/INTERNAL_TOKEN:ro
 # [...]

In der app.ini ist es nun wichtig, den in der Composedatei angegebenen Pfad einzusetzen:

# Gitea's app.ini
# [...]
 server:
 INTERNAL_TOKEN = /run/secrets/INTERNAL_TOKEN
 # [...]

Nicht etwa wie im oben verlinkten Issue angegeben INTERNAL_TOKEN_URI=/run/secrets/INTERNAL_TOKEN, denn dies erzeugt in der von mir momentan verwendeten V1.22.1 einen Fehler: Unsupported URI-Scheme.

Mal ganz grob testen

Um zu prüfen, ob die geänderten Konfigurationsdateien noch funktionieren, installiere ich mir docker und docker-compose auf meinem Laptop. Anschließend probiere ich, die Container mal hochzufahren.

# docker console log
Error: Network 'caddy-proxy' declared as external, but could not be found.

Stimmt ja, Docker ist hier noch gar nicht konfiguriert. Also das Netzwerk erstellen: sudo docker network create caddy-proxy und erneut versuchen. Schon beginnt der Download von Gitea samt Abhängigkeiten und der Container startet - wenn auch nicht so wie ich mir das vorgestellt habe: Innerhalb von Docker stimmen die Ordnerberechtigungen nicht, sodass weder Gitea, noch Act-runner auf alle benötigten Dateien zugreifen kann.

Dennoch, einen ersten Fehler finde ich:

# gitea container log
WARNING: The GITEA_RUNNER_REGISTRATION_TOKEN variable is not set. Defaulting to a blank string.

Ich hatte nämlich vergessen, den Token-String in Anführungszeichen zu setzen.

Für eine voll funktionsfähige Integrationsumgebung musste ich also noch mindestens zwei weitere Probleme lösen: Ordnerberechtigungen für den Main auf meinem Laptop müssen so angelegt sein, dass auch der User Docker Schreibrechte bekommt. Als einfache Lösung genügt vorerst, den betreffenden Volumes ein :Z anzuhängen und sie so als private unshared kennzuzeichnen. Eine Volumendefinition sieht in meiner docker-compose.yml nun so aus:

# gitea/docker-compose.yml
# [...]
volumes:
 - ./gitea:/data:Z
 # [...]

Ich benötige eine zweite Datei für Umgebungsvariablen, um meine Dienste auf localhost umzubiegen. Immerhin startet der Service auch so und ich sehe die Logausgabe. Die meisten Konfigurationsfehler kann ich bereits jetzt entdecken.

Ich bin mir nicht sicher, aber möglicherweise bekomme ich zusätzliche Probleme mit dem caddyserver wie Zertifikatsverwaltung, Proxy-Einstellungen und so weiter.

Eine Deploy-Pipeline erstellen

Jetzt wäre es noch super, wenn die in das Gitea-Repo hochgeladenen (und vorab lokal auf Funktion getesteten) Dateien automatisch ihren Weg auf meinen Server finden würden. Hierfür könnte ich ein weiteres Docker-Volume anlegen, wo act-runner dann die per on:push Trigger abgelegten Daten hinpackt. Sie würden dann auf meinem Server verfügbar werden.

Setup

Erinnern wir uns an meine letzten Versuche mittels act_runner Artefakte auf dem Server bereit zu stellen, so können wir einen Großteil dessen auch für diese Aufgabe übernehmen:

# deploy-to-server.yml
# Workflow for saving the server's config repo to the local disk system

name: Upload-server-config
run-name: ${{ gitea.actor }} uploads server configuration files
on:
 push:
 branches:
 - main

jobs:
 # Deploy job
 build:
 runs-on: ubuntu-latest # this is the "label" the runner will use and map to docker target OS
 container: 
 volumes: 
 # left: where the output will end up on disk, right: volume name inside container
 - /opt/server-config:/workspace/schallbert/server-config/tmp

 steps:
 - name: --- CHECKOUT ---
 uses: actions/checkout@v3
 with: 
 path: ./tmp
 - name: --- RUN FILE CHANGE TRIGGER ---
 run: |
 cd ./tmp/automation-hooks-trigger
 touch server-config-update.txt

Merkwürdige Volumefehler

Doch der Weg bis hierhin war steinig. Lange hatte ich unter volumes: auf der Containerseite lediglich /server-config angegeben und nicht das Arbeitsverzeichnis des Runners. Dann läuft die Action zwar durch und alle Befehle der #TEST-Sektion funktionieren auch. Wenn ich aber auf meinem Server nachschaue, bleibt der von Docker angelegte server-config Ordner leer.

Mit folgenem Debug-Code unter RUN FILE CHANGE TRIGGER helfe ich mir, die Pfadfehler zu finden:

# deploy-to-server.yml
# [...]
run: |
 echo "hello world"
 touch updated.txt
 pwd
 ls -al

Mit echo prüfe ich, ob mein Code im Runner überhaupt ausgeführt wird. Das touch-Kommando setzt mir den aktuellen Zeitstempel in die updated.txt-Datei, sodass ich dies später als “Hook” für weitere Automation verwenden kann. pwd zeigt mir den aktiven Pfad innerhalb des Runners an, sodass ich das Docker-Volume korrekt auf die Server-Festplatte abbilden kann. ls -al zeigt mir, ob die im Schritt CHECKOUT zusammengestellten Konfigurationsdateien korrekt geschrieben wurden.

Ich erkenne dadurch, dass der Volume-Pfad auf der “rechten Seite” falsch war. Ich biege ihn entsprechend auf das aktive Verzeichnis des Runners um:

# deploy-to-server.yml
# [...]
 # left: where the output will end up on disk, right: volume name inside container
 - /opt/server-config:/workspace/schallbert/server-config/
# [...]

Anschließend bekam ich Folgendes zu lesen:

# gitea / act-runner console log
failed to create container: 'Error response from daemon: Duplicate mount point: /workspace/schallbert/server-config'

Anscheinend legt sich der Runner die “rechte Seite” des Mountpoints automatisch selbst an und kann daher nicht erneut belegt werden. Erst durch das Hinzufügen eines weiteren Pfadteiles, in meinem Falle /tmp - siehe oben - behebe ich den Fehler und auf meinem Server erscheint endlich 😌 der lang ersehnte Ordner server-config mit Inhalt:

schallbert@schallbert-ubuntu-:/opt/server-config# ls -al
total 52
drwxr-xr-x 9 root root 4096 Jul 12 15:38 .
drwxr-xr-x 9 root root 4096 Jul 11 19:56 ..
-rwxr-xr-x 1 root root 395 Jul 11 20:05 boot-after-backup.sh
drwxr-xr-x 3 root root 4096 Jul 11 20:05 borgmatic
drwxr-xr-x 2 root root 4096 Jul 11 20:05 caddy2
drwxr-xr-x 3 root root 4096 Jul 11 20:05 fail2ban
drwxr-xr-x 8 root root 4096 Jul 12 15:38 .git
drwxr-xr-x 3 root root 4096 Jul 11 20:05 .gitea
drwxr-xr-x 4 root root 4096 Jul 11 20:05 gitea
-rw-r--r-- 1 root root 312 Jul 11 20:05 .gitignore
-rw-r--r-- 1 root root 557 Jul 11 20:05 README.md
-rwxr-xr-x 1 root root 371 Jul 11 20:05 shutdown-for-backup.sh
-rw-r--r-- 1 root root 0 Jul 12 15:38 updated.txt
drwxr-xr-x 2 root root 4096 Jul 11 20:05 watchtower

Verteilen der Konfiguration auf dem Server

Gut, damit sind die ersten Schritte getan. Ich habe nun ein vernünftig konfiguriertes Git-Repository, was meine Server-Konfiguration abbildet und vom Laptop aus gepflegt und zumindest rudimentär getestet werden kann. Außerdem kann ich über eine automatische Action Updates der Konfiguration auf dem Server ablegen und eine Update-Datei mit Zeitstempel beschreiben.

Nun muss das Update auf dem Server noch entgegengenommen, verteilt und die betroffenen Programme und Dienste sollen neu gestartet werden. Doch dies schauen wir uns im Artikel Serverkonfiguration ausrollen an.

Stahl bearbeiten

Schallbert — Mon, 10 Jun 2024 00:00:00 +0000

Für unseren Retro-Gaming Stand auf der Maker Faire Ruhr 2024 habe ich Ausschnitte in PC-Gehäuse gefräst. Die zugehörige Geschichte möchte ich hier nun erzählen und passende Parameter für die Bearbeitung von Stahl auf “weichen” Hobbymaschinen teilen.

Doch Vorsicht!

Vorab möchte ich erwähnen, dass ich einige sicherheitsrelevante Dummheiten begangen habe, die in Zukunft unbedingt zu vermeiden sind:

Niemals mit Handschuhen in der Nähe sich drehender Maschinenteile hantieren!¹
Kühl- und Schmiermittel müssen für den Verwendungszweck geeignet sein; Rauch- und Brandgefahr!
Schutz- und Abschrankeinrichtungen sind fest zu montieren und dürfen nicht umgangen werden!

Wer sich also mit Arbeits- und Betriebssicherheit auskennt, sollte das weiter unten zur Verfügung gestellte Video besser nicht anschauen.

Das Werkstück

Zu bearbeiten habe ich Stahlbleche von PC-Gehäusen (MIDI-Tower) mit einer Stärke von 0.7mm-0.9mm. Beim Material handelt es sich um galvanisch verzinkten, kalt gewalzten Stahl (SECC), also eine günstige und verhältnismäßig leicht zu verarbeitende Stahlsorte mit niedrigem Kohlenstoffgehalt und geringer Beimischung anderer Legierungselemente.

Diese Stahlsorte wird für Bleche im Automobilbau und vielen Haushaltsgeräten, vor allem in “weißer Ware” eingesetzt und findet zudem oft im Automaten- und Schaltschrankbau Verwendung. Somit ist diese Fräsarbeit übertragbar auf andere Einsatzgebiete.

Die Maße der Gehäuseseiten liegen zwischen 35x45xm und 52x50cm, passen also alle problemlos auf meine Maschine. Mit einer Ausnahme liegen die Seitenteile mit ihrer sichtbaren Seite plan und ohne Ausschnitte auf, sodass mein Vakuumtisch für das Niederhalten ohne Weiteres in Frage kommt.

Die Seitenwand eines der Gehäuse besitzt kiemenartige Perforationen zur Belüftung sowie eine Vertiefung für einen Griff. Bei den Lüftungsschlitzen behelfe ich mir mit Frischhaltefolie zum Halten des Vakuumdrucks, während der Verlust des Vakuums beim Durchfräsen der Griffmulde in Kauf genommen wird.

CAD/CAM

Die zu schneidenden Ausschnitte sind sämtlich geometrisch einfach und berücksichtigen für Rundungen r=1.5*Fräserradius. Das Fenster für den “Meeres-PC” ist dabei zweiteilig angelegt und soll eine Sturmszene auf See darstellen.

Das Fenster ist rundherum 0.25mm kleiner als die Aussparung, was in einer fast spielfreien Passung führt und sehr professionell aussieht.

Im CAM stelle ich Gegenlauffräsen ein, was bei weniger steifen Maschinen wie meiner bei Bearbeitung harter und zäher Materialien anzuraten ist. Die Maschine läuft so etwas weicher und leiser - trotzdem schüttelt und vibriert sie noch beträchtlich.

Bei der Tiefenzustellung wähle ich einen Wert, der vier hundertstel Millimeter geringer ausfällt als die Materialstärke beträgt. So lasse ich praktisch nur noch eine hauchdünne Folie aus Lack und Korrosionsschutz übrig, verschleiße mir aber nicht die Haftvermittlungsmatte aus Gummi.

Fräsparameter

Im Vergleich zur Bearbeitung von Holz liegen die Schnittgeschwindigkeiten bei Stahl deutlich niedriger. Während ich in Birke Multiplex mit 450m/min unterwegs bin, empfehlen mir verschiedene Schnittdatenrechner wie dieser hier Werte zwischen 80m/min und 200m/min. So ergibt sich beispielsweise ein Parametersatz wie S4250u/min, F255mm/min für meinen Zweischneider aus Feinstkorn-Hartmetall.

Dieser Fräser besitzt im 45°-Winkel abgeschrägte Schnittkanten von 0.2mm Länge und mit 30° einen starken Drall. Zur Erhöhung der Standzeit ist er im Vakuumverfahren PVD mit einer etwa 3µm starken TiAlN-Legierung beschichtet.

Ich habe auf meiner Maschine nach Rücksprache mit dem Hersteller des Fräsers Parameter vorgewählt, die ich in Testläufen nochmal anpassen und damit höhere Tiefenzustellung bei geringerer Spantemperatur erreichen konnte (keine blauen Späne mehr). Hier die Werte, die ich für die Bearbeitung schließlich verwendet habe:

Fräser	Schneidengeometrie	Drehzahl	Vorschub XY	Vorschub Z	Zustellung Z
6mm, Vollhartmetall	2Flutes 30°, l=12, 45°0.2Fase	6000u/min	550mm/min	250mm/min	0.8mm

Update Fräsparameter

Nach ein paar Rückfragen in verschiedenen Foren zum Thema habe ich neue Erkenntnisse gewonnen, die meine Fräsparameter für zukünftige Projekte nochmal deutlich verändern werden. Diese lauten:

In der Stahlbearbeitung für die Fräser auf abgeschrägte Schnittkanten achten
Vorschub hoch, Tiefenzustellung runter (gilt besonders für “weiche” Maschinen)
Trocken fräsen ist weniger problematisch als ich dachte

Dieses Youtube-Video von Stefan Gotteswinter erläutert den Vorteil durch geringere Spandicken bei Verwendung abgeschrägter Schnittkanten sehr anschaulich. Dies funktioniert dann am besten, wenn die Tiefenzustellung nicht größer ist als die Länge der Fase am Schneidenende. Auch auf cnczone wird mir empfohlen, einen “High-speed milling”-Ansatz zu wählen.

Für meinen Zweischneider passe ich die Schnittdaten also so an, dass ich die Tiefenzustellung drastisch zurücknehme, dafür aber Vorschub und Drehzahl erhöhe:

Fräser	Schneidengeometrie	Drehzahl	Vorschub XY	Vorschub Z	Zustellung Z
6mm Zweischneider	30°Drall, l=12, 45°0.2Fase	10600u/min	970mm/min	450mm/min	0.2mm

Ich bin schon sehr gespannt darauf, diese Werte in der Praxis zu erproben.

Vorbereitung des Fräsvorganges

Da ich das erste Mal in Stahl unterwegs bin, musste ich noch ein paar Besorgungen machen und Dinge vorab ausprobieren.

Kühlschmierstoff

Bei Arbeiten in Stahl sei Kühlung zum Schutz des Fräsers unerlässlich, meinte der Fräsenhersteller. Also habe ich mir eine Spritze besorgt, mit der ich Schmiermittel punktgenau aufbringen kann. Nur: Welches Mittel wählen?

Für nur drei Teile besorge ich mir nicht extra eine Minimalmengenschmierung oder Kühlschmierstoffe aus dem Industriebedarf. Also probiere ich im Haushalt verfügbare Mittel aus:

Sprühschmierstoff WD40: Für mich nicht geeignet. Verdampft schnell, riecht.
Nähmaschinenöl / Feinöl: Nicht geeignet. Sehr flüssig (fließt in Vakuumlöcher), raucht und stinkt.
Rapsöl zum Braten: Wunderbar! Schmiert gut, relativ viskos, geruchsarm, kaum Rauchentwicklung.

Spanschutz

Die bei der Bearbeitung entstehenden Metallspäne sind kurz, heiß und scharfkantig. Sie bleiben gern in der Kleidung hängen und fliegen so weit, dass selbst bei über einem Meter Entfernung zur Maschine noch reichlich Späne ankommen.

Also habe ich mir aus einem Acrylglasrohr mit 20cm Durchmesser ein Segment abgesägt, geschlitzt und es als Spanschutz an der Z-Achse eingehängt.

Mein Fehler an dieser Stelle: Ich habe auf die Klemmkraft alleine vertraut und den Spanschutz nicht zusätzlich mit Schrauben befestigt. Zum Glück verklemmte er sich erst beim Fertigen des letzten Teiles.

Fräsen

Man merkt sofort, dass die Maschine nicht die nötige Steifigkeit zur Verarbeitung von Stahl hat. Sobald der Fräser in das Material eintaucht, beginnt die Maschine zu rattern und zu schütteln. Dennoch kämpft sie sich tapfer durch das Material, während ich stets mit einem Tropfen Öl am Fräspfad bereit stehe.

Stahl fräsen!

Die Spindel hat mehr als genügend Reserven zur Verfügung selbst bei der geringen Drehzahl. Jedoch achte ich für die Werkstückpositionierung sehr darauf, möglichst mittig an der Kugelumlaufspindel der Y-Achse zu arbeiten. Hier erfährt die Maschine die geringsten Verwindungskräfte. Die Späne sehen für meine Augen gut aus.

Das Geräusch verändert sich beim Fräsen: Ich habe mehr Vibrationen in der Maschine, wenn ich in Y-Richtung fräse, als wenn sich nur die X-Achse bewegt. Diesem Phänomen werde ich später genauer auf den Grund gehen.

Das Ergebnis

Die Fensterausschnitte kann ich nach der Bearbeitung auf der CNC mit einem Cuttermesser einfach ausschneiden.

Your browser does not support the video tag.

Video: Auslösen des Ausschnittes mit einem Cuttermesser

Die (minimalen) Grate entferne ich fix mit einer Feile.

Danach fertige ich Fenster aus durchsichtigem Acrylglas in 3mm Stärke, welche ich rundherum mit einer 10mm breiten Falz von 1mm Tiefe versehe. Somit wird die Stärke des doppelseitigen Klebebands zum Einpassen berücksichtigt und die Scheibe schließt plan mit dem PC-Gehäuse ab.

Das obige Bild zeigt ein Celsius 1000 Workstation Gehäuse von Siemens, welches mit einem schlichten Fenster versehen, nun richtig edel aussieht.

Handschuhe können bei versehentlichem Kontakt mit dem Fräser mitgerissen werden. Dies kann schwere Handverletzungen nach sich ziehen. ↩︎

CNC Tuning #3

Schallbert — Sat, 04 May 2024 00:00:00 +0000

Dies ist der letzte Teil meiner Reihe über die Optimierung der Fertigungszeit auf CNC-Fräsmaschinen. Er konzentriert sich auf den Pfadinterpreter der CNC-Steuersoftware.

Der Pfadinterpreter der Steuersoftware ist dafür zuständig, die Anweisungen aus dem G-Code zu lesen und in Maschinenbewegungen zu übersetzen. Soll beispielsweise G01 X100 Y200 Z-2.0 F2000 S18000 ausgeführt werden, so muss der Pfadinterpreter die akuelle Position der Maschine kennen und einen Fräsvektor erzeugen, der zur gewünschten Position mit den vorgegebenen Parametern zeigt.

Hierbei muss der Interpreter die kinematischen Parameter der Maschine berücksichtigen: Mit welcher Rampe auf Zielgeschwindigkeit F1000 beschleunigt wird ob der gewünschte Vorschub überhaupt zulässig ist, und ab welchem Punkt wieder gebremst werden muss um den Zielpunkt exakt zu erreichen. Die so gewonnenen Daten werden schließlich in eine Schrittfolge für die drei Schrittmotoren übersetzt, in einen Pufferspeicher geladen und schließlich in Echtzeit an die Motorendstufen ausgegeben.

Schritt 3: Optimierung des Pfadinterpreters

Viele Steuersoftware-Anbieter haben integrierte Fräspfadfilter programmiert, welche mittels Kommando G64 oder per Menü zu konfigurieren sind. Ich verlinke hier mal ein paar Beispiele verschiedener Hersteller, wo für spezifische Details nachgelesen werden kann:

Die Kunst ist nun, eine Konfiguration passend zum Fräsjob und der Maschinenkinematik zu finden. Es geht hier immer um einen Kompromiss zwischen Fertigungsgeschwindigkeit und Bahntoleranz. Soll also mit hohem Vorschub gefahren werden, werden eigentlich spitze Kanten verrundet, verbundene Liniensegmente in einem Toleranzband angefahren oder Pfade so vereinfacht, dass außerhalb der von der Maschine erreichbaren Beschleunigung befindliche Pfadpunkte nicht angefahren werden.

Grundlagen: Was ist “Look Ahead Feed”?

Hiermit ist gemeint, dass der Pfadinterpreter der Steuersoftware sich während des Ausführens einer Fräsoperation - z.B. G01 X* Y* (lineare Bewegung Punkt zu Punkt) - bereits die nächste(n) Operation(en) anschaut und herausfindet, ob und wie stark zwischen den Operationen abgebremst und wieder beschleunigt werden muss bzw. direkt durchgefahren werden kann. Die Physik dahinter erkläre ich im Artikel zum CNC-Setup.

Hierdurch kann teils massiv Zeit gespart werden, der Fräsvorgang wird flüssiger und die Maschine erfährt geringere Belastungen. Zusätzlich zur Vermeidung von Beschleunigungs- und Bremsvorgängen kann mittels Parameter G64 eingestellt werden, ob und wie Fräspfadfilter die geplante Trajektorie verändern dürfen, um weiter auf höhere Bahngeschwindigkeiten zu optimieren.

Ideal im Gravurbetrieb

Im Gravurbetrieb kann man sich solche Optionen hervorragend zu Nutze machen: Höhere Toleranzen sind hier meist OK, und leicht verrundete Kanten oft akzeptabel. Bei 3D-Gravuren dauert das Fräsen durch die vielen Pfade lang, und hier ist besonders viel Zeit herauszuholen.

Da ich Eding CNC benutze, kann ich nur für Parameter dieser Steuerung Tipps geben. Nun aber ab ins Detail zur Erklärung der Einstellungen!

Fräspfadtoleranz `G64 P*`

Dieser Parameter gibt der Steuersoftware die allgemeine Toleranz der Pfadgenauigkeit vor.

Ich habe meine Maschine so eingestellt, dass sie im Gravurbetrieb Abweichungen vom vorgegebenen Fräspfad von bis zu LAF blending tolerance = 0.3mm zulässt. Alternativ kann die Konfiguration per Kommando G64 P0.3 erfolgen. Im Bild habe ich skizziert, wie sich eine solche Einstellung in der Praxis auswirken kann: Der Fräspfad (weiß) besteht aus G01-Liniensegmenten. Die Toleranz ist mit Hilfe von Kreisen eingezeichnet. Der Pfadinterpreter der Steuersoftware kann nun eigenständig Kreissegmente so definieren, dass innerhalb der Toleranz eine möglichst hohe Bahngeschwindigkeit erreicht wird.

Die so ermittelte Bahn (türkis) ähnelt einer Spline-Kurve. Zu beachten ist hier, dass sämtliche Linien von dieser Einstellung betroffen sein können - auch solche, die strenge Toleranzanforderungen haben. Ist dies nicht gewünscht, so sollte hier ein kleinerer Wert verwendet werden.

Pfadverrundung `G64 R*`

Treffen zwei Liniensegmente im Winkel von bis zu LAF full speed blending angle threshold = 12° aufeinander, wird die Maschine ohne abzubremsen versuchen, dem Winkel genau zu folgen. Bei größeren Winkeln wird mit reduzierter Geschwindigkeit mit per G64 P* definierter Toleranz gefahren. Diese Konfiguration wird mit G64 R12 programmiert.

Die Werte hier sind mit großer Vorsicht einzustellen, weil sie zu Beschleunigungsspitzen auf der Maschine führen. Große Werte können Schrittverluste und höheren Verschleiß der CNC-Fräse verursachen. Dafür werden Bahngeschwindigkeit und Genauigkeit optimal gehalten.

Pfadverrundung bei reduziertem Vorschub `G64 S* D*`

Diese Konfiguration gibt der Steuersoftware die Möglichkeit, Kanten bis zum eingestellten Toleranzwert zu verrunden: LAF reduced speed path smoothing delta = 0.001mm. In Kombination mit der Verrundung muss der Winkel eingestellt werden, bis zu dem diese Verrundung durchgeführt werden soll: LAF reduced speed path smoothing angle threshold = 0°.

Programmiert wird diese Funktion am Besten in Kombination mit der Pfadverrundung bei vollem Vorschub als G64 R* S* D*. Der Vorteil hierbei ist, dass Liniensegmenten wie im Bild gezeigt sehr genau gefolgt wird, und die Kanten gleichzeitig aber fein justierbar abgerundet werden. Bis zum über R definierten Winkel wird sogar mit vollem Vorschub dem Pfad exakt gefolgt.

Werden bei S sehr große Winkel eingestellt, so findet entsprechend D auch eine stärkere Verrundung statt. Überschreitet der im Fräsprogramm vorgegebene Winkel jedoch den konfigurierten Wert, so fällt der Algorithmus auf die für P hinterlegten Werte bzw. in den exakten Pfadfolgemodus zurück.

Pfadvereinfachung `G64 Q*`

Enthält die G-Code Datei zahlreiche, sehr kurze Liniensegmente (wie sie oft bei der Erstellung von Pfaden aus Bilddateien entstehen), kann diese Funktion durch Vereinfachen der Fräspfade Abhilfe schaffen. Dabei gibt die Zahl hinter dem Parameter die Toleranz an, bis zu der Liniensegmente zu einer Linie verschmolzen werden.

Diese Einstellung entlastet den Pufferspeicher der Maschine und erhöht gleichzeitig die mittlere Bahngeschwindigkeit. Für den Gravurbetrieb halte ich diese Einstellung insbesondere für interessant, wenn mit “verrauschten” Daten gearbeitet wird und im CAD nicht die Möglichkeit bestand, die Anzahl der Pfade zu reduzieren.

Beschleunigungsfilter `G64 F*`

Mittels diesen Parameters können die durch Look Ahead Feed möglicherweise erzeugten Beschleunigungsspitzen abgemildert werden. Der minimal einzustellende Wert ergibt sich durch den Quotienten aus gewähltem Vorschub für die Operation und maximaler Geschwindigkeit der Maschine.

Beispiel: Fmin = Foperate / Fg00, bei Fg00 = 12000mm/min und Foperate = 5000mmm/min ist Fmin = 0.42

Also wird bei Vorschub von 5000mm/min die maximal mögliche Beschleunigung der Maschine abgerufen und Kurvenradien so eingestellt, dass sie bei konstanter Bahngeschwindigkeit gefahren werden. Alle Werte größer gleich Fmin = 1 sind inherent sicher, unabhängig vom gewählten Vorschub.

Dieser Parameter wurde entwickelt für die Bearbeitung von elastischen Materialien wie Gummi oder Kork, wo eine konstante Vorschubgeschwindigkeit extrem wichtig und die Bahntreue eher zweitrangig ist. Der Parameter wird in Kombination mit G64 R* verwendet. Die folgende Programmierung für das obige Beispiel würde die volle Kapazität der Maschine abrufen: G64 R120 F0.42, wobei mit F5000 gefahren wird, F12000 der Maximalvorschub der Maschine ist und spitze Winkel bis 120° ohne abzubremsen gefahren werden sollen.

Wende ich diese Werte auf meine Maschine an, entsteht das nebenstehende Bild. Hier soll ein Rechteck mit 25 x 100mm Kantenlänge gefertigt werden. Weiß ist wieder die Zieltrajektorie dargestellt. Die türkise Kurve zeigt die durch die Programmierung des Beschleunigungsfilters gefahrene Kurve mit konstanter Bahngeschwindigkeit. Je geringer der Vorschub im Verhältnis zum Maximalvorschub und je höher die Beschleunigung der Maschine eingestellt ist, desto kleiner wird der notwendige Radius.

Für den Gravurbetrieb und das Fräsen fester Materialien wird dieser Parameter meiner Erfahrung nach jedoch nicht verwendet.

Meine Konfiguration für die Hobbyline 4530

Ich habe im Gravurbetrieb viel mit den verschiedenen LAF-Parametern herumgespielt und eine Menge Rohlinge als Lehrgeld “verbraucht”. Die kürzesten Fertigunszeiten erhielt ich bei vorheriger Optimierung der kinematischen Parameter mit folgender Konfiguration:

G64 Q0.3 R12 D0.3 S120

Damit sage ich der Maschine folgendes:

“Verwende den Pfadvorschau-Algorithmus und versuche, kurze Liniensegmente unter 0.3mm Länge zu verschmelzen. Versuche, den Vorschub bei einem Winkel zweier Streckenabschnitte von bis zu 12° nicht herunterzuregeln. Bei größeren Winkeln bis 120° kann statt einem exakten Nachfahren mit bis zu r=0.3mm verrundet werden. Bei noch größeren Winkeln ist dem vorgegebenen Pfad zu folgen und, falls erforderlich, bis zum Stillstand abzubremsen.”

Fazit

Da mich die Parameteroptimierung für den Gravurbetrieb ziemlich weit vom Parametersatz für den normalen Fräsbetrieb weggebracht haben, habe ich mein Steuerprogramm einfach ein zweites Mal installiert.

Dort konnte ich dann Geschwindigkeit, Achsbeschleunigung und Pfadparametrierung getrennt festlegen. Nun habe ich das Beste beider Welten auf einer Maschine zur Verfügung:

Einen sehr genauen, weich operierenden Fräsbetrieb mit folgenden Parametern:

Fmax XY 12000mm/min
Fmax Z 4800mm/min
Amax X 1000mm/s²
Amax Y 1000mm/s²
Amax Z 1000mm/s²
G64 P0.1 R6

Und über die andere Verknüpfung einen überaus flinken Gravurbetrieb:

Fmax XY 12000mm/min
Fmax Z 4800mm/min
Amax X 4000mm/s²
Amax Y 3200mm/s²
Amax Z 1600mm/s²
G64 Q0.3 R12 D0.3 S120

Und wo ist der Beweis?

Das eingebettete Video zeigt dasselbe Gravurprojekt mit vier verschiedenen Optimierungsstufen:

oben links: Herstellerkonfiguration der Maschine, Standard-Fräspfade aus CAD/CAM
oben rechts: Geschwindigkeit und Beschleunigung auf Fräsbetrieb erhöht
unten links: Look Ahead feed eingeschaltet G64 P0.3, Fräspfade im CAM optimiert
unten rechts: Optimiert für Gravurbetrieb wie oben beschrieben, CAM Flyover auf 2mm reduziert und Leerfahrten minimiert

CNC-Tuning für den Gravurbetrieb

CNC Tuning #2

Schallbert — Sat, 27 Apr 2024 00:00:00 +0000

Dies ist der zweite Teil meiner Reihe über die Optimierung der Fertigungszeit auf CNC-Fräsmaschinen. Er konzentriert sich auf die kinematischen Maschinenparameter für den Gravurbetrieb.

Schritt 2: Tuning der kinematischen Parameter der CNC

Die theoretischen Grundlagen habe ich im Artikel zur CNC-Steuerungskonfiguration ausführlich erläutert. Meine Probleme damit und zugehörige Lösungen habe ich nach vielen Tests und Rücksprache mit dem Hersteller im Fazit zu einem Jahr CNC-Betrieb festgehalten. Die folgenden Abschnitte wenden die obigen Erkenntnisse auf eine Demonstrationsmaschine an, die ich mir habe leihen können.

Verfahrgeschwindigkeit im Eilgang

Für die Demomaschine konnte ich die Geschwindigkeit im Eilgang von den vorgeschlagenen Fxy = 4m/min und Fz = 2.4m/min auf Fxy = 12m/min und Fz = 4.8m/min erhöhen. Setze ich alle drei Achsen gleichzeitig in Bewegung, erhalte ich durch Steigung der Kugelgewindespindeln und Mikroschrittkonfiguration (8 pro Vollschritt) der Motoren eine kombinierte Schrittfrequenz von 96kHz, was unter der maximalen Schrittfrequenz von 125kHz der Steuerung liegt.

Beschleunigung im Eilgang

Die Herstellerangaben empfehlen hier aXY = 300mm/s² und aZ = 200mm/s².

Ich habe die Beschleunigung in mehreren Schritten hochgesetzt und bin in einer ersten Runde bei aXY = 1000mm/s² und aZ = 400mm/s² gelandet. Diese Werte sind für diese kleine und leichte Maschine mit nur 30x45x14cm Verfahrweg nach meiner Erfahrung für den Normalbetrieb ohne Weiteres möglich. Sie erhöhen die Fertigungsgeschwindigkeit stark, denn jeder Richtungswechsel, auch die im Materialeingriff bei G01, G02, G03, werden nun um Faktor 3 bzw. 2.5 schneller ausgeführt.

So habe ich die Maschine oft betrieben und auch auf der Messe bin ich mit diesen Werten stabil und sicher gefahren. Das folgende Video zeigt die Fräse im Gravurbetrieb mit den angegebenen Werten.

CNC-Tuning: Vorschau

Danach jedoch wollte ich wissen, wie weit ich es treiben kann. Getreu dem vorher beschriebenen Motto

“Wer die Grenze nicht überschreitet, weiß nicht, wo sie liegt”

habe ich erst einmal geprüft, wie sich massive Schrittverluste bei dieser Maschine anhören. Also habe ich eine Achse mit einem Holzbalken blockiert und bin vorsichtig dagegen gefahren:

Your browser does not support the video tag.

Massive step loss soundcheck

Das deutlich vernehmbare Rattern entsteht wenn der Motorhochlauf zwar klappt, in Richtung Zielgeschwindigkeit aber diverse Vollschritte verloren gehen. Wird der Rotor bereits bei Anlauf des Motors “verloren”, so fiept der Motor nur noch, ohne die Achse überhaupt in Bewegung zu setzen. Verliert der Motor nur wenige Schritte, befindet sich aber auf Zielgeschwindigkeit, so gibt es einen rauen und unter Umständen kratzenden Ton.

Ich habe für das Experiment die X-Achse gewählt, weil sie sich am einfachsten blockieren lässt. Des Weiteren habe ich sie in X+-Richtung blockiert. Begründung: diese Maschine besitzt kein professionelles Festlager zur Aufnahme von Druck- und Zugkräften der Kugelumlaufspindel. Stattdessen werden Druckkräfte in Richtung Schrittmotor sicher von einem auf der Spindel montierten Flansch abgefangen, der gegen in der Portalwange befindliche Kugellager drückt.

Zugkräfte hingegen werden hauptsächlich von den Motorlagern aufgenommen - da wollte ich kein Risiko eingehen. Nun ist also das Geräusch bei plötzlichem und ruckartigen Schrittverlust bekannt - das Übertakten kann beginnen!

Meine Vorgehensweise:

Die Beschleunigung einer Achse der Maschine verdoppeln
Die betreffende Achse umher joggen, dabei auf merkwürdige Geräusche achten und die Achsbewegung beobachten
Vorige Schritte wiederholen, bis massive Schrittverluste auftreten
Beschleunigung auf den Mittelwert zwischen “klappt” und “klappt nicht” zurückfahren
Den vorigen Schritt solange wiederholen, bis die Maschine sauber fährt
Alle Schritte auch für die anderen Achsen durchführen

So bin ich schließlich bei für eine solche Hobbymaschine unglaublichen aXY = 4000mm/s², aZ = 1600mm/s² gelandet. Dies liegt nun eine Größenordnung über den empfohlenen Werten.

Die kleine Fräse scheint auch hier stabil zu laufen und die gefertigten Gravuren sehen gut aus. Allerdings konnte ich mir nicht vorstellen, dass ich Schrittmotoren, Treiberstufen und Netzteil noch innerhalb ihrer Spezifikation betreibe. Daher habe ich gemessen.

Elektrische Messwerte

Das Netzteil ist mit 3.7A bei 36V angegeben. Ich darf diesen Wert also in der Summe weder im Eilgang G00 noch im Materialeingriff dauerhaft überschreiten. Wie oben erklärt, ist der Eilgang im Gravurbetrieb durch die geringeren Fräskräfte maßgeblich, sodass ich besonderes Augenmerk auf das Verfahren mehrerer Achsen gleichzeitig legen muss.

Die Motoren können je einen Dauerstrom von 3.0A verkraften, limitieren mir hier also nichts. In den elektrischen Tests schaue ich lediglich, ob ich mit der Energieaufnahme des Systems im Rahmen bleibe.

Messaufbau

Ich schließe das aus diesem Artikel bekannte Multimeter direkt am Ausgang des Netzteils an und nehme Spannung und Strom auf. Für das Experiment simuliere ich die Fertigung der oben im Video verlinkten Gravur und führe in zwei Durchläufen zuerst eine zeitlich grob aufgelöste Leistungsfaktoranalyse (2Hz) durch, gefolgt von einer fein aufgelösten Stromermittlung mit 20kHz.

Ergebnisse

Im obigen Bild sind Spannung, Strom, Wirk- und Blindleistung aufgetragen. Zu erkennen ist, dass die Blindleistung (grün) immer dann kurze Spitzen zeigt, wenn mehrere Achsen gleichzeitig in den Eilgang beschleunigen. Die Leistungsaufnahme einer Achse im Eingriff G01/G02/G03, blau beträgt im Schnitt etwa 45W und ist ähnlich hoch wie bei der Konstantfahrt im Eilgang.

Das Netzteil ist in der Lage, die Spannung (orange) ziemlich konstant zu halten und knickt selbst unter Volllast nur um knapp 0.2V ein. Einzig der Stromwert sah mir etwas zu glatt aus. Ich vermutete an dieser Stelle, dass die zeitliche Auflösung zu gering ist und beschloss, das Experiment mit Konzentration auf den Strom zu wiederholen.

Und tatsächlich. Die höhere zeitliche Auflösung zeigt, dass die Stromaufnahme bei Beschleunigung mehrerer Achsen Spitzen zeigt, die über den bereits bekannten Werten liegt.

Hier stechen Bewegungen auf der Y-Achse, welche das gesamte Portal in Bewegung setzen muss, besonders heraus. Und zwar genau dann, wenn die anderen Achsen noch in Bewegung sind oder gerade gehalten haben. Dies hängt mit den Schrittmotortreibern zusammen. Sie betreiben die Motoren nämlich noch etwa 0.5s nach Anhalten bei vollem Strom weiter. Die dadurch entstehende Überlagerung lässt die Spitzen noch dramatischer aussehen.

Benchmark Spitzenlast

Na dann treiben wir es mal auf die Spitze mit einem Beschleunigungs-Benchmark. Wird das Netzteil auch bei voller Last unter Beschleunigung aller Motoren gleichzeitig die Ausgangsspannung halten können?

Um dies zu testen, habe ich einen G-Code geschrieben, der alle Achsen gleichzeitig auf Höchstgeschwindigkeit beschleunigen und dann wieder abbremsen lässt. Anschließend wird unter gleichen Bedingungen zum Ausgangspunkt zurückgefahren und das Ganze wiederholt.

Auf diese Weise kann ich herausfinden, ob das Netzteil genügend Reserven hat, um Lastspitzen abzufangen und gleichzeitig schauen, ob die Motoren bereits im größeren Maße Schritte verlieren. Im Mittel liegt hier die aufgebrachte Leistung bei 95W und die Versorgungsspannung sinkt um 0.28V auf 35.72V ab. Dabei muss das Netzteil in der Spitze 5.14A abgeben, was knapp 40% über Nennstrom liegt.

Your browser does not support the video tag.

Benchmark

Hört man ganz genau hin, so klingt die Maschine direkt zu Beginn des Benchmarks etwas rau, fängt sich dann aber. So können auch Schrittverluste klingen. Es ist daher sehr wichtig, die Maschine mit allen Sinnen zu überwachen.

Mechanische Prüfung

Nun zur letzten Prüfung: Ich gebe beim Eilgang-Benchmark zusätzlich Last auf die Achsen, indem ich während des Programmablaufes mit meinem Arm an der jeweiligen Achse ziehe. Die Achsen Z und X laufen stabil weiter. Bei der Portalachse Y merke ich jedoch, dass die Maschine nun anders klingt. Irgendwie rau, als würde man mit mit einer Raspel leicht über eine Holzplatte ziehen.

Lege ich eine große Last an, so fährt der Schrittmotor auf dieser Achse nicht mal mehr an, sondern fiept nur noch. Er kann den Pulsen der Endstufe nicht mehr folgen. Ich reduziere nun also die Beschleunigung schrittweise, bis der Motor die Portalachse auch unter mittlerer Last wiederholbar und ohne hörbare Schrittverluste beschleunigen kann. Hier lande ich am Ende bei immer noch flinken [aX = 4000mm/s² aY = 3200mm/s² aZ = 1600mm/s²].

In einem letzten Schritt führe ich nach fünfmaliger Wiederholung des Benchmarks eine weitere Referenzfahrt durch und schaue mir die Logs der Steuersoftware an. Alle Achsen sind nun unauffällig hinsichtlich Schrittverlusten.

Appelle zum CNC-Tuning

Bitte geht beim Tuning eurer Maschine behutsam vor. Lernt sie richtig kennen, bevor ihr damit beginnt. Hört genau hin und optimiert Achse für Achse nacheinander. Nehmt euch Zeit für Tests, Prüfungen und Experimente.

Selbst wenn ihr eine sehr ähnliche Maschine wie meine besitzt, machen andere Abmessungen bereits einen riesigen Unterschied hinsichtlich Steifigkeit und damit auch möglicher Verfahrgeschwindigkeit bzw. Beschleunigung. Sogar Wartungszustand, leichtgängigere Wellen, andere Führungen o.Ä. können dazu führen, dass ihr am Ende mit anderen Werten fahrt als ich.

Es wird kein Profi-Equipment benötigt, um die Grenzen der Maschine auszuloten. Nicht einmal eine Messuhr, da Schrittverluste auch mit Hilfe der Referenzschalter hinreichend genau bestimmt werden können.

Alles was ich durch die elektrischen Messungen oben festgestellt habe, ist, dass der Hersteller bei der Auslegung der Maschine sauber gearbeitet hat und keine Komponente unterdimensioniert ist. Im Gegenteil, diese Maschine ist für die Übertaktung bestens geeignet.

Und nun weiter zum letzten Teil 3: Pfadinterpreter optimieren.

CNC Tuning #1

Schallbert — Sat, 20 Apr 2024 00:00:00 +0000

Dies ist der erste Teil meiner Reihe über die Optimierung der Fertigungszeit auf CNC-Fräsmaschinen. Er konzentriert sich auf den Einsatz von CAD- und CAM-Werkzeugen zur Erzeugung effizienteren G-Codes.

Es gibt diverse Maßnahmen zur Reduktion der Fertigungszeit mit einer CNC-Maschine. Erstmal jedoch sollte beleuchtet werden, warum so etwas gewünscht ist und welche möglichen Nachteile sich hierdurch ergeben.

Warum überhaupt?

Aus kaufmännischer Sicht sorgen geringere Fertigungszeiten für einen höheren Teiledurchsatz und ermöglichen damit einen höheren Umsatz in einer gegebenen Zeitspanne. Zudem ist die Investition der Maschine schneller amortisiert.

Als Hobbyist sind kürzere Fertigungszeiten vor allem dann interessant, wenn das Ziel die Herstellung sehr komplexer Geometrien oder die 3D-Fertigung ist. Hier können Fräszeiten durchaus mehrere Stunden betragen und die möglichen Einsparungen sind folglich besonders groß.

Bei mir steht wie auch in der Lehre der wissenschaftliche Gedanke im Vordergrund: Ich will herauszufinden, wo die Grenze der Maschine liegt. Ich möchte wissen, warum sie dort liegt. Ich werde versuchen, sie stabil innerhalb ihrer Grenzen zu betreiben. Dabei ist der Verschleiß unter Kontrolle zu halten.

Um diese Grenze jedoch genau zu kennen, muss sie zuerst übertreten werden. Woher sonst soll ich wissen, wo sie sich befindet?

Was sind mögliche Nachteile?

Bestimmte Komponenten einer “übertakteten” Maschine könnten schneller als üblich verschleißen. Dazu zählen etwa Netzteile und Motor-Endstufen, die höhere transiente Ströme verkraften müssen. Lager und Führungen werden durch höhere Beschleunigungen stärker beansprucht. Umlaufspindeln und Maschinenrahmen müssen die dadurch resultierenden, stärkeren und schneller wechselnden Kräfte und Vibrationen aufnehmen und können früher Ermüdungserscheinungen oder sich lösende Verbindungen aufweisen.

Bei der Ermittlung der Grenzen kann die Maschine im Extremfall sogar beschädigt werden: Mit hoher Wahrscheinlichkeit treten jenseits der Grenze Schrittverluste¹ auf. Das ist zwar im Testbetrieb nicht weiter problematisch. Doch stimmt die angenommene Position dann nicht mehr mit der tatsächlichen Position überein und es besteht das Risiko des “Crashes” - wenn nicht mit Bedacht vorgegangen wird. Hier noch ein ziemlich gutes Youtube-Video von gammaflow zum Thema Schrittverluste vermeiden.

Werden die Fräsbahnen im CAD oder CAM zugunsten kürzerer Fertigungszeiten verändert, so kann dies außerdem negative Auswirkungen auf Schnitt-, Kanten- und Oberflächenqualität haben.

Bei der Optimierung des Pfadinterpreters der Steuersoftware ist ebenfalls ein Kompromiss einzugehen: Höhere Fertigungsgeschwindigkeit wird hier mit geringerer Genauigkeit und/oder höherem Maschinenverschleiß eingekauft.

Welche Maßnahmen werden nicht diskutiert?

Nicht betrachten werde ich hier die Optimierung von Vorschub F und Drehzahl S des gewählten Fräsers im Eingriff. Diese Parameter hängen vom zu bearbeitendem Material, der Fräsergeometrie, den Fähigkeiten der Maschine und dem Mut des Bedienpersonals ab, sodass ich keine allgemein gültigen Tunings vorschlagen kann.

Einen anderen, großen Einflussfaktor muss ich hier ebenfalls ausklammern: Die Bearbeitungsstrategie des CAM-Programms bezogen auf Eilgänge. Mein CAM-Programm lässt mich da nicht besonders tief eingreifen, sodass ich für die Optimierung der letzten paar Prozent Fertigungszeit stets von Hand im G-Code arbeiten muss, was entsprechend fehleranfällig ist.

Tuning in drei Schritten

Bei meiner Optimierung bin ich in drei Schritten vorgegangen, die allerdings unabhängig voneinander umgesetzt werden können. Jeder Schritt hat mir hierbei deutlich spürbare Verbesserungen gebracht. Dieser Artikel konzentriert sich aus mehreren Gründen auf den Gravurbetrieb:

Gravuren erlauben meist größere Toleranzen als andere Betriebsarten. Dadurch kann stärker verrundet werden, was zu geringeren Beschleunigungen führt. Dies ermöglicht im Mittel größere Vorschübe
Die zu erwartenden Fräskräfte sind geringer: Keine Durchfräsungen, kaum Energieeinsatz bei der Spanverdrängung, kleineres Spanvolumen als bei Schaftfräsern
Dadurch kann die Maschine näher an ihren mechanischen und elektrischen Grenzen betrieben werden
Durch im Schnitt größere G-Code Dateien mehr Optimierungspotential

Schritt 1: Besserer G-Code

Dieser Abschnitt folgt dem Credo Garbage in, Garbage out. Will heißen: Wenn mein G-Code schon schlecht ist, kann die Maschine niemals optimale Fertigungszeiten erreichen. Was zeichnet also “schlechten” G-Code in Bezug auf Fertigungszeit aus?

übermäßig komplex und lang, möglicherweise Dateigröße im Megabyte-Bereich
extrem viele Stützpunkte und eine Menge kurzer Liniensegmente
Einen Haufen “Leerfahrten” im Eilgang auf XY mit hochgezogener Z-Achse
Viele Rückzüge der Z-Achse auf Sicherheitshöhe
Häufige Wartezeiten der Maschine (Spindelhochlauf, Kühlmittelpumpe, Controller-Puffer voll)
Übermäßiges Feinstschlichten auch bei B-Oberflächen

Aber wie soll ich meinen G-Code vereinfachen?

Kurze Frage, lange Antwort: Es fängt im CAD an und hört möglicherweise im CAM nicht auf.

Beispiel CAD

Nehmen wir an, wir möchten eine Schrift fräsen. Unser CAD-Programm hat auch einen Haufen toller Schriftarten dazu. Wir erzeugen nun eine DXF-Datei für’s CAM. Im CAM dann sehen wir plötzlich beim Hineinzoomen, dass alle Buchstaben aus sehr kurzen Liniensegmenten bestehen statt aus Kreissegmenten oder Splines. Die Folge: Das CAM wird G01-Bewegungen, also “Linear Moves” bzw. eine Aneinanderreihung von Strecken erzeugen.

Die verbundenen Strecken machen sehr viele Richtungswechsel der Maschine erforderlich. Folglich muss sie vor dem Verbindungspunkt ständig abbremsen und danach wieder beschleunigen. Die Maschine kann also nicht mit konstanter Geschwindigkeit fahren, denn das würde eine unendliche Beschleunigung am Knickpunkt erfordern.

Für dieses Problem gibt es Lösungen, die im Idealfall gemeinsam angewendet werden:

Im CAD-Programm einstellen, dass wann immer möglich Splines oder Kurven statt Liniensegmenten erstellt werden sollen
Vereinfachung der Zeichnung durch Reduktion der Stützstellen
Vermehrte Nutzung von Radien und Splines an Kanten, Vermeidung von Winkeln

In meinem Falle war die erste Option nicht verfügbar, sodass ich nun ein anderes Programm für die Gravur von Schriften verwende als für meine üblichen Zeichnungen. Dadurch kann ich Schrift jetzt in Linien- und Bogensegmenten ausdrücken. Die dafür erforderliche Fräszeit halbiert sich und gleichzeitig kommt der G-Code mit weniger Zeilen aus. Außerdem wird die Schrift runder und hält sich sogar noch genauer an die anfangs gewählte Schriftart.

Gute Beispiele für die Vereinfachung von Pfaden durch Reduktion von Stützpunkten liefern Gimp und Inkscape - für Inkscape habe ich das sogar bereits meinem Artikel zum Thema Bild-zu-Pfad-Konversion gezeigt. Mit ein paar wenigen Klicks erhält man auf Kosten der Genauigkeit Zeichnungsdaten, die teils deutlich schneller zu fertigen sind.

Da ein Schaftfräser sowieso keine Tasche mit r=0 in den Ecken fertigen kann, habe ich mir angewöhnt, sämtliche Ecken und Kanten im CAD abzurunden. Nicht nur liegen so hergestellte Teile besser in der Hand, sie sind außerdem schneller zu fertigen - die Zeitersparnis summiert sich, besonders auf langsamen und trägen Maschinen.

Beispiel CAM

Im CAM kann ich durch vermehrte Verwendung von Anfahrpunkten und Rampen ein wenig Zeit sparen. Ich lege sie zumeist an das kürzeste Liniensegment und spare so einen Brems/Beschleunigungsvorgang. Bei der Eintauchart ist der Vorteil von “Rampe” gegenüber “Helix”, dass sämtliche Wege des Fräsers Nutzwege sind und ich ohne zusätzliche Achsbeschleunigungen durchfahren kann. Je nach Rampensteigung allerdings verlängert sich der Fräspfad, da Überlappungen entstehen.

Einen viel größeren Effekt auf die Fertigungszeit hat die kluge Auswahl von Räumzustellungen und -strategien für Taschen passend zu Material, Fräser und gewünschter Oberflächengüte. So erzeugt Wirbelfräsen (Trochoidalfräsen²) in vielen Fällen längere Dateien und kostet auf der Maschine mehr Zeit als der klassische “Rasenmäher”, welcher die Tasche bloß abzeilt. Für die Räumzustellung wähle ich bei Materialien wie Holz und Acrylglas gern große Werte über 60% - es sei denn, der Boden der Tasche muss besonders hohen Qualitätsansprüchen genügen.

Für Gravuren ist es meiner Meinung nach oft am Schnellsten, auf einen Räumgang mit einem zweiten Fräser zu verzichten und wenn möglich einen Gravurfräser mit abgeflachter Spitze - ähnlich derer für meine Tests mit Dibond - zu verwenden. Dieser benötigt zum Räumen zwar länger; das kann ich durch gesteigerte Gravurtiefe und eine recht breite Abflachung von 1.5mm aber kompensieren. Ich verwende bei einem solchen Fräser eine Räumzustellung in XY von 1mm. Übrig bleibt schließlich der Zeitvorteil durch weniger Werkzeugwechsel.

Aber wie soll ich die Leerfahrten reduzieren?

Endlich mal ein paar knackig-kurze Antworten:

Geringere Rückzugshöhe in Z (ich verwende 5mm aber 2mm würde bei mir wahrscheinlich auch funktionieren)
Optimierung der Frässtrategie im CAM auf “minimale Wege”
Bei Nesting: Darauf achten, dass die Geometrie möglichst nicht Zeile für Zeile, sondern Teil für Teil gefertigt wird.
Im Zweifel Optimierung der Strategie im G-Code von Hand. Lohnt sich dann, wenn das CAM-Programm nicht gut genug arbeiten kann und viele Gleichteile zu fertigen sind

Und wo ist das Problem mit Rückzügen der Z-Achse?

Rückzüge finden vor allem im Gravurbetrieb sehr häufig statt
der Zeitverlust summiert sich
Beim Wiedereingriff wird meist nicht im Eilgang sondern mit für den Fräser vorgesehener Geschwindigkeit mit G01 auf das Material gefahren

Eine Verbesserung kann hier eine gute Planung der Fräsreihenfolge im CAM bringen. Möglichst viele Sektionen sollten verbunden und ohne Absetzen des Fräsers gefertigt werden. Im CAM sollte für Rückzug und Wiedereinfahrt in Z der Eilgang verwendet werden.

Wie reduziere ich Wartezeiten?

Mit Kühlschmierstoffschaltvorgängen, Wechsel der Spindeldrehzahl oder des Werkzeugs sind Wartezeiten verbunden, die meist leicht zu reduzieren sind:

Kühlschmierstoffförderung durchlaufen lassen während des Programmablaufes
die Verwendung möglichst weniger Werkzeuge bei gleichbleibender Drehzahl für ein Produkt
Anschläge verwenden, um die Maschinenbeschickung zu vereinfachen und Nullpunkte nicht immer wieder neu setzen zu müssen
Wird die Maschine mit komplett verschiedenen parametern für Gravur- und Fräsbetrieb gefahren, empfiehlt sich die doppelte Installation der Steuersoftware mit jeweils passenden Parametersätzen. Dadurch entfällt das ständige Ändern der Konfiguration.

Weiter geht es in Teil 2: Kinematische Parameter hochdrehen.

Schrittverluste treten dann auf, wenn die Achse eines Schrittmotors nicht mehr synchron mit der durch die Steuerung vorgegebenen Schrittfolge dreht, sondern weniger bzw. mehr Schritte zurücklegt als vorgegeben. Fast immer ist die Ursache eines Schrittverlustes in einer unzureichenden Auslegung des Systems (z.B. zu geringe oder instabile Versorgungsspannung, zu schwache oder nicht an den Motor angepasste Endstufen) oder einer Überlastung des Schrittmotors zu finden. Selten jedoch können Schrittverluste Symptome von Defekten sein wie Lagerfraß, Windungsschluss oder durchschlagene Pufferkondensatoren. ↩︎
Das Trochoidalfräsen ist keine schlechte Praxis. Es hat andere Stärken, ist im Gravurrbetrieb aber nur selten von Nutzen. ↩︎

Vakuumspannen

Schallbert — Tue, 02 Apr 2024 00:00:00 +0000

Wie ich im Artikel zur Maker Faire Ruhr 2024 erwähnte, hatte ich große Probleme beim Spannen meiner Werkstücke für die Fertigung von Spirographen.

In diesem Beitrag möchte ich genauer darauf eingehen, eine Analyse der Ursachen vornehmen und schließlich ein paar Lösungsmöglichkeiten vorstellen.

Was ich vorwegnehmen kann: Sämtliche Probleme lassen sich mit Wissen über die Ursachen sowie etwas Zeit-, Planungs- und Materialaufwand beheben.

Das Problem

Ich hatte wie üblich die Bahnplanung für die Spirographen so festgelegt, dass ich erst die inneren Bereiche (Taschen, Teile, Bohrungen) und danach die äußeren Bereiche fräsen lasse. Ganz zum Schluss sollten Ausschnitte und Fasen gefertigt werden. Des Weiteren sah ich vor, die Teile doppelseitig zu bearbeiten, damit auch die Rückseiten der Zahnräder gebrochene Kanten und weiche Übergänge aufweisen würden.

Vakuumverlust

Bei meinem ersten Versuch bin ich so vorgegangen wie ich das im Spirographen-Projekt mit dem Material Acrylglas bereits erfolgreich durchführen konnte: Die Rückseite wird zuerst bearbeitet, aber nicht ganz durchgefräst. Nach dem Wenden des Werkstückes dann soll nur noch mit dem Fasenfräser ausgeschnitten und gleichzeitig die Kanten gebrochen werden.

Dies funktionierte für die erste Aufspannung auch hervorragend.

Your browser does not support the video tag.

Rückseitige Bearbeitung der Spirographen.

Bei der zweiten jedoch ging mit dem Durchstoßen der Oberfläche so viel Unterdruck verloren, dass sich das Material vom Vakuumtisch löste und seine ursprüngliche, leichte Wölbung annahm. Somit musste ich den Fräsvorgang abbrechen und mir eine andere Strategie zum Niederhalten überlegen.

Ich konnte mir zu diesem Zeitpunkt noch nicht richtig erklären, warum jetzt so viel mehr Druck verloren ging als bei der Fertigung in Acrylglas.

Frischhaltefolie

Ich probierte mit Frischhaltefolie dem Druckverlust entgegenzuwirken. Dabei stellten sich gleich mehrere Folgeschwierigkeiten: Fährt der Fräser durch die Folie, so wird sie beim Fräsen geschlossener Konturen vom Fräser erfasst und in Windeseile um selbigen gewickelt. Der Fräser schneidet nun nicht mehr, sondern reibt nur noch am Material, was sehr schnell zu Hitzespuren am Holz führt.

Doch selbst wenn ich die Frischhaltefolie vorab befestige: Da ich Teile ausschneide, ist beim ersten Eindringen in die auf der Unterseite bereits vorhandene Nut der lokale Unterdruck am Teil bereits wieder so klein, dass es sich kaum an Ort und Stelle halten lässt.

Verdrehung des Werkstücks

Für den zweiten Versuch passte ich die Strategie an: Der Schaftfräser würde das Werkstück durchfräsen, so dass ich keine zweite Aufspannung benötigte. Ich wollte die Kantenbrechung auf der Rückseite später optional über eine auf dem Tisch festgespannte Halterung realisieren, in die ich die Teile würde einlegen können.

Während das Ausschneiden der Teile noch problemlos funktionierte (erneut die “inneren” Teile zuerst fräsen), so bekam ich beim Anbringen der Fase bereits auf der Vorderseite große Probleme. Die Zahnräder begannen, sich zu verdrehen und die Schablone mit Hohlrad war überhaupt nicht niederzuhalten.

Zu wenig Zeit

Ich musste also schon bei der Bearbeitung der Vorderseite auf speziell für die Werkstücke angefertigte Halterungen zurückgreifen. Deren Konstruktion und Fertigung nahm Zeit in Anspruch die ich an dieser Stelle so nicht eingeplant hatte.

Vor der Messe konnte ich mich nicht in der Tiefe mit der Analyse beschäftigen - eine schnelle Lösung musste her.

Die Ursachen

Mit ein paar Wochen Abstand kann nun ich sagen, dass mehrere Faktoren zu den Problemen führten. So kommen eine schwierige Geometrie, ungünstige Materialeigenschaften und bestimmte Eigenheiten des Vakuumtischdesigns zusammen. Aber gehen wir dem Ganzen hier mal auf den Grund.

Werkstück

Das Ausgangsmaterial ist mitteldichte Faserplatte von 10mm Stärke. Sie ist einseitig mit 0.75mm starkem Olivenholzfurnier versehen. Dieses Material ist für die Bearbeitung auf einem Vakuumtisch bereits von Grund auf problematisch:

Durch Furnierung und Lagerung sind die Platten leicht gewölbt¹, wollen sich also von meinem Vakuumtisch abheben.

MDF ist luftdurchlässig, sodass die Vakuumpumpe mit größeren Leckageströmen zu tun hat als üblicherweise (so bekomme ich bei Aufspannung der Platte nur -300mBar zusammen statt der üblichen -800mBar ohne Leckströme). Die geringe Materialdicke verstärkt diesen Effekt.
MDF ist nicht nur senkrecht zur Plattenebene luftdurchlässig, sondern auch waagerecht. Dadurch sind die Haltekräfte in der Nähe von Fräsungen stark reduziert, denn Luft kann nun auch seitlich in das Material eindringen und erhöht so zusätzlich die Leckageströme.

Das hier verlinkte Video Youtube: Verschiebekraftmessungen von Anton CNC zeigt anschaulich, wie sich verschiedene Materialien auf einem Vakuumtisch mit poröser Oberfläche verhalten. Ebenfalls sehr empfehlenswert zum Thema ist dieses Video YouTube: Haltekraftermittlung während des Zerspanens von vakuumtischDE um einen Eindruck zu gewinnen, unter welcher Belastung das Werkstück während des Fräsvorganges stehen kann.

Geometrie

Mein Design für die Spirographen lässt sich nicht besonders gut niederhalten:

Die Schablone mit Hohlrad besitzt dünne Wände von nur etwa 2cm Stärke. Am dicksten sind sie an den Seiten links und rechts, weisen in der Mitte aber eine große Aussparung auf, durch die Luft in alle Richtungen in das Material eindringen kann und so die Haltekräfte reduziert.
Das Zahnrad verfügt über Löcher zur Aufnahme von Stiften. Um die Löcher herum ist der Anpressdruck reduziert.
Die Zähne von Hohlrad und Zahnrad liegen so frei, dass sie durch Querströme der Luft im Material praktisch keinen Beitrag zur Haltekraft leisten können. Gleichzeitig bieten die Zahnköpfe aber einen großen Hebel für Verdrehung oder Verschiebung des Werkstücks: Eine ungünstige Paarung.

Nehme ich das als Grundlage für die Praxis, so sind nur die im Bild oben innerhalb des Kreises befindlichen Vakuumlöcher überhaupt in der Lage, nennenswerte Spannkräfte zu erzeugen. Diese sind aber wiederum nahe am Zentrum und bieten folglich nur wenig Widerstand gegen Verdrehen des Werkstücks. Hinzu kommt, dass das Zahnrad hier mehrere Bohrungen und damit zusätzliche “Lecks” aufweist.

Fräskräfte

Die durch das Werkzeug (den Fräser) in das Material eingebrachten Kräfte wirken stets in XY-Richtung, bei V-cut Fräsern und Schaftfräsern mit Spirale/Drall zusätzlich in Z-Richtung.

Kräfte durch Vorschub: Je schneller durch das Material gefahren wird, desto stärkere Kräfte in XY-Richtung wirken auf das Material in Verfahrrichtung.
Kräfte durch Fräserdrehung bzw. Gleich- oder Gegenlauf: Verwendet man einen Schaftfräser ohne Drall, so entstehen Kräfte orthogonal in der Ebene der Verfahrrichtung. Fahre ich also in positive X-Richtung, wird der Fräser auch in Y-Richtung eine Kraft ausüben, die durch seine Eigendrehung eingebracht wird: Im Gleichlauf möchte der Fräser dem Material ausweichen, wird also nach Y+ abgelenkt (wie in diesem Artikel anschaulich gezeigt). Im Gegenlauf ist die Ablenkrichtung invers und der Fräser möchte nach Y- ausweichen.
Kräfte durch Fräsergeometrie: Weist der Fräser eine Spirale auf oder ist er in der Geometrie abgeschrägt, so wirken zusätzlich Kräfte in Z-Richtung. Bei Vcut- und Downcut-Fräsern wird das Material auf das Maschinenbett gedrückt, bei Upcut-Spiralfräsern hingegen wird der Span wie gewünscht ausgeworfen. Das Werkstück erfährt aber auch eine Kraft, die es im Extremfall vom Maschinenbett abheben kann.
Wird in der Vollnut gefräst (d.h. der Fräser ist statt an der Werkstückkante entlang zu fahren über seinen kompletten Durchmesser im Eingriff), erhöhen sich die Kräfte quer zur Fräsrichtung sogar noch: Im Bild fährt er am oberen Rand der Nut im Gegenlauf, was den Fräser “vom Material weg”, im Bild also nach unten, drückt. Gleichzeitig fährt er am unteren Nutrand im Gleichlauf, was ihn “in das Material” zieht - ebenfalls nach unten.

Vakuumspannsystem

Wie in den Artikeln über Vakuumpumpen und Vakuumtische beschrieben, verfüge ich über eine trockenlaufende Drehschieberpumpe, angeschlossen an einen Lochrastervakuumtisch. Bei der Bearbeitung poröser Werkstoffe ist diese Kombination ebenso wie Rastervakuumtische mit kleinvolumigen Pumpen problematisch:

Mein Lochrastervakuumtisch besitzt Löcher mit einem Vakuumkanal von 0.5mm Durchmesser. Durch diese Engstelle wird die Pumpe zwar bei offenliegenden Löchern entlastet, denn sie muss nicht den vollen Luftstrom bringen, die das 5mm große Sackloch ermöglicht. Allerdings kann das Loch durch den begrenzten Luftstrom in Kombination mit MDF weniger Unterdruck aufbauen.
Durch die hohen Leckströme ist meine Vakuumpumpe mit ihrem Volumenstrom an ihrer Grenze. Hier sind andere Pumpentypen deutlich besser geeignet (siehe Radialgebläse, Seitenkanalverdichter).
Ein Vakuumtisch spannt generell nur nach unten (in Z-Richtung). Allerdings müssen auch Kräfte in XY-Richtung abgefangen werden, damit es nicht zu einer Verschiebung oder Drehung des Werkstückes kommt. Diese sind über den Haftreibkoeffizienten µ zwar an den Unterdruck am Werkstück gekoppelt (und lässt sich über Materialpaarung und Oberflächenbeschaffenheit beeinflussen), wenn Letzterer aber zu niedrig ausfällt, wird das Werkstück nicht zuverlässig gehalten.

Obwohl sich die Vakuumkanäle im 10mm-Raster befinden, beträgt der für den Leckstrom maßgebliche Abstand nur 5mm. Die Ränder der Sacklöcher (je 5mmDurchmesser) befinden sich nämlich in diesem Abstand zueinander, sodass der Luftstrom quer zum Material eine geringere Distanz zurücklegen muss als durch das Material hindurch.

Vergleich zum Widerstandsnetzwerk

Die tatsächliche Spannkraft lässt sich gut abschätzen wenn man sich Pumpe, Vakuumtisch und Werkstück als elektrisches Netzwerk vorstellt. Ich habe hierfür ein Modell vorbereitet und stelle es im Folgenden vor.

Widerstände: Vakuumtisch, Werkstück

Die Sauglöcher des Vakuumtisches stellen Widerstände für den Luftstrom dar, welche sich in einer Parallelschaltung befinden. In Reihe dazu ist das Werkstück erneut als Widerstand geschaltet, was mit seinem anderen Pol an “Masse”, also dem Umgebungsluftdruck, liegt.

Vakuumverteiler = Schalter, Manometer = Spannungsmesser

Das Manometer im Saugkanal kann als Spannungsmessgerät gesehen werden. Den Vakuumverteiler mit seinen Ventilen zum Schalten der Vakuumsektionen sehe ich als elektrische Schalteinrichtung. Ist der Schalter geschlossen, so stellt er die Verbindung zwischen Pumpe und Vakuumtisch her. Ist er geöffnet, so blockiert er den Luftstrom.

Vakuumpumpe = Spannungsquelle

In diesem Bild stellt die Pumpe eine Spannungsquelle dar, die in meinem Falle maximal U = 8V entsprechend -800mBar bereitstellen kann. Durch den bei realen Spannungsquellen vorhandenen inneren Widerstand von 0.2Ohm kann sie einen Kurzschlussstrom von I = 40A erzeugen, analog zu den 40m³/h Durchsatz. Dieser Vergleich ist physikalisch natürlich nicht korrekt, denn ich müsste hier mit Masse- statt Volumenströmen arbeiten. Außerdem hängt die Fördermenge nicht überall im Kennfeld linear mit dem Druck zusammen und die von mir angenommenen Widerstandswerte sind nur Richtgrößen. Zur Modellierung des Sachverhaltes eignet es sich meiner Meinung nach trotzdem.

Bei Werkstückmaterialien wie Acrylglas oder Metall ist der Luftdurchfluss nahe Null, ihr “Widerstand” ist also extrem hoch. Dadurch fällt hier der allergrößte Teil der Spannung (Unterdruck) ab, sodass das Werkstück fest gespannt wird.

Bei Verwendung luftdichter Materialien ist die Welt entsprechend in Ordnung: Das Manometer zeigt beim noch unbearbeiteten Werkstück den den Druck auf dem Material korrekt an an. Selbst bei Durchfräsungen wird lediglich der Widerstand des Materials “in Reihe” zu den betroffenen Sauglöchern zu Null gesetzt. So wird der Unterdruck und damit Haltekraft am Teil selbst kaum reduziert.

Schaut man genau hin, so ist zu erkennen, dass das Manometer die Druckdifferenz vor dem Vakuumverteiler misst. Sein Wert ist also nur dann auch aussagekräftig für die Spannkraft, wenn das Werkstück einen sehr hohen Durchströmungswiderstand bietet.

Sonderfall poröse Werkstoffe

Ganz anders sieht das Bild bei porösen Werkstoffen wie MDF aus:

Hier liegt der Durchgangswiderstand des Materials nur knapp eine Größenordnung über dem der Vakuumlöcher. Ich habe die Werte durch Versuche am Vakuumtisch ermittelt. Sie basieren auf Druckmessungen und Berechnungen von Werkstückfläche und der Anzahl vom Material abgedeckter, aktiver Sauglöcher. Besonders hervorzuheben sind hier zwei Effekte, die mir das Niederhalten zusätzlich schwer gemacht haben:

Augenmerk auf die Widerstände im Material in Parallelschaltung zum Durchgangswiderstand in Z-Richtung. Sie entstehen dadurch, dass die Luft sich nun auch “zwischen den Löchern” durch das Material bewegen kann.
Auf der rechten Seite des Bildes ist zu erkennen, was passiert, wenn das Werkstück in einen inaktiven Vakuumbereich hineinragt: Die Sauglöcher sind untereinander praktisch ohne Widerstand mittels Vakuumkanälen im Tisch verbunden. Da das Werkstück “Querluftzug” in XY-Richtung ermöglicht, muss durch Verbindung der Sauglöcher deutlich weniger Widerstand überwunden werden, als für die Durchdringung in Z. Hierdurch liegen nur noch R29 und R22||R21 in Reihe. Überdeckt das Werkstück mehrere inaktive Lochfelder, geht R22 gegen 0.

In der Folge werden die Widerstände vor R19, nämlich R18||(R29+(R21||R22)) so klein, dass die Pumpe hier praktisch nur noch Umgebungsluft zieht und an der Stelle kaum Spannkraft aufbringen kann. Über R25 wirkt sich der Querluftstrom außerdem auf den Druckabfall von R17, R15 aus.

Jetzt wirken die kleinen Sauglöcher als Spannungsteiler, sodass an ihnen ein nicht unerheblicher Teil des Unterdrucks “hängen” bleibt.

Also stimmt auch der auf dem Manometer angezeigte Druck überhaupt nicht mehr mit den Gegebenheiten am Werkstück überein: Obwohl ich hier noch immer -200mBar angezeigt bekomme, reduziert sich die Spannkraft genau an den für das Niederhalten empfindlichsten Stellen

am Rand des Werkstücks
in angrenzenden Bereichen zu denen, wo das Werkstück nicht aktiv angesaugt wird
sowie an jeder Durchfräsung und einem gewissen Umkreis

auf nahe null.

Für alle anderen Bereiche gelten die Kirchhoff’schen Gesetze: Gebildet wird ein Spannungsteiler bestehend aus Innenwiderstand der Pumpe, Vakuumsystem sowie dem Durchdringungswiderstand des Werkstücks. Nur die noch am Werkstück abfallende Spannung bestimmt die Niederhaltekraft. Sie ist - ich wiederhole mich jetzt - unter Umständen viel geringer als der Blick auf das Manometer vermuten lässt.

Lösungen

Ganz schön viel Theorie für die banale Erkenntnis, dass mir das Werkstück auf dem Maschinenbett verdreht wird, oder? Folgende Lösungen habe ich für ein solches Problem im Köcher:

Pumpe / Vakuumtisch

Bei der Arbeit mit porösen Werkstoffen ist es wichtig, dass der Tisch selbst einen geringen Durchströmungswiderstand aufweist. Nur so fällt der Großteil des Unterdrucks am Werkstück ab, was zu höherer Spannkraft führt. Hier wäre nach dem Motto “viel hilft viel” also eine Pumpe mit mehr Durchsatz, ein Tisch mit größeren Saugöffnungen und ein Vakuumverteiler mit größeren Schlauchdurchmessern angemessen. Kommt für mich aber überhaupt nicht in Frage.

Haftvermittler

Ich könnte probieren, eine grobmaschigere Gummimatte zu verwenden. Mit einem 20mm Lochraster etwa verdreifacht sich der Widerstand für den Querluftstrom, sodass Außenbereiche nicht mehr so stark vom Druckverlust betroffen sind. Zudem besitzt eine solche Matte mehr Gummifläche, was die Haftreibung erhöht.

Klebeband statt Frischhaltefolie auf der Materialoberfläche löst das Problem des Verfangens im Fräser und verschließt lokal die Poren des Werkstoffes, kann also die Haltekraft in kritischen Bereichen verbessern.

Natürlich können auch auf einem Vakuumtisch gängige Methoden wie die Aufbringung doppelseitigen Klebebandes oder das Festschrauben des Werkstückes angewandt werden. Mache ich aber nicht - denn dann müsste ich mir ja eingestehen, dass mein Vakuumtisch nicht für alle Fälle geeignet ist.

Haltestege, Spannvorrichtung

Diese Lösung zielt darauf ab, Verdrehen und Verschieben des Werkstückes zu vermeiden. Der Vakuumtisch wird hier nur noch zum Niederhalten verwendet, während eine passend angefertigte Halterung Kräfte in XY-Richtung aufnimmt. Im Bild sind Halterungen für die Schablone sowie das Zahnrad zu erkennen, die ebendiese Aufgabe erfüllen. Sie werden auf dem Maschinenbett befestigt und benötigen einen präzisen Nullpunkt, um die Kanten versatzfrei brechen zu können.

Ich verwende eine Spielpassung mit 0.1mm Luft zwischen den Komponenten. Ist das Spiel kleiner, benötige ich zu viel Kraft, den Rohling einzusetzen. Setze ich größere Werte an, lassen sich die Werkstücke zu stark verdrehen.

Mit dieser Variante kann ich verzogene Werkstücke geradeziehen, weiterhin sehr feine Gravuren anfertigen und gehe trotzdem sicher, dass mir nichts mehr verrutscht.

Nachteilig sind der Zeit- und Materialaufwand für Planung und Herstellung individueller Halterungen bzw. Schablonen.

Modifikation des Werkstückes

Dies liegt auf der Hand: Ich kann das Werkstück in seinen Eigenschaften so verändern, dass es undurchlässiger wird für Luft. So kann ich z.B. die Unterseite mit einer Folie bekleben und damit zusätzlich die Haftreibung verbessern.

Wer wie ich nicht so gerne Plastik verwendet: Ich habe herausgefunden, dass Backpapier / Frischhaltepapier aus ungebleichtem Zellstoff kaum Luft hindurch lässt. Demnächst probiere ich mal aus, Materialien damit zu bekleben bzw. von Durchfräsung betroffene Bereiche damit abzudecken statt mit Kunststofffolie.

Liegt ein solches Problem regelmäßig vor, sind Rastervakuumtische mit Dichtschnur eine hervorragende Lösung: Hier mittels einer linienförmigen Dichtung an den Außenkanten des Werkstückes gegen den Umgebungsluftdruck abgedichtet, sodass Werkstückkanten keine Chance bekommen, sich hochzuwölben. Bei meinem Lochrastertisch jedoch wirkt die gesamte Fläche der Gummimatte als Dichtung, sodass die Wölbung in Form einer Kontaktlinie auf der Matte vorliegt. Linien haben jedoch keinen Flächeninhalt, und nur durch jenen kann mein Tisch niederhalten. Dies ist übrigens auch der Grund, warum biegsame Materialien wie Folien so leicht vom Vakuumtisch abgezogen werden können. ↩︎

Maker Faire Ruhr 2024

Schallbert — Mon, 25 Mar 2024 00:00:00 +0000

Vorbereitung

Seit Anfang Januar bereiten sich zwei meiner Freunde und ich auf die Maker Fair Ruhr in der DASA Dortmund vor. Im Zuge dessen habe ich Faserplatten furniert, Rohlinge für Gravuren ausgeschnitten, Tischdecken besorgt, PC-Gehäuse bearbeitet, Zahnräder gefräst, LED-Streifen programmiert, ein Standschild designt, eine CNC-Maschine eingerichtet, sie für den Gravurbetrieb optimiert und so weiter…

Als der Termin dann nahte, wurde es dann doch knapp. Es geht schon eine Menge Zeit und Koordination in so eine Messevorbereitung.

Impressionen von der Maker Faire Ruhr 2024.

Hier wird der Vakuumtisch in Betrieb genommen und getestet.

Die CNC-Maschine für die Messe. Fertig eingerichtet und betriebsbereit.

Selbstgefräster Schilder für die dargestellten Projekte.

Das Standschild für einen guten Freund, der Retro-PCs und -Spiele ausstellt.

Schöner Abfall - ein Reststück Acrylglas in Form einer Welle

Das Gegenstück zur Welle: Ein PC mit einzigartigem Fenster, selbstgefräst.

Die LED-Streifen sind fertig programmiert und alles steht an seinem Platz.

Retro-2000er-PCs sind aufgebaut und vernetzt. Bereit zum Spielen.

Die betriebsbereite CNC-Maschine auf der Messe.

Bereits einige Besucher, Maker und Interessierte am Samstag.

Backstage des betriebsbereiten Standes.

Doch am Sonntag war noch viel mehr los.

Projekte

Auf der Messe wollte ich ein paar meiner schönsten Projekte vorstellen wie etwa den Seifenbutler, meine übergroßen Spirographen und Besuchern ermöglichen, eigene Schilder graviert zu bekommen, nach Bedarf sogar mit QR-Code.

Damit die Fräsarbeiten schnell von der Hand gehen, habe ich Rohlinge gefertigt, die später nur noch graviert werden mussten. Die Spirographen musste ich wegen der erforderlichen doppelseitigen Bearbeitung ebenfalls vorab fertigen.

Maschinen

Ich konnte ein paar Firmen davon überzeugen, mir Maschinen und -Teile für die Messe zu leihen:

Von Sorotec borgte ich mir eine “Hobbyline4530”, deren kleinste und leichteste Maschine.

Die Firma Stritzelberger stellte mir einen zur Maschine passenden Vakuumtisch inkl. passender Pumpe zur Verfügung.

EdingCNC unterstützte bei der Einrichtung ihrer Software, lieh mir Aussteller für die aktuellste Steuerungshardware und kam schließlich sogar live an meinem Messestand zwecks Austausch vorbei.

Das Standschild

Für das Standschild habe ich mir etwas ganz Besonderes ausgedacht: Ein Planetengetriebe! Drei bewegliche Zahnräder umkreisen hierbei ein feststehendes Sonnenrad. Um das Standschild aufhängen und das Getriebe dabei randlos behalten zu können, kam für die Planetenträger keine mittig gelagerte Achse in Frage.

Diese Aufgabe übernimmt ein durch das Sonnenrad verdecktes, durch drei Kugellager (Bild: Im 120°-Winkel angeordnet, montiert auf den Zähnen des Sonnenrads) gehaltenes Hohlrad. Es wird von einem Schrittmotor mit der Untersetzung 1:5 angetrieben. Das Hohlrad bietet Aufnahmen für die Planetenträger. So bekomme ich den mittleren Bereich des Sonnenrades frei und kann dort sowohl Antriebsmotor als auch Beleuchtung und Schildhalterungen unterbringen.

Ein auf meinem PeerTube-Kanal befindliches Video zeigt, wie ich das Standschild mit meiner CNC-Portalfräse fertige.

Herstellung Standschild

Verzögerungen

Wie immer bei solchen größeren Unternehmungen ging bei den Vorbereitungen auch einiges schief:

Ablösung des Vakuums bei der Fertigung der Spirographen

Die Spirographen wollte ich aus furniertem MDF herstellen, da das Material sehr schön anzusehen und gleichzeitig stabil genug ist, dass es auch bei rauer Behandlung keinen Schaden nimmt. Also habe ich 10mm starke mitteldichte Faserplatte mit Olivenholzfurnier beklebt (zeitraubend!) und es dann auf meiner Portalfräse beareitet.

Da ich ein Vakuumspannsystem verwende, ist es total wichtig, einen Mindestunterdruck zu erreichen, da mir sonst die Werkstücke nicht an Ort und Stelle bleiben. Nun ist MDF luftdurchlässig, sodass die Pumpe selbst bei noch nicht bearbeiteter Platte gut zu tun hat. Die Geometrie meines Entwurfs für die Spirographen ist nun leider so, dass die für das Spannen verbliebene Oberfläche bei der Bearbeitung immer weiter sinkt.

In letzter Konsequenz hatte ich das Problem, dass sich die Zahnräder spätestens bei der Kantenbearbeitung der Rückseite mitdrehen wollen. Sogar meine verzweifelten Versuche genügend Unterdruck aufrecht zu erhalten, indem ich großflächig Frischhaltefolie auf dem Werkstück aufbrachte, scheiterten.

So erhielt ich anstatt der geplanten zehn Spirographen nur vier - die Restlichen waren Ausschuss. Merke: MDF ist auf meinem Vakuumspannsystem nur für großflächige Werkstücke einsetzbar.

Problematische Zahnradpaarung beim Spirographen

Der erste Spirograph aus MDF war zudem leider gar nicht richtig zu gebrauchen: Ständig verklemmte sich ein Zahn auf der Flanke des Hohlrades und weigerte sich, in Eingriff zu gehen. Die Ursachen dafür liegen darin, dass ich kein Flankenspiel vorgesehen und die Zahnköpfe ohne Radius gefertigt hatte.

In der Folge muss das Zahnrad immer kräftig gegen das Hohlrad gedrückt werden, um den nächsten Zahneingriff zu ermöglichen. Rutscht das Zahnrad nur ein paar Zehntelmillimeter heraus, so blockiert es. Abhilfe: Sowohl Zahnrad- als auch Hohlradzahnköpfe mit r=3.0mm versehen und die Zahnradpaarung mit Flankenspiel von a=0.25mm konstruieren.

Falsch gravierte Schriften auf dem großen Standschild

Hier habe ich mich sogar zweimal vertan und damit leider viel Ausschuss produziert. Beim ersten Versuch hatte ich übersehen, das Zahnrad für die rückseitige Bearbeitung zu spiegeln. Ich dachte, das sei nicht nötig, weil das Zahnrad selbst spiegelsymmetrisch ist. Leider waren die Haltestifte aber nicht spiegelsymmetrisch eingelassen, sodass sich die Rückseite leider nicht in Deckung mit der Vorderseite befand.

Beim zweiten Versuch - siehe Video oben - hatte ich dies zwar behoben, jedoch vergessen, den Nullpunkt ensprechend der neuen Zentrierstiftlage auf der Rückseite anzupassen. Zum Glück habe ich das während der Bearbeitung bemerkt und konnte korrigieren.

Retro-PC Fensterfertigung

Bei einem der drei Retro-PCs habe ich die Gehäuserückseite um 180° gedreht aufs Maschinenbett gelegt. Das Fenster wurde also “verkehrt herum” gefräst, was ich erst nach Beendigung des Fräsjobs bemerkte. Zum Glück konnte mein Freund durch Feilen und Biegen der Rastnasen dafür sorgen, dass die Gehäuserückseite auch “verkehrt herum” am PC angebracht werden konnte.

Bei der Fertigung des letzten Fensters verhakte sich der Spanschutz im Gehäusefalz und brach, da ich die Maschine nicht rechtzeitig zum Stehen bekam. Dies konnte überhaupt nur passieren, weil sich der Spanschutz durch die Vibrationen bei der Bearbeitung lockerte. Merke: Die Fräse ist kein Spielzeug. Also keine Kompromisse machen oder halbgare Provisorien anbringen!

Die Maker Faire Ruhr 2024

Die Messe selber war super. Ich wurde sehr freundlich empfangen und seitens der DASA erhielt ich hervorragende Unterstützung beim Ausladen und aller weiterer Logistik. Auch der mir zugeteilte Stand war toll: Sehr groß, gut gelegen, mit ausreichend Steckdosen - was will man mehr.

Ich hatte eine Firma zu Besuch an meinem Stand, Familie und Freunde waren gekommen und sogar einige Leute aus den CNC-Foren sowie ein paar Arbeitskollegen waren extra angereist. Mehr kann ich mir nicht wünschen.

Aufbau

Beim Ausladen kam uns zum Glück ein Stapler zur Hilfe.

Your browser does not support the video tag.

Unloading the CNC

Alles Weitere war Handarbeit und nicht deutlich anders, als für ein Musikkonzert aufzubauen: Tische rücken, Stromleitungen legen, Lichtanlage montieren, Ausstellungsstücke aufbauen.

Besucher

Für meine erste Maker Faire kann ich eine positive Bilanz ziehen: Es waren echt viele Leute an unserem Stand und ich hatte kaum ein paar Minuten zum Ausruhen - ständig gab es etwas zu erzählen, meine Projekte vorzustellen oder über die ausgestellte Maschine zu sprechen. Aber genau das war es ja, was uns an diesem Format gereizt hat. Außerdem hat die Technik funktioniert, die Maschine lief problemlos und alle Dinge, die ich so lange vorher vorbereitet hatte (wie etwa das Standschild), konnten ausgestellt bzw. im Betrieb gezeigt werden.

Your browser does not support the video tag.

QR-Codengrave Demonstration

Was ich beim nächsten Mal trotzdem anders machen würde

Die Maker Faire ist vom Setup her keine Verkaufsmesse, sondern ein riesiges Show & Tell. Daher würde ich nicht nochmal einen kostenpflichtigen Verkaufsstand buchen, denn das hat sich in meinem Falle nicht gelohnt.
Ein bis zwei Personen mehr für die Standbetreuung wären prima. Dann könnte man sich mal ablösen.
Mehr Material für die Spirographen! Die Stifte waren am Ende der Veranstaltung komplett durch und Papier hatten wir schon Mitte des zweiten Tages keines mehr.
Mehr Vorträge / Demos. Die Fräse lief zwar schon oft, aber es mangelte dann doch an Vorlagen und Wünschen seitens der Besucher. Beim nächsten Mal werde ich mehr eigene Designs mitnehmen und auch ohne Anfrage zu Demozwecken fertigen.
Bessere Verweise auf die Internetpräsenz vorbereiten, denn ein QR-Code alleine hilft da nicht allen weiter.
Mehr Kaffee: Die Versorgung mit Heißgetränken (und jetzt wo ich es schreibe, auch die mit Nahrung) war unterdimensioniert und leider auch nicht so schmackhaft, wie ich mir das gewünscht hätte. Also besser selbst Stullen schmieren und Thermoskannen mitbringen.

Seifenbutler - jetzt erhältlich

Schallbert — Fri, 01 Mar 2024 00:00:00 +0000

März-2024 — Seifenbutler jetzt erhältlich! —

Mein Langzeitprojekt, der Seifenbutler, ist nun nach 13 Versionen endlich abgeschlossen. Ich habe eine Nullserie gefertigt und glaube, dass ich damit ein gutes Produkt geschaffen habe. Unterstützt meine Arbeit gern, indem ihr euch in Mopemasters Onlineshop ein Exemplar kauft oder weiterempfehlt!

Montage Seifenbutler

Das obige Video zeigt, wie einfach die Montage vonstatten geht. Die ganze Geschichte zum Seifenbutler erzähle ich auf der entsprechenden Projektseite. Weitere Hintergrundinformationen zu Herstellung und Preisfindung finden sich im Nullserien-Artikel.

Schallbert

Seifenbutler - Nullserie!

Schallbert — Thu, 08 Feb 2024 00:00:00 +0000

Jetzt ist mein Hardware-Projekt Seifenbutler abgeschlossen. Nach langer Entwicklungszeit habe ich einige Exemplare in weiß, schwarz, transparent und opalweiß hergestellt und sie in einem ersten Online-Shop platzieren lassen können.

Wie bestimme ich den Verkaufspreis?

Da ich hochwertige Materialien verwende und die Fertigungs- sowie Montagezeit lang ausfällt, habe ich bei der Preisgestaltung nicht so viel Luft nach unten. Andererseits kann ich für einen Gebrauchsgegenstand wie den Seifenbutler keine Mondpreise aufrufen - es sei denn, ich verwendete edle Hölzer oder andere, ausgefallene oder aufwändig zu bearbeitende Materialien. Für solche Kalkulationen gibt es eine Menge Material online. Ich habe mich dafür an einem Youtube-Video des Kanals “Cutting It Close” orientiert.

Meine Preisberechnung setzt sich aus folgenden Posten zusammen:

Endpreis = Materialpreis
 + Maschinenzeit (Investition, Verschleiß, Werkzeuge, Verbrauchsmaterialien)
 + Fertigungs- und Montagezeit 
 + Verpackungskosten 
 + Gebühren (Porto, Zahlungsdienstleister, Shops)

Wie zu erkennen ist, habe ich meine eigene Zeit für die Produktentwicklung da überhaupt nicht eingerechnet - müsste ich dies tun, so würden ganz locker noch einmal der Gegenwert zu 250h Arbeitszeit hinzukommen.

Materialpreise

Stand Ende 2023

Ok, dann listen wir mal schnell die Auslagen pro Teil auf:

Sückzahl	Artikel	Preis/Einheit	Verwendete Einheit	Endpreis
2	PMMA 5mm XT	90€/m²	0,03	2,70€
1	Rändel M4 A2 22mm	7,54€/25St	0,04	0,30€
1	Scheibe M4 A2 12mm	0,94€/100St	0,01	0,01€
1	Stift M4 A2 12mm	6,70€/50St	0,02	0,13€
5	Schraube M4 A2 8mm	12,40€/200St	0,025	0,31€
			Materialpreis/Teil	3,45€

Maschinenzeit

Die Maschinenzeit setze ich für dieses Projekt mit 100€/h an. Der Löwenanteil sind hierbei Investitions-, Wartungs-, sowie Verschleißkosten der Maschine mit 50€/h plus meiner eigenen Arbeitszeit, die ich einfach mal mit 30€/h ansetze.

Die Werkzeugkosten liegt mit ca. 15€/h recht hoch, da ich vier verschiedene Werkzeuge, allesamt mit kleinem Durchmesser und damit entsprechen hohem Verschleiß benutzen muss.

Verbrauchsmaterialien sind Vakuumvliese, Positionierstifte, Schnittschutzhandschuhe und Klebeband. Letzeres benötige ich für die Fixierung der kleinen Frästeile sowie der Spirale. Ihr Anteil an den Maschinenzeitkosten liegt bei etwa 5€/h.

Die Maschinenzeit beträgt momentan 8min/Teil. Somit beläuft sich Posten Maschinenzeit auf 13,30€/Stück.

Montagezeit

Für die Montage eines Seifenhalters benötige ich etwa 5 Minuten. Lege ich einen Stundensatz von 30€ zugrunde, so komme ich hier auf 2,50€/Stück.

Verpackungskosten und Materialeinkauf

Ich verpacke die Seifenhalter in einfache DIN A6-Briefumschläge, nachdem ich sie sorgfältig in Packpapier eingewickelt habe. Die Kosten belaufen sich hier auf lediglich 0,20€/Stück. Rechne ich nun jedoch meine Arbeitszeit für Verpackung und Versandaufkleber mit ein, liegen wir bereits bei 0,90€/Stück. Hinzu kommen Aufwendungen für Porto beim Materialeinkauf und Kosten für Papier und Druck der Bedienungsanleitung, die ich mit weiteren 0,50€/Stück berechne - hier schlagen die geringen gefertigten Mengen voll durch.

Gebühren

Gebühren fallen z.B. für Versand- und Zahlungsdienstleister an. Hier variieren die Preise je nach Anbieter, sodass ich einen Versandaufschlag von 3,50€ (Versand per Großbrief) einplane - dieser entfällt bei Verkäufen “an der Theke”.

Der Gesamtpreis

Summiere ich alle Posten zusammen, so müsste ich einen Ladenpreis von 20,15€ (bei Barzahlung) für die unverpackte Ware und 24,75€ im Versandfalle mit bargeldloser Zahlung aufrufen. Und dann wäre in der Firma noch immer kein Cent Gewinn gemacht.

Ich bin mir nicht sicher, ob sich der Seifenbutler für solche Preise verkaufen lässt. Wenn man sich aber ehrlich macht und am Ende nicht draufzahlen will, sind solche Rechnungen zumindest überschlagsweise unumgänglich.

Der angenommene Kaufmann mit Ladengeschäft

Wäre ich nun Kaufmann¹, so müsste ich noch Mehrwertsteuer aufschlagen und würde auch die Entwicklungskosten irgendwie amortisiert sehen wollen. Ich bin mir auch nicht sicher, ob ich “als Kaufmann” mit einem Stundensatz von 30€ durch die Tür käme.

Puh. Rechnet man jetzt noch Dinge wie Ladenmiete, Kosten für Lagerfläche, Werkstattmiete, Strom, Abfallentsorgung, Mitgliedschaft beim “Grünen Punkt” nach Verpackungsgesetz, Beiträge für IHK, Berufsgenossenschaft sowie Steuern und Abgaben mit ein, so muss selbst bei einem weiteren Preisaufschlag von 20% schon ein ganzer Haufen Seifenhalter verkauft werden, um am Ende nicht ärmer dazustehen als vorher!

Nehmen wir mal an, ich kann mich in eine Werkstatt einmieten und einen winzigen Laden eröffnen.

Ein fiktiver Laden

Überschlagen wir mal kurz mit ein paar angenommenen Werten:

Posten	Preis/Einheit	Verwendet	Endpreis
Laden	16€/m² u. Monat	40m²	640€
Lagerfläche	4€/m² u. Monat	8m²	32€
Werkstatt	8€/m² u. Monat	30m²	240€
Nebenkosten	pro Monat	1	200€
Abgaben	IHK / BG / Vers.	1	125€
Gebühren	20€/Monat	3	60€
		Summe	1297€
		Personal	1600€

Und würde ich in diesem Laden nun nochmal für 20h/Woche jemanden für den Verkauf anstellen, entstünden hier überschlagsweise 1600€ an Kosten.

Summa summarum

Ok, fassen wir zusammen: Ich gehe mit einem Aufschlag von 20% auf die Herstellungskosten ins Rennen. Als angenommener Kaufmann müsste ich allerdings Mehrwertsteuer abführen, die ich erneut aufzuschlagen hätte.

Ladenpreis = Herstellungspreis 
 + Deckungsbeitrag (20%)
 + Mehrwertsteuer (19%)
 = (1,2 * 20,15€) * 1,19 = 28,77€

Oha, damit liegen wir schon bei fast dreißig Euro pro Teil.

Wie viele Seifenbutler müssen also pro Monat über die Ladentheke gehen, bevor ich als Kaufmann mit Ladengeschäft Gewinn machen würde? Der Deckungsbeitrag liegt bei 4,03€ (20% des Herstellungspreises). Wenn ich jetzt die durch Produktion und Verkauf erzeugten Kosten durch diesen Betrag teile, erhalte ich meine Mindestverkaufsmenge: 719 Stück/Monat.

Wie viele Wochenstunden müsste ich nun also mindestens an meiner CNC-Fräse stehen bzw. Seifenbutler zusammenbauen und verpacken? Nehme ich die Werte von oben, so liege ich bei insgesamt 8 + 5 + 2 = 15min/Teil.

Bei der Mindestverkaufsmenge würde mir das eine Wochenarbeitszeit von etwa 45h bescheren! Ach, 60h pro Woche gehen doch auch locker, oder?! Somit könnte ich 960 Stück pro Monat herstellen - und angenommen, sie verkaufen sich hervorragend, erzielte ich 971€ extra zur Amortisation der Entwicklungskosten (Überschlag 250h*30€ = 7.500€). Knaller!

Ich würde dann mit der Unternehmung nach nur acht Monaten (mit je 60h/Woche, ist klar) in die Gewinnzone marschieren. Oh, oder muss man etwa noch Steuern entrichten? Und wann war noch gleich meine Maschine abbezahlt?

Fazit zur Wirtschaftlichkeit

Mir ist klar, dass die Rechnung nicht so einfach zu machen ist. Einige Parameter lassen sich nicht beliebig und linear hoch- oder herunterskalieren und z.B. die Maschinenkosten kann ich gar nicht realistisch abschätzen, weil mir schlicht Erfahrungswerte im Dauerbetrieb fehlen, Stichwort Abnutzung.

Dennoch genügt mir die meinerseits zu erbringende Arbeitszeit um festzuhalten:

Das wird nix. Nettes Projekt, lohnt sich aber nicht. Jedenfalls nicht aus Eigenmitteln und allein in Eigenregie. Es bleibt bei einer Nullserie und bei meiner Freude über ein gelungenes, funktionales Produkt.

Glücklicherweise ist das alles hier “nur mein Hobby”, sodass ich die desaströse Bilanz nicht gezwungen bin zu ziehen 😉

Obacht. Meine Berufung ist nicht Händler oder Kaufmann, sondern das Ingenieur-dasein. Daher habe ich nur sehr rudimentäre Kenntnis von Betriebswirtschaft (dieses eine Semester damals im Studium eben, wo niemand so recht zuhören mochte). Alle meine Ausführungen hier sind Überschlagsrechnungen. Sie sollten also mit großer Vorsicht genossen werden. Ich freue mich allerdings sehr über Korrekturzuschriften und konstruktive Kritik! ↩︎

'redir' im Caddyserver

Schallbert — Tue, 30 Jan 2024 00:00:00 +0000

Als ich meine Website weg von Github Pages auf einen eigenen Server umzog, hatte ich einige Probleme und offene Fragen bezüglich automatischer Weiterleitungen. Mein Blog ging nämlich von der root-Domain in eine Subdomain (blog.schallbert.de) über.

Anforderungen an die Weiterleitung

Bereits auf meine Blogartikel unter altem Namen referenzierte Links z.B. auf schallbert.de/about sollen korrekt auf die Subdomain weiterleiten (kein 404)
Die Stammseite unter schallbert.de soll vollständig nutzbar sein
Daten und Dateien für Domain und Subdomains sollen unabhängig voneinander sein
Die Webserver sollen für verschiedene Unterseiten unterschiedliche Technologien verwenden können

Umsetzung

Zuerst hatte ich gedacht, dass ich die Weiterleitungen im DNS-provider über A und CNAME Einträge erreichen könnte. Schnell wurde mir jedoch klar, dass ich a) keine Ahnung hatte, wie DNS überhaupt funktioniert und b) der richtige Weg über die Konfiguration meines Webservers führt.

Erster Versuch: redir bei ‘/’

Auf meinem Webserver (Caddy) werden Weiterleitungen in der Caddyfile per redir spezifiziert. Dabei kann das permanent (als sogenannte http 301) oder temporary per 302 (Standardeinstellung) geschehen.

Mein erster Gedanke war, dass ich schallbert.de unmodifiziert lasse und alles hinter einem eventuellen / weiterleite. Dies sieht dann in der Caddyfile wie folgt aus:

schallbert.de {
 # Define webserver
 root * /www/landing
 encode gzip
 file_server

 # Redir to subdomain if domain has a slash
 @redirect path_regexp /*
 redir @redirect https://blog.schallbert.de{uri}
}

In der Folge hat Caddy schlicht alles an die Subdomain weitergeleitet. Der Haken dabei war, dass die Subdomain selbst ja auch wieder Slashes bzw. eine URI hinter dem Slash enthält und dann wiederum weitergeleitet wird. Beispiel:

schallbert.de/post -> blog.schallbert.de/post -> blog.schallbert.de/post -> blog.schallbert.de/post -> [...]

Somit bekam ich eine rekursive Endlosweiterleitung. Ich habe meinen Server damit komplett lahmgelegt 😅

Zweiter Versuch: Filterung per Regexp

Ich brauche also eine bessere Filterung, sodass nur Slashes mit weiteren Zeichen dahinter auch wirklich weitergeleitet werden und die Weiterleitung nicht rekursiv ablaufen kann. Zum Glück hatte ich Hilfe von einem guten Freund, sodass kurze Zeit darauf folgendes Caddyfile entstand:

schallbert.de {
 # Define webserver
 root * /www/landing
 encode gzip
 file_server

 # Redir to subdomain to maintain links for blog
 @redirect path_regexp ^/[^/]+(/.*)?$
 redir @redirect https://blog.schallbert.de{uri}
}

Die Regexp prüft ab, ob ein Slash hinter der Domain URL vorliegt und dahinter zumindest ein weiteres Zeichen folgt. Hier funktioniert die Weiterleitung nun wie gewünscht und mein Blog ist auch unter den alten Links weiterhin vollständig erreichbar.

Trotzdem war ich noch nicht ganz zufrieden. Denn als ich mir eine schöne “Landing Page” auf meiner Root Domain erstellte, war von ihr plötzlich nur noch das reine HTML zu sehen. Kein favicon, keine Bilder, kein CSS.

Ein kurzer Blick in die Entwickleroptionen brachte schnell die Erkenntnis dass die Pfade aller Assets, die ich auf meiner Landing Page hinterlegt hatte, durch die Ordnerstruktur mit / gekennzeichnet, an die Subdomain weitergeleitet wurden. Wo sie natürlich nicht liegen.

Dritter Versuch: Regexp plus Dateisuche

Zum Glück bin ich wieder mal mit dem Problem nicht allein, sodass im Forum von Caddy die Lösung zu finden war:

Mit dem not file Marker kann ich in der Caddyfile Weiterleitungen definieren, falls Ressourcen auf der aktuellen Seite unauffindbar sind.

Somit sieht meine Lösung jetzt wie folgt aus:

schallbert.de {
 @filenotfound {
 path_regexp ^/[^/]+(/.*)?$
 not file
 }

 # show Caddy where to find page resources
 root * /www/landing
 encode gzip

 route {
 # Redirect to subdomain if article cannot found on root
 redir @filenotfound https://blog.schallbert.de{uri}

 # else, define webserver and show page
 file_server
 }
}

Hier ist wichtig, dass ich die Seite mit root * /www/<pagelocation> definiere, bevor ich die route anlege. Denn sonst werden die Assets erst verfügbar, nachdem ich bereits aus Ermangelung vorhandener Dateien weitergeleitet habe.

Erfolg!

Jetzt endlich wird meine Baustellenseite korrekt dargestellt.

Automatische Updates für alles!

Schallbert — Sat, 20 Jan 2024 00:00:00 +0000

Wie der Titel schon sagt, möchte ich Sicherheitsupdates gern installiert haben, sobald sie erscheinen. Dies gilt gleichsam für das Ubuntu meines Cloud-Servers wie auch für alle Applikationen, die ich in Docker betreibe. Da ich faul bin, möchte ich diese Sicherheitsupdates nicht manuell vornehmen, sondern vollautomatisch ablaufen lassen.

Für Funktionsupdates und -Erweiterungen hingegen ist es auch weiterhin OK für mich, von Zeit zu Zeit manuell einzugreifen. Beginnen wir also mit den Systemupgrades.

Sicherheitsupdates per `unattended-upgrades`

Ubuntu stellt - wie eine kurze Suchmaschinenabfrage ergibt - bereits ein konfigurierbares Werkzeug für solche automatisierten Updates zur Verfügung: unattended-upgrades. Ich prüfe zuerst, ob es bereits auf meinem System vorhanden ist:

Installation

schallbert:~# which unattended-upgrades
/usr/bin/unattended-upgrades

Prima, es ist bereits da. Ansonsten hätte ich die Installation schnell mit apt install unattended-upgrades nachgeholt.

unattended-upgrades konfigurieren

Hier hilft das Debian Wiki weiter: Die Konfigurationsdateien liegen in /etc/apt/apt.conf.d.

Zuerst gehe ich sicher, dass automatische Updates aktiviert sind. Hierfür prüfe ich die Datei 20auto-upgrades und stelle sicher, dass Paketindex-Updates und Upgradeinstallation aktiviert sind:

APT::Periodic::Update-Package-Lists "1";
APT::Periodic::Unattended-Upgrade "1";

Sehr gut. Jetzt sollte ich noch festlegen, zu welchem Zeitpunkt das Tool loslaufen und welcher Typ Updates installiert werden soll. Hierfür öffne ich die Datei 50unattended-upgrades und entferne die Kommentare bei den entsprechenden Zeilen.

Updatequellen festlegen

Der erste Abschnitt der Konfigurationsdatei widmet sich der erlaubten Quellen für die Updates. Hier sollten selbstverständlich nur vertrauenswürdige Provider stehen. Meine Konfig sieht hier wie folgt aus:

Unattended-Upgrade::Allowed-Origins {
 "${distro_id}:${distro_codename}";
 "${distro_id}:${distro_codename}-security";
 "${distro_id}ESMApps:${distro_codename}-apps-security";
 "${distro_id}ESM:${distro_codename}-infra-security";
};

Erlaubt werden hier Quellen für die von mir verwendete Linux-Distribution im Allgemeinen und Sicherheitsupdates inklusive ESM, was für “Extended Security Maintenance” steht.

Updates auch für Dev Releases?

Die folgende Zeile legt fest, ob auch Vorabversionen von Ubuntu Updates erhalten sollen. Bei mir steht der Wert auf auto.

Unattended-Upgrade::DevRelease "auto";

Automatischer Neustart

Einige Sicherheitsupdates (z.B. den Kernel betreffend) erfordern einen Neustart der Maschine. Sie werden daher nur in Kraft treten, wenn man in der Datei entsprechende Werte gesetzt hat. Dabei ist WithUsers natürlich Geschmackssache, denn man wird ausgeloggt, falls zufälligerweise gerade ein Update installiert wurde, was einen Neustart erfordert. Um das praktisch auszuschließen, habe ich unter Reboot-Time eine Zeit eingetragen, bei der ich sicher nicht an der Maschine hocke.

Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-WithUsers "true";
Unattended-Upgrade::Automatic-Reboot-Time "03:45";

Unangekündigte Neustarts haben natürlich Rückwirkung auf alle Programme, die ich verwende. Daher stelle ich in meinen docker-compose.yml Dateien sicher, dass dort bei restart: auch wirklich always oder unless-stopped notiert ist.

Benachrichtigungen

Automatische Mails oder anderweitige Push-Benachrichtigungen habe ich erst einmal nicht eingeschaltet, da ich mich noch im Testbetrieb befinde und keine große Lust auf einen Haufen weiterer Nachrichten habe. Sobald ich dies ändere, gibt es hier ganz bestimmt ein Update.

Funktionsprüfung

Um zu sehen, ob unattended-upgrades tut was es soll, schaue ich ein paar Tage später mal in die Logs unter /var/log/unattended-upgrades. Hier steht in der Datei unattended-upgrades.log zum Beispiel folgendes:

# [...]
2024-01-12 06:17:59,781 INFO Starting unattended upgrades script
2024-01-12 06:17:59,781 INFO Allowed origins are: o=Ubuntu,a=jammy, o=Ubuntu,a=jammy-security, o=UbuntuESMApps,a=jammy-apps-security, o>
2024-01-12 06:17:59,781 INFO Initial blacklist:
2024-01-12 06:17:59,782 INFO Initial whitelist (not strict):
2024-01-12 06:14:33,956 INFO Packages that will be upgraded: libc-bin libc-dev-bin libc-devtools libc6 libc6-dev locales python3-twisted
2024-01-12 06:14:33,956 INFO Writing dpkg log to /var/log/unattended-upgrades/unattended-upgrades-dpkg.log
2024-01-12 06:14:54,578 INFO All upgrades installed
# [...]

Die Datei unattended-upgrades-shutdown.log ist allerdings noch leer. Ich werde zu einem späteren Zeitpunkt prüfen, ob hier auch alles funktioniert.

Container-Updates mit `Watchtower` automatisieren

Nun zu den Updates meiner Applikationen. Ein kurzes Gespräch mit ein paar Admins ergab:

Es ist mühsam, alle Programme von Hand auf Stand zu halten
Für Anwendungen im Container gibt es Dienste, die diese Aufgabe zentral lösen
Es gab bereits schlechte Erfahrungen, wenn in der docker-compose.yml auf den aktuellsten Release referenziert wird
Bei image: <application>:latest seien hier nicht alle Anwendungen stabil bzw. erzeugten Probleme mit Abhängigkeiten

Einer Lösung für dieses Problem bietet Watchtower, welches in meinem Falle selbst wieder in einem Container läuft.

Installation

Wie üblich schreibe ich mir in einem neuen Ordner unter opt/watchtower eine docker-compose.yml:

# copied from https://containrrr.dev/watchtower/notifications/

# watchtower/docker-compose.yml
version: "3"
services:
 watchtower:
 image: containrrr/watchtower
 restart: unless-stopped
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock

Watchtower benötigt docker.sock, um die Updates zu ziehen und auf den vorhandenen Containern anzuwenden. Ansonsten habe ich hier erst einmal nichts weiter unternommen. Keine Benachrichtigungen (aus obengenannten Gründen), keine Logs, nichts. Ich hoffe, dieses Setup bleibt geräuschlos und ich muss mich hier lange nicht mit einem Update zu Wort melden.

Weitergehende Schritte für die Validierung der Funktion von Watchtower finden sich z.B. in einem Tutorial von DigitalOcean.

Ablauf

Watchtower prüft die Installierten Docker images lt. Doku täglich auf Updates. Sollte des ein neues Image-release geben, schickt Watchtower ein SIGTERM-Signal an upzudatende Container, worauf sich selbige herunterfahren (Quelle). Anschließend werden die Container wieder hochgefahren.

Unfreiwillige Funktionsprüfung

Ein paar Tage nach Start des Containers wählte ich mich nochmal in meinen Server ein und sah auf gut Glück ein paar Logs durch. Ich wollte nur kurz nach dem Rechten schauen.

In den fail2ban Logdateien sah ich zu einem bestimmten Zeitpunkt, Uhrzeit 14:42:56 plötzlich seitenweise Einträge. Mehr davon, als ich die Tage vorher insgesamt gesehen hatte. Als ich zum Beginn dieser Kette von Einträgen hochscrollte, sah ich, dass fail2ban mir wohl kurz ausgestiegen war.

 2024-01-26 14:42:50,817 <container_id> INFO Shutdown in progress...
 2024-01-26 14:42:50,817 <container_id> INFO Observer stop ... try to end queue 5 seconds
 2024-01-26 14:42:50,837 <daemon_id> INFO Observer stopped, 0 events remaining.
 2024-01-26 14:42:50,878 <container_id> INFO Stopping all jails
 2024-01-26 14:42:50,879 <container_id> INFO Removed logfile: '/var/log/auth.log'
 2024-01-26 14:42:50,879 <container_id> INFO Removed logfile: '/var/log/caddy2/gitea_access.log'
 2024-01-26 14:42:50,879 <container_id> INFO Removed logfile: '/var/log/caddy2/server_access.log'
 2024-01-26 14:42:51,052 <daemon_id> NOTIC [sshd] Flush ticket(s) with iptables
 2024-01-26 14:42:51,063 <container_id> INFO Jail 'sshd' stopped
 2024-01-26 14:42:51,137 <daemon_id> NOTIC [caddy-status] Flush ticket(s) with iptables-multiport
 2024-01-26 14:42:51,137 <container_id> INFO Jail 'caddy-status' stopped
 2024-01-26 14:42:51,138 <container_id> INFO Connection to database closed.
 2024-01-26 14:42:51,139 <container_id> INFO Exiting Fail2ban
 2024-01-26 14:42:56,173 <new_container_id> INFO --------------------------------------------------
 2024-01-26 14:42:56,173 <new_container_id> INFO Starting Fail2ban v1.0.2
 2024-01-26 14:42:56,173 <new_container_id> INFO Observer start...
[...]

Die ganzen Log-Einträge zur selben Uhrzeit beginnen am Ende des oben gezeigten Abschnitts. Ein ganzer Haufen IP-Adressen wird dort zur Vorbereitung des Banns in Fail2ban geladen. Leicht beunruhigt schaute ich ins Syslog von Ubuntu:

Jan 26 14:42:55 schallbert systemd[1]: docker-<ID>.scope: Deactivated successful
Jan 26 14:42:55 schallbert systemd[1]: docker-<ID>.scope: Consumed 21:05 CPU time
Jan 26 14:42:55 schallbert dockerd[690]: time="2024-01-26T14:42:55.228607617Z" level=info msg="ignoring event" 
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.229864632Z" level=info msg="shim disconnected" 
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.230125409Z" level=warning msg="cleaning up after shim disconnected" i>
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.230145478Z" level=info msg="cleaning up dead shim"
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.240586557Z" level=warning msg="cleanup warnings time=\"2024-01-26T14:>
Jan 26 14:42:55 schallbert dockerd[690]: time="2024-01-26T14:42:55.241839655Z" level=warning msg="ShouldRestart failed
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.870912387Z" level=info msg="loading plugin \"io.containerd.event.v1.p>
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.870997689Z" level=info msg="loading plugin \"io.containerd.internal.v>
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.871007368Z" level=info msg="loading plugin \"io.containerd.ttrpc.v1.t>
Jan 26 14:42:55 schallbert containerd[639]: time="2024-01-26T14:42:55.871150831Z" level=info msg="starting signal loop" namespace=moby path>

Hm, cleaning up dead shim. Das klingt ja bedrohlich. Eine kurze Recherche zeigt, dass die Shim eine Zwischenschicht zwischen Containermanager und dem Container selbst bildet und Ein-und Ausgaben des Containers weiterleitet. Ihre Laufzeit ist an die des Containers gekoppelt.

Also war dies ein normales Herunterfahren mit anschließendem Neustart. Zum Glück kein Einbruch! Bleibt nur noch der Grund für den Neustart von Fail2ban herauszufinden. Da fällt mir ein, dass ich noch gar nicht weiß, wann Watchtower genau die Updates fährt…

Also mal schnell in die Logs von Watchtower geschaut mit docker container logs <container_id> und siehe da:

time="2024-01-26T14:42:47Z" level=info msg="Found new lscr.io/linuxserver/fail2ban:latest image (9bda077d765e)"
time="2024-01-26T14:42:50Z" level=info msg="Stopping /fail2ban (e0317a105d53) with SIGTERM"
time="2024-01-26T14:42:55Z" level=info msg="Creating /fail2ban"
time="2024-01-26T14:42:55Z" level=info msg="Session done" Failed=0 Scanned=6 Updated=1 notify=no

Damit habe ich den Beweis: Watchtower tut was es soll. Es zieht Container auf eine neue Version hoch, sobald Updates verfügbar werden. Prima!

PS: Da ich Watchtower nicht groß konfiguriert habe, nehme ich anhand der in den Logs befindlichen Zeitstempel an, dass die Updates täglich zur Zeit des Starts von Watchtower gefahren werden. Bald werde ich von latest für meine Container wohl auf ein älteres Tag release umschwenken.

Den Server absichern

Schallbert — Fri, 12 Jan 2024 00:00:00 +0000

Motivation

OK. Nun läuft mein Server, baut automatisch meinen Blog und zeigt ihn auch problemlos an. So ganz fertig bin ich aber noch nicht. Denn ich könnte mehr für die Sicherheit des Servers tun, als überall Passwort-Logins zu deaktivieren.

Außerdem habe ich noch keine Backups. Und das ist ja nie gut. Also, packen wir’s an!

Unerwünschte Besucher aussperren

Ich bekomme in meinem SSH-Log im Root-Account des Servers einen Haufen Verbindungsversuche, die nicht von mir kommen:

[...]
Jan 11 00:19:29 sshd[93842]: Invalid user admin from 41.207.248.204 port 37194
Jan 11 00:19:29 sshd[93842]: pam_unix(sshd:auth): check pass; user unknown
Jan 11 00:19:29 sshd[93842]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ru>
Jan 11 00:19:31 sshd[93842]: Failed password for invalid user admin from 41.207.248.204 port 37194 ssh2
Jan 11 00:19:32 sshd[93842]: Connection closed by invalid user admin 41.207.248.204 port 37194 [preauth]
Jan 11 00:20:14 sshd[93886]: Invalid user svn from 84.108.40.27 port 44968
Jan 11 00:20:14 sshd[93886]: pam_unix(sshd:auth): check pass; user unknown
Jan 11 00:20:14 sshd[93886]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ru>
Jan 11 00:20:16 sshd[93886]: Failed password for invalid user svn from 84.108.40.27 port 44968 ssh2
Jan 11 00:20:16 sshd[93886]: Received disconnect from 84.108.40.27 port 44968:11: Bye Bye [preauth]
Jan 11 00:20:16 sshd[93886]: Disconnected from invalid user svn 84.108.40.27 port 44968 [preauth]
[...]

Wenn ich nicht wüsste, dass dies das inzwischen übliche “Rauschen” im Internet ist, würde es mich schon etwas beunruhigen. Ist ja fast so, als würde alle paar Sekunden jemand mit bösen Absichten versuchen, irgendeinen Schlüssel an meiner Haustür auszuprobieren. Was kann man dagegen also tun? Wegschicken!

fail2ban

Genau dies soll die Software fail2ban für mich übernehmen.

 __ _ _ ___ _ 
 / _|__ _(_) |_ ) |__ __ _ _ _ 
 | _/ _` | | |/ /| '_ \/ _` | ' \ 
 |_| \__,_|_|_/___|_.__/\__,_|_||_|
 v1.1.0.dev1 20??/??/??

Vereinfacht gesagt durchforstet fail2ban Zugriffslogs¹ nach IP-Adressen, für die fehlgeschlagene Anmeldeversuche registriert wurden, und “bannt” sie bei Überschreiten einer benutzerdefinierten Anzahl Versuche innerhalb einer bestimmten Zeit für einen gewünschten Zeitraum.

Wie dieser Bannspruch umgesetzt wird? Fail2ban modifiziert die iptables, greift also auf Paketfilterregeln zu (Stichwort Firewall), welche sich unten auf der Netzwerkschicht befinden. So werden hereinkommende Anfragen bereits geblockter Adressen gar nicht erst bis zu meinen Applikationen durchkommen².

fail2ban installieren

fail2ban scheint so etwas wie Industriestandard bei der Abwehr unerwünschter Zugriffsversuche auf Linux zu sein. Jedem Hobby- und Profiadmin den ich kenne war das Programm geläufig. Ich erntete für meine Unwissenheit des Öfteren ein müdes Lächeln.

Zu Installation und Konfiguration gibt es bereits einen Haufen Anleitungen da draußen plus der (sehr gut geschriebenen), die im Repo von Fail2ban gleich mitgeliefert wird. Daher gehe ich nicht besonders tief hierauf ein.

Ich entschied mich für die Installation im Docker-Container, damit ich die üblichen Abhängigkeiten gleich mitgeliefert bekomme. Dafür verwende ich die open-source Distribution von linuxserver und verfasse die folgende docker-compose.yml:

# /fail2ban/docker-compose.yml
version: "2.1"
services:
 fail2ban:
 image: lscr.io/linuxserver/fail2ban:latest
 container_name: fail2ban
 cap_add:
 - NET_ADMIN
 - NET_RAW
 network_mode: host
 environment:
 - PUID=1000
 - PGID=1000
 - TZ=Etc/UTC
 - VERBOSITY=-vv #optional
 volumes:
 - ./config:/config
 - /var/log/auth.log:/var/log/auth.log:ro # host ssh
 - /var/log/caddy2:/var/log/caddy2:ro  # gitea via caddy, caddyserver
 restart: unless-stopped

Das Einzige, was hier zu beachten gilt: fail2ban benötigt die Access logs per Volume zur Verfügung gestellt (oben als :ro nur mit Lesezugriff angegeben). Eine Menge Filterregeln liegen bereits vorkonfiguriert im config-Ordner, daher muss ich nur die jail.local nach linuxserver/fail2ban-confs sowie filter.d für Caddy nach muetsch.io anpassen und schon habe ich einen automatischen Türwächter.

fail2ban Beispiel

So sieht ein fail2ban-Log nun für meinen SSH-Daemon aus:

# schallbert:/opt/fail2ban/config/log/fail2ban# grep "220.124.89.47" fail2ban.log 
 2024-01-11 17:12:20,600 7FBB3630BB38 INFO [sshd] Found 220.124.89.47 - 2024-01-11 17:12:20
 2024-01-11 17:12:23,003 7FBB3630BB38 INFO [sshd] Found 220.124.89.47 - 2024-01-11 17:12:22
 2024-01-11 17:12:25,205 7FBB3630BB38 INFO [sshd] Found 220.124.89.47 - 2024-01-11 17:12:24
 2024-01-11 17:12:27,206 7FBB3630BB38 INFO [sshd] Found 220.124.89.47 - 2024-01-11 17:12:26
 2024-01-11 17:12:32,610 7FBB3630BB38 INFO [sshd] Found 220.124.89.47 - 2024-01-11 17:12:32
 2024-01-11 17:12:33,045 7FBB36104B38 NOTIC [sshd] Ban 220.124.89.47

Und tschüss!

Was (noch) nicht funktioniert: Gitea & fail2ban

Ich bekomme auch auf meiner Gitea-Instanz ssh-Anfragen rein, die ich ebenfalls gern wegblocken möchte. Allerdings kann ich Gitea bis jetzt partout nicht dazu bekommen, die Logs dafür auch in eine Datei zu schreiben. Bis jetzt werden die stets an die Konsole geschickt, wo ich sie fail2ban natürlich nicht zuführen kann und möchte. Tatsächlich wird die Verbindung zu Gitea per SSH zum Glück bereits gesichert, da sie über denselben sshd geht wie der Shell-Zugriff auf meinen Server selbst.

Was mir noch fehlt sind nur die Überwachung fehlgeschlagener Logins auf dem Web-Frontend.

Dabei sieht Giteas app.ini für mich sauber aus:

# gitea/conf/app.ini
#[...]
[log]
MODE = file
LEVEL = warn
ROOT_PATH = /data/gitea/log
ENABLE_ACCESS_LOGS = true
ENABLE_SSH_LOG = true
logger.access.MODE = access-file

[log.access-file]
MODE = file
ACCESS = file
LEVEL = info
FILE_NAME = access.log
[...]

Ich habe sowohl die Access-Logs aktiviert ENABLE_ACCESS_LOGS und den Access-Logger in eine Datei schreiben lassen. Die Logs werden auch erstellt, nur sind da keine Zugriffe drin aufgelistet - diese gehen nach wie vor in die Konsole des Containers. Ich bin mir aber noch unsicher, ob der Reverse-Proxy von Caddy hier vielleicht einen Einfluss hat und er zum Beispiel die Zugriffe vor Gitea bereits abfängt. Aber das finde ich schon irgendwann noch heraus.

Update Aug-2024

Irgendwann fragte ich mich, ob fail2ban auch tatsächlich auf den iptables meines Servers arbeitet oder nur innerhalb des Containers korrekt funktioniert. Zum Glück war ich nicht der Erste mit dieser Frage (stackoverflow) und fand die vorgeschlagene Lösung ganz charmant:

im Docker-Container eine beliebige IP sperren (docker exec -it fail2ban sh): fail2ban-client set sshd banip 111.111.111.111
In den iptables nachsehen, ob diese IP dort auftaucht: iptables -n -L --line-numbers
In meinem Falle: freuen, denn sie ist da: 1 REJECT all -- 111.111.111.111
Die IP wieder entsperren fail2ban-client set sshd unbanip 111.111.111.111

Update Jul-2025

Ich habe jetzt eine Lösung für Gitea, aber auch alle anderen meiner Websites zustande gebracht:

Schutz vor Brute-Force Angriffen per ssh wie oben beschrieben
Schutz vor Überlast mittels Rate Limiter
Schutz vor Angriffen auf die APIs (404/403 Attacken) mittels caddy-status Konfiguration für fail2ban, Logs in JSON

# /config/fail2ban/filter.d/caddy-status.conf

# this regex works for caddy with json-style logs
failregex = "client_ip":"<HOST>"(.*)"status":(400|401|403|404|500)
datepattern = \d+
ignoreregex =

Regelmäßige Backups

Ein wichtiger Aspekt für mich ist die Möglichkeit, den Server wiederherstellen zu können. Sollten unvorhergesehene Ereignisse eintreten wie ein Update einer Komponente welches die Funktion anderer Programme beeinträchtigt, der Ausfall des Servers, oder sogar der Zugriff fremder Personen auf selbigen - in jedem Falle könnte ich mit einem Backup recht schnell eine neue Instanz des Servers erzeugen, konfigurieren und die Website wieder zum Laufen bringen.

Diese Updates möchte ich aber ungern selbst von Hand aus meinen Ordnern erzeugen, komprimieren und per SCP / SFTP herunterladen. Besser soll das vollautomatisch vonstatten gehen, und das im Optimalfall noch kostenfrei. Nach einer kurzen Recherche stellen sich für meine Zwecke die quelloffenen Werkzeuge borgmatic und restic als geeignet heraus.

Ich entscheide mich willkürlich für Borgmatic.

Borgmatic in Docker installieren

Wie bei allen anderen Komponenten auch, möchte ich Borgmatic in einem Container laufen lassen. Glücklicherweise gibt es da bereits eine fertige Lösung, die ich nur noch ein wenig konfigurieren muss.

Mein docker-compose File für Borgmatic sieht wie folgt aus:

# /borgmatic/docker-compose.yml
version: '3'
services:
 borgmatic:
 image: ghcr.io/borgmatic-collective/borgmatic
 container_name: borgmatic
 volumes:
 - ${VOLUME_SOURCE}:/mnt/source:ro  # backup source
 - ${VOLUME_TARGET}:/mnt/repository  # backup target
 - ${VOLUME_ETC_BORGMATIC}:/etc/borgmatic.d/  # borgmatic config file(s) + crontab.txt
 - ${VOLUME_BORG_CONFIG}:/root/.config/borg  # config and keyfiles
 - ${VOLUME_SSH}:/root/.ssh  # ssh key for remote repositories
 - ${VOLUME_BORG_CACHE}:/root/.cache/borg  # checksums used for deduplication
 # - /var/run/docker.sock:/var/run/docker.sock # add docker sock so borgmatic can start/stop containers to be backupped
 environment:
 - TZ=${TZ}
 - BORG_PASSPHRASE=${BORG_PASSPHRASE}
 restart: always

Als Inspiration hierfür habe ich reichlich in der Dokumentation auf Github gestöbert.

Borgmatic konfigurieren

Alle konkreten Daten (die Angaben in ${}) habe ich zur besseren Übersichtlichkeit in einer .env-Datei im selben Verzeichnis abgelegt. Ganz nebenbei verhindere ich, aus Versehen Passphrases zu veröffentlichen. Diese Passphrase habe ich mir zusätzlich auf einem Zettel notiert - man weiß ja nie, ob man sie nochmal benötigt.

Ich muss anschließend nur noch die sich in dem Ordner borgmatic.d/ befindliche config.yml leicht verändern, indem ich Backup-Quelle, -Ziel und die von mir gewünschten Zeitintervalle für die Sicherungserstellung eintrug und war quasi schon bereit für einen ersten Test.

Borgmatic Funktionstest

docker exec borgmatic bash -c \
"cd && borgmatic --stats -v 1 --files 2>&1"

Mit diesem Befehl führe ich über Docker im Container borgmatic den Befehl zum Anlegen einer Sicherung an, um die Funktion von Borgmatic zu verifizieren.

Hier kam dann direkt eine Fehlermeldung à la repository does not exist zurück. Also existiert das Backup-Ziel noch gar nicht. Ein kurzer Blick in die Dokumentation zeigt, dass das Repository erst initialisiert werden muss.

Dies hole ich mit dem Kommando

docker exec borgmatic bash -c \
"borgmatic init --encryption repokey-blake2"

nach, was mit ein “leeres”, verschlüsseltes Repository anlegt. Versuche ich erneut, ein Backup zu erzeugen, läuft Borgmatic nun durch und erzeugt mir das Backup im Repository.

Ein Backup ist nur ein Backup…

…wenn man es einspielen kann, sagt mein Kumpel.

Er hat Recht, aber so richtig traue ich mich nicht, über meine funktionierende Serverkonfiguration drüberzubügeln. Also erstelle ich mir eine docker-compose.restore.yml Datei nach Vorbild auf dem Repository und ziehe modem7s Anleitung zum Thema hinzu.

Tatsächlich kann ich durch Ausführen der docker-compose.restore.yml dann in der Container-Shell folgende Kommandos ausführen:

mkdir backuprestoremount
borg mount /mnt/repository /backuprestoremount

mkdir backuprestore
borgmatic extract --archive latest --destination /backuprestore

Hier erstelle ich den Ordner backuprestoremount und lasse ihn von borg auf mein Backup zeigen. Anschließend extrahiere ich das Backup in den ebenfalls neu erstellten Ordner backuprestore.

Nun prüfe ich, ob auch “alles da ist”:

# cd /mnt/backuprestore
# /restore/mnt/source ls
borgmatic caddy2 containerd fail2ban gitea hostedtoolcache watchtower

Yeah, alle Applikationen sind vorhanden und die enthaltenen Daten sind gesichert! Weiter gehe ich jetzt mal nicht, denn ich bin zu feige (und zu faul), die auf dem Server unter /opt befindlichen Container zu überschreiben.

Was (noch) nicht funktioniert: Borgmatic & docker-compose down

Borgmatic bietet eine einfache Möglichkeit in der Konfigurationsdatei, Aktionen vor- und nach dem Backup auszuführen.

Da ich die Konsistenz der Datenbanken meiner zu sichernden Container sicherstellen möchte, sollten die Container zum Zeitpunkt des Backups heruntergefahren sein. Daher schrieb ich mir ein Skript, was alle Applikationen vor dem Backup per docker compose down stoppt und nach dem Backup wieder hochfährt.

Dies würde auch alles prima funktionieren, wenn Borgmatic nicht selbst in einem Container liefe. Durch die Kapselung bin ich nun nicht in der Lage, die im Stamm-Dateisystem der Maschine befindlichen Skripte auszuführen. Kurzzeitig dachte ich, dass ich dies mittels Durchreichung von var/run/docker.sock in den Borgmatic-Container umgehen könne, scheiterte dann aber an der Ankopplung an Docker compose.

Ich bin mir sicher, dass das zu lösen ist. Allerdings habe ich gerade dringendere Themen. Daher begnüge ich mich mit der Annahme, dass schon nichts passiert, wenn ich das Backup nachts ziehe³.

Auch bei den Auto-Backups scheint es noch zu haken:

/ # borgmatic --stats
Starting a backup job.
Failed to create/acquire the lock /mnt/repository/lock (timeout).
local: Error running actions for repository
Command 'borg create --stats /mnt/repository::{hostname}-{now:%Y-%m-%dT%H:%M:%S.%f} /etc/borgmatic.d/config.yml /mnt/source /root/.borgmatic' returned non-zero exit status 2.
Error while creating a backup.
/etc/borgmatic.d/config.yml: An error occurred

Dies entnehme ich der über Docker aufgerufenen Log-Konsole von Borgmatic. Ich muss also beizeiten nochmal um meine Backups kümmern.

Beim SSH-Daemon meines Servers liegen die Zugriffslogs z.B. in /var/log/auth.log, können aber auch als access.log oder ähnlich abgelegt werden. Auch von mir verwendete Dienste wie Gitea und Caddy legen solche Logdateien an. ↩︎
Was ich allerdings noch nicht verstehe ist, wie fail2ban im Container laufend überhaupt an die iptables herankommt. Ich dachte, dass ein positiver Nebeneffekt der Containerisierung in der Kapselung liegt. Oder ist sie nur bei “rootless”-Containern zu erreichen? ↩︎
Hintergrund: Ich bin zur Zeit der Einzige, der Inhalte auf gitea hochlädt. Meine Webseite ist statisch. Auf dem Webserver caddy ändern sich also nur dann Dateien, wenn ich sie über Gitea hochlade. Programmupdates über watchtower und unattended-upgrades (Thema eines weiteren Artikels) habe ich so gelegt, dass sie nicht während des Durchlaufs von borgmatic stattfindet. Einzig die Logs, welche bei fail2ban aufschlagen, werden auch zur Zeit der Erstellung des Backups geschrieben. Das Risiko des Datenverlustes gehe ich an der Stelle bewusst aber ein, da die Paketfilterung für geblockte IP-Adressen durch fail2ban nach einer von mir bestimmten Zeit sowieso wieder aufgehoben wird. ↩︎

Jekyll build: defekte relative Links

Schallbert — Fri, 29 Dec 2023 00:00:00 +0000

Das Problem

Jetzt bin ich nach ewigem Probieren nun endlich in der Lage, meinem Caddyserver die gebauten Dateien per Docker-Volume zur Verfügung zu stellen. Leider sieht die Seite aber wie folgt aus:

Die Analyse

Zuerst hatte ich den Webserver in Verdacht. Wenn ich die Website aber testweise in meinem Browser aufrufe¹, zeigt sich dasselbe Verhalten. Merkwürdig.

Offensichtlich fehlen sämtliche Stylesheets. Sieht man genau hin, sind aber auch Bilder und andere Medien nicht geladen worden, sondern lediglich ihre Beschreibung. Dann klicke ich wild auf ein paar Links zu Artikeln und Unterseiten. Dabei fällt auf, dass die Pfade anders aussehen, als ich erwartet hätte:

# --- Erwartung ---
# Bilddatei
/assets/images/test.jpg
# Artikel
/this-is-a-post

Stattdessen sehe ich:

# --- Beobachtung ---
# Bilddatei
/pages/<username>/<repositoryname>/assets/images/test.jpg
# Artikel
/pages/<username>/<repositoryname>/this-is-a-post

Dies zeigen auch die mit F12 zugeschalteten Entwickleroptionen des Browsers (siehe Bild oben): sämtliche per relativen Link eingebundene Quellen können nicht geladen werden. Übrigens ist es im Allgemeinen eine klare Empfehlung, die Entwickleroptionen bei Problemen mit der Darstellung von Webseiten aktiviert zu haben.

Liegt ja irgendwie nahe, dass meine Jekyll-Konfigurationsdatei _config.yml oder meine Übersetzungsheader i10.yml Fehler enthalten. Dafür gibt es zum Glück bereits hervorragende Hilfeseiten.

Ein Test zeigt jedoch schnell, dass ich die Angabe repository, woher der Build <username>/<repositoryname> herbezieht, nicht einfach leer lassen kann:

# bundle exec jekyll serve
Generating... 
 Jekyll Feed: Generating feed for posts
 Liquid Exception: No repo name found. 
 Specify using PAGES_REPO_NWO environment variables, 'repository' in your configuration, 
 or set up an 'origin' git remote pointing to your github.com repository. in /_layouts/default.html
 ERROR: YOUR SITE COULD NOT BE BUILT

Und, verflixt, wo kommt der Unterordner /pages plötzlich her?

Die Lösung

Durch das /pages im Pfad liegt die Vermutung nahe, dass die Ursache in einer Kombination aus Jekyll-Bauoptionen und dem Github-Pages Gem zu finden ist.

Natürlich bin ich mit diesem Problem nicht allein, und nach längerer Recherche finde ich tatsächlich eine Dokumentation der Lösung.

Also ändere ich die Umgebungsvariable JEKYLL_ENV (steht für die Bauumgebung) von production auf development, so wie es normalerweise für das lokale Bauen vorgesehen ist.

# workflows/jekyll-build-action.yml
env:
 JEKYLL_ENV: development # I had "production" here before

Und, was soll ich sagen: Kaum macht man es richtig, schon funktioniert’s!

Die Website offline darstellen funktioniert wie folgt: Die gebauten Dateien (den _site-Ordner) auf den eigenen Rechner ziehen und die index.html mit dem Browser öffnen. ↩︎

🗸 Gitea Actions Teil2 - Jekyll-Dockerimage

Schallbert — Sat, 09 Dec 2023 00:00:00 +0000

Die Vorgeschichte

Leider hatte ich im Teil1 mit einer leicht modifizierten Kopie der Github-Action zum Bauen von Jekyll kein Glück. Daher wollte ich nun probieren, Jekyll direkt als Dockerimage laufen zu lassen. Im Docker hub gab es nicht so furchtbar viel Auswahl. Trotzdem habe ich ein (in 2023) aktiv gewartetes und gut dokumentiertes Image finden können.

“Set up job”

Und so binde ich das Docker-Jekyllimage dann in meinen workflow ein:

# workflows/jekyll-build-action.yml
jobs:
 # Build job
 build:
 runs-on: ubuntu-latest # this is the "label" the runner will use and map to docker target OS
 container: jvconseil/jekyll-docker
# [...]

Hier wird dem gitea act_runner gesagt, dass er mit dem ubuntu-latest label laufen soll, was in meinem Fall auf eine sehr kleine und schnell hochzufahrende node16:bullseye Maschine (abgeleitet vom Betriebssystem Debian11) gemappt wird. Zusätzlich wird Docker mitgeteilt, dass bitte das jekyll-docker image zu laden ist, wo die von mir benötigten Abhängigkeiten (Ruby, Sass, Jekyll…) bereits berücksichtigt wurden.

bundle install

Das Bauen schlägt hier allerdings fehl wegen in der Gemfile angegebenen, aber nicht installierten Abhängigkeiten. Das kann dann so ählich aussehen wie hier:

bundler: failed to load command: jekyll (/usr/gem/bin/jekyll)
/usr/local/lib/ruby/gems/3.2.0/gems/bundler-2.4.22/lib/bundler/resolver.rb:332:in `raise_not_found!': Could not find gem 'github-pages' in locally installed gems. (Bundler::GemNotFound)
	from /usr/local/lib/ruby/gems/3.2.0/gems/bundler-2.4.22/lib/bundler/resolver.rb:392:in `block in prepare_dependencies'

Bundler ist der Paketmanager für in Ruby geschriebene Software. Ähnlich wie npm für Javascript oder pip für Python ist bundler in der Lage, von einem Ruby-Programm genutzte Bibliotheken und andere Abhängigkeiten herunterzuladen und so einzubinden, dass sie ohne weitere Konfiguration auf dem Zielsystem verwendet werden können. Damit bundler weiß, was zu installieren ist, wird eine sogenannte Gemfile angelegt.

Also dem Script schnell bundle install hinzufügen, etwa so:

# workflows/jekyll-build-action.yml
# [...]
 steps:
 - name: --- CHECKOUT ---
 uses: actions/checkout@v3
 - name: --- INSTALL GEMS ---
 run: bundle install # will fail with permissions rights to write to Gemfile.lock but anyways installs required dependencies.
 - name: --- BUILD WITH JEKYLL ---
 # Outputs to the './_site' directory by default
 run: bundle exec jekyll build --destination /opt/blog_staging
 env:
 JEKYLL_ENV: production

act_runner: Kein Schreibzugriff auf `Gemfile.lock`

Dies schlägt wieder fehl - wegen fehlender Schreibrechte des act_runner:

gitea-runner-1 | [Deploy Jekyll site/build] | `/workspace/schallbert/blog/Gemfile.lock`. It is likely that you need to grant
gitea-runner-1 | [Deploy Jekyll site/build] | write permissions for that path.
gitea-runner-1 | [Deploy Jekyll site/build] ❌ Failure - Main ---INSTALL GEMS ---
gitea-runner-1 | [Deploy Jekyll site/build] exitcode '23': failure

Nach langer Suche muss ich feststellen, dass Gemfile.lock auf meinem Rechner nicht der Versionskontrolle unterliegt, da es in der .gitignore auftaucht. Der Bundler des act_runner versucht nun also, diese Datei selbst aus der Gemfile zu erzeugen und scheitert, weil keine Schreibrechte auf dem Repository bzw. der temporären Kopie vorliegen.

Dies lässt sich am besten beheben, indem die Gemfile.lock in die Versionskontrolle aufgenommen wird, d.h. aus der .gitignore verschwindet. Somit stelle ich sicher, dass ich für das lokale Bauen auf meinem Laptop dieselben Umgebungsbedingungen habe wie auf dem Server.

Update Nov-2025

Nach einem Update meiner lokalen Bildumgebung per bundle update stellt sich bei mir nun erneut das oben genannte Problem, obwohl ich Gemfile.lock inzwischen versioniere. Die Lösung diskutiere ich in einem Artikel zum Thema Bundler

Abhängigkeiten: `sass-embedded`

Nach weniger als 20 Sekunden die nächste Fehlermeldung:

Resolving dependencies...
Could not find gem 'sass-embedded (= 1.69.5)' with platform 'x86_64-linux' in
rubygems repository https://rubygems.org/ or installed locally.

Nach weiteren Minuten der Recherche die Lösung: In der Gemfile eine bestimmte Version des jekyll-sass-converter spezifizieren oder alternativ das Gem “github-pages” in der Gemfile belassen. Dieses kümmert sich ebenfalls darum, dass der CascadingStyleSheets (CSS) Präprozessor Sass vorhanden ist.

Nun endlich läuft bundle install erfolgreich durch:

✅ Bundle complete! 5 Gemfile dependencies, 43 gems now installed.

jekyll build

Damit Jekyll die gebauten Dateien auch irgendwo abspeichern kann, habe ich dem act_runner in der docker-compose.yml ein weiteres Volume gegönnt:

# gitea/docker-compose.yml
# [...]
volumes:
 - ./runner/blog_staging:/opt/blog_staging
 - ./runner/data:/data
 - /var/run/docker.sock:/var/run/docker.sock

Und jetzt direkt nochmal probieren, ob Jekyll erfolgreich baut:

 Destination: /opt/blog_staging
 Generating... 
 Jekyll Feed: Generating feed for posts
jekyll 3.9.3 | Error: Permission denied @ dir_s_mkdir - /opt/blog_staging
/usr/local/lib/ruby/3.2.0/fileutils.rb:406:in `mkdir': Permission denied @ dir_s_mkdir - /opt/blog_staging (Errno::EACCES)
	from /usr/local/lib/ruby/3.2.0/fileutils.rb:406:in `fu_mkdir'

Auch dieses Problem lässt sich leicht lösen, indem man entweder nach /tmp baut, wo der user jekyll während des Bauens ebenfalls Zugriff hat, oder indem man der Action vor dem jekyll build-Befehl einen Nutzerwechsel im Build-Arbeitsverzeichnis vornimmt: chown -R jekyll /opt/blog_staging.

Mit dieser Änderung läuft die Action endlich durch.

Artefakte transferieren

Doch wo finde ich jetzt die in der Action gebauten Dateien, welche mein Webserver dann veröffentlichen soll? Der _site-Ordner ist nirgendwo zu finden - weder auf dem Volume der Hostmaschine, noch im Gitea-Dockercontainer oder im Runner!

Docker volumes für `act_runner` können Artefakte nicht verteilen

Dass ich über Docker volumes nicht dort herankomme erscheint logisch wenn man weiß, wie act-runner funktioniert: Die Action erzeugt ein eigenes Dockerimage mit wiederum per Task-ID assoziierten Volumes, welches nur für dessen Laufzeit existiert.

DRIVER VOLUME NAME
--> local GITEA-ACTIONS-TASK-84_WORKFLOW-Deploy-Jekyll-site_JOB-build <--
--> local GITEA-ACTIONS-TASK-84_WORKFLOW-Deploy-Jekyll-site_JOB-build-env <--
local act-toolcache
local blog_staging

Legt man die Artefakte also nirgendwo extern ab, so werden sie nach Durchlauf der Aktionen zusammen mit dem Image demontiert und sind futsch. Das oben angelegte Volume des Runners hat gar keine Auswirkung auf die Action, weil sie wieder in einem isolierten Image läuft.

Dies zu verstehen hat mich einige Zeit und Fehlversuche gekostet, dabei ist es in einem Abschnitt der Dokumentation beschrieben.

Das Ganze gestaltet sich ja deutlich komplizierter als ich dachte. Mit Kanonen auf Spatzen schießen angesichts meiner kleinen Website und als Einziger, der sie pflegt. Egal, ich ziehe das jetzt durch.

Aber man kann doch `upload-artifact` verwenden!

Na ja, das dachte ich jedenfalls. Also habe ich mein Action-Skript entsprechend erweitert und die von Github Actions zur Verfügung gestellte Funktion eingebaut:

# workflows/jekyll-build-action.yml
# [...]
# Automatically upload the build folder to Giteas blog repo folder
 - name: --- UPLOAD ARTIFACT ---
 uses: actions/upload-artifact@v3
 with:
 path: /workspace/schallbert/blog/
 name: Blog_Staging
 retention-days: 2

Super, jetzt erscheint ein herunterladbares Zip-file auf der Weboberfläche von Gitea:

Nur: Wie bekomme ich das Ding jetzt automatisiert auf meine Serverinstanz? Schließlich kennt die Action diese nicht - sie hat ja nicht einmal einen eigenen Docker Daemon.

Also schaue ich mal im Gitea-Container selbst nach, wo die Artefakte unter /data/gitea/actions_artifacts/BUILD_ID abgelegt sind. Allerdings als ein Haufen (hunderte) .chunk.gz Dateien mit kryptischen Nummernfolgen als Name, bei denen ich wiederum nicht weiß wie ich sie zu einem Archiv zusammenfügen soll.

Und noch etwas gefällt mir an upload-artifact nicht: Da meine Website inzwischen eine Menge Bilder, Audiodateien und Videos enthält, ist sie recht groß. Daher benötigt der uploader für’s Verpacken und Versenden schon jetzt fast zwei Minuten - Tendenz linear steigend mit der Anzahl meiner Medieninhalte.

Sackgasse.

Auch Docker `cp` funktioniert in diesem Falle nicht

Dann versuche ich mit Hilfe des Kopierbefehls von Docker, die Artefakte auf meinen Host zu transferieren:

# workflows/jekyll-build-action.yml
# [...]
- name: --- COPY ARTIFACT ---
 run: docker cp gitea-runner-1:/workspace/schallbert/blog /tmp/blog_staging

Dies schlägt wieder fehl:

gitea-runner-1 | docker cp gitea-runner-1:/workspace/schallbert/blog /tmp/blog_staging
[...]
gitea-runner-1 | [Deploy Jekyll site/build] | /var/run/act/workflow/3.sh: line 2: docker: not found
gitea-runner-1 | [Deploy Jekyll site/build] ❌ Failure - Main --- COPY ARTIFACT ---

Auch erwartbar, denn der Action-Container selbst kennt kein Docker. Es ist also nicht möglich, etwas von “innerhalb” des Containers per Docker heraus zu bekommen. Dies ist für mich aber erforderlich, da die Action ja den ganzen Prozess vollständig automatisieren soll.

Oder geht es doch irgendwie? Der Daemon der Hostmaschine docker.sock steht laut Giteas Dokumentation zumindest dem act_runner per Volume zur Verfügung - wird aber scheinbar nicht in die Action weitergeleitet. Vielleicht aus gutem Grund, sonst wäre die Kapselung futsch und eine schadhafte Action könnte praktisch meinen Docker Daemon auf dem Host kapern 😰.

Transferieren per SFTP würde klappen

So langsam gehen mir die Alternativen aus. Ich überlege nun, die Artefakte per SFTP aus dem vom act_runner erzeugten Action-Dockerimage heraus in den Webserver-Container zu schieben¹.

Glücklicherweise gibt es hierfür wieder eine vorgefertigte Action: scp-files. Nun muss ich aber den Container des Webservers so umbauen, dass er per SCP erreichbar ist und den SSH-Schlüssel der Action akzeptiert.

Andererseits wird davor in vielen Foren gewarnt - Ein Container sollte nur eine Applikation beherbergen. Aber auch hier gibt es eine Lösung: ein eigener Docker-Container mit SSH-Daemon. Diesem könnte ich dann ein Volume geben, welches er mit dem Webserver teilt.

Sieht leider nach einigem Aufwand aus. Und ich möchte als fauler Entwickler mein System so einfach wie möglich halten - also recherchiere ich weiter.

Dem Action-Container ein Volume zur Verfügung stellen

Diese ganzen Fehlschläge und Sackgassen begleiten mich jetzt schon seit über einem Monat. Ich will es trotzdem unbedingt schaffen, vollautomatisch bauen, testen und veröffentlichen zu können. Auf dem Weg hierhin habe ich eine Menge gelernt und jetzt hoffe ich, dass dieser Ansatz mich endlich zur Lösung bringt.

Bei meiner Suche stieß ich auf die Möglichkeit, die Konfiguration des Runners zu verändern. So könnte ich am Ende vielleicht doch noch ein Volume einbinden, welches ich zwischen der Action und meinem Server über den Daemon auf dem Host teilen kann.

Wenn das klappt, hätte ich kein zusätzliches Sicherheitsrisiko wie ein öffentlich verfügbarer file transfer container oder die langen Wartezeiten durch upload-artifact. Also frisch ans Werk! Es gibt noch weitere Gründe, weswegen Volumes in der jeweiligen Action Sinn machen können - es muss also bereits Leute da draußen geben, die das hinbekommen haben.

Ich versuche also, die Volumes im Action-Skript anzulegen:

# workflows/jekyll-build-action.yml
# [...]
container: 
 image: jvconseil/jekyll-docker:latest
 volumes: 
 - /tmp/blog_staging:/blog_staging
 - /opt/cache:/opt/hostedtoolcache

Doch irgendwie landen die Artefakte noch immer nicht auf der Platte meines Hosts. Ich vereinfache die Action soweit, dass ich nur noch prüfe, ob die Erzeugung des Volumes auch einen entsprechenden Ordner anlegt:

# workflows/jekyll-build-action.yml
# [...]
steps:
 - name: --- CHECK_VOLUME ---
 run: |
 ls -al /blog_staging

und schon schlägt die Aktion wieder fehl:

gitea-runner-1 | [Deploy Jekyll site/build] [DEBUG] Working directory '/workspace/schallbert/blog'
gitea-runner-1 | [Deploy Jekyll site/build] | ls: /blog_staging: No such file or directory
gitea-runner-1 | [Deploy Jekyll site/build] ❌ Failure - Main --- CHECK_VOLUME ---

Nach ein paar weiteren, erfolglosen Versuchen (vielleicht hatte ich etwas falsch geschrieben?) und langer Recherche in den Foren fand ich heraus, dass es das valid_volumes Attribut im act gibt - taucht das Volume dort nicht auf, so wird es auch nicht eingebunden.

OK, also schnell der Action hinzugefügt:

# jekyll-build-action.yml
# [...]
container: 
 image: jvconseil/jekyll-docker:latest
 valid_volumes: 
 - '**' # This does not work. Also specialized lists indicating the volumes directly won't work
 volumes: 
 - /tmp/blog_staging:/blog_staging
 - /opt/cache:/opt/hostedtoolcache

Aber immer noch nichts. Immerhin kann ich in den Logs mit dem Wissen über valid_volumes jetzt eine Warnung entdecken:

gitea-runner-1 | [Deploy Jekyll site/build] [/tmp/blog_staging] is not a valid volume, will be ignored
gitea-runner-1 | [Deploy Jekyll site/build] [/opt/cache] is not a valid volume, will be ignored

Etwas stimmt mit der Übergabe dieser Option nicht. Also recherchiere ich weiter. Es gibt Berichte, in denen das Anmelden der Volumes funktioniert. Also erzeuge ich nach Anleitung eine Konfigurationsdatei, wo ich das Folgende eintrage:

# runner/config.yml

# Volumes (including bind mounts) can be mounted to containers. Glob syntax is supported, see https://github.com/gobwas/glob
 # You can specify multiple volumes. If the sequence is empty, no volumes can be mounted.
 # For example, if you only allow containers to mount the `data` volume and all the json files in `/src`, you should change the config to:
 # valid_volumes:
 # - data
 # - /src/*.json
 # If you want to allow any volume, please use the following configuration:
 # valid_volumes:
 # - '**'
 valid_volumes: ["/tmp/blog_staging", "/opt/hostedtoolcache"]

Wichtig: Die Notation muss als String vorliegen, kommasepariert, und gibt stets die Source des Volumes an. Also den Teil, der vor dem : steht. Doch noch immer erscheint beim Bauen die Fehlermeldung “not a valid volume”.

Doch dann fällt mir auf, dass die Config dem act_runner selbst als Volume zur Verfügung gestellt werden muss - sonst kann der im Container laufende Runner ja gar nicht darauf zugreifen!

Daher sieht meine docker-compose.yml für Gitea, Abschnitt “runner” nun wie folgt aus:

# gitea/docker-compose.yml
# [...]
 runner:
 image: gitea/act_runner:latest
 environment:
 - CONFIG_FILE=/config.yml
 - GITEA_INSTANCE_URL=https://git.schallbert.de
 - GITEA_RUNNER_NAME=ichlaufe
 - GITEA_RUNNER_REGISTRATION_TOKEN= <redacted>
 volumes:
 - ./runner/config.yml:/config.yml
 - ./runner/data:/data
 - /opt/hostedtoolcache:/opt/hostedtoolcache
 - /var/run/docker.sock:/var/run/docker.sock

Und endlich:

gitea-runner-1 | ls -al /blog_staging
gitea-runner-1 | [Deploy Jekyll site/build] | total 8
gitea-runner-1 | [Deploy Jekyll site/build] | drwxr-xr-x 2 root root 4096 Dec 27 07:32 .
gitea-runner-1 | [Deploy Jekyll site/build] | drwxr-xr-x 1 root root 4096 Dec 27 07:46 ..
gitea-runner-1 | [Deploy Jekyll site/build] ✅ Success - Main --- CHECK_VOLUME ---

Was für ein Akt. Ich bin so froh, dass jetzt alles durchläuft und ich auf meinem lokalen Hostsystem tatsächlich die gebauten Dateien vorfinde! 🥳

Noch ein letzter Tipp

Wenn ihr so wie ich mit einem Reverse Proxy arbeitet und so komische connection refused Fehlermeldungen beim Hochfahren des Runners erhaltet wie:

docker compose up
[+] Running 2/0
 ✔ Container gitea Created 0.0s 
 ✔ Container gitea-runner-1 Created 0.0s 
Attaching to gitea, gitea-runner-1
gitea-runner-1 | level=info msg="Starting runner daemon"
gitea-runner-1 | level=error msg="fail to invoke Declare" error="unavailable: dial tcp <address>: connect: connection refused"
gitea-runner-1 | Error: unavailable: dial tcp <address> connect: connection refused
gitea | Server listening on :: port 22.
gitea-runner-1 exited with code 1

Dann ist euer Reverse Proxy entweder falsch eingestellt oder - wie in meinem Falle - nicht hochgefahren.

Die Nutzung des SFTP (Secure File Transfer Protocol), also der Dateitransfer über ssh (secure shell), erhöht die Angriffsfläche meines Systems ein wenig. Der SSH-Dienst ist nämlich dann nicht nur für meine Action, sondern ganz allgemein von außen erreichbar. ↩︎

🗙 Gitea Actions - Jekyll Workflow

Schallbert — Thu, 30 Nov 2023 00:00:00 +0000

Nachdem ich in diesem Projekt meinen eigenen, kleinen Server aufgesetzt und mit den entsprechenden Programmen zum Hosten meines Blogs ausgestattet habe, möchte ich ihn nun in die Lage versetzen, die Website automatisch zu bauen.

Gewünschter Ablauf

Ich möchte folgendes erreichen: Sobald Gitea eine push-Aktion auf dem Blog-Repository verzeichnet, soll ein Action Runner in einem eigenen Docker-Container loslaufen und Ruby, Bundler, Jekyll sowie sämtliche Abhängigkeiten nachladen. Dann soll der Runner meine Quelldateien für den Blog kopieren und dem bundle exec jekyll build Prozess zur Verfügung stellen, welcher dann die Website baut und schließlich im _site-Ordner ablegt. Anschließend soll der Runner sich selbst beenden und alle in Anspruch genommenen Ressourcen wieder freigeben.

An dieser Stelle möchte ich nachkontrollieren können, ob die Website fehlerfrei gebaut wurde und in Zukunft eventuell noch ein paar weitere Prüfungen darüberlaufen lassen - z.B. kaputte Links erkennen, nicht angezeigte Bilder markieren, Rechtschreibprüfung durchführen.

Die Freigabe sowie die Veröffentlichung soll dann ein anderer Prozess übernehmen, um den ich mich später kümmere.

Ausgangspunkt: Github Actions

Wie üblich wildere ich erst einmal bei anderen Menschen, die ein ähnliches Problem für sich bereits gelöst haben. Ich wurde im Github Actions starter-workflows Repository von Github selbst fündig und habe die Workflowdatei für Jekyll mit leichten Modifikationen direkt mal mit meiner Gitea-Instanz ausprobiert:

# jekyll-build-pages.yml
# Sample workflow for building and deploying a Jekyll site
name: Deploy Jekyll site
run-name: ${{ gitea.actor }} builds Jekyll site
on: [push]

jobs:
 # Build job
 build:
 runs-on: ubuntu-latest
 steps:
 - name: Checkout
 uses: actions/checkout@v3
 - name: Setup Ruby
 uses: ruby/setup-ruby@55283cc23133118229fd3f97f9336ee23a179fcf # v1.146.0
 with:
 ruby-version: '3.1' # Not needed with a .ruby-version file
 bundler-cache: true # runs 'bundle install' and caches installed gems automatically
 cache-version: 0 # Increment this number if you need to re-download cached gems
#[...]

Nachdem ich diesen Workflow in mein Blogverzeichnis unter workflows/jekyll.yml hochgeladen hatte, lief der Runner tatsächlich direkt los:

Probleme mit der Ruby-Installation

Schon mal prima. Allerdings wenig erbaulich, dass bereits bei der Installation von Ruby etwas nicht passt. Werfen wir einen Blick in die Logs:

::error::The current runner (debian-11-x64) was detected as self-hosted because the platform does not match a GitHub-hosted runner image 
(or that image is deprecated and no longer supported).
In such a case, you should install Ruby in the $RUNNER_TOOL_CACHE yourself, for example using https://github.com/rbenv/ruby-build
You can take inspiration from this workflow for more details: 
https://github.com/ruby/ruby-builder/blob/master/.github/workflows/build.yml

Na, das ist doch mal eine hilfreiche Fehlermeldung!

Der Runner läuft um Ressourcen zu sparen standardmäßig im Docker mit einem abgespeckten Image basierend auf Debian namens node:16-bullseye (Referenz). Scheinbar ist dieser nicht kompatibel mit dem unter Ubuntu22 betriebenen Github Actions Runner. Ich habe also ein paar Lösungsmöglichkeiten zur Verfügung:

Möglichkeiten zur Fehlerbehebung

Den Runner über seine “Labels” auf Ubuntu22.04 umsatteln.
Ren Runner nicht im Docker, sondern nativ auf dem Server laufen lassen.
Wie in der Fehlermeldung vorgeschlagen, Ruby im Cache des Runners vorinstallieren.
Ein Jekyll-Dockerimage verwenden, welches Jekyll bereits im Gepäck hat und nicht erst die Installation benötigt.

Den Runner mit Ubuntu22 statt Node16 betreiben

Das entsprechende Dockerimage existiert zwar. Aber es kostet aber einen Haufen Speicherplatz auf meinem Server, benötigt durch seinen größeren Funktionsumfang mehr RAM und braucht vor allem länger, bis es hochgefahren ist.

Und Zeit ist bei Runnern wertvoll, schließlich will ich ja möglichst schnell wissen, ob das Bauen geklappt hat.

Den Runner direkt auf der Hostmaschine (Ubuntu22) laufen lassen

Ist sicherheitstechnisch nicht so sehr zu empfehlen (Bei einem ungeschützten Branch würde der Runner von Dritten per git push --force hochgeschobenen Schadcode unbesehen auf meiner Hostmaschine ausführen) und zudem ginge die Portabilität flöten, weil ich das Zielsystem des Runners dann fest verdrahte.

Gitea act_runner direkt auf dem Host laufen lassen

Für den zweiten Ansatz habe ich mir per Anleitung eine Konfiguration für den runner angelegt und darin das bestehende label-mapping so geändert, dass nicht mehr in Richtung Docker, sondern auf dem Ubuntu des Servers selbst gebaut wird. Dafür genügt es in meinem Fall, das Label ubuntu-latest:host statt ubuntu-latest in die Konfiguration zu schreiben. Leider erhielt ich hier Fehlermeldungen bei den Zugriffsrechten des Runners, welcher aus Docker heraus auf dem Hostsystem laufen müsste.

Nicht so schlimm, ich wollte diese Lösung wegen der oben beschriebenen möglichen Probleme sowieso nicht dauerhaft verwenden. Also investiere ich hier keine weitere Zeit.

Ruby im Cache vorinstallieren

Wie von der Fehlermeldung empfohlen habe ich dieser Anleitung folgend in der docker-compose.yml von Gitea ein Volume angelegt für den Tool Cache des runners und das Zielverzeichnis in der Umgebungsvariable RUNNER_TOOL_CACHE abgelegt.

# gitea/docker-compose.yml
# [...]
runner:
 image: gitea/act_runner:nightly
 environment:
 - GITEA_INSTANCE_URL=<redacted>
 - GITEA_RUNNER_NAME=<redacted>
 - RUNNER_TOOL_CACHE=/opt/hostedtoolcache
 - GITEA_RUNNER_REGISTRATION_TOKEN= <redacted>
 volumes:
 - ./runner/data:/data
 - /opt/hostedtoolcache:/opt/hostedtoolcache
 - /var/run/docker.sock:/var/run/docker.sock

Hiermit wird dem in Docker laufenden Runner der Ordner /opt/hostedtoolcache im Dateisystem des Hosts unter dem Namen /opt/hostedtoolcache zur Verfügung gestellt. Nun probiere ich mal, Ruby direkt dort hinein zu installieren.

Also lade ich das ruby-build repository herunter (git clone) und lasse das Installerscript mit ./ruby-build/install.sh durchlaufen. Danach führe ich den Build mit dem in der Fehlermeldung angegebenen Pfad aus: ruby-build 3.1.4 /opt/hostedtoolcache/Ruby/3.1.4/x64

==> Downloading openssl-3.1.4.tar.gz...
 % Total % Received % Xferd Average Speed Time Time Time Current
 Dload Upload Total Spent Left Speed
100 14.8M 100 14.8M 0 0 81.3M 0 --:--:-- --:--:-- --:--:-- 81.1M
==> Installing openssl-3.1.4...

BUILD FAILED (Ubuntu 22.04 on x86_64 using ruby-build 20231114)

Probleme mit prebuilt-Ruby

Das Log zeigt das Problem:

[...] No C compiler found, please specify one with the environment variable CC [...]

Also tippe ich apt install build-essential und stelle dann mit which gcc fest, dass er nun unter /usr/bin/gcc installiert ist. Auf ein Neues!

crypto/comp/c_zlib.c:36:11: fatal error: zlib.h: No such file or directory

Dann schnell apt install libz-dev eingeben und erneut probieren. Dieses mal läuft er recht lange, dann:

*** Following extensions are not compiled:
openssl:
 Could not be configured. It will not be installed.
 /tmp/ruby-build.20231205114312.9174.0gmhNf/ruby-3.1.4/ext/openssl/extconf.rb:100: OpenSSL library could not be found. You might Check ext/openssl/mkmf.log for more details.
readline:
 Could not be configured. It will not be installed.
 /tmp/ruby-build.20231205114312.9174.0gmhNf/ruby-3.1.4/ext/readline/extconf.rb:62: Neither readline nor libedit was found
 Check ext/readline/mkmf.log for more details.
*** Fix the problems, then remove these directories and try again if you want.
[...]

OK, nun ist es openssl. Fix nachinstallieren mit apt install libssl-dev sowie apt install libreadline-dev und endlich 🎉:

Installed ruby-3.1.4 to /opt/hostedtoolcache/Ruby/3.1.4/x64

Noch immer Fehler beim Bauen mit dem Github-Acitons script

Merkwürdig, das Log spuckt mir immer noch denselben Fehler aus:

💬 ::debug::isExplicit: 3.1.4

gitea-runner-1 | [Deploy Jekyll site/build] 💬 ::debug::checking cache: /opt/hostedtoolcache/Ruby/3.1.4/x64
gitea-runner-1 | [Deploy Jekyll site/build] | ::debug::checking cache: /opt/hostedtoolcache/Ruby/3.1.4/x64
gitea-runner-1 | [Deploy Jekyll site/build] 💬 ::debug::not found
gitea-runner-1 | [Deploy Jekyll site/build] | ::debug::not found
gitea-runner-1 | [Deploy Jekyll site/build] ❗ ::error::The current runner (debian-11-x64) was detected as self-hosted

Das geht auf folgende Abfage in der ausführenden Action zurück:

// setup-ruby/ruby-builder.js
if (common.shouldUseToolCache(engine, version)) {
 inToolCache = common.toolCacheFind(engine, version)
 if (inToolCache) {
 rubyPrefix = inToolCache
 } else {
 const toolCacheRubyPrefix = common.getToolCacheRubyPrefix(platform, engine, version)
 if (common.isSelfHostedRunner()) {
 const rubyBuildDefinition = engine === 'ruby' ? version : `${engine}-${version}`
 core.error( [...] )

Update Jan-2024

Es es gibt zwei weitere Möglichkeiten dafür, dass der toolcache nicht gefunden wird:

Ich habe das Volume nicht der Action, sondern dem Runner zur Verfügung gestellt. Ich bin mir nicht sicher, dass die Daten auch in der Action verfügbar sind.
Der toolcache-Pfad ist nicht in der Konfigurationsdatei des runners unter dem Eintrag valid_volumes enthalten. Eine pull request Kommunikation lässt mich jedoch vermuten, dass dies automatisch passiert. Dennoch bin ich mir nicht 100% sicher, ob die Information noch dem Stand der Dinge entspricht.

Docker volume überprüfen

Mist. Prüfen wir schnell mal, ob Ruby in dem Volume auch wirklich verfügbar ist. Dafür suchen wir mit docker ps die Container ID des runners heraus und geben sie bei folgendem Kommando ein:

docker exec -it <containerID> bash

Dann navigiere ich in den gesuchten Ordner cd /opt/hostedtoolcache, liste dort den Inhalt mit ls und siehe da: Ruby. Es liegt also alles vor, nur wird es nicht gefunden.

Misserfolg anerkennen

So komme ich hier also nicht weiter 😖. Daher öffne ich mein Problem für die Community unter dem Titel act_runner cannot find hostedtoolcache und probiere

einen anderen Ansatz.

Problemursache

Der Support der Action setup-ruby für selbsgehostete CI-Pipelines wie meinen act_runner wurde wohl eingestellt. Die Dokumentation mit den Hinweisen zur Fehlerbehebung bei Verwendung selbstgehosteter Runner allerdings zum Zeitpunkt der Verwendung durch meine Wenigkeit war aber noch nicht auf Stand gebracht worden.

Mehrsprachige Webseiten - l10n

Schallbert — Tue, 14 Nov 2023 00:00:00 +0000

Die Bereitstellung einer Webseite in mehreren Sprachen wird “internationalization” - kurz i16n beziehungsweise “localization” l10n genannt. Sucht man nach diesen Begriffen im Netz, findet man eine Menge tollen Materials zum Thema. Die Zahlen in den Kurzformen dieser Begriffe geben die Anzahl Buchstaben in der Wortmitte an.

Motivation

Ich bin schon vor langer Zeit gefragt worden, ob ich nicht mal eine deutsche Version dieser Webseite anfertigen wolle. Bis dato hielt ich das für zu viel Arbeit. Dies änderte sich erst vor gut einem halben Jahr, als ich dieselbe Anfrage verbal von mehreren Leuten unabhängig voneinander in kurzer Zeit erhielt.

Also investierte ich einen Haufen freier Abende in die Fleißarbeit, rund 80 Artikel auf Deutsch zu übertragen. Doch ich war noch immer nicht fertig.

Jekyll plugin

Ich sah mich nach Möglichkeiten um, meinen Internetauftritt mit Jekyll mehrsprachig zu gestalten. Dabei fand ich unter Anderem demondehellis’ plugin-freie Lösung, untras polyglot plugin, kurtssons jekyll-multiple-languages-plugin und noch ein paar weitere Möglichkeiten, diesen Webauftritt in mehreren Sprachen anzubieten.

Nun musste ich mich für eine entscheiden. Die plugin-freie Lösung fiel recht schnell heraus, da ich “gleiche” Posts verschiedener Sprache gleich benennen wollte und damit Interlinks zwischen Beiträgen unabhängig von der verwendeten Sprache bestehen bleiben sollten - irgendwas muss also dafür sorgen, dass sich die Sprachen nicht wild mischen.

Blieben die Plugins übrig. Kurz gesagt stieß ich zufällig auf leo3418s hervorragende Artikelserie für die Implementierung von Polyglot - und so entschied ich mich für ebendieses Plugin.

Polyglot: Installation

Die Installation von Polyglot war einfach, denn sowohl die im Repository bereitgestellte readme.md als auch der von leo3418 geschriebene Blogartikel beschäftigen sich ausführlich mit den ersten Schritten. In der Tat fand ich die Dokumentation so gut, dass ich darauf verweisen möchte und hier gar nicht weiter darüber berichten werde.

Umstrukturierung der Website

Bei Polyglot gibt es zwei Möglichkeiten, die Ordnerstruktur für die Website auf mehrsprachig umzustellen:

Man benutzt das Sprachkürzel im Artikelnamen und ermöglicht so eine Zuordnung. Dieser Artikel hier würde dann z.B. heißen: 2023-11-14-jekyll-polyglot-language-support-de.md und analog in jeder weiteren Sprache mit einem anderen Sprachkürzel
Man erstellt Ordner mit dem Sprachkürzel, z.b. /de, behält aber identische Dateinamen für verschiedene Sprachen.

Ich habe mich für letzteres entschieden, um der Umbenennung meiner schon vorhandenen Artikel zu entgehen. Die Sprache wird von Polyglot auch bei Verwendung von Interlinks auf der Webseite beibehalten. Klickt man z.B. auf den Artikel https://schallbert.de/milling-small-parts/, so wird Polyglot ausgehend von der Sprache des aktuellen Artikels auch den neuen Artikel in dieser Sprache aufrufen. Einzig bei Überschriften von Abschnitten wird es schwierig: Die sind nämlich übersetzt. Also wird der Link auf die englische Version der Seite für die Überschrift #Umstrukturierung-der-Website in einem 404-Fehler enden.

Daher muss man für die Überschriften den kompletten Artikelpfad inkl. der Lokalisierung angeben. In diesem Beispiel wäre folglich /posts/en/jekyll-polyglot-language-support/#restructuring-the-website der korrekte Interlink.

Update: Alternativ kann man der Überschrift auch eine sprachunabhängige “ID” geben, sodass auch hier die Anchor-Links auf die Überschriften identisch bleiben. Beispiel: ## Umstrukturierung der Website {# website-restructuring}, Aufruf im Link per #website-restucturing.

Hier wird es ein wenig komplizierter. Die _config.yml von Jekyll lässt ohne Weiteres nicht zu, dass mehrere Varianten von ihr existieren. Man benötigt für sprachsensitive Parameter wie site.title oder site.description in der config daher die Möglichkeit, die Standardwerte zu überschreiben. Meine Methode das zu lösen war, im _data-Ordner eine Datei mit Namen l10n.yml anzulegen, in der dann diese Parameter abgelegt sind. Um sie dann auch korrekt anzuzeigen, sind die html-Dateien im _includes-Ordner so anzupassen, dass Parameter dieser Datei statt der config eingelesen und durch die Templatesprache Liquid dann in html umgesetzt werden. Beispiel: {{ site.data.ui-text[site.data.l10n.locale].follow_label | remove: ":" | default: "Follow" }}. Hier wird dann wie im Bild gezeigt dann in der deutschen Version FOLGEN: angezeigt und in der englischen FOLLOW:.

Sprachauswahl

Natürlich möchte ich die Möglichkeit geben, die Sprache der Website selbst zu wählen. Ich habe mich hier für das Sprachkürzel sowie die entsprechende Flagge entschieden, welche im unteren Bereich einer jeden Seite eingeblendet werden. Klickt man hier drauf, so wird die Seite in der entsprechenden Sprache neu geladen. Dafür war es notwendig, einen “language-switcher” in Liquid zu schreiben.

// _includes/language-switcher.html
{% raw %}
{% for lang in site.languages %}
 {% assign url_parts = page.url | split: "/" %}
 {% assign lang_code = lang %}

 {% assign collection_name = url_parts[1] %}
 {% assign post_url = url_parts | last %}

 {% if lang == site.default_lang %}
 {% if collection_name == post_url %}
 {% assign lang_url = "/" | append: post_url %}
 {% else %}
 {% assign lang_url = "/" | append: collection_name | append: "/" | append: post_url %}
 {% endif %}
 {% else if url_parts.size > 2 %}
 {% assign lang_url = "/" | append: lang_code | append: "/" %}
 {% if collection_name == post_url %}
 {% assign lang_url = lang_url | append: post_url %} 
 {% else %}
 {% assign lang_url = lang_url | append: collection_name | append: lang_url | append: post_url %}
 {% endif %}
 {% endif %}
 <a href=" {{ lang_url }}">{{ site.data[lang].l10n.lang_name }}</a>
{% endfor %}
{% endraw %}

Hierfür wird die aktuelle url am Slash in Einzelteile zerlegt. Anschließend der letzte Teil der url als Artikelname post_url gesetzt und angenommen, dass der erste Teil der URL der collection entspricht, z.B. posts-hardware. Die anschließende Logik setzt die Sprachkürzel je nach Bedarf in die url ein, sodass je nach Verwendung einer collection oder ohne die entsprechende Zielurl korrekt erzeugt wird.

Veröffentlichung

Ich war echt stolz auf diesen Umbau. Ich finde, dass sich alles gut einfügt und ich mit der Zweisprachigkeit meinen Nutzerkreis gut erweitern kann. Der Nachteil für mich ist die zusätzliche Übersetzungsarbeit, die von nun an bei jedem Artikel auf mich zukommt.

Als ich diese Seite das erste mal auf die Github Page hochlud, merkte ich, dass das so überhaupt nicht funktioniert. Github Pages unterstützt Polyglot nämlich nicht, sodass plötzlich alle Artikel unabhängig von ihrer Sprache auf einmal auf meiner Website erscheinen.

Nun blieben mir nur zwei Möglichkeiten: Eigene Github Actions für das Deployment aufzusetzen - oder ein Umzug auf einen eigenen Server. Ich habe mich für Letzteres entschieden, da die Github-Server für diese Seite meines Wissens nach in UK stehen und und ich mit einem Server in Deutschland lieber auf der sicheren Seite wäre.

Der eigentliche Umbau ist aber deutlich zu groß, um ihn in diesem Post abzuhandeln - dafür gibt es ein eigenes Softwareprojekt.

Kleinteile fräsen

Schallbert — Wed, 01 Nov 2023 00:00:00 +0000

Warum kleine Teile überhaupt fräsen?

Es ist meist schwierig, sehr kleine Teile zu fertigen, zudem wenn sie nur in geringer Stückzahl benötigt werden. Spritzgießen lohnt sich hier nicht und 3D-Drucker wie sie im Hobbybereich eingesetzt werden sind erfüllen nicht die Toleranzanforderungen für meine Passungen. Die Laserschneider, auf die ich Zugriff habe, können das Teil ebenfalls nicht fertigen, weil es verschiedene Oberflächenhöhen hat. Auf die Option, das Teil in Fernost anfertigen zu lassen, möchte ich verzichten.

Dennoch: Diese Teile können auf einer Fräsmaschine gefertigt werden. Dieses Video zeigt, wie:

Kleinteile fräsen

Welche Ausstattung muss die Maschine dafür besitzen?

Einen Vakuumtisch
Eine Vakuumpumpe, vorzugsweise mit hohen Unterdrücken
Etwas Frischhaltefolie
Ein Vakuumvlies

Wofür ist dieses Kleinteil?

Das im Video gefertigte Teil gehört zu einem meiner Seifenbutler. Die aktuelle Version kann an jeder handelsüblichen Duschstange mit Durchmesser von 18-25mm befestigt werden und benötigt dieses Teilchen zum Klemmen. Es drückt sich an der Rückseite an die Stange und sorgt so dafür, dass der Seifenbutler weder verrutscht noch wackelt.

Mit diesem Upgrade gegenüber früheren Versionen ist der Seifenbutler nicht nur in der Lage, festes Shampoo zu halten, sondern auch die viel schwereren Shampooflaschen.

Der “Klemmer” muss ohne merkliches Spiel in seine Führung passen und dennoch leichtgängig zu verschieben sein, um sich an verschiedene Duschstangendurchmesser anpassen zu können.

Was muss noch beachtet werden?

Frischhaltefolie: Wenn Teile ausgeschnitten werden, sollten sie nicht zu groß sein. Ansonsten wird die Folie vom Fräser mitgerissen und hinterlässt hässliche Spuren im Werkstück. Außerdem kann sie eine Unwucht erzeugen, die bei hohen Drehzahlen zu Beschädigung des Fräsers oder sogar der Maschine führen kann. Um das Einziehen zu vermeiden hilft das Anbringen eines kleinen Stückes doppelseitigen Klebebandes auf dem auszuschneidenden Teil.
Vakuumvlies: Das Vlies wird bei Anlegen des Vakuums auf weniger als die Hälfte seiner Höhe zusammengepresst. Es ist also erforderlich, die Werkstückhöhe bei angelegtem Vakuum abzunullen.
Nicht ganz durchfräsen sondern eine dünne Materialschicht stehen lassen. Ihre Stärke hängt vom bearteiten Material ab. Bei PMMA lasse ich 0.3mm stehen, bei Holz 0.7mm.
Ich berücksichtige die Frischhaltefolie (etwa 10µm stark) nicht beim Einmessen der Werkstückhöhe, da sie sich in der Größenordnung meiner Maschinentoleranz befindet. Dickere Schutzfolien (20-30µm), wie sie z.B. bei Plexiglas und Dibond verwendet werden, hingegen schon - zumal sie doppelseitig aufgebracht sind.

DIY Kantenfinder

Schallbert — Sun, 21 May 2023 00:00:00 +0000

Als CNC-Bediener muss ich bei manchen Arbeiten genau wissen, wo sich mein Werkstück befindet. Daher benötige ich in solchen Fällen die X/Y-Werte einer Ecke des Werkstücks im Maschinenkoordinatensystem. Bisher habe ich dieses Problem mittels eines V-Fräsers gelöst, dessen Spitze ich manuell auf die Kante des Werkstücks verfahren und immer wieder mit Augenmaß geprüft habe, ob die Positionen übereinstimmen.

Das Problem

Obwohl diese manuelle Methode relativ schnell und unkompliziert anzuwenden ist, so ist sie für die meisten Aufträge nicht mehr genau genug. Als ich in die doppelseitige Bearbeitung eingestiegen bin wie damals mit Dibond war der Versatz so groß, dass ich die ersten Teile nur noch entsorgen konnte.

Lösung

Ich habe mein Problem mit dem Hersteller meiner Fräsmaschine besprochen - in der Annahme, dass ich einen elektrischen, in die Spindel einzuspannenden Kantentaster “3D finder” empfohlen bekommen würde und nun wieder viel Geld und Arbeit in Kauf und Einrichtung eines solchen Messwerkzeugs fließen müsse. Da lag ich aber falsch. Stattdessen erhielt ich einen Tipp, wie ich einen einfachen aber genauen Kantenfinder bauen kann, der zudem praktisch nichts kostet.

Einzelteile

Roy sagte “Na ja, das Einzige, was du dafür brauchst, ist ein Kugellager. Befestige es auf einer Achse und wechsle sie in die Spindel ein wie jedes andere Werkzeug auch. Lasse die Spindel im niedrigen Drehzahlbereich laufen und bewege die Maschine langsam in Richtung Werkstückkante. Sobald der äußere Ring des Kugellagers nicht mehr mitläuft, hast du die Kante gefunden.” Alles was ich dann noch tun muss, ist, den Radius des Kugellagers auf die Maschinenposition zu addieren und ich habe die Position bestimmt.

Aufbau

Ich fand die Idee genial. Da ich leider kein gut sortiertes Metallfachgeschäft in der Nähe habe, durchwühlte ich den Haushalt nach einem Kugellager. Voilà, meine Kinder haben einen Fidget Spinner, den sie eine Weile nicht mehr benutzt haben. Also habe ich ihn… stibitzt. Er enthält ein Kugellager mit 22mm Durchmesser für eine 8mm Welle.

Hierfür bot sich der Schaft eines stumpfen 8mm Bohrers an. Also schnitt ich ihn in der Mitte durch, setzte den Schaft in das Kugellager ein und befestigte ihn mit einem Tropfen Kleber - Fertig!

Update: Kurz nach Veröffentlichung dieses Artikels schrieb ein Leser, dass alte Inline Skates oder Roller auch hervorragende Spender für Kugellager im Haushalt seien.

Kanten finden

Wechseln Sie den selbstgebauten Kantenfinder in die Spindel ein und verfahren sie in die Nähe des Werkstücks
Schalten Sie die Spindel bei niedriger Drehzahl ein, z.B. S500....S3000
Optional: Für eine einfachere Positionsbestimmung wechseln Sie in das Maschinenkoordinatensystem
Lassen Sie die Maschine langsam in Richtung des Werkstücks fahren, z.B. mit dem Kommando G01 X<endpunktImWerkstück> F1
Drücken Sie auf Stop/Pause, sobald das Lager sich nicht mehr mitdreht
Notieren Sie sich die Maschinenkoordinaten bzw. verschieben das Arbeitskoordinatensystem der angetasteten Achse G92 auf diesen Punkt
Wiederholen Sie ab Schritt 2 für die nächste Achse

Your browser does not support the video tag.

Einfacher Kantenfinder im Einsatz.

Hardware Test

Schallbert — Sun, 23 Apr 2023 00:00:00 +0000

Ein neuer Antrieb

Kürzlich habe ich Zerspanobert ein Spindel-Upgrade gegönnt. Ich bin jetzt auf eine Drehstrom-Asynchronmaschine umgestiegen, welche mit einem 24V-Lüfter fremdgekühlt wird. Für den Betrieb im benötigten Drehzahlbereich musste ich in einen Frequenzumrichter investieren, der in meinem Falle wie beim vorigen Fräsmotor auch über ein analoges 0-10V Signal gesteuert wird. Aus Sicht der CNC ist die neue Spindel bis auf eine Ausnahme identisch mit der alten: Der Frequenzumrichter kann nun ein “Not-Aus” Signal erzeugen und an die Steuerung melden, z.B. wenn die Drehzahl ungeplant abfällt, zu lange ein Überlastzustand auftritt etc.

Wie man sich vorstellen kann ist das neue Subsystem rund um die Spindel deutlich komplizierter als das alte.

Warum extra Tests?

Mit höherer Systemkomplexität erhöht sich auch das Risiko für Fehlfunktionen. Es sind eine Menge mehr elektrischer, elektronischer und mechanischer Bauteile verbaut als bei meinem Fräsmotor, die selbst Defekte aufweisen oder bei falscher Verdrahtung selbst in Rauch aufgehen können. Da ich als Systemdesigner selbst nur ein Mensch bin der Fehler macht, wäre es nicht besonders schlau, das System irgendwie zusammenzustecken und dann direkt auszuprobieren.

Während ich die Verdrahtung erstellte, überlegte ich mir also, wie ich das System effizient testen könne, ohne etwas zu zerstören.

Teststrategie

Ich habe die unterschiedlichen Testbereiche von meiner Arbeit in der Softwareindustrie geborgt. Sie passen hier denke ich recht gut hinein:

Unit: Ein Test, der das Verhalten einer Komponente des Systems isoliert überprüft. Alle externen Einflüsse wurden entweder entfernt oder durch Komponenten ersetzt, auf die im Test selbst problemlos zugegriffen werden kann. Beispiel: Prüfe, ob der Lüfter bei Anlegen seiner Betriebsspannung wie erwartet im richtigen Drehsinn anläuft.
Integration: Diese Tests prüfen das Zusammenspiel verschiedener Komponenten, welche gemeinsam eine Funktion abbilden. Beispiel: Überprüfe, ob die Luftkühlung der Spindel auch nach Abschalten derselben für eine bestimmte Zeit nachläuft.
Subsystem: Verifiziert die korrekte Interaktion aller Komponenten eines Subsystems. Beispiel: Die Spindeldrehzahl kann über eine analoge Spannung am Eingang des Frequenzumrichters verändert werden.
System (End2End): Diese Tests werden aus Kundensicht ausgeführt und durchlaufen das komplette System. Beispiel: Wenn ich den Not-Aus an der CNC betätige, muss der Frequenzumrichter die Spindel umgehend sicher zum Stillstand bringen.

Teste früh

Aus meiner Erfahrung macht es Sinn, die Tests zum frühestmöglichen Zeitpunkt durchzuführen. Nachdem die Spindel geliefert worden war, konnte ich auf diese Weise sofort nachvollziehen, ob alle Lager leichtgängig sind, ob der Lüfter funktioniert und ob der elektrische Widerstand der Statorwicklungen im erwarteten Bereich liegt. Alle diese Tests waren durchführbar noch bevor ich mit dem Bau des Schaltschranks überhaupt begonnen hatte.

Your browser does not support the video tag.

Unit test: Lüfter

Die schnell und einfach durchführbaren Unit Tests können einen Haufen Zeit sparen, denn diese Fehlerquellen kann man später bei der Inbetriebnahme direkt ausschließen. Und findet man doch etwas so früh, kann man sich direkt um Ersatz kümmern und hält nicht den Einrichtbetrieb auf.

Teste “von unten nach oben”

Bei den vier Testebenen versuche ich, so viel wie möglich mit einfachen und schnellen Unit Tests abzudecken. Was hier noch nicht geht, wird jeweils auf der nächsthöheren Ebene abgearbeitet und so weiter. Am Ende möchte ich nur ein paar Wenige Tests aus Kundensicht durchführen, da diese meist einen größeren Aufwand für Vor- und Nachbereitung benötigen und außerdem zumeist nicht genau in der Lage sind, den Fehler zu lokalisieren.

Dies deckt sich mit dem Konzept der Testpyramide, welche in der Softwareentwicklung des Öfteren herangezogen wird.

Testplan

Für meine privaten Hobbyprojekte schreibe ich üblicherweise keinen Testplan. Meine Systeme sind meist deutlich einfacher als dieses. Außerdem benötigen nur die wenigsten potentiell gefährliche Niederspannung wie in diesem Fall.

Um das System besser zu visualisieren habe ich mal einen groben Schaltplan mit allen Komponenten sowie relevanten Ein- und Ausgängen gezeichnet.

Von diesem Bild habe ich einen Testplan abgeleitet. Hierbei habe ich versucht, die Interaktionen jeder Komponente mit jeder anderen abzudecken und wenn möglich versucht, dem Komponententest den Vorrang zu geben.

Your browser does not support the video tag.

Unit test: Stromversorgung +24V OK

Hier überprüfe ich die Versorgungsspannung für den 24V-Lüfter

Your browser does not support the video tag.

Unit test: Abfallverzögerung

Mit diesem Test stelle ich sicher, dass die Konfiguration der Anzugs- und Abfallverzögerung wie gewünscht funktioniert. Für den Test habe ich kürzere Zeiten gewählt als später im produktiven Betrieb.

Your browser does not support the video tag.

Integrationstest: FU Inbetriebnahme

Hier prüfe ich, ob der Frequenzumrichter die Spindel mit der korrekten Drehrichtung und mit unterschiedlichen Drehzahlen betreiben kann.

Ausführung der Tests

Es gibt natürlich noch viele weitere hardwarebasierte Tests die ich oben nicht erwähnt habe. Dinge wie “ist die Spindel korrekt mit der Z-Achse ausgerichtet?” “Habe ich alle Schrauben mit dem vorgeschriebenen Drehmoment angezogen?” “Sind alle Stecker angeschlossen und verriegelt?”

Bevor ich nach dem Umbau also das erste mal wieder Späne mache, habe ich den Testplan komplett abgearbeitet und tatsächlich ein Problem auf Systemebene entdeckt: Ich habe den Analogausgang zur Vorgabe der Spindeldrehzahl falsch verdrahtet, sodass andere Pins das Signal führten als geplant. Dies führte dazu, dass sich die Spindel trotz Freigabe nicht starten ließ, obwohl die CNC “Spindel läuft” ausgab.

Dank der vorausgehenden Tests am Frequenzumrichter (“Reacts to speed command”) habe ich nur Minuten benötigt um den Fehler zu finden und zu beheben - denn ich wusste, am FU liegt’s nicht.

Dokumente

Falls Sie planen, eine Frequenzumrichtergesteuerte Motorspindel an Ihrer Maschine einzusetzen, können Sie sich meinen Testplan kostenlos herunterladen. In case you plan on adding a VFD-controlled spindle motor to your machine, please find my full test plan below.

VFD-controlled spindle motor test plan

Aber bitte betrachten Sie diesen Plan mehr als Unterstützung denn als vollumfängliche Prüfung und beachten Sie vor allem die üblichen Warnhinweise:

⚠️ Warnung vor gefährlicher Spannung ⚠️

Dieses System sollte nur von Profis konstruiert, zusammengebaut, angepasst, in Betrieb genommen und schließlich fachgerecht geprüft werden. In diesem Falle meine ich mit “Profi” jemanden, der eine abgeschlossene Berufsausbildung zum Elektriker oder Elektroniker, optimalerweise in der Fachrichtung Anlagenbau/Betriebstechnik sowie Erfahrung im Umgang mit Industrieelektronik vorzuweisen hat. Vermeiden Sie insbesondere, unter Spannung stehende Teile zu berühren oder an einer der Komponenten zu arbeiten, bevor der Frequenzumrichter nach dem Abschalten genügend Zeit hatte, seine Pufferkondensatoren zu entladen.

Dibond Tests

Schallbert — Fri, 10 Mar 2023 00:00:00 +0000

Anmerkung: Die in diesem Artikel analysierten Gravuren sind recht fein. Die Schrifthöhe beträgt zwischen 3 und 6mm, und die Größe des Werkstückes liegt bei 80x80mm. Blickt man von einer Distanz von 30cm oder mehr auf das Werkstück, so sind die rauen Kanten etc. nicht mehr wahrnehmbar.

Weitere Qualitätsverbesserungen bei Arbeiten mit Dibond

Die in meinem letzten Fräsprojekt in Dibond erzielten, nur mittelmäßigen Ergebnisse wollte ich so nicht auf mir sitzen lassen. Deshalb habe ich mögliche Einflussgrößen ersonnen und niedergeschrieben.

In diesem Artikel versuche ich, sie Stück für Stück zu analysieren und schließlich, falls erforderlich, auszuschalten.

Mögliche Gründe für schlechte Qualität

Untersuchung der Fräser

Ich bin kein Fräserexperte, aber ich kann mir kaum vorstellen, dass ein VHM-Fräser nach nur dreißig Arbeitsminuten in Kontakt mit 0.3mm starkem AlMg1 stumpf sein soll (Na gut, da mögen ein paar Zusätze drin sein für die gebürstete Oberfläche samt Färbung). Die Schneiden sehen recht sauber aus. Das Einzige, was mir auffällt, ist eine dünne Schicht Aluminium, welche der Schneide anzuhaften scheint.

Diese habe ich vorsichtig mit einem Cuttermesser entfernt. Nun sehen sie wieder normal aus.

Update Okt-23: Ich habe mit denselben Graviersticheln - Sie sind inzwischen ca. 4h gelaufen - etwas in Acrylglas (PMMA) gefertigt. Die Schnittkanten sind hier rauer als bei brandneuen Gravierfräsern.

Schneidengeometrie

Die für diesen Test verwendeten Fräser haben keine Spiralnut zur Spanabfuhr, sondern sind auf der Eingriffseite offen ausgeführt. Daher ist aber auch stets die komplette Schneide im Eingriff und ich frage mich, ob das einen Unterschied macht. Vielleicht wäre eine gewundene Schneide (Habichtschnabel, Helix) hier besser geeignet?

Hintergrund dieser These ist, dass mein CAM-Werkzeug für Gravuren keine Pendelbewegung oder Helix zum Eintauchen verwendet sondern stets gerade in das Material eintaucht. Wenn man bei den Bildern unten (z.B. in der Vergrößerung des t) genau hinsieht, so erkennt man Kratzer im Klarlack, wo der Fräser ins Material eingetaucht ist und die Späne nicht hat rechtzeitig abführen können.

Auf der anderen Seite werden spiralgenutete Fräser das Material nach oben ziehen. Da das Aluminiumblech lediglich thermisch mit dem PE-Kern verklebt ist, könnte die Haltekraft besonders bei filigranen Gravuren durchaus zu gering sein und sich die Aluminiumschicht ablösen - die Gefahr ist besonders hoch bei Inseln, wie es sie z.B. bei den Buchstaben e, a, o, g, p... gibt.

Kurzgesagt Gravierfräser mit Spiralnut kaufen, ausprobieren und die Fräsergebnisse hier dokumentieren

Ungeeignete Parameter für Vorschub und Drehzahl

Ich habe die empfohlenen Parameter nochmal geprüft, mit dem Hersteller der Fräser besprochen und sie auch in ein paar Berechnungstools eingegeben. Optimalerweise werden sie bei noch höherer Drehzahl als 24000U/min betrieben, was an meiner Maschine allerdings das Maximum ist - also behalte ich das so bei.

Also bleibt mir jetzt noch der Vorschub zum Herumspielen übrig. Schnell eine Testgravur im CAD erstellt und im CAM dann mit verschiedenen Vorschüben abfahren lassen: F600mm/min, F800mm/min sowie F1000mm/min.

In diesem Bild kann man viele Dinge erkennen:

Die Beschriftungen für verschiedene Vorschubgeschwindigkeiten sind so klein geraten, dass der Gravierstichel nicht einmal die Aluminiumschicht vollständig durchbricht. Vielmehr quetscht er das Aluminium in die darunter liegende Polyethylenschicht und zur Seite weg.
Obwohl ich die Vorschubgeschwindigkeit um bis zu 20% pro Umdrehung verändere, bleibt die Schnittqualität gleich. Dies bestätigt, dass für meinen Stichel in Dibond ein Vorschub von F1000mm/min in Ordnung ist.
Es ist deutlich zu sehen, dass die äußeren Kanten der Gravur rau sind. Ich kann dies fühlen, wenn ich mit dem Finger über das Werkstück streiche.
Die inneren Ränder der Gravuren sind wirklich glatt. Sie glänzen im Gegensatz zu ihren matten Gegenstücken.
Die schwarzen, inneren Teile der Spirale sind sehr gleichmäßig und ohne Schnittspuren gefertigt.
Das große T des Wortes “Test” sieht etwas seltsam aus, da senkrechte Kerben an der Schnittkante auftreten. Darauf kommen wir später noch zu sprechen.

Kurzgesagt: Drehzahl- sowie Vorschubparameter sind OK und scheinen für mein Problem nicht die Ursache gewesen zu sein.

Gleichlauf- vs. Gegenlauffräsen

Um zu entscheiden, ob es bei der Verarbeitung von Aluminiumsandwichplatten eine bevorzugte Fräsrichtung gibt, schauen wir uns die Spirale etwas genauer an:

Die schmalere Linie wurde in einem Schritt gefertigt während die breitere einen zweiten Durchlauf mit nur Z-0.1mm Tiefenzustellung hat. Sofort ist zu erkennen, dass die Gravur außen viel glattere Kanten hat als innen. Die Spirale wurde von außen nach innen mit einer rechtsdrehenden Spindel gefräst. Das bedeutet also, dass außen im Gegenlauf und innen im Gleichlauf gearbeitet wurde.

Kurzgesagt wird auf einer CNC zwar eher der Gleichlauf empfohlen, bei der Bearbeitung von Dibond ist unter Verwendung von Graviersticheln jedoch im Gegenlauf mit deutlich besseren Ergebnissen zu rechnen.

Zu niedrige Gravurtiefe

Wie die Bilder oben zeigen, sollte die Aluminiumschicht beim Gravieren satt durchbrochen werden. Nach ein paar weiteren Tests konnte ich die minimale Gravurtiefe bei 0.3mm Schichtstärke des Blechs bei etwa 0.5mm ermitteln.

Zu hohe Gravurtiefe

Diese Mutmaßung ergab sich bei meinem vorigen Experiment mit Dibond. Zum Vergleich habe ich hier zwei verschieden Dicke Gravurpfade gefertigt. Tiefere Gravuren werden tatsächlich etwas sauberer, wenn man sie mit einem Schlichtgang nochmal nachzieht. Für schmale Gravuren halte ich die Verbesserung für vernachlässigbar. Daher ist eine Hohe Gravurtiefe meiner Einschätzung nach kein Problem.

Vibrationen

Betrachtet man erneut die Kerben und Unregelmäßigkeiten an der Schnittkante, so liegt der Schluss nahe, dass sie sich aus der gebürsteten Oberfläche ergeben. Tatsächlich nämlich wird die Oberfläche aber nicht gebürstet, sondern unter hohem Druck mit Hilfe von Walzen geprägt. Die Kerben könnten also durch Dichteunterschiede im Material begünstigt werden. Es gibt aber eine weitere mögliche Ursache: Maschinenvibrationen.

Die Texte wurden mit verschiedenen Vorschubwerten gefertigt. Die Zahlen geben hierbei den Vorschub an: 6 bedeutet 600mm/min und so weiter. Ich habe noch ein weiteres Bild gemacht, was die Buchstaben nochmal stärker vergrößert darstellt. Hier zeigt sich, dass die Texte bei größerem Vorschub ein klein wenig besser aussehen.

Im letzten halben Jahr habe ich viel mit den mechanischen Werten der Maschine experimentiert, um die Grenzen auszuloten. Ich habe damals recht hohe Werte für Geschwindigkeit und Beschleunigung festgelegt, da ich die Maschine für fähig hielt, diese zu unterstützen. “Unüblich hoch” nannte der Hersteller der Steuersoftware diese Werte, als ich ihn wegen eines anderen Problems kontaktierte (“Velocity was higher than max!”).

Also habe ich ein weiteres Teststück designt, wo ich nur gerade Linien und Texte gravieren würde, sodass rechtwinklige Ecken entstehen an denen die Maschine auf null abbremsen und von dort wieder beschleunigen würde.

Dieses mal habe ich den Vorschub bei F1000mm/min belassen, aber in jedem Durchgang die Beschleunigungswerte der Maschine verändert.

Dieses Experiment zeigt, dass die vertikalen Kerben bei geringerer Beschleunigung deutlich weniger sichtbar werden und unterhalb irgendwann sogar ganz verschwinden. Da ich die Maschine für diese Anpassung stets neustarten musste, waren Werkzeug und Z0-Höhe immer neu einzumessen. Möglicherweise hatte ich ein Staubkorn unter dem Werkzeuglängensensor bei der Vermessung für die geringste Beschleunigung, daher kommt die Gravur hier nicht ganz so gut hervor.

Testergebnisse: Detailaufnahmen von Stichel und Material bei variabler Maschinenbeschleunigung.

The 6mm 90° 0.5m tip V-cut tool. At the cutting edge, there's a little built-up material.

It has been used for roughly 30minutes. The cutting edge looks intact.

Minimal residues of Aluminium seem to stick to its tip.

Also here, the tip colour is different than the rest of the bit.

Result with high machine acceleration

Result with medium machine acceleration

Result with low machine acceleration.

Beleuchten wir kurz, ob die Maschine bei diesen kleinen Strukturen überhaupt die Zielgeschwindigkeit von F1000mm/min erreichen kann: Die Texthöhe beträgt s0=6mm, sodass die Maschine bei a=800mm/s², etwa t=F/a=20ms für die Beschleunigung auf den angepeilten Vorschub benötigt. Dabei legt sie eine Distanz von s=a/2*t^2=0.17mm zurück. Daher wird für s1=6-2*0.17=5.66mm mit voller Geschwindigkeit verfahren, z.B. für den vertikalen Strich im Buchstaben t. Hier sind die kinematischen Gleichungen mal wieder sehr nützlich gewesen 😃

Jetzt wäre es noch interessant, die Eigenfrequenz der Maschine in X-Richtung zu bestimmen, denn hier treten die Kerben ja auf. Meine Überschlagsrechnung ergibt: 11 Kerben auf 6mm Weg bei einer Geschwindigkeit von F1000mm/min --> F16.67mm/s ergibt fE=30Hz. Da die Anregung der Maschine in der “Ansteigenden” Halbwelle geschieht, sollte ich stets versuchen, die Maschine weit weg von t=1/(2f) = 16ms auf Zielgeschwindigkeit zu bringen und so die Resonanzfrequenz vermeiden.

Kurzgesagt: Die kinematischen Parameter sollten - besonders bei weniger steifen und eher leichten Maschinen - fein auf die jeweilige Fräsmaschine angepasst werden. Hierbei it es hilfreich, die Eigenfrequenz der instabilsten Achse zu kennen und “weiträumig” zu umschiffen. Für meine Maschine habe ich festgestellt, dass eine Beschleunigung von a=400mm/s² noch ausreichend zügig ist, meine Probleme mit am Werkstück sichtbaren Schwingungen aber löst.

Halterung des Fräsmotors

Ich wusste, dass dies bei Überlastung der Maschine ein Problem darstellen würde. Für Gravurarbeiten jedoch fräst die Spindel quasi im Leerlauf. Daher klammere ich diesen Aspekt hier aus.

Unwucht des Fräsers oder der Spannzange

Wenn dies der Fall gewesen wäre, hätte ich ungewöhnliche Geräusche oder Vibrationen der Maschine wahrnehmen müssen. Da dies alles nicht vorlag, schließe ich Unwucht des Werkzeugs als Ursache aus.

Maßnahmen

Fräser nach Benutzung prüfen und reinigen, bei übermäßigem Verschleiß austauschen.
Vermeiden von Gleichlauf bei der Verarbeitung von Dibond. Die Gravurpfade lieber minimal weiter auslegen und dann beide Seiten der Gravur im Gegenlauf fertigen.
Bei höheren Gravurtiefen einen Schlichtgang hinzufügen
Maschinenbeschleunigung in Verbindung mit Vorschüben bei weniger steifen Maschinen drosseln.
Vor Einstieg in die Fertigung ein paar Probefräsungen durchführen.

Dieses Teil wurde nach Ausführung der oben genannten Maßnahmen gefertigt.

Aluminiumverbundmaterial

Schallbert — Thu, 02 Mar 2023 00:00:00 +0000

Experimente mit Dibond

Ein Freund von mir gründet gerade eine Unternehmung. Er wollte etwas haben, was er seinen Kunden geben kann, etwas, an das sie sich erinnern und so erneut seine Dienste in Anspruch nehmen würden. Es sollte nicht der Standard-Kugelschreiber oder die Tasse sein. Sondern etwas, das etwas näher an dem dran ist, was er selbst tut. Irgendwas metallisches. Vielleicht eine Visitenkarte aus Metall, mit dreidimsionalen Touch. Etwas Graviertes.

Als ich passende Materialien recherchierte, stieß ich auf Aluminiumverbundplatten. Dies sind Sandwichplatten, die einen Kern aus Polyethylen besitzen, welcher auf beiden Seiten mit dünnen Aluminiumblechen kaschiert sind. Solche Platten sind bekannt unter den Markennamen Dibond®, Dilite®, Alcubond® etc. und werden blank oder beschichtet, lackiert oder sogar mit strukturierter Oberfläche angeboten.

“Der PE-Kern ist schwarz durchgefärbt, also könnte es sich prima für Gravurarbeiten eignen”, dachte ich.

Also habe ich ein paar Muster bestellt und sie meinem Freund gezeigt. Er war völlig aus dem Häuschen. Und so begann es.

Der Untersetzer

Wir überlegten, was wir alles mit diesem Material anstellen könnten. Es sollte leicht zu designen sein und nicht zu groß werden, sodass es leicht als Werbegeschenk weitergegeben werden kann.

Ich wusste, dass Alu-Sandwichplatten zu dreidimensionalen Objekten gefaltet werden können (Youtube video link) - Aber das schien uns zu kompliziert für den Anfang. Daher war die nächste Idee:

Untersetzer gravieren. Rund oder quadratisch mit abgerundeten Ecken, sogar besondere Formen sind möglich.

Ich begann, ein paar meiner Gravurfräser für ein paar Experimente auf das Material loszulassen. Die Qualität sah OK aus, war aber noch lange nicht perfekt. Die Aluminiumschicht neigt dazu, zu verschmieren und möchte dem Fräser ausweichen, also drückt es sich beim Eintauchen (90°) in das weichere Polyethylen ein und benötigt so höhere Gravurtiefen als die Blechdicke allein vermuten lassen würde.

Der Freund von mir meinte jedoch, ich solle es einfach weiter probieren. Und so bestellte ich ein paar Platten und setzte die Experimente fort.

Fräser, Vorschübe, Drehzahl

Da die Untersetzer filigrane Teile kleiner als 100x100mm sind, nutze ich kleine Fräser:

		[mm]	[RPM]	[mm/min]	[mm]	[mm]
Acrylfräser 30° upcut	1	2	24000	1600	800	3
Gravierfräser 90°	1	6	24000	1000	500	1.5

Die Werte mögen für die Aluminiumbearbeitung zu aggressiv sein, ich muss aber einen Mindestvorschub einhalten um den PE-Kern des Plattenmaterials nicht aufzuschmelzen. Die Späne sehen jedenfalls gut aus - kurz und dick. Mit diesen Werten gibt Zerspanobert beim Fräsen eine ruhiges, summendes Geräusch von sich.

Das erste Teil

Ich habe zuerst den Halter für die Untersetzer gefertigt. Er besteht aus vier Teilen, die einfach zusammengesteckt werden können. Sie müssen nicht geklebt werden, da ich eine Übergangspassung gewählt habe. Ich verwende einen Anschlag als Orientierung für den XY-Nullpunkt des Werkstücks, da ich beidseitig fräsen möchte. Auf diese Weise kann ich die Ausschnitte in einem letzten Schritt anbringen und den Vakuumdruck auf meinem Tisch bis zu diesem letzten Schritt aufrechterhalten. Außerdem wollte ich vermeiden, dass ich die Teile manuell nachbearbeiten muss.

Der erste Versuch war miserabel - die vorderen und hinteren Fräsbahnen waren nicht perfekt ausgerichtet. Schon ein paar Zehntelmillimeter Versatz zwischen Vorder- und Rückseite machen hier einen großen Unterschied, also musste ich die Ursache beheben (Kanten am Anschlag, die ich vorher nicht bemerkt hatte und die ich abschleifen musste) und es erneut versuchen.

Hier ist das Ergebnis:

Ich bin ziemlich zufrieden damit. Ich musste keine manuelle Nacharbeit leisten - die Teile sind einfach so aus der CNC gefallen. Die Fasen allerdings, die ich hinzugefügt habe, um dem Material eine glatte Oberfläche zu geben, waren leider von sehr unterschiedlicher Qualität. Während sie auf der “Rückseite” wirklich gut geworden sind, fühlen sie sich auf der Vorderseite viel rauer an. Hier musste das Werkzeug aber auch tiefer eintauchen.

Sechs Stück auf einmal

Dann wählte ich ein einfach herzustellendes Logo - das Bitcoin-Blitz-Symbol - und plante einige einfache Gravurpfade, um es zu gravieren. Auch hier habe ich zweiseitig gefräst, so dass das Material nicht vollständig durchtrennt wird. Unten bleibt eine hauchdünne Schicht Aluminium stehen, die in einem zweiten Durchgang auf der Unterseite beim Fase fräsen entfernt wird.

Die Maschine brauchte für diesen Job etwa 20min. Leider erwies sich der Anschlag als zu ungenau, um Vorder- und Rückseite mit demselben Nullpunkt passgenau zu fertigen. Der Ausschnitt an der Unterseite wich nur um ein oder zwei Zehntelmillimeter ab, was in meinem Fall die Gesamtabweichung verdoppelt, wenn ich ihn um seine diagonale Achse drehte. Auf diese Weise hatte ein Teil der Kontur meines Untersetzers eine sehr tiefe Fase, während die andere Hälfte überhaupt keine Fase aufwies.

Ich muss bald eine Lösung dafür finden. Bis dahin schleife ich die Kanten von Hand nach. Dann habe ich die restlichen Späne entlang der Gravurwege mit einer Zahnbürste entfernt und das obige Titelfoto aufgenommen.

Qualitätsanalyse

Nachdem ich das Teil genauer untersucht hatte, machte ich die folgenden Beobachtungen:

Prototypen eines Untersetzers aus Metall.

Top sheet machining complete. Cutout and engravings.

Coaster holder cutouts, bottom view

Rough edges where engravings are more deep

Less wide engravings looks more clean.

Residues and chips left in the engrave channels

Wondering why engrave quality reduces on deeper engravings

Alle Teile sehen gleich aus

Das sind doch gute Neuigkeiten. Es bedeutet, dass die Fräser, die ich erstmals bei vhf gekauft habe, scharf geblieben sind und ihr Durchmesser daher konstant war. Ich kann mit den eingestellten Schnittweiten also wahrscheinlich viele weitere Prototypen fertigen. Dibond scheint also ein weniger anspruchsvolles Material zu sein als HPL, wo meine Fräser oft nach zwei Teilen bereits abgenutzt sind und z.B. Passungen klemmen - mehr dazu in diesem Beitrag.

Es bedeutet auch, dass die Maschine keine Schrittverluste oder andere mechanische Probleme hat, und dass mein Klemmbereich eben ist, sodass der 90°-Gravierstichel sehr gleichmäßige Fräsergebnisse liefert. Linien behalten durch die zur Ausrichtung der Z-Achse orthogonale Ebene des Maschinentisches eine einheitliche Breite.

Breitere Gravuren sind qualitativ schlechter als schmalere

Ich bin mir nicht sicher, warum. Da ich noch kein Experte im Umgang mit Dibond bin und keine Ausbildung als Zerspanungsmechaniker vorweisen kann, muss ich raten: Bekommt der Gravierstichel die Späne nicht rechtzeitig aus dem Fräskanal heraus gefördert? Dadurch würde er sie bei der nächsten Drehung erneut erfassen und “durch das Material ziehen”.

Sollte dies der Fall sein, würde ein zusätzlicher Schlichtgang Abhilfe schaffen.

Kantenbrechen ohne vorherige Nutfräsung ergibt rauere Schnittkanten

Hier könnte ich es mit demselben Problem wie oben zu tun haben. Ich probiere es mal mit einem zusätzlichen Schlichtgang aus und schaue, ob es dann besser wird. Eine Tiefgehendere Analyse hierzu gibt es in diesem Beitrag Eine weitere Alternative wäre, mit Vorschub und Drehzahl herumzuprobieren um das Optimum herauszufinden. Dafür benötige ich aber erst einmal frisches Material 😅

Zweiseitige Bearbeitung? Werkstückposition präzise festlegen!

Offensichtlich war ich nicht in der Lage, die Position des Werkstückes nach dem Umdrehen auf die Rückseite mit Hilfe eines Anschlags genau genug festzulegen. Hier reichen ein paar Zehntelmillimeter Abweichung und die Sandwichplatte ist Schrott.

Lösungsansätze:

Einen Job00 einfügen, der Locatorlöcher (Positionsgeber) mit 5.04mm Durchmesser in einen Teil des Werkstücks einbringt, was später ein Abfallstück wird. Wenn ich sie symmetrisch platziere und diese Löcher ebenfalls im Frästisch fertige, so kann ich Passstifte einbringen, die mir die genaue Werkstückpositionierung beim Drehen auf die Rückseite sicherstellen.
Die Position des Anschlags überprüfen und sicherstellen, dass das Rohteil genau rechtwinklig und ohne Lichtspalt dort anliegt.
Ich könnte auch durchfräsen und die scharfen Kanten auf der Rückseite an einem Frästisch von Hand brechen. Da ich allerdings a) keine Frästisch besitze, b) meine Werkstücke oft sehr klein sind und c) Ich manuelle Nacharbeit verabscheue, wird dies wohl eine Rückfallebene bleiben für den Fall, dass die beiden obigen Lösungen für mich nicht funktionieren.

Einige Späne kleben in der Fräsnut fest

Ich habe keine Ahnung, warum. Werden die Späne zu heiß und schmelzen sich in die Polyethylenschicht ein? Ich werde wohl mal mit dem Fräserhersteller telefonieren müssen, um das zu klären.

Zusammenfassung

Alles in Allem kann ich einigermaßen zufrieden sein. Die Maschine ist in der Lage, Dibond und andere Aluminiumverbundmaterialien zu bearbeiten und die Ergebnisse sehen für einen ersten Versuch OK aus. Das Verbundmaterial nutzt die Fräser nicht übermäßig schnell ab und sieht einfach toll aus im Kontrast mit dem schwarzen Kern. Die Späne stören mich allerdings etwas, denn sie haften überall an und mögen ungern abgesaugt werden.

Dennoch. Die Qualität überzeugt mich noch nicht voll. Ich werde weiter probieren und meinen Fortschritt im Blog dokumentieren.

Github Actions: Fehler beheben

Schallbert — Tue, 14 Feb 2023 00:00:00 +0000

Motivation

Warum ich einen Beitrag zu Github Actions schreibe, obwohl es im Internet zahllose Tutorials und Blogeinträge zum Thema gibt? Weil ich für mein letztes Software-Projekt QR-codengrave eine Build Pipeline aufsetzen wollte und sich dies schwieriger gestaltete als angenommen. Sollte ich das an irgend einem Punkt in der Zukunft wiederholen müssen und erinnere mich nicht, wie ich damals in der IDE gebaut, getestet und veröffentlicht habe, kann die Pipeline weiterhelfen.

Ebenso, wenn sich meine IDE ändert oder meine Virtuelle Umgebung defekt ist, die launch.json fehlt oder irgend etwas inkompatibel mit dem von mir verwendeten Compiler/Interpreter wird. Dennoch will ich in der Lage sein, Releases zu veröffentlichen, Bugfixes zu erstellen und Tests zu fahren.

Obwohl das nicht das übliche Argument ist, eine CI/CD Pipeline aufzubauen - normalerweise wird da zuerst die einfachere Zusammenarbeit mehrerer Menschen an einem gemeinsamen Programm(teil) genannt - ist der Anreiz für mich stark genug, mir mal Githubs Automation dafür, bekannt unter dem Namen Github Actions, auszuprobieren.

Meine Software ist zu unbedeutend um “Nightlies” zu bauen oder agil entwickelt zu werden, und daher werde ich die Pipeline auf “build”, “lint/static code checks”, “testing” und “deployment” beschränken und dies auch nur dann automatisch triggern, wenn es Änderungen auf dem Produktionsbranch gibt.

Alles klar, aber warum ein extra Blogeintrag?

Weil es mich so viel Zeit gekostet hat, alles richtig aufzusetzen. Ich habe dafür stundenlang Fehler suchen, oft fluchen und wütend Spaziergänge machen müssen, bevor ich meine in der IDE bereits getestete und lauffähige Software auch mit Github vereinen zu können.

Wäre ich klüger gewesen, hätte ich gleich zu Anfang nach Tools dafür recherchiert wie dieses hier, sodass Github Actions auch lokal ausgeführt werden kann. Dies hätte mir die ständigen Pushes und Wartezeiten auf den nächsten, immer noch fehlerhaften Build ersparen können.

Das Script

Github Actions benutzt YAML um Befehle der Nutzer zu interpretieren. Die Verwendung ist sehr gut dokumentiert und stellt einige plug-and-play Beispiele bereit, die in vielen Szenarien und für die meisten Programmiersprachen direkt passen.

Die sogenannte “Workflowdatei” sieht so aus:

# This workflow will install Python dependencies, run tests and lint with a single version of Python
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python

name: python_integrate

on:
 push:
 branches: [ "master" ]
 pull_request:
 branches: [ "master" ]

permissions:
 contents: read

jobs:
 build:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v3
 - name: Set up Python 3.10
 uses: actions/setup-python@v3
 with:
 python-version: "3.10"
 - name: Install dependencies
 run: |
 python -m pip install --upgrade pip
 pip install flake8 pytest
 pip install qrcodegen # Dependency install of qrcodegen
 if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 - name: Lint with flake8
 run: |
 # stop the build if there are Python syntax errors or undefined names
 flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
 # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
 flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
 - name: Test with pytest
 uses: GabrielBB/xvfb-action@v1  # Diverts tkinter GUI to a virtual frame buffer (VFB)
 with:
 run: |
 pytest

Dieses sieht nicht einmal groß anders aus als die Vorlage mit der ich gestartet bin. Die einzigen Anpassungen waren der nun vorhandene pytest Aufruf sowie das Hinzufügen eines virtuellen Bildpuffers um Darstellungsprobleme meiner GUI zu lösen. Meine Tests schlugen nämlich fehl sobald die GUI gestartet wurde, da auf den Github Servern gar kein Display zur Verfügung steht.

Github Action runner Fehlermeldungen

Die folgende Liste enthält die Fehler (und zugehörige Lösungen) mit denen ich konfrontiert wurde, bevor ich eine stabile CI aufsetzen konnte - erst nach fast 50 Durchläufen.

Ordner nicht vorhanden?

Output:

/opt/hostedtoolcache/Python/3.10.9/x64/lib/python3.10/importlib/__init__.py:126: in import_module
 return _bootstrap._gcd_import(name[level:], package, level)
test/test_machinify_vector.py:4: in <module>
 from bin.platform.machinify_vector import MachinifyVector, Tool, EngraveParams
E ModuleNotFoundError: No module named 'bin'

Hintergrund: Ich habe meine Quelldateien unter /bin abgelegt und meiner lokalen Instanz von Pyinstaller (das Werkzeug, was ich auswählte, um aus den Skripten eine ausführbare Datei zu erzeugen) zur Verfügung gestellt. Beim Upload konnte Github Actions die Pfade nicht auflösen und zeigte diesen Fehler an.

Lösung: Eine leere Datei mit Namen __init__.py im /bin Ordner ablegen. Dies zeigt alle im Ordner befindlichen Dateien als Package an, die so für Github Actions verfügbar werden. Die IDE hatte dieses Problem nicht, weil sie alle im Projektordner befindlichen Dateien automatisch indiziert.

YAML Syntaxfehler

Diese Fehler entstanden, weil ich versucht hatte, mehrere Workflows in eine Datei zu schreiben. Github Actions scheint nur einen Workflow pro Datei zu akzeptieren.

Fehler: Pfad-nicht-gefunden

Ich hatte lange Probleme mit solchen Fehlern bedingt durch meine Ordnerstruktur:

- assets  # images, persistence file, etc.
- src  # source files
- test  # pytest files for unit and integration testing
- dist  # build artifacts
- build  # build process files

Ich fand die echt schön aufgeräumt. Aber meine lokale IDE, PyInstaller und Github Actions bzw. dessen worker für Pyinstaller waren sich nicht einig, wie sow etwas aussehen soll. Immer würde sich eine der beteiligten Parteien beschweren, dass ein Pfad nicht existiere oder die Datei soundso nicht gelesen werden könne. Daher habe ich am Ende die Verwendung relativer Pfade verworfen und stattdessen pythons importlib_resources verwendet.

Aber auch hier gab es Probleme mit Pyinstaller auf Github.

Letztendlich konnte ich das Problem erst lösen, als ich den Ordner für assets in src integrierte. Auf diese weise kann der ./ Operator nicht falsch verstanden werden. Obwohl ich dieses Konstrukt nicht so schön finde, war ich immer weniger bereit, noch mehr Zeit dort hinein zu buttern. (Wenn Sie wissen, wie sich das Pfadhandling sowohl lokal als auch remote mit Eleganz lösen lässt, freue ich mich sehr über Ihren Beitrag auf meiner Dissussionsseite).

Tkinter headless

Spät im Entwicklungsprozess habe ich meinen Unit Tests ein paar Integrationstests zur Seite gestellt. So wollte ich sicherstellen, dass Popups die erforderlichen Callbacks an Main machen würden und umgekehrt Daten ausgetauscht werden können, sodass z.B. eine Werkzeugliste an das Konfigfenster übergeben werden kann.

Diese Tests liefen lokal zwar, aber mit einem Nachteil: Wenn ich einen Fehler oder eine Warnung erzeugte, ließ sich das messageBox-Popup nicht automatisiert schließen. Es wollte unbedingt vom Nutzer selbst per Mausklick geschlossen werden. Dies ließ sich auch nicht durch einen Overlay oder Invoke der Click-Aktion umgehen.

Was also in der IDE nervig war, würde auf dem Server in der Automation zu Testabbrüchen führen. Also habe ich die bittere Pille geschluckt und eine Wrapperklasse um tkinters messageBox geschrieben, sodass ich dort ein Mock injizieren konnte was dann wiederum nicht das echte Popup triggern würde.

Ausschnitt:

class MsgBox:
 """Re-implementation due to testing purposes: With this trick, we are able to mock these windows
 so we do not have to wait for users to manually close the dialog, unblocking the application again."""
 def showinfo(self, title, message):
 showinfo(title=title, message=message)

 def error(self, title, message):
 showerror(title=title, message=message)

Als das funktionierte, habe ich die Änderungen voller Hoffnung nach Github gepusht. Und erhielt folgenden, wunderschönen Fehler:

_tkinter.TclError: no display name and no $DISPLAY environment variable

Das war zum Glück leicht zu verstehen - Tkinter wusste nicht, wo es die Fenster hinzeichnen sollte. Erscheint logisch, da der Server headless betrieben wird.

Also durchsuchte ich Foren und wurde mit nur einer Zeile Code belohnt, die dieses Problem sofort behob:

uses: GabrielBB/xvfb-action@v1 # Diverts tkinter GUI to a virtual frame buffer (VFB)

Seitdem führt Github Actions bei Pull request auf main alle tests aus und endlich ergießt sich ein langersehnter Regen grüner Häkchen kühlend auf meine heißgelaufenen Hirnwindungen. Was für ein schönes Gefühl.

QR-codengrave V1.1 / V1.2

Schallbert — Sun, 12 Feb 2023 00:00:00 +0000

Kurze Fakten des Updates

Schnellerer Gravuralgorithmus und -Pfadoptimierung
Diverse Bugfixes
Bedienbarkeit verbessert

Demo Video

QR-codengrave Quick Demo

Version 1.1

Algoritmusoptimierung

Die Zeilen des QR-Codes werden nun horizontal eingelesen
Die Ausgabe der Pfade verläuft nun “rechts nach links”, danach “links nach rechts” und reduziert damit Maschinenbewegungen
Linien werden Punkten vorgezogen, da sie schneller gefertigt werden können
Linien werden nun vertikal und horizontal berechnet, die längere Linie bekommt den Vorzug
Eilgänge werden nun per XY-Vektor gefahren und nicht mehr nur eindimensional, was Zeit spart
Der neue Pfadalgorithmus benötigt 20% weniger Maschinenzeit

Bugfixes

Bei nicht vorliegendem Datensatz Persistence.dat wird das Startbild nicht angezeigt (qruwu.jpg)
Crash bei Klick auf Stop Draw wenn zuvor keine Zeichnung angefragt wurde
Crash bei Hinzufügen eines Werkzeuges bei leerer Werkzeugliste
Wird das Programm ohne Werkzeugauswahl gestartet, ist das dropdown-Menü gesperrt
Fehler in der QR-Code Größenschätzung
Fehler in der Blockbreitenberechnung bei Verwendung von V-Fräsern
Das gegenwärtig ausgewählte Werkzeug wird bei Start der Anwendung nicht im Dropdown-Feld angezeigt
QR-codes können größer dargestellt werden der Anzeigebereich

Bedienbarkeit

Default Werkzeugname geändert von name nach default zur besseren Verständlichkeit
Fräser mit geraden Schneiden (also kein V-cut) ist jetzt das Standardwerkzeug
Erstellen eines Offsets für den XY-Nullpunkt ist jetzt intuitiver gelöst (Y- nach unten, X+ nach Rechts)

Version 1.2

Kleine Änderungen zu 1.1, am Wichtigsten die Behebung eines Bugs, bei dem die Aufforderung zum Werkzeugwechsel verloren gehen kann. Außerdem werden die Winkel von V-Fräsern jetzt bei Berechnung von Pixelbreite und Größe der QR-Codes mit einbezogen.

Bugfixes

Werkzeugauswahl Tx und Werkzeugwechselkommando M06 befinden sich nun in derselben Zeile G-Code wie üblich und können so wie gewünscht Makros auslösen.
Das beim letzten Speichern verwendete Werkzeug wird nicht angezeigt, stattdessen das erste Werkzeug der Liste
Programmabsturz wenn versucht wird, den Jobstatus zu aktualisieren obwohl keine Gravurparameter vorliegen

Bedienbarkeit

Versionsnummer als Kommentar in G-code hinzugefügt
Prefix qr_ der Zieldatei im Datei-Speichern-Dialog hinzugefügt
Genauigkeit der Maschinenzeitabschätzung verbessert

Download

Der aktuelle Release ist hier zum Download verfügbar. Das Programm ist für die private Anwendung sowie Schulungszwecke kostenlos. Für weitere Informationen und Projektdokumentation stehen die readme sowie eine Projektseite zur freien Verfügung.

Upgrade von einer früheren Version

Es wird empfohlen, die Persistenzdatei von der alten Version in die neue Version zu übernehmen. Auf diese Weise werden gespeicherte Werkzeuglisten, Gravurparameter und XY-Offsets portiert. Und so geht’s:

Wechseln Sie in den Ordner, wo sich das QR-codengrave Programm befindet. Anschließend navigieren Sie zu src/assets.
Kopieren Sie die Datei Persistence.dat in einen temporären Ordner oder z.B. auf Ihren Desktop.
Entfernen Sie die alte Version durch Löschen des QR-codengrave Ordners.
Laden Sie die letzte Version herunter und verschieben Sie sie zur gewünschten Position auf Ihrem Rechner.
Verschieben Sie nun die vorab zwischengespeicherte Persistence.dat in den src/assets Ordner des aktualisierten Programms.

Steckbrett-Lagerfeuer

Schallbert — Sat, 10 Dec 2022 00:00:00 +0000

Materialliste

Gegenstand	Menge	~Preis [€]
LED: Warmweiß, z.B. Ifwd=30mA, 3lm	5	1,50
LED: Gelb, z.B. Ifwd=35mA, 1lm	2	0,60
LED: Rot, z.B. Ifwd=35mA, 0.4lm	1	0,30
Arduino Nano Atmega328	1	18
Steckbrett klein, z.B. 170 pins	1	0,70
Brückendrähte, pin-pin, z.B. 5cm	10	3,30

Dazu: Ein paar weitere Drähte, Mini USB-Kabel, Powerbank / USB-Ladegerät

Werkzeuge

Optional: Heißklebepistole
Optional: Lötkolben

Aufbau

LED aus der Nähe betrachtet ^[1]

Die rechte Pin-Seite des Arduino Nano mit der linken Seite des Steckbretts verbinden. Dabei darauf achten, dass alle Pins auf gleicher Höhe sind und möglichst nicht mit den Fingern zu berühren, da die Gefahr einer elektrostatischen Entladung besteht, die zu Beschädigung führen könnte.
Die Anoden (+) der LEDs mit den Ausgängen D2 bis D9 auf dem Steckbrett verbinden. Die Anode ist meistens der Pin der LED, der nicht mit der Lichtquelle belegt ist (im Bild oben wäre das links).
Die Kathoden (-) der LEDs auf der rechten Seite des Steckbretts auf gleicher Höhe einstecken.
Alle Kathoden mit Hilfe von Überbrückungsdrähten verbinden. Alternativ können die Kathoden auch gleich zusammen gelötet oder mittels einer Verteilerbrücke, wie in meinem Beispiel oben verwendet, durchverbunden werden.
Verbinden Sie die “gemeinsame Kathode” mit Hilfe eines Brückendrahtes mit einem der “GND”-Pins der Mikrocontroller-Platine.
Die Anoden der LEDs sollten sich nicht berühren. Das kann man einfach sicherstellen, indem sie mit etwas Heißkleber fixiert werden.

Programmierung

Der Code ist so einfach, dass ich ihn hier in Gänze herunterschreiben kann kann. Kopieren Sie ihn in Ihre Lieblings-IDE, programmieren Sie Ihr Board und schon sind Sie fertig!

Disclaimer: Dieser Code ist “quick’n’dirty” und hat viel Potential für Refactoring. Zum Beispiel sind die Pin-IDs hartkodiert, ich verwende nicht die tollen und einfachen Features von C++11 wie Range-based for loop und der Geschwindigkeitsalgorithmus wird ziemlich oft die untere Grenze erreichen und kein zufälliges Verhalten zeigen. Ich freue mich über Ihre Verbesserungsvorschläge auf meiner Github discussions Seite.

#include <Arduino.h>

#define MAXLONG 0xFFFFFFFF
#define SPEED_HIGHLIMIT 1000 // 500Hz
#define SPEED_LOWLIMIT 0x1FFF // 20Hz

void calcFlicker(uint32_t randomFlicker);
void writeLed(uint8_t columnCode, uint16_t speed);
uint32_t iRNG = 1;

void setup() 
{
 randomSeed(analogRead(0));
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(7, OUTPUT);
 pinMode(8, OUTPUT);
 pinMode(9, OUTPUT);
 iRNG = 1;
}

void loop() 
{
 iRNG = (iRNG >> 1) ^ (-(iRNG & 1u) & 0xd0000001u);
 calcFlicker(iRNG);
}

/*
 This function takes a 32bit random value,
 and moves this value along a window of an 8bit 
 flicker output value.
*/
void calcFlicker(uint32_t randomFlicker)
{
 uint8_t currentFlicker = (uint8_t)(randomFlicker & 0xFF);
 uint16_t randomSpeed = min(SPEED_LOWLIMIT, (uint16_t)(randomFlicker & SPEED_HIGHLIMIT));
 for(uint8_t i = 0; i < 24; ++i) // 24 because of 32bit length of random, may not run empty
 {
 writeLed(currentFlicker, randomSpeed);
 randomFlicker = randomFlicker >> 1;
 } 
}

/*
 this function outputs a code to an LED column of 8 LEDs
 connected to arduino's pins with a selectable delay.
*/
void writeLed(uint8_t columnCode, uint16_t speed)
{
 digitalWrite(2, columnCode & 0x01);
 digitalWrite(3, columnCode & 0x02);
 digitalWrite(4, columnCode & 0x04);
 digitalWrite(5, columnCode & 0x08);
 digitalWrite(6, columnCode & 0x10);
 digitalWrite(7, columnCode & 0x20);
 digitalWrite(8, columnCode & 0x40);
 digitalWrite(9, columnCode & 0x80);
 delayMicroseconds(speed);
}

Testen

Sobald Sie das Gerät über USB einschalten, sollte die LED-Flackersequenz beginnen. Es sollte sich ein ruhiges Flackern einstellen. Wenn man im Regal einen leeren Platz findet und ein paar Zweige zur Hand hat, könnte das doch ganz schön aussehen, oder? Mit einer Powerbank kann man dieses Lagerfeuer auf dem Steckbrett sogar überall hin mitnehmen. Das war’s, viel Spaß damit!

Zur Hauptseite des Projektes

Vakuumpumpen

Schallbert — Fri, 28 Oct 2022 00:00:00 +0000

Was ist das?

Eine Vakuumpumpe ist ein Gerät, welches ein Gefäß evakuieren kann. Es ist also in der Lage, eine Menge an Gasatomen aus einem Gefäß zu entnehmen, sodass dieses schließlich weniger Atome pro Volumeneinheit enthält als das umgebende Medium. Dies erzeugt in dem Gefäß einen Unterdruck. Hier auf der Erde scheint es nicht möglich zu sein, die Zahl der Atome in einem Gefäß auf null zu senken, aber das ist natürlich für unsere Zweck auch nicht erforderlich. Ein technisches Grobvakuum ist hier vollkommen ausreichend.

Es gibt verschiedene Typen von Vakuumpumpen, jeder optimiert für andere Einsatzbedingungen. Doch mehr dazu später.

Wie kann die Vakuumpumpe Werkstücke festhalten?

Für Niederhalten und Spannen von Werkstücken mittels Vakuumpumpe wird ein Vakuumtisch (siehe mein Beitrag zum Thema) beziehungsweise eine Unterdruckklemmvorrichtung benötigt. Hier sind wir an der Druckdifferenz zur Umgebungsluftdruck (103000Pa = 10.3N/cm² = 1kg/cm²) interessiert. Dies ist die maximale Niederhaltekraft pro Fläche, die mit einem Vakuumtisch und dazu passend ausgelegter Pumpe theoretisch erreicht werden kann.

Volumenförderstrom vs. Unterdruck

Die wichtigsten Parameter einer Vakuumpumpe sind - wie bei anderen Pumpentypen auch - die maximal erreichbare Förderleistung, gemessen in m³/h (bei niedriger Druckdifferenz), sowie geringster erreichbarer Absolutdruck im vakuumierten Gefäß in hPa (bei niedrigem Volumenstrom) auf der Saugseite. Die Druckseite ist bei Vakuumpumpen logischerweise uninteressant.

Das erinnert mich ein wenig an die elektrische Welt, wo z.B. Leerlaufspannung (max. Druckdifferenz) und Kurschlussstrom (max. Volumenstrom) eine Spannungsquelle charakterisieren und es darum geht, einen optimalen Arbeitspunkt zu finden.

Wenn man auf eine Spannung aus ist, kann man eine Quelle nur mit einem geringen Strom belasten und so die Spannung oben halten. Anders herum kann bei geringer Spannung ein hoher Strom aus der Quelle bezogen werden. In jedem Falle ist auch bei der Vakuumpumpe ein optimaler Arbeitspunkt zu finden und den Pumpentyp entsprechend auszuwählen. Einige Pumpentypen nämlich sind auf Durchsatz optimiert und damit für andere Zwecke gut geeignet als Pumpen, die große Unterdrücke bei geringerem Volumenstrom erreichen.

Wird viel von beidem benötigt, steigen Kosten und Energiebedarf der Pumpe stark an - es kommt also wieder einmal darauf an, was man braucht, denn die “Alleskönnerpumpe” ist ökonomisch oft nicht sinnvoll.

Charakteristika der Pumpen

Ich habe mir mal die Mühe gemacht, Volumenstrom über Druckdifferenz in einem Diagramm einzutragen und für verschiedene Pumpentypen in ähnlicher Leistungsklasse auszuwerten. Dann zog ich eine Linie durch die beiden Punkte (sicher, das ist nur eine Annäherung, der wahre Verlauf ist eher asymptotisch), um sie besser vergleichbar zu machen.

Für das Beispiel habe ich willkürlich eine elektrische Leistung der Pumpe von rund 1.5kW angenommen. Die Werte habe ich aus online abrufbaren Datenblättern verschiedener Pumpenhersteller entnommen.

Natürlich ist das nur eine grobe Annäherung und gilt eher für Pumpentypen mit großem Durchsatz als für diejenigen mit hoher Druckdifferenz. Die Funktion letzterer sieht eher aus wie ein hyperbolisches Parabolid (siehe Abbildung weiter unten), da erreichbare Druckdifferenz von Leckströmen stark gemindert wird.

Wir können solch eine Kurve gut für die Arbeitspunktbestimmung verwenden: Der Hersteller des Vakuumtisch empfiehlt meist den erforderlichen Volumenstrom für das jeweilige Produkt. Dieser wird nun auf der Linie markiert, und schon ergibt sich das dann erreichbare Vakuum. Am Schluss des Artikels komme ich hierauf zurück und versuche, ein paar Empfehlungen zu geben.

Pumpentypen

Es gibt viele verschiedene Pumpentypen zur Vakuumerzeugung in der Industrie. Sie haben teils verschiedene Wirkprinzipien und selbstverständlich unterschiedliche Einsatzzwecke. Ich konzentriere mich hier auf die vier Typen, die im Hobbybereich meiner Ansicht nach am Häufigsten zum Einsatz kommen.

Radialgebläse (Sehr hoher Volumenstrom)
Seitenkanalverdichter (Hoher Volumenstrom)
Kolbenpumpe (Tiefes Vakuum)
Drehschieberpumpe (Tiefes Vakuum)

Radialgebläse

Radialgebläse beschleunigen die Luft zwischen ihren Schaufeln. Luft wird axial in Mitte des Gebläses angesaugt und durch Fliehkräfte radial nach außen gedrückt, wo sie über einen Kanal an einer Stelle radial austreten kann.

Radialgebläse werden für sehr viele Anwendungen gebaut. Sie kommen beispielsweise in Großfeuerungen von Kraftwerken, in Hüpfburgen und dem Automotive-Bereich vor und waren vor fast zwei Jahrzehnten sogar auf Grafikkarten häufiger anzutreffen (Ich hatte mal einen auf meiner ATI Radeon X1900XT). Sie sind sehr einfach im Aufbau, kostengünstig herzustellen und sind in der Lage, einen unglaublich hohen Luftdurchsatz bereitzustellen. Nachteilig sind die hohen Laufgeräuschpegel und die im Vakuumbereich relevanten, geringen erreichbaren Unterdrücke.

Wenn allerdings mit Plattenmaterial und großflächigen Werkstücken gearbeitet wird, kann diese Vakuumlösung trotzdem sehr gut passen. Im Hobbybereich können hier oft sogar günstige Staubsauger (mit Fremdkühlung durch einen eigenen Lüfter) verwendet werden.

Seitenkanalverdichter

Seitenkanalverdichter kombinieren einen hohen Volumenstrom mit mittleren Druckdifferenzen. Man kann sie als ein- oder mehrstufige Systeme erwerben (Serienschaltung). Dadurch sind sie gut auf die Bedürfnisse der Kundschaft anpassbar. Wie Radialgebläse interagieren sie nur mit dem Medium und verschleißen nicht durch Teil-zu-Teil-Reibung. Dadurch sind sie ebenso wartungsarm und tolerieren auch Dämpfe und staubige Umgebungen.

Wünscht man einen Seitenkanalverdichter mit hohen Druckdifferenzen, muss man einen sehr leistungsfähigen Motor wählen, denn die charakteristische Kurve verläuft recht flach. Die Geräuschbelästigung kann durch beidseitige Verwendung von Schalldämpfern gut reduziert werden. Dennoch sind sie bei vergleichbaren Leistungswerten teurer als Radialgebläse.

In dieser Aufzählung sind sie die eierlegende Wollmilchsau: Sie können einen passablen Unterdruck bei hohem Volumenstrom erzeugen, ihr Preis ist moderat, sie benötigen kaum Wartung und ihr unangenehmes, turbinenartiges Geräusch lässt sich mit ein paar technischen Maßnahmen in den Griff bekommen.

Ich fand diese tiefgehende Erklärung von Seitenkanalgebläsen ebenfalls nützlich: Link geht zur “GutmbH”. Und dieses Youtube-Video zeigt einen herrlich verspielten Einsatz als Verdichter.

Kolbenpumpe

Der Klassiker. Kolbenpumpen werden sowohl für Kompressoren als auch für Vakuumpumpen verwendet. Sie stellen bei vergleichbar geringen Volumenströmen hohe Druckdifferenzen bereit, benötigen nicht viel Platz in der Werkstatt, und sind schon allein durch die hohen Produktionsvolumen günstig in der Anschaffung.

Auf der anderen Seite bieten sie nur einen pulsierenden Luftstrom und sind konzeptbedingt eher laut. Überdies können nur speziell dafür angefertigte Modelle mit Flüssigkeiten (Flutkühlung) oder Stäuben umgehen und benötigen mehr Wartung als die obengenannten Typen. Ich habe längst nicht so viele Anwendungsbeispiele dieses Pumpentyps für Vakuumtische gefunden wie bei den anderen. Das heißt aber nicht, dass ich sie für diese Einsatzzwecke als ungeeignet einstufe.

Drehschieberpumpen

Drehschieberpumpen teilen sich wiederum in zwei Klassen: Trockenlaufend und ölgeschmiert. Während trockenlaufende Drehschieberpumpen gleicher Leistung bei etwas höherem Durchsatz ähnliche Unterdrücke erzeugen können wie Kolbenpumpen, sind ihre ölgeschmierten Pendants in der Lage, deutlich größere Unterdrücke zu erreichen. Zudem benötigen sie weniger Energie zum Betrieb als ihre trockenlaufenden Kollegen.

Auf der anderen Seite benötigen sie eine Warmlaufzeit für das Öl und einen Entgasungszyklus vor ihrer Abschaltung. Zudem benötigen sie durch Ölwechsel und leichte Ölnebel in der Abluft mehr Wartungsaufwand.

Das Wirkprinzip: Ein Motor treibt eine auf seiner Welle befindliche geschlitzte Scheibe an, welche exzentrisch in einem Gehäuse montiert ist. In den Schlitzen sind kleine Platten eingelassen, die sich radial frei bewegen können. Startet der Motor nun, werden die Platten durch Fliehkräfte an die Wände der Kammer gedrückt und schließen diese beinahe luftdicht gegen die anderen Kammern ab. Durch die Exzentrizität ist das Volumen dieser Kammern über einen Umlauf variabel und verkleinert sich in Richtung Auslass, sodass auf der Saugseite ein Unterdruck und am Auslass ein Überdruck entsteht.

Drehschieberpumpen sind nur für kompressible Medien geeignet, benötigen Staubabscheider am Einlass und vertragen keine Flüssigkeiten im Medium. Dafür liefern sie einen kontinuierlichen Saugstrom und sind im Betrieb vergleichsweise leise. Die Drehschieber sind Verschleißteile, die irgendwann ersetzt werden müssen - besonders bei den trockenlaufenden Geräten. Im Vergleich zu Seitenkanalverdichtern gleichen Volumenstroms liegen ihre Kosten zur Zeit des Verfassens dieses Artikels um den Faktor zwei bis drei höher.

Weitere Details gefällig? Wie oben bereits erwähnt halte ich diese Seite von GutmbH für lesenswert.

Das Werkstück bestimmt die Pumpe

Um eine gute Wahl für eine Vakuumpumpe treffen zu können, sollte der Einsatzzweck also klar und der zu verwendende Vakuumtisch eine bekannte Größe sein.

Wie in der Zeichnung zu erkennen ist, hängt die erreichbare Niederhaltekraft stark von der Größe der Oberfläche des Werkstücks ab - je kleiner sie ist, desto größer muss der Unterdruck sein, den die Pumpe liefert, um dieselbe Niederhaltekraft zu erreichen. Leider ist der Unterdruck wie oben beschrieben durch das absolute bzw. das durch die gewählte Pumpe erreichbare technische Grobvakuum limitiert. Trotzdem können Vakuumtische sehr homogene Niederhaltekräfte bieten.

Was wir vermeiden wollen, ist, dass das Werkstück durch das Werkzeug beim Eingriff vom Maschinentisch gelöst wird. Ebenfalls möchten wir Parallelverschiebung oder Drehung des Werkstücks durch das Werkzeug verhindern. Um ein paar Anhaltspunkte zu bekommen, können wir zuerst die Niederhaltekraft für unser Werkstück berechnen. In einem zweiten Schritt dann können wir abschätzen, wie viel Widerstand uns dies gegen laterale Verschiebung oder Drehung bietet. Solange die vom Werkzeug in das Werkstück eingebrachte Kraft unter dieser Losbrechkraft liegt, sind wir auf der sicheren Seite und können möglicherweise eine preisgünstigere Pumpe wählen.

Niederhaltekraft

Die Klemmkraft, die das Werkstück auf dem Maschinentisch festhält, ist leicht zu berechnen:

$$f_{clamp}= F_N = \Delta p A + F_g $$

Sie wird in Newton angegeben und ergibt sich aus der Druckdifferenz zwischen Ober- und Unterseite des Werkstücks und der Erdanziehungskraft, die das Werkstück nach unten drückt.

Der erforderliche Wert hängt stark von der Werkzeuggröße- und Geometrie, Werkstückmaterial sowie vom Vorschub und gewählter Drehzahl ab. So wird wesentlich mehr Klemmkraft bei harten und zähen Materialien wie Hochdrucklaminaten oder Stahl benötigt, wenn Werkzeuge mit großen Durchmessern oder Drallwinkeln eingesetzt werden, die zudem bei großen Vorschüben und geringer Drehzahl durch das Material gehen als bei Weichhölzern, wo gern mit hohen Drehzahlen und gerade geschliffenen Fräsern gearbeitet wird.

Die Berechnung der Zerspankräfte, insbesondere der hier für uns interessanten Vorschubkraft, würde einen eigenen Artikel erforderlich machen. Für den Hobbybereich sind meine Erfahrungswerte, dass Werkstücke kleiner als 80x80mm nur mit großen Unterdrücken um -0.8Bar gehalten werden können, wenn man nicht gerade im Schneckentempo arbeiten möchte. Andersherum reichen bei 600x600mm großen Platten ohne Durchfräsungen bereits -0.1Bar, um die Platte sicher zu halten.

Parallelverschiebung

Um Niederhaltekraft in Widerstand gegen Parallelverschiebung umzurechnen, führe ich hier den statischen Reibungskoeffizienten $µ_s$ ein.

Nehmen wir an, wir legen eine Lage Gummi zwischen unser (metallisches) Werkstück und den Vakuumtisch. Nehmen wir weiter einen statischen Reibungskoeffizienten µs = 0.7 zwischen Gummi und Werkstück an - den Wert habe ich online gefunden - was für mich aus mehreren Gründen nach einer konservativen Schätzung aussieht: Erstens klammern wir die Oberflächenrauigkeit von Gummimatte und Werkstück aus, und zweitens wird das Werkstück durch den Unterdruck etwas in die Gummimatte hineingedrückt, was die Losbrechkräfte durch Formschluss nochmal deutlich erhöht.

Egal, denn alles was zu tun bleibt, ist die oben berechnete Kraft mit dem Reibungskoeffizienten zu multiplizieren.

$$F_s = F_N µ_s$$

Hier kann man also an zwei Stellschrauben drehen: Der Materialpaarung und dem von der Pumpe bereitgestellten Anpressdruck. Es gibt auch spezielle Vakuumvliese, welche besonders hohe Reibungskoeffizienten besitzen und bei Anlegen des Vakuums durch Eindrücken des Werkstücks in das Vlies für zusätzlichen Widerstand gegen Verschiebung und Rotation sorgen.

Rotation

Hier wird die Berechnung schwierig. Interessanterweise wird weniger Kraft benötigt, ein Werkstück von seiner Position wegzudrehen, als es parallel zu verschieben. Das kann man sich aber zum Glück recht leicht klarmachen:

Wenn Sie z.B. Ihr Mobiltelefon auf dem Tisch um seinen Mittelpunkt herum drehen (etwa durch Berührung der rechten oberen Kante mit dem Zeigefinger), müssen nicht alle denkbaren Punkte auf dem Smartphone denselben Weg zurücklegen. Punkte, die sich näher am Drehpunkt befinden, legen eine geringere Distanz für den selben überstrichenen Winkel zurück als solche, die weiter in Richtung Kante des Smartphones liegen. Für eine Paralellverschiebung hingegen muss jeder Punkt einen gleich großen Weg zurücklegen, für den ein entsprechender Energieeinsatz erforderlich ist.

Für das Spannen auf dem Vakuumtisch sind lange, schmale Werkstücke besonders anspruchsvoll. Sie bieten mit ihren langen Kanten einen großen Hebel und bieten zudem keine große Oberfläche, die der Unterdruck zum Niederhalten nutzen kann. Daher lassen sie sich leicht versehentlich verdrehen.

Am einfachsten zu bearbeiten sind daher runde oder quadratische Werkstücke, zumal wenn sie nahe an ihrem geometrischen Mittelpunkt gefräst werden.

Welche Vakuumpumpe wird nun also benötigt?

Ok, fassen wir zusammen:

Es ist immer eine Kombination aus Werkstückmaterial (leicht/ schwer zu bearbeiten, niedrige/hohe Reibungskoeffizienten), -Größe (je mehr Oberfläche, desto einfacher sind hohe Klemmkräfte realisierbar), Bedürfnissen durch die Bearbeitung wie Durchfräsungen (Toleranz gegenüber Leckageströmen), Vakuumtischgröße- und Typ sowie Bearbeitungsparametern, die die Auswahl der Vakuumpumpe bestimmt.

Daher sollten ein paar Erfahrungswerte vorliegen und klare Wünsche formuliert werden können: Wie groß sind die Werkstücke typischerweise? Werden oft Teile aus Plattenmaterial ausgeschnitten? Welche Materialien sollen verarbeitet werden? Werden Kühlschmierstoffe benötigt? Muss mit aggressiven Parametern vorgegangen werden, um Fertigungszeiten niedrig zu halten?

Ein paar Vorschläge meinerseits:

Aluminium, kleine Werkstückgröße, keine Durchfräsungen: Kleinvolumige Kolben- oder Drehschieberpumpe mit einem Lochrastertisch
Holz und MDF, große Werkstücke, Nesting und eine Menge Durchfräsungen: Radialgebläse oder einstufiger Seitenkanalverdichter, Vakuumtisch mit poröser Oberfläche oder Rastervakuumtisch mit Vakuumvlies
Hochdrucklaminate, kleine Werkstücke, viele Durchfräsungen: Drehschieberpumpe mit großem Volumenstrom oder mehrstufige Seitenkanalgebläse sowie ein Lochrastervakuumtisch. Zudem Verwendung von an das Werkstück angepassten, speziellen Frässtrategien im CAM: späte Durchfräsungen in Kombination mit geringerer Tiefenzustellung.

Meine Wahl

Da ich auf meiner Maschine Platten mit 60x60cm Größe in einem Rutsch bearbeiten möchte, habe ich mich für einen recht großen Lochrastervakuumtisch (730 x 655 mm) mit 0.5mm Durchgangsbohrungen in einem 10mm Raster entschieden. Da ich noch immer eine Menge verschiedener Materialien auf meiner Maschine ausprobiere und hauptsächlich Prototypen anfertige, sehen meine Werkstücke selten ähnlich aus und haben sehr unterschiedliche Abmessungen (kleinstes Werkstück bis dato: 14x26mm). Daher musste ich in den sauren Apfel beißen und einen Haufen Geld in eine großzügig dimensionierte, trockenlaufende Drehschieberpumpe investieren, die für kleine Werkstücke einen hohen Unterdruck zur Verfügung stellt und dennoch eine Menge nicht abgedeckter Sauglöcher toleriert, ohne in die Knie zu gehen.

Vergleich mehrerer Drehschieberpumpen (Bild bereitgestellt von Stritzelberger GmbH) ^[1]

Die Pumpe stellt einen Volumenstrom von 40m³/h zur Verfügung und kann maximal 880mBar unter Umgebungsluftdruck gefahren werden. Sie wiegt in etwa 40kg und wird von einem 3-Phasen Asynchronmaschine mit einer Nennleistung von 1.3kW angetrieben.

Durch einen Umbau läuft meine Pumpe auf nur einer Phase. Ich habe zudem einen Motorschutzschalter hinzugefügt, um die Maschine vor Überlast zu schützen.

Ist die Pumpe laut?

Na ja, 68dB(A) aus einem Meter Abstand sind nicht so richtig leise. Das Geräusch erinnert mich an das Außengerät einer Klimaanlage, die bei voller Last läuft. Ist die Fräsmaschine allerdings in Betrieb, so geht das Geräusch der Pumpe in den Fräsgeräuschen praktisch unter.

Aber überzeugen Sie sich selbst; ich habe ein kleines Video vom Betrieb der Pumpe erstellt:

Drehschiebervakuumpumpe: Inbetriebnahme

Vakuumtisch für die CNC

Schallbert — Fri, 21 Oct 2022 00:00:00 +0000

Nehmen wir mal an, Sie sind nicht durch Zufall beim Surfen durch das Internet auf diesen Beitrag gestoßen. Sie wissen also bereits was ein Vakuumtisch ist (falls nicht: hier weiterlesen). Sein Wirkprinzip wird im Bild auf der rechten Seite erläutert. Wahrscheinlich wissen Sie außerdem bereits, dass es verschiedene Typen Vakuumtische für unterschiedliche Zwecke gibt, und vielleicht auch schon, dass Sie einen anschaffen möchten.

Hervorragend! Dieser Artikel beschreibt sowohl meinen eigenen Weg hin zu einem Vakuumtisch, soll aber ebenfalls als Entscheidungshilfe für Sie dienen. Beginnen wir mit einem kleinen Interview.

Warum möchten Sie einen Vakuumtisch haben?

Gleich zu Anfang die wichtigste Frage.

🤩 Weil er toll aussieht, eine Menge Gewicht auf die Waage bringt, stabil und teuer ist?
😪 Weil Sie keine Lust mehr haben, sich ständig über das richtige Klemmen des Werkstücks Gedanken zu machen?
😖 Oder weil Sie bereits ein paar Fräser verschlissen haben beim Versuch durch Klemmen zu fahren?
😨 Oder doch weil sich Doppelklebeband als nicht stark genug erwiesen hat und Ihr Werkstück fliegen ging?
😎 Professionalisieren Sie Ihr Gewerk vielleicht gerade und Sie versuchen, Produktionszeit einzusparen?
😕 Vielleicht ist auch die Qualität Ihrer Werkstücke nach Bearbeitung unzureichend oder Sie haben Probleme, Plattenware plan zu bekommen?

Meine Gründe: Qualität und höhere Fertigungsgeschwindigkeit

Dies hier soll mein Vakuumtisch in den Griff kriegen:

Bei Gravuren machen nicht vollkommen plan aufliegende Werkstücke mir einen Strich durch die Rechnung, da die Gravurbreite ungleichmäßig wird. Dies ist leider nicht nur auf Holzwerkstoffe beschränkt.
Momentan arbeite ich mit Anbindungen, um Frästeile in Position zu halten. Meine Frästeile benötigen also manuelle Nacharbeit und die Anbindungen am Werkstück können danach immer noch erahnt werden.
Wenn ich keine Anbindungen wünsche, muss ich eine “Zwiebelhaut” übrig lassen, kann also nicht ganz durchfräsen. Das macht die Bearbeitung der Rückseite z.B. mit einem Gravurfräser erforderlich, was durch die genaue Positioniererfordernisse viel Zeit in Anspruch nimmt.
Mit einem Vakuumtisch werden ballige Werkstücke für die Bearbeitung plan gezogen, sodass Probleme ungleicher Gravuren, nicht erwünschter Durchfräsungen usw. behoben sind.
Unter bestimmten Bedingungen leidet Meine Maschine an Vibrationen, besonders bei Verwendung langer Zweizahnfräser bei großer Tiefenzustellung und größeren Geschwindigkeiten. Das zusätzliche Gewicht und die flächige Kraftverteilung durch den Vakuumtisch könnten dieses Problem lösen.

Welcher Typ Vakuumtisch?

Ok, nun sollten wir herausfinden, welche Art Vakuumtisch sich am besten für Ihren Einsatz und für Ihre Randbedingungen eignet. Vakuumtische sind prinzipbedingt nur dann sinnvoll, wenn Plattenmaterial mit entsprechend großer Oberfläche bearbeitet wird. Zudem sollte das Plattenmaterial nicht zu biegsam oder sehr porös sein - Folien, Gummimatten und Weichschäume beispielsweise können von einem Vakuumtisch kaum gehalten werden, da durch die Fräskräfte angehobene Kanten des Plattenmaterials sofort das Vakuum kollabieren lassen.

Es gibt drei Typen Vakuumtische:

Rastervakuumtische
Lochrastervakuumtische
Vakuumtische mit poröser Oberfläche

Rastervakuumtisch

Ein Rastervakuumtisch (Bild zur Verfügung gestellt von Stritzelberger GmbH) ^[1]

Viele Rastervakuumtische haben nur einen Vakuumanschluss, der in der Mitte des Tisches platziert ist. Der Bereich, in dem Unterdruck das Werkstück halten soll, wird mittels einer in das Raster gelegten (Schaum-) Gummidichtung bestimmt. Hierbei muss sich die Dichtung stets innerhalb des Werkstückes befinden.

Da die Dichtung bei Einschalten des Vakuums zusammengepresst wird und damit Vakuumtisch und Werkstück luftdicht miteinander verbindet, muss die Pumpe nur einen geringen Volumenstrom zur Verfügung stellen. Zudem hält das Werkstück bei entsprechend starkem Unterdruck sehr großen Zug- und Scherkräften stand, ohne sich zu lösen. Durch die flexible Dichtung können auch nicht ganz plan aufliegende Werkstücke oder solche mit rauen Oberflächen auf dieser Art Tisch gut bearbeitet werden.

Bei all den Vorteilen haben sie aber zwei gewichtige Nachteile: Werden erstens verschieden große Werkstücke verarbeitet, ist die Verlegung der Dichtung stets anzupassen. Außerdem muss beachtet werden, dass durch das meist in der Mitte befindliche Absaugloch auch die Werkstücke zentriert werden müssen; Anschläge für das vereinfachte Kantenfinden sind daher oft nicht verwendbar.

Zweitens darf nicht “innerhalb der Dichtung” durchgefräst werden. Tut man es doch, wird das Vakuum sofort zusammenbrechen, da die Pumpe plötzlich einen riesigen Luftstrom bewältigen muss. Daher darf das Werkstück nicht zu klein werden (das Raster ist das Maß der Dinge) oder man muss zusätzlich Arbeit in Klemmen oder Halterungen stecken, die dieses Problem lösen.

Kurzgesagt:

Rastervakuumtische funktionieren sehr gut, solange man nicht durchfräst.
Rastervakuumtische stellen geringe Anforderungen an die Pumpe und halten auch unebene oder verzogene Werkstücke sicher.
Rastervakuumtische sind günstig, benötigen aber bei unterschiedlichen Werkstückgrößen, kleinen Werkstücken oder Durchfräsungen extra angepasste Halterungen.

Lochrastervakuumtisch

Ein Lochrastervakuumtisch (Bild zur Verfügung gestellt von Stritzelberger GmbH) ^[2]

Lochrastervakuumtische verfügen über - wie der Name schon sagt - in einem Raster angeordnete Sacklöcher, über die Luft abgesaugt wird. In jedem dieses Sacklöcher befindet sich eine winzige Durchgangsbohrung, die zu einem im Tisch befindlichen Kanalsystem führt. Der Durchmesser der Durchgangsbohrung wird vom vorrangig zu bearbeitenden Material vorgegeben - sie sind etwas größer bei “porösen” Materialien wie Holz und MDF, und kleiner für die Aluminium- oder Stahlbearbeitung.

Zumeist sind sie in zuschaltbare Segmente unterteilt, sodass bei kleineren Werkstücken nicht der ganze Tisch abgedeckt werden muss um Leckströme zu vermeiden. Dennoch ist es sinnvoll, weiterhin freiliegende Löcher abzudecken und damit den Vakuumdruck zu erhöhen.

Diese Vakuumtische bestehen meist aus drei Teilen: Dem Unterbau zur Montage auf dem Maschinenbett, einer mittleren Ebene mit Vakuumanschlüssen und dem Kanalsystem sowie einer oberen Ebene mit Lochraster, was zudem oft eine Bearbeitungsreserve zum Planfräsen aufweist.

Sie sind in der Lage, Werkstücke jeglicher Form niederzuhalten, vorausgesetzt sie besitzen eine ebene Fläche auf der Unterseite. Die kleinen Durchgangsbohrungen ermöglichen auch das Durchfräsen: die betroffenen Löcher liefern zwar keinen Beitrag mehr zur Klemmkraft, überfordern mit dem geringen Leckstrom aber auch die Vakuumpumpe nicht, sodass sie den Unterdruck bei den anderen Löchern aufrecht erhalten kann (solange man es mit der Anzahl freiliegender Löcher nicht übertreibt). Das Ausrichten des Werkstücks ist auf solchen Tischen ebenfalls einfach, da das Lochraster einfach mit Zentrierstiften bestückt werden kann, die einen Anschlag o.Ä. bilden.

Nachteile dieses Tischtyps sind ihr hoher Preis durch das aufwändige Design, mehr benötigtes Zubehör wie Vakuumverteiler bei einem Mehrkammersystem (und alles muss leckfrei gehalten werden), sowie hohe Anforderungen an die Vakuumpumpe bei Durchfräsungen.

Kurzgesagt:

Lochrastervakuumtische sind für jedes feste Werkstück mit genügend Oberfläche und glatter Unterseite geeignet.
Lochrastervakuumtische tolerieren Durchfräsungen und freiliegende Löcher, erfordern dann aber großzügig dimensionierte Vakuumpumpen.
Lochrastervakuumtische vereinfachen die Positionierung von Werkstücken ungemein.
Lochrastervakuumtische sind komplex in der Fertigung und daher vergleichsweise teuer.

Vakuumtische mit poröser Oberfläche

Ein Porenvakuumtisch (Bild zur Verfügung gestellt von 'Jens´ Vakuumtische') ^[3]

Diese Art Vakuumtisch benötigt weder sichtbare Löcher noch Kanäle an seiner Oberfläche: Stattdessen ist die Oberfläche selbst luftdurchlässig. Für das Fräsen von Leiterplatten wird als Material oft Aluminiumschaum verwendet. Im Hobbybereich gibt es auch gute Erfahrungen mit überplanter mitteldichter Faserplatte. Bei Letzterer ist es beim Durchfräsen nicht einmal schlimm, wenn man sich mit der Materialdicke vertan hat, da MDF solche Fehler gut verzeiht und bei Bedarf einfach eine frische Platte aufgelegt werden kann.

Die Tische sind leicht und - mit viel Hintergrundwissen über Werkstoffe und Dünwwandfräsen - sogar als “Marke Eigenbau” zu fertigen. Im Netz gibt es dazu viele Beispiele.

Sie funktionieren am besten über einen großen Volumenstrom und arbeiten daher meist mit geringen Unterdrücken - sie erhalten ihre Klemmkraft also über die Fläche. Besser noch als Lochrastervakuumtische sind sie also für Durchfräsungen geeignet. Zudem sind sie in der Anschaffung günstig und können sogar mit Staubsaugern betrieben werden, deren Motoren auch ohne Förderstrom durch ein eigenes Gebläse gekühlt werden.

Ihre Nachteile: Durch ihr geringes Gewicht sind sie anfälliger für Vibrationen. Sie benötigen Werkstücke mit eher großer Oberfläche um adäquate Klemmkräfte zu realisieren und bei hohen Unterdrücken bleibt das poröse Obermaterial nicht maßhaltig, es “schrumpft” also bei aufgelegtem Werkstück etwas. Außerdem sind sie nicht geeignet bei Verwendung von Kühlschmierstoffen und haben einen ungünstigen statischen Reibungskoeffizienten (Je nach Werkstückpaarung bieten sie keinen besonders guten Halt gegen laterale Verschiebung).

Kurzgesagt:

Porenvakuumtische sind günstig zu erwerben und zu betreiben.
Porenvakuumtische sind für größere Werkstücke und Materialien, die keine Kühlschmierstoffe benötigen, gut geeignet.
Porenvakuumtische sind bei Durchfräsungen sehr gut geeignet.
Porenvakuumtische sind bei Verwendung von MDF nicht präzise in Z-Richtung.

Was alle diese Vakuumtische gemeinsam haben

Die Klemmkraft auf das Werkstück in Z-Richtung kann für einen gegebenen Unterdruck auf identische Art berechnet werden. Aber vorsicht, dieser Unterdruck ist bei Durchfräsungen und anderen Quellen für Leckagen am Werkstück geringer als auf dem Manometer angezeigt.

Werden keine Durchfräsungen gefertigt, lässt sich die volle Werkstückoberfläche zur Berechnung der Klemmkraft hinzuziehen (und nicht nur die Summe der Fläche aller Löcher im Bereich unter dem Werkstück im Falle des Lochrastertisches). Das kommt daher, dass mikroskopisch kleine Unebenheiten auf der Oberfläche von Werkstück und Tisch einen geringen lateralen Luftfluss an der Grenzschicht zulassen.

Andererseits gilt dies auch für die Ränder des Werkstücks. Nutzt man also keinen Rastervakuumtisch, wird es immer Leckageluftströme geben. Fräst man zusätzlich komplett durch das Material, werden weitere Randzonen erzeugt, die wiederum geringere Klemmkräfte aufweisen als der Rest des Werkstücks.

Welches Zubehör für einen Vakuumtisch?

Ohne Pumpe funktioniert der Vakuumtisch natürlich gar nicht. Und obacht, werden hohe Unterdrücke und gleichzeitig große Volumenströme verlangt, bewegt sich der Preis für die gewünschte Pumpe ganz schnell in derselben Liga wie der Vakuumtisch. Aber das führt hier zu weit - ich habe den Vakuumpumpen einen eigenen Artikel gewidmet. Aber es wird weiteres Zubehör benötigt:

Schrauben, Unterlegscheiben, Nutensteine / Muttern um den Tisch auf der Maschine zu befestigen
Sortiment verschieden dicker Unterlagsbleche für die plane Montage des Tisches gegenüber der Z-Achse der Maschine
Einen Vakuumverteiler, falls der Vakuumtisch mehrere Zonen besitzt
Vakuumleitungen
Einen Schalter mit Motorschutz für die Vakuumpumpe
gegebenenfalls ein Vakuumvlies (Holz-, Kunststoffbearbeitung) oder eine Lochrastermatte aus Gummi (Alu, Stahl)
Dichtband (für Rastervakuumtische)

Zusammenfassung

Alles in allem will die Anschaffung eines Vakuumtisches gut überlegt sein - gerade wegen des großen Kosten- und Zeitaufwandes für Montage, Einrichtung und Betrieb des Tisches. Entscheidet man sich dennoch dafür, so wird man bei zweckmäßigem Einsatz mit höherer Fertigungsqualität durch die flächige Auflage des Werkstücks, kürzerer Richtzeit durch Wegfallen der Klemmen und einfacherer Jobplanung belohnt - denn Materialanbindungen sind nun passé.

Meine Wahl

Ich arbeite ausschließlich mit Plattenmaterial. Ich fertige bisher Produkte aus Holz, Hochdrucklaminaten, Acrylglas, mitteldichter Faserplatte oder Aluminium-Verbundmaterial. Zumeist muss ich Konturen aus einer größeren Platte ausschneiden (Durchfräsen) und wende Nestingverfahren an, um möglichst wenig Abfall zu erzeugen. Ich arbeite oft zweiseitig, was eine genaue Lokalisierung des Werkstückes auf dem Maschinentisch erfordert. Daher kommt ein Rastervakuumtisch für mich nicht infrage.

Um die Kanten auf der Werkstückunterseite anzufasen, schneide ich im ersten Arbeitsgang meist nicht ganz durch, sondern lasse einen V-Fräser diesen letzten Schritt auf der Unterseite erledigen. Da ich hierfür eine sehr exakte Bestimmung der Werkstückhöhe benötige und der Unterdruck sich bei Auffräsen einer Kontur durch den Fasenfräser verringert, muss die Oberfläche des Vakuumtisches starr sein - daher kommt ein Porenvakuumtisch mit Oberfläche aus MDF für mich nicht in Frage.

Stattdessen habe ich einen Hersteller für Vakuumtische direkt kontaktiert, um ein paar kleine Lochrastervakuumtische zu kaufen, die ich unabhängig voneinander einschalten und damit je nach Größe des Werkstücks Segmente auf meiner CNC mit Unterdruck versorgen könnte. Dieser meinte, dass die einfachere und bessere Lösung ein für meine Maschine angepasster Vakuumtisch sei, da bei Zusammenstellen mehrerer Tische Höhenunterschiede und Undichtigkeiten entstehen würden und die Zuführung der Vakuumleitung erschwert würde.

Also habe ich gespart und mir den teureren, großen Tisch zugelegt. Hierfür habe ich dem Hersteller Zeichnungsdaten meiner Maschine zur Verfügung gestellt und nach ein paar Gesprächen und Vorschlägen seitens des Herstellers hatte ich dann einen an meine Bedarfe angepassten Entwurf.

Lieferung des Tisches

Der von mir ausgewählte Hersteller sitzt nicht zu weit von meinem Wohnort entfernt. Also bin ich hingefahren für eine kleine Führung durch die Produktion und konnte den Tisch dabei direkt mitnehmen. Da ich für die Montage meine alte Werkstückunterlage vom Maschinentisch nehmen musste, konnte ich in einem Zug direkt Schalldämmung im Maschinenrahmen anbringen. So wird die Maschine nochmal etwas leiser.

Danach habe ich den Vakuumtisch mit M6 Maschinenschrauben und T-Nut Muttern am Rahmen befestigt. Für eine ebene Oberfläche (gemessene Abweichung in Z über die gesamte Fläche des Maschinentisches unter 15/100mm, Messuhr siehe Bild unten links) habe ich Unterlegbleche verwendet und stundenlang nachkontrolliert und -justiert, bis ich zufrieden war.

Parallelität der Z-Achse prüfen

Für noch bessere Ergebnisse könnte man:

Den Vakuumtisch einmal komplett planfräsen
Dn Tisch wieder herunternehmen und den Maschinenrahmen so nachrustieren, dass die Profile exakt waagerecht aufliegen und die Oberseiten aller Rahmenteile auf das Hundertstel genau auf einer Ebene enden.

Dies erschien mir als unverhältnismäßig großer Aufwand angesichts der vorhandenen Maschinentoleranzen (Immerhin handelt es sich hier um einen Eigenbau), also gebe ich mich mit den oben erreichten Werten zufrieden.

Anschluss des Vakuumverteilers

Als ich einfach drauflos die dünnen Vakuumleitungen zur Verbindung von Tisch und Verteile zurechtschnitt, dachte ich mir: “Warte mal eine Sekunde. Wäre es nicht klüger, die 9mm-Leitungen so kurz wie möglich zu halten, und lieber die 18er-Leitung zur Pumpe länger zu lassen und so den Druckabfall zu reduzieren?” Also habe ich mich erst einmal mit dem Taschenrechner zurückgezogen.

Mein Tisch hat etwa 4900 Sauglöcher mit je 0.5mm Durchmesser. Ihre zusammengerechnete Oberfläche beträgt $A_{table}=962mm^2$, was in etwa einem Loch mit 35mm Durchmesser entspricht (ich ignoriere hier komplett die Widerstände an den Lochrändern.)
Die sieben Vakuumleitungen zum Verteiler haben einen Durchmesser von 9mm. Zusammengenommen liegt ihre Oberfläche bei $A_{hose}=445mm^2$, entsprechen also einem Loch mit 24mm Durchmesser; deutlich weniger also als der Gesamtquerschnitt der Löcher des Tisches.
Für den Saugschlauch mit 18mm Innendurchmesser sieht es sogar noch schlimmer aus: $A_{pump}=254mm$ liegt bei unter 30% des Querschnitts auf dem Tisch.

Wenn ich jetzt also von einem gleichmäßigen Leckagestrom über die sieben Segmente meines Tisches ausgehe, macht es Sinn, die Pumpenzuleitung so kurz wie möglich zu wählen, da sie bei vielen offenen Sauglöchern die höchste Flussgeschwindigkeit und damit den höchsten Druckverlust aufweist. In einem Szenario mit weniger verwendeten Segmenten wird irgendwann die 9mm-Leitung ausschlaggebend.

Daher ist also zu beachten, dass das Manometer am Vakuumverteiler bei größeren Leckageluftströmen einen höheren Wert anzeigt, als am Tisch tatsächlich anliegt!

Da ich die Zahl freiliegender Löcher aber begrenzen werde, kann ich mir einfach eine komfortable Position für den Vakuumverteiler aussuchen und die Verlegung abschließen 😉. Übrigens ist das erste auf meinem neuen Vakuumtisch gefertigte Teil ein Halter für den Vakuumverteiler aus Holz - wie im Bild rechts zu erkennen.

Estlcam: Inverse Gravuren

Schallbert — Tue, 27 Sep 2022 00:00:00 +0000

Der Plan war, ein Holzschild mit meiner CNC zu fertigen. Es sollte jedoch invertiert sein. Das heißt, die Lettern sollten sich vom flachen Hintergrund abheben. Da es verschiedene Wege gibt, so etwas in Estlcam umzusetzen (ein sogenanntes Computer Aided Machining Programm, was aus Zeichnungsdaten Fräspfade und später Maschineninstruktionen erzeugen kann), aber nicht alle Wege leicht zu finden oder gut anwendbar sind, biete ich hier eine Schritt-für-Schritt Anleitung an.

1. Den Rahmen des Schildes importieren

Zuerst sollten Zeichnungsdaten des Rahmens von dem zu fertigenden Schild vorliegen, beispielsweise im DXF-Format. Ich habe ein rechteckiges Schild mit abgerundeten Ecken und definierter Rahmenstärke in meinem CAD-Programm gezeichnet. Es gilt sicherzustellen, dass die Frästiefe später nicht die Breite des Rahmens überschreitet, ansonsten könnte die Fräsarbeit zu instabil werden.

2. Den Text hinzufügen

Jetzt kann der Inhalt des Schildes in Form von Text durch Tastendruck auf das “Carve”-Symbol hinzugefügt werden. Dabei ist es sinnvoll, die Breite der Textbox an die inneren Rahmengrenze anzupassen, sodass der Text stets hineinpasst. Man hat verschiedene Carve-Stile zur Auswahl. Für die hier dargestellte Fräsarbeit ist Carve aussen zu wählen. Nun den Text eintippen, Schriftart selektieren und die Schrifthöhe so anpassen, dass es im Schild ein harmonisches Bild ergibt.

Abhängig vom zu verwendenden Fräser sollte dann die Frästiefe gewählt werden. Bei kleineren Winkeln der V-Nutfräsers ist die Frästiefe meist größer zu wählen als bei breiten 90°-Fräsern wie ich ihn verwende. Für mein 12mm starkes Plattenmaterial setze ich eine Frästiefe von 4.5mm an. Anschließend wird die maximale Fräsbreite festgelegt. Gemeint ist hier, wie breit die “Täler” zwischen den Buchstaben sein sollen. Da ich für den invertierten Carve eine “Talsohle” benötige, habe ich hier einen sehr großen Wert eingestellt. Zum Schluss dann sollte die Taste Umrahmung auswählen geklickt werden. Hiermit ist die Fräsarbeit dann nach außen begrenzt.

Bitte dieses Bearbeitungsfenster vorerst geöffnet lassen.

3. Werkzeugauswahl

Wählen Sie nun das V-Nutwerkzeug durch Klicken in der entsprechenden Zeile Ihrer Werkzeugliste für die Textfräsung aus. Stellen Sie sicher, dass das Häkchen bei Textobjekt zerlegen im Fenster “Text Fräsen” nicht erscheint, denn nur dann können Sie weitere Anpassungen vornehmen. Schließen Sie nun dieses Fenster per Klick auf OK. Nun wählen Sie Vorschau aus, um sich einen Eindruck von der Fräsarbeit zu verschaffen. Sehen Sie die eng beisammenstehenden parallelen Linien rechts im Bild? Dies wird durch den Parameter Räumzustellung aus der Werkzeugtabelle verursacht. Für saubere Arbeiten mit einem Gravurfräser sollte dieser Wert bei kleiner gleich 5% bleiben.

Hmm, so werden Sie noch keine befriedigenden Arbeitsergebnisse erhalten, und die Fräsarbeit wird lange dauern. Wir benötigen also zusätzlich ein paar Räumpfade mit einem normalen Schaftfräser.

4. Räumen

Speichern Sie Ihr Projekt spätestens jetzt ab. Nach dem aktuellen Schritt kann der Text nicht mehr bearbeitet werden!

Um den Fräser für die Räumung der “Talsohle” hinzuzufügen, wählen Sie den Carve-Pfad aus und wählen Textobjekt zerlegen an. Bestätigen Sie mit OK und wählen den Fräspfad erneut aus. Nun erscheint die Werkzeugkonfiguration. Fügen Sie das Räumwerkzeug hinzu. Vorzugsweise ist sein Durchmesser geringer als der Abstand zwischen Schrift und Rahmen, sodass eine möglichst große Fläche später glatt geräumt werden kann (Anmerkung: Ich habe das nicht gemacht, weswegen auf meinem Beispiel ein paar raue Stellen übrig geblieben sind). Die Räumzustellung dieses Fräsers wähle ich bei Holz zwischen 20% und 40%.

Wenn Sie für die Gravur einen Fräser ohne Abflachung am Boden gewählt haben (ich empfehle hier gern 0.5mm als guten Kompromiss zwischen hoher Auflösung und guter Fertigungsqualität), können Sie die Räumzustellung des Fräsers in der Werkzeugtabelle zur Verbesserung der Oberflächenqualität noch einmal nach unten korrigieren.

5. Zweite Vorschau

Ok, jetzt sollten wir durch sein. Nochmal kurz die Vorschau ausgewählt und sich über die reduzierte Verarbeitungszeit gefreut, und ran an die Maschine?

Ah, eine weitere Optimierung kann für das Gravurfräsen angebracht sein: Unter Einstellungen die Sicherheitshöhe auf ein Minimum reduzieren (aber ohne in Klemmen oder andere Hindernisse zu rauschen). Das ständige Aus- und Eintauchen ins Material kostet bei Gravuren in Estlcam immer recht viel Zeit, wenn sich die Sicherheitshöhe in großem Abstand zur Werkstückoberfläche befindet.

Keine Sorge, wenn die Schrift in der Vorschau nun nicht mehr lesbar ist. Das ist total normal, weil ja nur die (jetzt wegen Verwendung des Räumfräsers gröber dargestellten) Fräspfade angezeigt werden.

Nach einer letzten Prüfung von Vorschüben und Werkzeugen kann’s jetzt endlich losgehen :)

6. Auf die CNC damit!

Viel Spaß beim Fräsen. Ich für meinen Teil fand es sehr entspannend, der Maschine dabei zuzusehen, wie sie langsam ein immer deutlicher werdendes Bild ins Holz schneidet, was aber erst bei Verwendung des V-Fräsers lesbar wird.

AnywhereAmps Alpha

Schallbert — Sat, 10 Sep 2022 00:00:00 +0000

Pläne

{% include gallery id=“gallery” caption=“Die von mir angefertigten und verwendeten Pläne für AnywhereAmps Alpha. Zum Vergrößern anklicken.” %}

Listen

Werkzeuge

Benötigte Tools
Bohrmaschine
Oberfräse, Zirkelhalterung
Multitool: Schleifen, Holzschnitt, Fräskopf
Hand- oder Tischkreissäge mit Schutzbügel
Handsäge, fein
Lochschneider d>=100mm
Stechbeitel, 12mm
Hammer
Schraubendreher, Bits
Holzbohrer: 3mm, 4, 5, 6, 8, 10, 12mm, Senkbohrer 45°, Forstner 30mm
Stahlbohrer: 4,3 mm, Senkung 45°
Oberfräsere: 8mm gerade, 12mm gerade, 45°/d12mm optional
Lötkolben, Lötzinn, Schrumpfschlauch, Heißkleber, 2m 0,75mm² Kabel etc.

Materialliste

Artikel	Größe [mm]	Anzahl	~ Preis [€]
Kessel: Pappel Multiplex	12" x 6" x 7mm	1	62
Ober-/Unterteil: Pappel-Multiplex	12" x 12mm	2	8
Lautsprecher-Adapterplatten: Pappel Multiplex	L 300 B 150 W 12	1	2
Verstärker-Halteplatte: Pappel Multiplex	L 160 B 95 W 12	1	1
Verstärkung & Halterungen: Birke Multiplex	L 220 B 30 W 12	4	2
Schrauben (vorzugsweise Torx)	12 x 3	20	2
Schrauben (Batteriehalter, Haltegriff)	16 x 3	12	2
Schrauben & Muttern, Leiterplattenhalter, Unterlegscheiben	15 x M4	8	2
Schaumstoffdichtung	2000 x 9 x 3	1	6
1/4" Eingangsbuchse	50 x 12	1	3
Netzschalter mit LED, 250VAC 4A		1	3
Potentiometer 250k log 6mm Achse + Lautstärkeknopf	22mm Durchmesser	1	5
9V Ausgangsbuchse	5.6 brl, 2.4pin	1	2
Lüftergitter (Lautsprecherschutzabdeckung)	120 x 120	1	1
“I-Type” Schaumstoffdichtung (Lautsprecher)	600 x 9 x 2	1	2
Aluminium-Gehäuse	143 x 72 x 43	1	4
Class-D Endstufenplatine, z.B. TPA 3110	70 x 100 + 22	1	16
Piezo-Hochtöner, z. B. Monacor MPT-005	85 x 85 x 72	2	12
4" Tief-/Mitteltöner, z. B. Visaton KT100 V 4Ohm	99 x 99 x 52	1	25
Batterie, 10V - 18V	Was Sie bevorzugen	1	?
Elektronikteile für Platine, Sicherung…		1	10
Ersatzholz z.B. als Maske, Schablone, Helfer	z.B. 300 x 300	1	0

Bauteile auf der Platine

ID	Artikel	Typ	Wert
R1	Widerstand	0207	100k
C1	Elko	RM=2 D=5	1 µF
C2	Elko	RM=2 D=5	4,7 µF
R3	Widerstand	0207	10k
R2	Widerstand	0207	100k
-	Stiftleiste	2-polig	-
-	Stiftleiste	4-polig	-
-	Stiftleiste	2-polig	-
C1	Elko	RM=2 D=5	2,2 µF
R4	Widerstand	0207	10k
IC1	NE5532	DIP-8	-

Brückendrähte

Von	Nach	Länge [mm]
(11/1)	(11/2)	2.54
(10/3)	(10/1)	5.08
(14/6)	(14/2)	10.6
(8/1)	(8/6)	12.7
(9/2)	(9/5)	7.62
(3/2)	(3/0)	5.08
(22/0)	(22/1)	2.54

Loch (x/y)

Der Aufbau

Löcher schneiden

Warnung Wenn Sie den Lochschneider als Handwerkzeug verwenden, seien Sie sehr vorsichtig. Ich halte es für ein gefährliches Werkzeug. Gehen Sie sanft vor, wählen eine relativ hohe Drehzahl >300rpm und üben Sie nur geringem Druck aus. Verwenden Sie eine Drehmomentstütze und den Drehmomentbegrenzer Ihrer Bohrmaschine. Vergewissern Sie sich, dass die Schneidköpfe richtig befestigt sind und dass das Werkstück sicher befestigt ist. Bereiten Sie sich darauf vor, dass die Maschine plötzlich hängen bleiben kann und beachten Sie das hohe Trägheitsmoment des schweren Werkzeugs.

Bereiten Sie das Brett für die Lautsprecheradapterplatten vor wie in den “Plänen” gezeigt.
Bereiten Sie das Gehäuse vor: Markieren Sie die Mitte der Höhe und zeichnen Sie eine Hilfslinie an der Außenseite. Eventuell sollte ein Maßband verwendet werden, um die Krümmung zu berücksichtigen. Markieren Sie dann die drei Lochmitten. Ich schlage eine geodätische Kurve von 125mm Radius zwischen ihnen vor.
Bereiten Sie den oberen Kreis für den Ausschnitt des Bedienfeldes vor.
Wähle einen Lochdurchmesser von 75mm auf dem Lochschneider.
Schneiden Sie zwei Löcher für die Hochtöner in die Adapterplatte. Wenn die Platine nach der Hälfte des Schnitts umgedreht wird, werden die Kanten der Löcher sauberer.
Schneiden Sie nun die beiden Löcher in das Gehäuse. Seien Sie hier sehr vorsichtig, Sie können die innere Oberfläche leicht zerstören, wenn Sie mit zu geringer Geschwindigkeit schneiden oder vertikalen Druck ausüben.
Schneiden Sie ein Loch in die von Ihnen vorbereitete obere Platte des Gehäuses. Ich habe 76mm verwendet.
Ändern Sie den Lochdurchmesser an Ihrem Cutter auf 92mm und wiederholen Sie den Vorgang für den Bass/Mitten-Lautsprecher.
Den Schnitt für das mittlere Loch des Gehäuses wiederholen.

Fräsen

Legn Sie den Kessel auf das Brett, aus dem Ober- und Unterteil des Gehäuses gefertig werden sollen. Zeichnen Sie Innen- und Außendurchmesser an.
Finden Sie den Mittelpunkt dieses Kreises, z.B. mit Hilfe der Methode 3 dieser Anleitung.
Montieren Sie das Zirkelwerkzeug auf Ihrer Oberfräse und spannen Sie einen geraden Fräskopf mit 12mm Durchmesser ein.
Schneiden Sie den “inneren” Kreis für den Falz. Ich empfehle eine Tiefe von 4mm.
(optional) Montieren Sie den 8mm-Fräskopf.
Schneiden Sie den “äußeren” Kreis in mehreren Schritten, bis Sie die gesamte Tiefe Ihres Brettes ausgeschnitten haben.
Drehen Sie den Kreis um, und fasen Sie die Kanten z.B. mit einem Radiusfräser an.

Schnitz- und Modellierarbeiten

Sowohl die Adapterplatten als auch die Batteriehalterung sitzen am Durchmesser des Gehäuses, so dass sie eine gebogene Form haben müssen. Mit Handwerkzeugen fand ich die Arbeiten recht anspruchsvoll.

Bestimmen Sie die benötigten Tiefen für die parallelen Schnitte, damit beim Verbinden der Schnitte eine gewölbte Oberfläche entsteht. Für die Adapterplatten nehmen Sie den inneren Schalendurchmesser, für die Akkuhalterung den äußeren. Beachten Sie, dass die Adapterplatten für die Lautsprecher konvex sind, während die Batteriehalterung konkav sein muss.
Verwenden Sie eine Säge, um diese parallelen Schnitte durchzuführen. Berechnen Sie dabei die Breite des Sägeblatts mit ein.
Verbinden Sie die Schnitte mit einem Stechbeitel oder Meißel. Versuchen Sie, entlang der Maserung zu arbeiten.
Verwenden Sie einen Bandschleifer, Multitool oder eine Raspel um die Wölbung zu glätten, bis sie sehr gut passt. Die Verbindung muss schließlich am Ende Luftdicht sein.

6. Kleben Sie die Adapterplatten mit Holzleim auf der Innenseite des Kessels fest. 7. Vergewissern Sie sich, dass die Löcher gut ausgerichtet sind. Nehmen Sie dann Heißkleber oder eine Mischung aus Leim und Holzmehl zur Hand, um die Adapter zu fixieren und abzudichten, während der Leim aushärtet. 8. Schleifen Sie den Anschluss zwischen den beiden Teilen an oder nehmen Sie eine Viertelstabfräser und bringen eine Rundung an. Ich fand, dass dies der am wenigsten kontrollierbare Teil des ganzen Baus war, weil die Oberfräse nicht richtig auf der gekrümmten Oberfläche sitzen möchte, was die Kanten unterschiedlich breit werden lässt. Ich musste mit dem Multitool einiges an Nacharbeit leisten.

Weitere Holzarbeiten

Kopieren Sie die Abmessungen des Verstärkerträgers aus dem Abschnitt Pläne. Verwenden Sie einen Forstnerbohrer oder den Lochfräser, um die Vertiefung für das Potentiometer zu fertigen. Eine Tiefe von 6mm sollte ausreichen, um das Potentiometer richtig zu montieren. Für den Schalter ist ein Stufenbohrer gut geeignet, sodass der benötigte Durchmesser genau erreicht werden kann. Bohren Sie schließlich die Löcher für die Buchsen.

Da es eine Vielzahl von Batterietypen gibt, habe ich kein spezielles Design für den Schieber und die Batteriekontakte entworfen. Ich habe einfach typische Kabelschuhe verwendet und sie in die Adapterplatte geklebt, damit sie einen guten elektrischen Kontakt zu den Polen der Batterie herstellen können. Da meine Batterie keine Verriegelung hat, habe ich den Schieber wie einen Keil allmählich dicker werden lassen, so dass die Batterie an der richtigen Stelle klemmen würde.

Um das Gehäuse oben und unten geschlossen zu halten und gleichzeitig die Holzoberfläche vor Stößen zu schützen, habe ich ein paar Holzstangen zugeschnitten. Sie sind 25mm länger als die Gesamthöhe des Gehäuses und ihre Breite liegt bei 25mm und 12mm an den Gehäuseseiten.

Elektronik

Schneiden Sie die Platine auf die benötigte Größe. Fertigen Sie Bohrungen für die Schrauben nach Plan. Es ist ratsam, das Layout maßstabsgetreu auszudrucken, damit Sie ihn als Maske verwenden können.
Platzieren Sie die Leiterbahnunterbrechungen. Man kann dafür einen 3mm Metallbohrer verwenden und von Hand vorgehen, falls kein spezielles Werkzeug dafür vorhanden ist.
Fertigen und platzieren Sie die Brückendrähte. Nehmen Sie gern diese Liste als Referenz.
Platzieren Sie die Widerstände.
Verwenden Sie etwas Klebeband, um die Teile auf der Platine zu fixieren. Anschließend können Sie diesen Satz Teile verlöten.
Platzieren Sie die Kondensatoren. Denken Sie daran, dass Sie vielleicht nicht genug Platz in Ihrem Gehäuse haben, so dass Sie sie eventuell lieber waagerecht einbauen möchten.
Platzieren, fixieren und schließlich löten Sie nun die restlichen Bauteile.
Bereiten Sie alle Verbindungen und Drähte zur Platine vor: Potentiometer, Instrumenteneingang, Endstufenausgang, “VCC/GND”.
Überprüfen Sie ob Stromversorgung funktioniert. Wenn nur VCC/GND angeschlossen wird, sollte die Schaltung zwischen 2mA und 10mA Strom ziehen, je nach Potentiometerstellung und Versorgungsspannung. Achten Sie darauf, dass Sie die Polarität nicht verwechseln, der NE5532 wird dadurch zerstört (glauben Sie mir, ich weiß es!). Sie sollten VCC/2 messen, wenn Sie den Ausgang der Op-Amp-Stufe, die die virtuelle Masse erzeugt gegen Masse abgreifen.
Überprüfen Sie die Verstärkungsstufe. Wenn Sie ein Oszilloskop und einen Funktionsgenerator haben, sollte das eine einfach sein. Stehen solche Werkzeuge nicht zur Verfügung, schließen Sie den Eingang an eine Audioquelle an, z. B. ein Smartphone, und den Ausgang an einen 2k2-Widerstand in Reihe mit einer LED und einer Diode wie 1N4148 oder 1N4007. Drehen Sie Ihr Smartphone auf volle Lautstärke. Die LED sollte anfangen zu flackern, wenn der Widerstand des Potentiometers vergrößert wird. Ab welcher Position das Flackern einsetzt, hängt von der Vorwärtsspannung der LED, der Versorgungsspannung und der maximalen Ausgangsspannung der Quelle ab.
Ich schlage vor, die gesamte Elektronik und den Audioeingang - mit Ausnahme des “9V”-Versorgungsreglers - in ein Metallgehäuse einzubauen, um elektromagnetische Störungen zu reduzieren. Je nach Leistung der Endstufe werden passive oder sogar aktive Kühlkörper benötigt. In meinem Fall genügen einige Löcher im Gehäuse.
Befestigen Sie das Gehäuse an der Adapterplatte der Endstufe.
Schneiden Sie Löcher in das Gehäuse, wie auf der Adapterplatte angegeben.
Schalter, Potentiometer und Buchsen einsetzen. Die Anschlussdrähte anlöten.
Fügen Sie eine Sicherung, z.B. 4.0A, in den Aufbau auf dem Minuspfad zur Batterie für zusätzliche Sicherheit ein.
Montieren Sie Vorverstärker und Endstufe.
Nun kommt der finale Test. Nehmen Sie dafür z.B. einen alten Lautsprecher. Ohne angeschlossene Quelle sollten Sie bei voller Verstärkung nur ein leichtes Rauschen aus dem Lautsprecher hören. Wenn Sie Ihr Smartphone anschließen, beginnen Sie mit einer Verstärkung von “0” und einer geringen Lautstärke des Smartphones. Erhöhen Sie dann die Verstärkung des Vorverstärkers, um zu prüfen, ob alles funktioniert.

Endmontage

Montieren Sie die Lautsprecher. Verwenden Sie Heißkleber oder eine Schaumstoff-/Gummidichtung, um die Verbindungen luftdicht zu machen.
Verschließen Sie alle noch vorhandenen Löcher.
Löten Sie die Hochtöner parallel zum Basslautsprecher und schließen Sie das Ausgangskabel Ihres Verstärkers an.
Montieren Sie den Batteriehalter und schließen Sie die Kabel an die Klemmen des Verstärkers an.
Bringen Sie eine Dichtung an der oberen und unteren Deckelplatte an um das Gehäuse später luftdicht versiegeln zu können.
Drehen Sie die Baugruppe um und setzen Sie die “obere” Platte mit dem Verstärker wie auf dem Bild gezeigt ein.
Achten Sie darauf, dass keine der Lautsprecherklemmen das Verstärkergehäuse berührt, sonst besteht die Gefahr eines Kurzschlusses in der Endstufe.
Die Simulation zeigt, dass die Basswiedergabe besser wird, wenn man Dämmwolle hinzufügt. Ich habe ein altes Kissen “geschlachtet”, um welche zu bekommen.
Schließen Sie das Gehäuse und befestigen Sie es mit den Holzstäben, die Sie zuvor vorbereitet haben (oder verwenden Sie stattdessen Schrauben)
Fertig, Applaus! Sieht AnywhereAmps Alpha nicht wunderschön aus?

Feinschliff

Die Hochtöner sind zu laut? Prüfen Sie, wie viel höher die Empfindlichkeitswerte Ihrer Hochtöner im Vergleich zum Bass-Chassis sind. Löten Sie ggf. 1W-Widerstände in Reihe zu den Hochtönern. Laut den technischen Daten der Chassis habe ich Werte von 96dB@1W/1m zu 80dB@1W/1m. Ich musste die Hochtöner also deutlich leiser machen. Mit mit einem 1k-Potentiometer in Reihe dämpfte ich die Hochtöner auf das von mir gewünschte Maß herunter und wählte schließlich einen Widerstand von 470Ohm, um das Potentiometer zu ersetzen.
Der Bass flattert bei hoher Lautstärke? Höchstwahrscheinlich ist das Gehäuse nicht luftdicht. Legen Sie einen Testton auf, z.B. 35Hz youtube link, und prüfen Sie, ob Sie hören oder fühlen, wo die Luft durchkommt. Reparieren Sie das/die Leck(s).
Ihr 9-Volt-Schaltwandler strahlt Rauschen in Ihre Verstärkeranlage ab? Versuchen Sie, mit einem 100nF-Kondensator zu glätten, und fügen Sie einen 10k-Parallelwiderstand hinzu, um eine Dummy-Last zu erzeugen. Wenn beides nicht hilft, nehmen Sie stattdessen einen Linearwandler wie LM7809. Da er viel mehr Wärme abgibt als sein schaltender Kollege, sollten Sie ihn an Ihrem Metallgehäuse montieren.

Zurück zur Projekt-Hauptseite

CNC job erstellen

Schallbert — Mon, 22 Aug 2022 00:00:00 +0000

Demo video über Vorbereitung und Ausführung eines Fräsjobs

How-to: CNC job setup & quick demo

Die folgenden Abschnitte beschreiben die im Video gezeigten Schritte.

Checkliste zur Vorbereitung

Bei komplett heruntergefahrener Anlage:

Das Werkstück sicher im Arbeitsbereich der CNC befestigen
Die G-Code Datei auf den Maschinenrechner übertragen
Not-Aus aktiviert (verhindert unbeabsichtigtes Anlaufen)
Energieversorgung zur CNC und Peripherie einschalten
Maschinenrechner mit der CNC verbinden und CNC-Programm starten
Not-Aus deaktivieren
Zu verwendende Fräser bereitlegen und auf Beschädigungen prüfen

Checkliste für Hochfahren der CNC

Not-Aus quittieren (Schrittmotortreiber aktivieren)
Maschine referenzieren
Werkzeugwechsel auf das erste Werkzeug im Job
X/Y Werkstücknullpunkte anfahren und setzen
Z-Nullpunkt ermitteln und setzen
CNC zurück in Warteposition fahren
Spindelwarmlauf durchführen
Peripheriegeräte auf Funktion prüfen (Absaugung, Kühlschmierung etc.)

Während des Automatikbetriebs

Maschine überwachen
1. Hören: Klingt die Maschine “wie immer”? Gibt es Vibrationen oder hört sich irgend etwas merkwürdig an?
2. Sehen: Ist die Düse für Kühlschmierstoff korrekt ausgerichtet? Alle Parameter am PC im grünen Bereich? Verfahrwege OK?
3. Fühlen: Treten Vibrationen der Maschine auf? Führen z.B. Kühlgebläse einen merklichen Luftstrom?
Falls erforderlich: Werkzeugwechsel durchführen bzw. Werkzeuge vermessen
Falls etwas nicht in Ordnung scheint: Job per “Pause”-Taste unterbrechen
Im Falle eines Falles den Not-Aus betätigen

Nach Abschluss des Fräsjobs

Maschine zurück vor die Referenzschalter bewegen
Not-Aus betätigen und Maschinenrechner trennen
Energieversorgung der Maschine abschalten
Werkstück und gegebenenfalls Reststücke vom Maschinentisch nehmen
Reinigung von Maschine und Werkstück

Einschaltstrom ermitteln

Schallbert — Tue, 16 Aug 2022 00:00:00 +0000

Vorbereiten des Multimeters / Oszilloskops

Für diesen Artikel habe ich mir ein Multimeter zur Messung von “Power Quality” direkt vom Hersteller GMC Instruments leihen können. Da dort ein Datenlogger verbaut ist, kann ich die Messungen aufnehmen und später aufbereiten.

Metrahit Energy

Dieses Multimeter ist eher im Profi-Segment angesiedelt. Sowohl der Reichtum an Funktionen als auch sein Preis deuten für mich klar darauf hin. Zusätzlich zum Datenlogger und den üblichen Funktionen eines Multimeters kann es Leistung- und Energie messen bzw. berechnen, harmonische Signalverzerrungen erkennen und nebenbei auch PT100-Temperatursensoren auswerten.

Software setup

So richtet man die Auswertesoftware ein:

Software MetraWin herunterladen und installieren, um die vom Multimeter erfassten Daten zu übertragen und anzuzeigen.
Driver-Control “Treiber” herunterladen und installieren. Diese Software dient dazu, die Kommunikation zwischen USB und dem im Lieferumfang des Multimeters befindlichen Infrarot-Schnittstellenadapter bereitzustellen.
In der MetraWin-Software METRAHit Starline Series auswählen (übrigens ist mir unklar, warum der Name der Serie weder auf dem Gerät noch auf der Website erscheint)
Nun wird der Infrarot-Adapter am PC angeschlossen. Der IR-Adapter sollte im Gerätemanager mit einer “COM”-Anschluss-ID angezeigt werden (Windows-Taste –> Gerät in die Suche eingeben und Gerätemanager auswählen –> nach unten zu Anschlüsse (COM & LPT) scrollen, aufklappen). Diese Nummer dann in MetraWins Gerät --> Kommunikation... --> SEL-COM angeben - fertig.

Einrichtung des Multimeters für die Aufzeichnung des Einschaltstroms

In den Einstellungen dieses Multimeters ist darauf zu achten, dass die Adresse auf einen anderen Wert als 00 eingestellt ist (Setup --> Set --> System --> Addr), da die Infrarot-Kommunikation das Gerät mit einem ungültigen Wert hier nicht erkennt (ich habe dies erlebt und brauchte einige Zeit, um herauszufinden, dass nicht die IR-Adapter-Erkennung fehlerhaft ist, sondern die Einstellungen des Multimeters). Hintergrund ist, dass die Software über die Adressierung bis zu 15 Geräte gleichzeitig unterstützt. Warum 00 dabei ungültig ist, das wissen wahrscheinlich nur die Entwickler der Software.
Stellen Sie die Abtastzeit auf den niedrigsten Wert für eine gute Impulsverfolgung ein: Measure --> Save --> rate und wählen 0.0005sec auswählen, was bedeutet, dass der Logger Messungen mit 2000Hz Abtastrate durchführt. Dies ist der niedrigste Wert, den man erreichen kann, und diese Werte beeinträchtigen bereits die Verfügbarkeit des Aufzeichnungskanals, z.B. für Energiemessungen, aufgrund der begrenzten Pufferfähigkeit des Geräts.
Wählen Sie nun den Wert aus, den Sie messen wollen (bei mir ist es DC Strom in Ampère), und passen über die MAN/AUTO Taste den Wertebereich im manuellen Betrieb so an, dass die zu erwartende Impulshöhe abgedeckt wird. Kleiner Hinweis: Wenn das Multimeter den Zusatz TRMS oder RMS anzeigt, ist dies für unsere Messung hier eher nicht erwünscht, da in diesem Falle eventuelle Spitzenwerte geglättet werden.

Um den Einschaltstrom meines Verstärkers zu bestimmen, verwende ich den Messbereich >10A. So habe ich zwar eine für den Normalbetrieb geringe Genauigkeit, kann allerdings die Stromspitze gut abbilden.

Alternative Messgeräte

Oszilloskope sind Multimetern bei der Zeitauflösung weit überlegen, benötigen aber weitere Hilfsmittel um Ströme exakt erfassen zu können.

Dennoch sind sie hier mit einfachen Hilfsmitteln verwendbar: Einen Widerstand mit niedrigem Wert (z.B. 0.1 Ohm) und geringer Toleranz in Reihe mit dem Prüfling schalten und den Spannungsabfall am Widerstand per Oszilloskop bestimmen. Bei einer Auflösung von 1V/div läge dann die Umrechnung für den Einschaltstrom bei 10A/division.

Ein günstiges Multimeter hingegen mit “Data Max Hold” Funktion wird für diesen Anwendungsfall wahrscheinlich aber nicht funktionieren, da die Messintervalle für die zu messenden, sich schnell aufladenden Kondensatoren schlicht zu lang sind.

Der Prüfling

Die zu untersuchende Schaltung ist eine Endstufe mit 30W Dauerleistung AA-AB32996, produziert von “sure electronics”. Er basiert auf dem integrierten Class-D-Verstärkerbaustein TPA3110.

Die Energieversorgung besitzt einen Verpolschutz (drei parallel geschaltete Schottkydioden) und bindet sechs Pufferkondensatoren mit einer Kapazität von je 220uF ein. Zusätzlich befinden sich nahe der Versorgungspins des IC zwei weitere Entstörkondensatoren.

Zum Vergleich: Das Referenzlayout des IC-Herstellers sieht der oben beschriebenen Lösung recht ähnlich. Hier werden zusätzlich FB (Ferritkerne) verwendet, um die Ströme auf der Eingangsseite zu glätten. Dafür wird weniger Pufferkapatizät vorgesehen. Darüber hinaus verwendet das Referenzdesign einfache Ferritkerne anstatt hochwertigerer Filterspulen am Verstärkerausgang.

Motivation: Ausfall eines Prototypen bei Verwendung von USB-C PD

Für einen meiner Prototypen hatte ich vorher ein USB-C Power Delivery Entwicklungsboard - erklärt in diesem Beitrag - verwendet. Leider musste ich feststellen, dass dieser nach nur ein paar Einschaltzyklen in Rauch aufging - wahrscheinlich verursacht durch einen hohen Einschaltstrom, für den der IC nicht ausgelegt ist.

Daher wollte ich genau wissen, wie hoch die Stromspitzen sind und mit welcher Komponente ich den Einschaltstrom so in den Griff bekomme, dass hierdurch verursachte Schäden an elektronischen Bauteilen ausgeschlossen werden können.

Durchführung der Messung

Ich verbinde den Messpfad für Strom des Multimeters mit dem Minuspol des Verstärkers und die Masse des Multimeters mit dem Minuspol des Netzteils. Die Messspitze für Spannung verbinde ich mit dem Pluspol des Verstärkers, und letzteren wiederum schließe ich über einen Schalter am Netzteil an.

Um die Messung zu beginnen, wähle ich beim Multimeter SET --> Store --> Start --> Store und lege den Schalter an der Spannungsversorgung um. Nach ein paar Sekunden beende ich die Messung mit der Taste Stop.

Da ich zu beginn die höchstmögliche Datenrate eingestellt hatte, musste ich die Daten hernach manuell an den Computer übermitteln und konnte nicht die Liveübertragung wählen. Hierfür wählt man in der Software folgende Einstellung aus: Read Memory --> Get Memory Info --> Move Memory Data to File --> save --> Open Memory Data File --> Display Data from File. Mir ist dabei nicht ganz klar, warum an der Stelle so viele Schritte erforderlich sind - ich hätte hierfür nur einen Knopfdruck erwartet.

Das Dateiformat Measurement Data File hat einen großen Vorteil gegenüber dem ebenfalls möglichen Memory Data File: Es enthält Metadaten wie Messdatenauswahl für die Ansicht, Labels und Details zur Darstellung wie Einheiten etc. Ohne großen Aufwand lassen sich Auswertungen erstellen und beispielsweise im PDF-Dateiformat exportieren.

Visualisierung des Einschaltstroms

Der ganze Spuk dauert nur ~10ms, also 20 samples. Nach einem hohen Strompuls von >12A zeigt sich ein Plateau bei rund 4A bis sich die Kondensatoren aufgeladen haben. Danach geht der Strom zurück, bis er dem Leerlaufstrom des Verstärkers entspricht.

Der Spitzenwert liegt allerdings nur für einen Datenpunkt vor - daher kann ich nicht sagen, ob es sich um einen Messfehler / Ausreißer oder ein tatsächliches Ereignis handelt. Ein paar Annahmen zur Ursache:

Es wurden schaltungsweit Entkopplungskondensatoren mit sehr geringem ESR (Serienwiderstand) verwendet
Verlassen des Messbereichs des Multimeters
Limiter des Labornetzteils begrenzt den Strom auf Niveau des Plateaus (war auf 5A konfiguriert, passt also nicht recht zusammen)

Spannungsverlauf an den Versorgungspins des Verstärkers

Die Spannungsmessung zeigt einen sprunghaften Anstieg beim ersten Messwert nach Einschalten des Verstärkers, gefolgt von einem fast linearen Anstieg bis die Quellspannung nach etwa ~6ms erreicht wird.

Diese Werte passen zeitlich prima mit den Strommessungen zusammen und bestätigen sowohl Impuls- als auch Plateauwerte.

Wiederholung & Ergebnis

Ich wiederholte die Messung mit unterschiedlichen Randbedingungen: Lautsprecher angeschlossen/ nicht verbunden, Verstärker in Standby/ Leerlauf usw. aber die Messergebnisse waren stets ähnlich. Somit wird die Verstärkerschaltung im Moment des Einschalten nicht durch seine Konfiguration oder Peripherie beeinflusst.

Die Werte sind also bedingt durch den Versorgungspfad und seine Schutzmaßnahmen, Energiespeicher und seine Entkopplungsschaltung.

Nachteile der Messung mittels Multimeter sind geringe Datenrate (10-100kHz wären besser gewesen), keine Möglichkeit, die Messwerte live abzulesen, und langen Datentransferzeiten zum PC, geschuldet durch die Kommunikation per Infrarot. Andererseits kann ich das Multimeter jetzt schnell mal als “offline Datenlogger” auch über längere Zeit verwenden, ohne einen Computer zur Konfiguration dabei haben zu müssen. Optimal für die Anwendung im Feld.

Für den Verstärker werde ich mit diesen Erkenntnissen jetzt eine Schutzschaltung entwickeln, ähnlich wie in diesem Beitrag diskutiert, und so in Zukunft Probleme mit USB-PD ICs vermeiden.

Meine CNC vibriert

Schallbert — Thu, 14 Jul 2022 00:00:00 +0000

Hintergrund

Langsam werde ich mutiger im Umgang mit meiner Maschine. In letzter Zeit bearbeite ich des Öfteren Birke Multiplex in der Vollnut, möglichst mit nur einem Fräsdurchgang um nicht so lange im kalten Keller stehen zu müssen. Das bedeutet aber auch, dass die Maschine eine Tiefenzustellung Z+ von 12mm bei F2700mm/min mit einem 6mm 2-Schneider Schruppfräser bei S=24000rpm``Z+ bewältigen muss. Dabei fräse ich im Gleichlauf.

Nun fängt meine Maschine in bestimmten Situation an, hörbar zu vibrieren.

Nun liegt es nahe, die Schneidkräfte an der Maschine zu reduzieren, entweder durch Reduktion der Tiefenzustellung oder des Vorschubs. Die Drehzahl kann ich bei meinem Fräsmotor nämlich nicht weiter erhöhen. Das werde ich vielleicht auch tun, aber erst einmal möchte ich verstehen, was die Fräse zum Vibrieren bringt und ob ich das auch durch andere Maßnahmen abstellen kann, ohne die Maschinenzeit zu erhöhen oder Standzeiten meiner Fräser merklich zu reduzieren.

Problembeschreibung

Die Maschine vibriert nicht nur bei Konturschnitten, sondern auch wenn ich Taschen fertige. Allerdings nur bei bestimmten Bewegungsrichtungen. Es fühlt sich so an, als würde sich die ganze Maschine leicht schütteln, und das Geräusch ähnelt einem Stuhl, der unter Last über Parkettboden zurückgeschoben wird.

Um das etwas zu verdeutlichen, habe ich zwei kleine Referenzvideos gemacht.

Your browser does not support the video tag.

Vibrationen nur an bestimmten Stellen beim Taschenfräsen (80% Räumzustellung)

Your browser does not support the video tag.

Vibrationen beim Formatieren

Analyse

Das Fräsbild sieht trotz Vibrationen ordentlich aus.

Ich habe versuchsweise ein paar Einstellungen angepasst: Reduzierte Tiefenzustellung Z+ von nur noch 6mm bei erhöhtem Vorschub von 3600mm/min mit demselben Fräser - Vibrationen abgestellt.

Nun war es zugegebenermaßen nicht so klug, zwei Parameter gleichzeitig zu ändern - so weiß ich nicht, ob die erhöhten Schnittkräfte oder ein Vorschub im Resonanzbereich der Maschine zu den Vibrationen lag - tsja.

Dennoch habe ich den Maschinenhersteller auf das Problem angesprochen hier verlinkt, und seiner Meinung nach ist der wahrscheinlichste Grund die etwas schwach ausgelegte Verbindung zwischen Fräsmotor und Z-Achse.

Der Fräsmotor hat weniger hochwertige Lager als professionelle Hochfrequenzspindeln, also sind sie potentiell eher von Spiel betroffen. Außerdem klemmt die 42mm Eurohals-Halterung den Fräsmotor mit nur einer Verschraubung, die zudem bei recht niedrigen 7Nm drehmomentbegrenzt ist, da der vordere Lagersitz des Fräsmotors sonst zu stark gequetscht wird.

Im Gegensatz dazu werden Motorspindeln meist direkt und vollflächig mit der Z-Achse verschraubt, sodass Kraftschluss und Kontaktfläche viel größer ausfallen.

Ergebnis

Ich habe jetzt ein paar Optionen:

Weiter mit großer Tiefenzustellung arbeiten und die Vibrationen und damit einhergehenden erhöhten Maschinenverschleiß tolerieren
Geringere Zustellungen fahren, dafür aber Maschinenzeit opfern
Die Spindel aufrüsten, welches meine Maschine deutlich teurer macht
Mein Maschinenbett aufrüsten und so die Steifigkeit des Grundrahmens erhöhen

Update September 2023

So, ich habe jetzt sowohl die Spindel als auch das Maschinenbett aufgerüstet. Die Vibrationen sind leider immer noch da. Das finde ich ziemlich ärgerlich.

Wenn ich mir die Umstände nochmal genau ansehe, dann treten die Vibrationen immer dann auf, wenn sich das Portal vorwiegend auf der breiten Achse (bei mir X) bewegt, gleichzeitig aber ebenfalls leicht auf der Längsachse (Y) unterwegs ist. Fahre ich nur in Y, passiert nichts. Fahre ich nur in X, treten die Vibrationen schwächer auf.

Ich kan inzwischen ebenfalls sagen, dass die Vibrationen in schwächerer Form auch in Acrylglas bei einer Tiefenzustellung von Z+5mm, Vorschub F3000mm/min und einem 4mm-Einschneider auftreten.

Ich werde einmal ausprobieren, ob ich das Problem auch noch bei F3600mm/min habe.

Da ich inzwischen Maschinenbett und Spindelbefestigung als Ursache sicher ausschließen kann, liegt die Ursache der Vibrationen meiner Einschätzung nach am Zusammenspiel der Portalachsen.

Nun habe ich eine recht breite Maschine ohne zusätzlich verstärkte Portalwangen, die zudem nur mit einer statt zwei Linearführungen auf der Z-Achse ausgestattet ist. Ich spreche die nächsten Wochen nochmal mit dem Hersteller, um diesen Verdacht zu erhärten bzw. aus dem Weg zu räumen.

Vom Bild zum Pfad

Schallbert — Mon, 04 Jul 2022 00:00:00 +0000

Dies ist ein kurzer Beitrag über die Verwendung der beiden Open-Source-Programme Paint.NET und Inkscape, um aus Pixelgrafiken Pfade zu erzeugen. Diese können dann z.B. für Gravuren auf einer CNC-Maschine, einem Laserschneider oder einem Plotter verwendet werden. Und das sogar auf Grundlage eines digitalen Bildes von geringer Qualität in einem verlustbehafteten Datenkompressionsformat wie JPEG.

Der Beitrag wurde inspiriert von diesem ausgezeichneten Stackexchange-Thread.

Die Bildquelle

Alles beginnt mit zu konvertierenden dem Bild (bzw. der Pixelgrafik).

Geistiges Eigentum

Zu beachten ist, dass Bilder (auch selbstgezeichnete) in der Regel urheberrechtlich geschützt sind, so dass zunächst die (schriftliche) Zustimmung des Eigentümers des geistigen Eigentums eingeholt werden muss.

Sind Sie der Inhaber der geistigen Eigentumsrechte, ist das viel einfacher. Aus diesem Grund habe ich für diese kurze Demo ein Bild gewählt, das ich selbst erstellt habe.

Bildqualität

Richtig gut zeichnen kann ich allerdings nicht, wie das Bild klar andeutet. Einige Linien sind übereinander gemalt und der Kontrast ist gering. Perfekte Bedingungen, um zu zeigen, was die Software leisten kann!

Hinweis: Es gilt wie immer das Credo “Garbage in, garbage out”. Es ist also sicher zu stellen, dass vor Beginn der Arbeiten die bestmögliche Bildqualität erreicht wird. Auf diese Weise ist die Bereinigung des Bildes viel einfacher und die Gravurpfade fallen simpler und genauer aus.

Paint.NET

Farbkorrektur und Freistellung

Schneiden Sie Ihr Bild zunächst auf den Inhalt zu, den Sie später verwenden möchten. Nehmen Sie dann das Werkzeug Helligkeitskurve (Anpassen -> Kurven) und versuchen Sie, die hellen und dunklen Töne so weit wie möglich zu trennen.

Zweitens, wenn Ihr Bild so schlecht ist wie meines, verwenden Sie das Werkzeug Zauberstab. Spielen Sie mit den Toleranzen für die Farberkennung - um so den Hintergrund so gut wie möglich zu entfernen und das Motiv freizustellen.

Drittens: Verwenden Sie das Kontur-Werkzeug (Effekte -> Stilisieren -> Kontur), um eine schöne dicke Linie als Umriss zu erhalten. Eine Umwandlung des Bildes in Graustufen und eine weitere Erhöhung des Kontrasts können helfen, diese Linie schwarz zu machen. Falls Sie Linien verlieren, die nicht dunkel genug sind - keine Sorge, das lässt sich später in Inkscape leicht beheben.

Weitere Bereinigung

Entfernen Sie so viele “Pixelwolken” und andere Artefakte aus dem Bild wie möglich mit den Werkzeugen Zauberstab oder Radiergummi, das ist jetzt einfacher als später.

Speichern Sie Ihr Bild als portable Netzwerkgrafik .PNG.

Inkscape

Öffnen Sie das Bild in Inkscape. Wählen Sie die Standard-Import-Einstellungen DPI der Datei verwenden.

Nachzeichnen

Wählen Sie Pfad -> Bitmap nachzeichnen. In dem neu geöffneten Tab wählen Sie Trace Bitmap, Single Scan, Brightness Cutoff und spielen mit den Optionen herum, bis sich die Kontur Ihres Motivs vom Hintergrund abhebt. Stellen Sie sicher, dass Sie das Bild per Mausklick auswählen, bevor Sie auf “Aktualisieren” oder “Anwenden” klicken. Wenn Sie mit der Vorschau nicht zufrieden sind, passen Sie die Werte an. Falls Sie bei der Vielzahl der Einstellungen nicht weiterkommen, schauen Sie sich einfach dieses Tutorial von Inkscape - Link zur Inkscape Website an.

OK, jetzt haben wir eine Menge Pfade. Per Klick auf Pfad -> Vereinfachen wird die Anzahl der Stützpunkte reduziert. Entfernen Sie dann manuell Artefakte, die sich bei Verwendung der Luminanzkurven eingeschlichen haben, mit dem Knotenwerkzeug.

Füllen und Streichen

Damit gibt es nun genau zwei die Zeichnung außen und innen umreißende Pfade sowie eine Füllung zwischen diesen Pfaden, die die Linienstärke der ursprünglichen Zeichnung darstellt. Da wir nur die äußere Kontur behalten wollen, müssen wir die Füllung und die innere Linie entfernen.

Wählen Sie das Werkzeug Linie und Füllung im unteren Teil der rechten Symbolleiste. Wählen Sie die Registerkarte Linienfarbe und setzen Sie den Strich auf eine deckende Farbe. Wählen Sie unter Linienstil eine Linienbreite, die Ihnen zusagt. Gehen Sie dann zur Registerkarte Ausfüllen und stellen Sie Ohne ein. Jetzt haben Sie nur noch zwei Umrisslinien, von denen Sie eine löschen können, wenn Sie möchten.

Und noch mehr Bereinigung

Das sieht doch schon ziemlich gut aus, oder? Wenn es Ihnen nichts ausmacht, dass die Umrisse mehr als ein einziger Strich sind, sind Sie schon fertig. Sie können nun das Bild weiter verbessern, indem Sie Pfade herausziehen oder Kurven umwandeln.

Verwenden Sie das Werkzeug Pfad an ausgewählten Knoten unterbrechen, bevor Sie parallele Linien entfernen, damit Sie nicht versehentlich die Linien zerstören, die Sie behalten möchten. Wenn Sie mit dem Ergebnis zufrieden und alle Unsauberkeiten ausgebügelt sind, speichern Sie Ihr Werk als skalierbare Vektorgrafikdatei SVG.

Das war’s! Jetzt kann Ihr CAM-System das Bild importieren (denken Sie an die DPI-Einstellung, damit Ihre Skalierung gültig bleibt).

CNC: Überlastung Fräsmotor

Schallbert — Sat, 18 Jun 2022 00:00:00 +0000

Was ich eigentlich wollte

Ich hatte eine Anfrage zum Schneiden und Gravieren von Hochdrucklaminaten. Dabei handelt es sich um eine Lasagne aus gepresstem Papier und Phenolharz, überzogen mit einer dünnen Schicht (farbigen) Melaminharzes. HPL ist so widerstandsfähig, dass es für Fassadenbeplankungen verwendet wird. Es ist spülmaschinenfest und einige Varianten können auf bis zu 200°C erhitzt werden, ohne Schaden zu nehmen. HPL findet man als Platten auf Spielplätzen, Gartentischen, als Paneele in der Straßenbahn und an vielen anderen Stellen im Alltag. Also dachte ich mir: “Cooles Zeug, Probieren geht über Studieren!”

Schnittdaten in Hochdrucklaminaten (HPL, “Resopal”)

Ich habe die von einigen Websites empfohlenen Schnittdaten mit Werten für “Hartholz” verwendet. 2-Schneider.Holz-Hartmetallschaftfräser, Schnittgeschwindigkeit 450m/min, d6mm, Z+6,5mm, S24000rpm, F3500mm/min, Vollnut, Gleichlauffräsen.

Schnittergebnisse

Und ich war erschrocken, wie der Schnitt aussah, als ich fertig war. Hier sind die Symptome:

Während des Schneidens fiel die Spindeldrehzahl wiederholt ab, stieg aber schnell wieder auf die gewünschte Drehzahl an.
hohe Spanlast am Fräser, große Späne, sah alles gut aus
der Fräser folgte keiner geraden Linie: schien dem Material irgendwie ausweichen zu wollen.
bei der Herstellung von Anbindungen, um das Werkstück an Ort und Stelle zu halten, bewegt sich der Fräser ein wenig quer zur Fräsbahn, obwohl er das nicht sollte

Suche nach dem Übeltäter

Zuerst habe ich die Spindel überprüft. Keine Überhitzung, immer noch fest an der Portalfräse eingespannt, kein Lagerspiel, Schaftfräser sicher befestigt. Dann dachte ich: “Vielleicht stimmt etwas mit dem Portal nicht? Kann ich es merklich verwinden?” Nein, das konnte ich nicht. Dann sah ich mir den Schaftfräser an.

Es sah überhaupt nicht gut aus. Die Schnittkanten waren an den Stellen, an denen sie das Material berührt hatten, praktisch weg. Seltsam. Es war nagelneu als ich den Auftrag begann, und der lief nicht einmal 20 Minuten lang.

Analyseergebnisse

Ich habe viel zu aggressive Schnittdaten verwendet.
Dadurch wurde der Motor der Oberfräse weit über seine Möglichkeiten hinaus betrieben.
Dies führte zu einem plötzlichen Abfall der Motordrehzahl.
Dies wiederum führte zu einer erhöhten Spanbelastung meines Fräsers
Da die Lager und die Befestigung des Fräsmotors am Portal “weich” sind, versuchte der Fräser, seiner Fräsbahn auszuweichen
Dies hat mich wahrscheinlich vor dem Bruch des Fräsers bewahrt.

Verbesserungen

Neubewertung der Schnittparameter für Hochdrucklaminat

Ich habe nochmal online recherchiert. HPL ist unglaublich hart und steif. Hier mal ein paar Werte zum Vergleich (Brinellhärte):

Buche: ~3.7N/mm² (Source)
HPL: ~185N/mm² (Source)
Baustahl ST70: 215N/mm² (Source)

Des Weiteren fand ich einige Empfehlungen zur spanabhebenden Verarbeitung von HPL, z.B.: “Vollhartmetallfräser sollten eine Schnittgeschwindigkeit von bis zu 150m/min” und “Diamantbeschichtungen aufweisen oder als Einschneider zur Bearbeitung von Aluminium ausgeführt sein”.

Zwischenlösung

Um die Dinge zu korrigieren, habe ich alle Ausschnitte mit den Schlicht-Einstellungen in CAM erneut durchgeführt. Mit einem neuen Schaftfräser und weniger aggressiven Vorschubgeschwindigkeiten von F2500mm/min und einer aktualisierten Tiefe pro Durchgang von Z+1,5mm. Das Ergebnis sieht jetzt viel besser aus.

Optimierung der Schnittdaten

Dann berechnen wir schnell mal neue Schnittdaten aufgrund der oben gewonnenen Erkenntnisse. Ich wähle einen 4mm Einschneider (z=1) mit Beschichtung zur besseren Wärmeabfuhr für Aluminium und lege die oben genannte Schnittgeschwindigkeit von vc=150m/min für HPL zugrunde. Weiterhin wähle ich einen Zahnvorschub von fTooth = 0,025mm, ähnlich wie beim Fräsen von Stahl.

Zieldrehzahl:

$$n=\frac{v_c}{\pi d}=\frac{150000\frac{mm}{min}}{\pi \cdot 4mm}=12000\frac{1}{min}$$

Zielvorschub:

$$F=n \cdot f_{Tooth} \cdot z = 12000\frac{1}{min} \cdot 0,025mm \cdot min \cdot 1= 300\frac{mm}{min}$$

Ich habe einen 4mm-Schaftfräser gewählt, weil das Drehmoment meines Fräsmotors bei sinkender Drehzahl überproportional abnimmt. Bei größerem Fräserdurchmesser würde dieser Effekt wahrscheinlich zu einer unzureichenden Schnittleistung führen. Spindeln mit einer Asynchronmaschine sind hier durch ihr konstant hohes Drehmoment im unteren Drehzahlbereich (bei Vektorsteuerung kann es sogar deutlich über dem Nennmoment des Motors liegen) ganz klar im Vorteil.

Der berechnete Vorschub kommt mir so langsam vor. Ich hoffe, dass sich das Material dadurch nicht so stark erhitzt, dass es delaminiert (laut Wikipedia schmilzt es nicht…)

Zur Information: Hier ist der zugehörige Thread in dem Forum, das ich regelmäßig besuche.

Weitere Tests

Ich habe einige Teile mit oben angesprochenem Fräser und Einstellungen gefertigt. Um die Fertigungszeiten etwas im Zaum zu halten, habe ich die Werte leicht angepasst: ftooth = 0.04mm und vc = 130m/min. Für den 4mm Fräser ergibt sich

S = 10300U/min
F = 410mm/min
Z+ = 3mm
vc = 1%

Dieser Schaftfräser lebte etwa 1 Stunde lang. Nicht lange genug. Das Schneiden mit einem solchen Fräser könnte nie wirtschaftlich werden. Das HPL, das ich verwende, hat zwei Materialeigenschaften, die Hartmetallfräser schnell zerstören: Erstens ist es abrasiv, sodass die dünne Schneide des Fräsers abgetragen und zerstört wird. Meines ist ganz besonders abrasiv, da es einen unheimlich hohen Faseranteil besitzt. Zweitens leiten die Späne die entstehende Wärme nicht gut von der Schneide ab, so dass ihre Schärfe noch schneller nachlässt. Hitze scheint das Kryptonit für Hartmetallfräser zu sein.

Endgültige Lösung

Eine wirtschaftlichere Lösung mit 40-facher (Herstellerangabe) Lebensdauer wäre ein Hartmetallfräser mit Diamantschneiden (z. B. wie dieser hier). Der Nachteil ist, dass sie fast zehnmal so teuer sind. Wenn ich dieses Material in Zukunft öfter schneiden muss, kaufe ich vielleicht einen und teile meine Erfahrungen - in der Zwischenzeit lasse ich die Fräser lieber schärfen, um Geld zu sparen.

CNC 'Opferplatte'

Schallbert — Sun, 12 Jun 2022 00:00:00 +0000

Materialliste

Artikel	Anzahl	~ Kosten [€]
MDF, Stärke 19mm, 840x730	2	30
MDF, Stärke 5mm, 840x730	1	5
Einschlagmutter	17	9
M6 Maschinenschraube, 20mm + M6 Hammermutter + Unterlegscheibe	20	12
M6 Maschinenschraube, 35mm + Unterlegscheibe	17	5
Holzleim	-	0,10

Werkzeuge

Schraubendreher / Schraubenschlüssel / Steckschlüssel
Ihre CNC

Der Aufbau

Laden Sie die Zeichnungen als zip-Datei herunter
Passen Sie bei Bedarf die Abmessungen an ¹
Importieren Sie die Zeichnung in Ihr CAM-Werkzeug. Passen Sie die Materialstärke an, falls Sie andere Platten verwenden als ich.
Bereiten Sie Senkbohrungen für Ihre Befestigungselemente vor, die am Maschinenrahmen befestigt werden. Die Tiefe dieser Bohrungen bestimmt die Reserve für das Planfräsen und damit das Aufbereiten verschlissener Oberflächen.
Da sowohl der Anschlag als auch Opferplatt größer sind als der von der CNC erreichbare Bereich, müssen Sie mehrere Jobs programmieren. Wählen Sie Ihre XY-Nullpunkte mit Bedacht und ziehen Sie gern die Projektseite zu Rate, auf der ich mein Vorgehen detailliert beschrieben habe (unten verlinkt).
Beachten Sie auch, dass die T-Nuten “von unten” gefräst werden müssen, falls Sie keinen Schlüssellochfräser haben.
Nachdem Ihre CNC die Aufträge abgearbeitet hat, kleben Sie die obere und untere MDF-Platte zusammen, damit die Hammermuttern nicht durch die Schlitze fallen können.

Zurück zur Projekt-Hauptseite

Hinweis: Die mittlere Versteifung des Maschinenrahmens hat keine festgelegte Position, sie kann bei Ihnen also an einer anderen Position stehen. ↩︎

Mein Fräser 'kreischt'

Schallbert — Mon, 06 Jun 2022 00:00:00 +0000

Einordnung

Ich arbeite gerade an meinem allerersten CNC-Fräsprojekt: Eine “Opferplatte” mit Schraubmuffen und T-Nuten für die Niederhalter, welche einen Anschlag für Werkstücke und eine Aufnahme für den Werkzeuglängensensor besitzt.

Auf der Oberfräse habe ich bis jetzt nur gerade genutete HSS-Fräser mit großen Durchmessern verwendet. Für die CNC kaufte ich nun 6-mm-Vollhartmetallfräser “Fischschwanz” mit zwei Schneiden und einer Arbeitslänge von 21mm. Und der klingt einfach furchtbar, ganz anders als ich es von der Oberfräse gewöhnt bin.

Die Verwirrung des Anfängers

Mit diesem Fräser habe ich die vom Hersteller empfohlenen Vorschübe und Geschwindigkeiten für Hartholz auf meinem Werkstück aus mitteldichten Faserplatten eingehalten (Tiefe pro Durchgang: 6mm, Vorschub: 3500mm/min, Drehzahl: 24000U/min). Aber offensichtlich mache ich etwas falsch, denn beim Schneiden gibt es ein schrecklich lautes, unangenehmes schrilles und zischendes Geräusch.

Ich habe die Vorschubgeschwindigkeit allmählich erhöht, weil ich den Eindruck hatte, dass die Fräser wegen zu geringen Vorschubs so klingen. Ich landete bei 9100mm/min (!), wo es etwas besser war. Trotzdem ging dieses unangenehme Geräusch nicht weg.

Your browser does not support the video tag.

Fräser 'kreischt' beim Zerspanen von MDF

Analyse

Nachdem die 15-minütige Arbeit beendet war, habe ich den Schaftfräser angefasst - die Spannuten sind so gut wie neu und der Fräser fühlt sich kaum warm an. Hmm. Auch der Fräsmotor klang nicht gestresst. Meine Schrittmotoren ließen die Maschine buchstäblich durch das MDF pflügen (reibungslos und ohne Probleme), ich musste sogar die Absaugung aufdrehen, um nicht im Staub zu ertrinken. Auch das Ergebnis sieht für mich gut aus; die Toleranzen sind eng und der Schnitt ist so sauber, wie ich es erwarte - viel besser als ich es von Hand hätte machen können.

Offene Fragen

Was mache ich also falsch? Ist dieses Geräusch “normal” für einen 2-Schneider mit so kleinem Durchmesser? Braucht MDF ganz andere Parameter als Hartholz, um leise zu schneiden, z.B. viel weniger Spindeldrehzahl? Muss ich in meinem CAM-Tool eine andere Frässtrategie wählen?

Diese Fragen stelle ich schnell mal im Forum.

Fragen beantwortet

OK, ich habe eine Antwort vom Hersteller des Bits. Dieses Geräusch ist normal für Schaftfräser, die auf das Schneiden von Holz spezialisiert sind. Nun denn. Wahrscheinlich sollte ich ein Gehäuse für meine Maschine bauen und ein paar sehr gute Ohrstöpsel kaufen. 😬 Nach ein paar Gesprächen mit einem weiteren Werkzeughersteller bestätigt sich diese Aussage nochmal:

“Zweischneider sind immer lauter als gleichgroße Ein- oder Dreischneider. Ihre im 180°-Winkel gegenüberliegenden Flanken sorgen durch die im Wechsel im Eingriff befindlichen Schneiden für zusätzliche Schwingungen des Fräsers. Dafür bieten sie ein besseres Verschleißverhalten als Einschneider und ermöglichen eine bessere Spanabfuhr als Dreischneider.”

Vergleich: Gleiches Material, anderer Fräser

Hier ist ein Vergleichsvideo um zu beurteilen, wie unterschiedlich Fräser in demselben Material klingen können: 14mm 3-Schneider Planfräser, 10mm Schaft, S5500, F7100, Z0.3, Fxy 90%

Your browser does not support the video tag.

14mm Planfräser nivelliert in aller Ruhe meine Opferplatte.

Zum Testen habe ich in meinem CAM-Werkzeug eine Spiralstrategie verwendet, die 50% mehr Zeit benötigt als die typischen “Rasenmäher”-Strategien. Auf diese Weise gibt es keine sichtbaren Fräsbahnen im fertigen Material.

Update April-2024:

Nach etwa zwei Jahren Betrieb mit diesen Holzfräsern kann ich sagen, dass sie robust laufen und lange halten. Hier ist mehr Vorschub und mehr Tiefenzustellung besser, als zu behutsam vorzugehen (F4000 S24000 Z+12mm ist in Birke Multiplex auf meiner Maschine durchaus drin). Und die Fräser sind im Gegenlauf deutlich leiser als im Gleichlauf.

CNC Teil5 - Makros

Schallbert — Wed, 11 May 2022 00:00:00 +0000

Dies ist der fünfte Teil meiner Serie über Portalfräsmaschinen. Er befasst sich mit praktischem Zubehör, welches das Leben als CNC-Bediener erleichtert und zu schnelleren und genaueren Fräsergebnissen führen kann.

Übersicht

In diesem Artikel geht es um Makros für die CNC, mit deren Hilfe sich wiederholende Vorgänge automatisiert werden können. Ich decke sowohl grundlegende als auch anspruchsvollere Makros für mehrere Zwecke wie automatische Z-Nullstellung, Werkzeuglängenmessung oder Werkzeugwechsel ab. Ich führe ein paar G-Code Befehle ein. Die Beschäftigung damit half mir dabei, ein tieferes Verständnis der Funktionsweise zu erarbeiten und damit “Vertrauen” zu meiner Maschine aufzubauen.

Haftungsausschluss

Die folgenden Subroutinen wurden für den RS274 NGC Interpreter geschrieben. Ich habe sie mit EdingCNC validiert, da dies die von mir verwendete CNC-Software ist. Ich habe einige Aspekte von Makro-Dateien abgeleitet, die sowohl Sorotec als auch Eding zusammen mit ihren Maschinen ausliefern.

⚠️ Ich kann für die Funktion des hier beschriebenen Codes auf anderen Maschinen keine Verantwortung übernehmen. Meine Absicht ist lediglich zu erklären wie die Makros funktionieren.

Was ist ein Makro?

Ein Makro oder Unterprogramm ist eine Sammlung von Anweisungen, die für den CNC-Interpreter geschrieben wurden, um Aktionen auszuführen. Sie werden oft verwendet, um wiederkehrende Vorgänge zu automatisieren. Auf meiner Maschine beginnt ein solches Makro mit einem SUB-Befehl und endet mit einem ENDSUB. Makros enthalten oft Verzweigungslogik und G-Code-Befehle, beispielsweise um die Maschine Bewegungen ausführen zu lassen, Parameter abzuspeichern oder Benutzerdialoge anzuzeigen.

Auf meiner Maschine befinden sich alle Makros in einer einzigen Datei namens macro.cnc, die von meiner CNC-Software beim Start eingelesen wird. Einige “Soft-Buttons” der Software rufen direkt Makros aus dieser Datei auf, z.B. für die Referenzfahrt.

Als kleine Einführung öffne ich das Dokument macro.cnc mit einem Texteditor. Ich suche nach Sub user_9 (es sollte eine Routine sein, die nichts Relevantes tut), entferne ihren Inhalt und füge stattdessen MSG "hello world!" ein. Abspeichern, CNC-Software öffnen, die Taste 9 im user menu drücken und Voilà!

Ein einfaches Makro zur Erkennung des Status des Werkzeuglängensensors

Legen wir los und verbinden das neu erworbene Wissen über Makros mit einem nützlichen Beispiel.

Der Werkzeuglängensensor

Ein Werkzeuglängensensor (im Folgenden WZLS) ist ein Zubehörteil, das an einen Eingang der CNC-Maschine angeschlossen wird und bei Berührung (z.B. durch eine Werkzeugspitze) auslöst. Es gibt viele verschiedene Ausführungen, von einem einfachen Mikroschalter mit Gehäuse und Tastmechanismus bis hin zu hochpräzisen induktiven Sensoren aus feingedrehtem Edelstahl mit automatischer Luftspülung um sicherzustellen, dass die Oberfläche des Sensors sauber ist.

Der Werkzeuglängensensor wird entweder am Maschinenbett, auf dem Ablagetisch oder einfach an einer anderen festen Position an der Maschine angebracht. Meiner ist ein sehr einfacher Schalter. Seine Wiederholgenauigkeit ist mit 10µm angegeben.

Makro-Aufgabe

Das Makro soll vor der Messung prüfen, ob der WZLS betriebsbereit ist. Ich teste also, ob der Sensorschalter den Status “nicht ausgelöst” hat. Seine Verdrahtung ist als “normally closed” (NC) ausgeführt. Falls er doch ausgelöst ist (seine Kontakte also offen sind), könnte das Folgendes bedeuten:

Der Sensor klemmt in der ausgelösten Position
Kabelbruch in der Zuleitung zum WZLS
Sensor ist nicht mit der Maschine verbunden

Code: Prüfe Betriebsbereitschaft WZLS

SUB is_sensor_ok
 IF [sensorStatus == triggered] ;# 5068 == 0 (normally closed)
 DLGMSG "Tool length sensor not connected or already triggered - please check"
 IF [dialogButton == 1]
 IF [sensorStatus == triggered]
 ERRMSG "Tool length sensor input still unexpected - aborting"
 ENDIF
 ELSE
 ERRMSG "User abort."
 ENDIF
 ENDIF
ENDSUB

Der Name des Makros lautet is_sensor_ok. Ich prüfe den Sensorstatus und zeige eine Dialogmeldung an, falls hier etwas nicht stimmt. Sobald auf “OK” gedrückt wird, gehe ich davon aus, dass das Problem behoben wurde und versuche es erneut. Wenn er immer noch ausgelöst ist, breche ich die Routine ab.

Dieses Prüf-Makro ist in allen folgenden Abschnitten zu finden.

Benennung von Variablen

Die RS274/NGC-Sprache ist alt. Wirklich alt. Ihre erste Version wurde in den späten 1950er Jahren veröffentlicht. Kein Wunder, dass die Parameter (#1 - #5399 ist der erlaubte Bereich) alle numerisch sind. Sowohl in der Benennung als auch in den Werten, die sie speichern können. Es gibt kein Typsystem (wie Strings, int usw.) und keine praktischen Aliase oder menschenlesbare Namen, die das Verständnis eines Parameters wie sensorStatus erleichtert.

Im Makro auf der Maschine wird stattdessen #5068 erscheinen man muss sich selbst daran erinnern, dass der Hersteller der CNC-Software such auf diese Variable festgelegt hat, um den Status des Werkzeuglängensensors zu kennzeichnen. Und dass sie vom Typ boolean ist mit 0 = nicht ausgelöst und 1 = ausgelöst.

Um den Makrocode so lesbar und verständlich wie möglich zu gestalten, verzichte ich in diesem Artikel auf die Verwendung von numerischen Parameternamen. Eine Übersetzungstabelle ist ganz unten zu finden.

Verwendung des Werkzeuglängensensors zur Ermittlung der Werkstückhöhe (Z=0)

Hiermit kann die Werkstückhöhe automatisch eingemessen und auf der Obefläche abgenullt werden. So entfallen das manuelle Absenken der Z-Achse bis das Werkzeug die Oberfläche leicht ankratzt und dann das Festlegen der Werkstückkoordinaten.

Sobald das Makro programmiert und eingerichtet ist, wird der WZLS möglichst mittig auf dem Werkstück platziert und die Spindel der Maschine mit ein paar Millimeter Luft direkt über diesem in Position gebracht. Dann wird das Makro gestartet. Die Maschine wird nun automatisch ihre Z-Achse langsam absenken, bis der Sensor schaltet. Dann fährt sie sehr langsam zurück, bis der Sensorkontakt wieder geschlossen ist. Dieser Punkt wird dann zur Bestimmung von Z0 herangezogen, welcher dann automatisch gesetzt wird.

Voraussetzungen

Bevor wir das Makro schreiben können, benötigen wir die Z-Position des Werkzeuglängensensors “zTls” zum Zeitpunkt des Umschaltens von “ausgelöst” auf “nicht ausgelöst”. Ich habe meine vorerst (denn das ist nicht sehr genau) mit einem Messschieber gemessen und notiert. Wir brauchen diesen Wert, damit die Maschine ihn beim Ansetzen von der Z-Höhe abziehen kann, um die Position der Werkstückoberfläche zu ermitteln.

Wie man die Messung des Auslösepunktes präziser hinbekommt soll Gegenstand eines eigenen Artikels werden.

Außerdem ist es wichtig zu wissen, wie der Schalter mit der Maschine verbunden ist. Die bevorzugte Art ist “NC”, d.h. der Schalter öffnet sich, wenn er ausgelöst wird: “Ausgelöst = 0”.

Schließlich müssen wir den Vorwärts- und Rückwärtsvorschub des Messtasters festlegen, z.B. Absenken = 100mm/min, Anheben = 10mm/min.

Das Makro enthält auch einen etwas aufwändigeren Teil: Wenn Z0 gemessen werden soll, obwohl die aktuell Werkzeuglänge noch unbekannt ist, macht das keinen Sinn: Bei einem Werkzeugwechsel wäre sie nicht in der Lage, den Nullabgleich auszuführen.

Daher wird in diesem Fall die Werkzeugvermessung zwischengeschoben: die Maschine speichert die aktuelle Position posX, posY vor der Fahrt zum Werkzeuglängensensor in Hilfsvariablen zwischen und führt direkt das Makro get_tool_length aus. Anschließend fährt sie wieder in die Ausgangsposition zurück, um die Vermessung von Z0 nachzuholen.

Das Unterprogramm “Z0 bestimmen”

Nach dem Ausschalten der Spindel senkt das Programm mit dem Befehl G38.2 die Z-Achse der Maschine ab, bis der Fräser Werkzeuglängensensor auslöst (oder bis sie ohne eingelegtes Werkzeug so weit nach unten gefahren ist, dass die Spindelnase den Sensor fast berührt, wo das Makro dann wiederum abbrechen würde, weil es den Sensor nicht gefunden hat). Sobald der Sensor ausgelöst, fährt die Maschine vorsichtig die Z-Achse wieder hoch. Der Punkt der erneuten Freigabe des Sensors durch das Werkzeug wird dann als Koordinaten-Offset für die Z-Achse mit dem Befehl G92 gespeichert.

Code: Werkstücknullpunkt bestimmen

Bevor wir beginnen stellen wir sicher, dass alle Vorbedingungen erfüllt sind:

Die Werkzeuglänge ist bekannt
Der WZLS ist korrekt angeschlossen

SUB measure_workpiece_z0
 IF ![toolLengthStat]
 DLGMSG "WARNING - Please first measure tool length!"
 IF [dialogButton == 1]
 xPosReposition = xPos
 yPosReposition = yPos
 repositionTo = 1
 GOSUB get_tool_length
 ENDIF
 ENDIF

 GOSUB is_sensor_ok ;# Check if tool length sensor status is OK

Programmieren wir nun die eigentliche Routine, indem wir abfragen, ob der Z-Nullabgleich jetzt durchgeführt werden soll. Wenn die CNC im Simulationsmodus läuft (ohne angeschlossene Hardware), wird der Z-Nullabgleich nicht funktionieren. Also müssen wir auch dies überprüfen und den Schritt gegebenenfalls überspringen.

 DLGMSG "Start Z-Zeroing?"
 IF [dialogButton == 1] AND [operatingMode != simulator]
 M5 ;#Switch spindle off
 M9 ;#Switch coolant off
 G53 G38.2 Z[zSpindleTip + 5] F[touch] 
 ;# G38.2 = touch toward probe, stop on contact, flag error on fail
 ;# fail = 5mm before touching spindle tip
 IF [probeOk == 1] ;# #5067 == 1 : G38.2 command success
 G38.2 G91 Z20 F[rev] ;# now reverse slowly to find untrigger point (max. 20mm up)
 G90 ;# back to absolute coordinates
 IF [probeOk == 1] 
 G00 Z[zTouched] ;# #5063 Go to Z-axis's probe point	
 G92 Z[zTls] ;# Set Z-axis's coordinate offset (0) to tool length sensor's height
 G00 Z[zTls + 5] ;# clear sensor
 ELSE
 ERRMSG "Could not locate sensor untrigger point."
 ENDIF 
 ELSE
 DLGMSG "Could not locate sensor trigger point. Retry?" 
 IF [dialogButton == 1] 				
 GOSUB measure_workpiece_z0
 ELSE
 ERRMSG "User abort."
 ENDIF
 ENDIF
ENDSUB

Your browser does not support the video tag.

Ausführen des Makros Z-Nullabgleich auf Zerspanobert

Messung der Werkzeuglänge

Wenn die Maschine die Werkzeuglänge kennt, bevor sie den Z-Nullpunkt misst, muss der Z-Nullpunkt bei anstehenden Werkzeugwechseln während des Auftrags nicht erneut bestimmt werden. Das passende Makro beschreibe ich im Folgenden.

Vorbereitung

Die meisten CNCs leiten ihre aktuellen Positionsdaten durch Zählen der Motorschritte ab, die sie nach Abschluss der Referenzfahrt ausgeführt hat. Um nun die Werkzeuglänge zu vermessen, benötigt sie ein paar einprogrammierte Parameter:

Z-Position der Spindelnase zSpindleTip (berührt Werkzeuglängensensor ohne eingelegtes Werkzeug) damit berechnet werden kann, wie weit das Werkzeug aus der Spindel herausragt
X-Position xPosTls des Werkzeuglängensensors beim Werkzeugwechsel
Y-Position yPosTls des Werkzeuglängensensors bei Werkzeugwechseln
Sicherheitshöhe zSafety (stellt sicher, dass die Spindel auf ihrem Weg zum Werkzeugwechselbereich nicht auf ein Hindernis stößt)
Tastvorschub vorwärts und rückwärts. Wir können ihn aus dem Makro für den Werkstücknullpunkt wiederverwenden.

Die Unterroutine “Werkzeuglänge messen”

Legen wir zunächst fest, was diese Unterroutine tun soll:

Spindel, Kühlmittel etc. anhalten.
Dialog: Bediener soll geschätzte Werkzeuglänge eingeben
Eilgang Z auf Sicherheitshöhe, dann XY zur Position des Werkzeugsensors
Werkzeuglängensensor antasten, ähnlich wie bei der Werkstücknullpunktbestimmung
Werkzeuglänge berechnen
Berechnung der Differenz zwischen der letzten und der aktuellen Werkzeuglänge
Z-Nullpunkt entsprechend aktualisieren
Z im Eilgang wieder auf Sicherheitshöhe bringen

Code: Werkzeug vermessen

SUB get_tool_length
 GOSUB is_sensor_ok ;# Check if tool length sensor status is OK

 DLGMSG "Start tool length measurement? Please enter estimated tool length: " [toolLengthEst]
 IF [dialogButton == 1] AND [operatingMode != simulator]
 IF [toolLengthEst < 0]
 ERRMSG "Error: tool length cannot be negative."
 ENDIF

 IF [zSpindleTip+ toolLengthEst + 10] > [zSafety]
 ERRMSG "Error: tool too long - could collide with sensor."
 ENDIF

 M5 ;# Switch spindle off
 M9 ;# Switch coolant off
 G53 G00 Z[zSafety] ;# Go to safety height (machine coordinates)
 G53 G00 X[xPosTls] Y[xPosTls] ;# Go to tool length sensor
 G53 G00 Z[zSpindleTip + toolLengthEst + 10] ;# Move Z down to 10mm above estimated tool tip

 ;# measure tool length, save results, apply Z-offset if needed
 G53 G38.2 Z[zSpindleTip] F[touch] ;# probe sensor, latest stop point is spindle tip
 IF [probeOk == 1] ;# #5067 == 1 : G38.2 command success
 G38.2 G91 Z20 F[rev] ;# now reverse slowly to find untrigger point
 G90 ;# back to absolute coordinates
 IF [probeOk == 1] 
 toolLength = [zTouched - sTip]
 MSG "Tool length = " toolLength

 IF [toolLengthStat == 1] ;# defaults to 0 on startup
 lastToolLength = currToolLength ;# save last tool's length
 currToolLength = toolLength ;# save current tool's length
 toolLengthDiff = [currToolLength - lastToolLength]	
 G92 Z[zPos - toolLengthDiff] ;# Set Z-axis's coordinate offset (0)
 ELSE
 currToolLength = toolLength ;# save current tool's length
 ENDIF
 toolLengthStat = 1
 GOSUB reposition_spindle
 ELSE
 ERRMSG "Could not locate sensor untrigger point."
 ENDIF
 ELSE
 ERRMSG "Could not locate sensor trigger point."
 ENDIF
 ENDIF
ENDSUB

Your browser does not support the video tag.

Werkzeuglängenmakro auf meiner Maschine

In diesem Video ist die Maschine so konfiguriert, dass sie zum XY-Nullpunkt zurückkehrt, wenn die Werkzeugmessung abgeschlossen ist.

Werkzeugwechsel

Wenn es kein Makro für den Werkzeugwechsel gibt, hält die Maschine ihren Auftrag an. Sobald die Z0-Position des Werkstücks erneut ermittelt wurde (denn die Werkzeuglänge hat sich ja wahrscheinlich geändert), kann der Auftrag fortgesetzt werden.

Diese Aufgabe kann automatisiert werden, indem der Z-Nullpunkt durch Bestimmen der neuen Werkzeuglänge gegenüber der alten neu kalibriert wird.

Voraussetzungen

Ein optionales Flag getToolLength kann das Verhalten des Werkzeugwechsel-Makros konfigurieren - ob die Länge jedes Werkzeugs nach einem Werkzeugwechsel gemessen werden soll oder nicht. Wenn Sie einen automatischen Werkzeugwechsler haben, brauchen Sie dies wahrscheinlich nicht: In diesem Falle ist die Werkzeuglänge in einer Tabelle festgehalten und die Längenkompensation erfolgt ohne Vermessung.

Die folgenden zusätzlichen Parameter werden ebenfalls benötigt:

X-Position xToolChg wo der Werkzeugwechsel stattfindet (bei mir ist es xToolChg = xPosTls)
Y-Position yToolChg, wo der Werkzeugwechsel stattfindet (bei mir ist es yToolChg = yPosTls)
Wiederverwendung von zSafety aus get_tool_length Makro
newToolNumber zur Angabe des angeforderten Werkzeugs aus dem G-Code (oder bei manueller Eingabe)
currToolNumber zur Angabe des “alten” Werkzeugs, das ersetzt werden soll
ToolChangeDone-Hilfsflag, um anzuzeigen, ob ein Werkzeugwechsel bereits stattgefunden hat

Das Makro “Werkzeugwechsel”

Die folgenden Schritte werden von dem Makro ausgeführt, wenn ein Werkzeugwechsel entweder durch den Befehl M06 “Werkzeugwechsel” in der G-Code-Datei eines Jobs oder manuell durch Benutzer ausgelöst wird:

Spindel, Kühlmittel etc. anhalten.
Wenn das angeforderte Werkzeug das aktuelle Werkzeug ist, erscheint ein Dialog mit der Frage, ob es trotzdem gewechselt werden soll.
Z im Eilgang nach oben (zSafety), dann XY auf die Werkzeugwechselposition fahren
Dialog: Angabe des aktuellen Werkzeugs a und Aufforderung, das gewünschte Werkzeug b einzusetzen
Prüfen, ob die Werkzeugwechselkonfiguration die Bestimmung der Werkzeuglänge impliziert. Wenn ja, Makro “get_tool_length” aufrufen.

Code

SUB change_tool
 toolChangeDone = 0
 M5 ;# Switch spindle off
 M9 ;# Switch coolant off

 IF [operatingMode != simulator]
 TCAGuard off ;# tool change area guard: off for tool change

 ;# handle case that tool is already in place
 IF [newToolNumber == currToolNumber]
 DLGMSG "Tool already mounted. Change anyways?"
 IF [dialogButton == 1]
 toolChangeDone = 0
 ELSE
 toolChangeDone = 1
 ENDIF
 ENDIF

 ;# go to tool change position and prompt to change tool
 IF [toolChangeDone == 0]
 G53 G00 Z[zSafety] ;# Go to safety height (machine coordinates)
 G53 G00 X[xToolChg] Y[yToolChg] ;# Go to tool change position
 DLGMSG "Please mount tool now. Old tool number: " [currToolNumber] 
 " New tool number: " [newToolNumber]
 IF [dialogButton == 1]
 IF [newToolNumber > 99] OR [newToolNumber < 0]
 TCAGuard on ;# tool change area guard: on for normal job
 ERRMSG "New tool number implausible."
 ENDIF
 toolChangeDone = 1
 ELSE
 ERRMSG "Tool change aborted."
 ENDIF
 ENDIF

 ;# prompt when complete and optionally call tool length measurement
 IF [toolChangeDone == 1] 
 MSG "Tool change from " [currToolNumber] " to " [newToolNumber] " complete."
 M6 T[newToolNumber]				 ;# set new tool number

 IF [getToolLength == 1] ;# config flag 0 = no, 1 = yes
 GOSUB get_tool_length ;# Measure tool length. Careful: To be called after M6 T !
 ELSE
 GOSUB reposition_spindle
 ENDIF
 ENDIF

 TCAGuard on ;# tool change area guard: on for normal job
 ENDIF
ENDSUB

Repositionieren (auf gespeicherte Koordinaten)

Dieses kurze Makro wird von anderen Unterprogrammen aufgerufen, um die Maschine entweder zu einer gewünschten Position oder zum XY-Werkstücknullpunkt zu fahren. Es kann mit mehreren repositionTo-Flag-Werten erweitert werden, z.B.

0 = keine_Neupositionierung, 1 = benutzerdefinierte_Position, 2 = Werkstücknullpunkt, 3 = Maschinennullpunkt ...

Code

SUB reposition_spindle
 G53 G00 Z[zSafety] ;# Go to safety height (machine coordinates)
 IF [repositionTo == 1]
 G00 X[xPosReposition] Y[yPosReposition] ;# Move back to where requested before
 repositionTo = 0 ;# reset reposition flag and values
 xPosReposition = 0
 yPosReposition = 0
 ELSE
 G00 X0 Y0 ;# Move back to XY zero (workpiece coordinates)
 ENDIF
ENDSUB

Tabelle der Variablen

Typ-Erläuterungen:

protected: Parameter gehört zu festen Befehlen oder Zuständen, die schreibgeschützt sind
reserved : Parameter hat eine feste Verwendung innerhalb meiner CNC-Software
free : Parameter kann frei durch den Programmierer verwendet werden (Ist nach Not-Aus oder Neustart aber zurückgesetzt!)
persisted: Parameter wird im nicht-flüchtigen Speicher abgelegt

Systemparameter

Variable name	Parameter nr.	Type	Comment
xPos	#5001	protected	current CNC position
yPos	#5002	protected	current CNC position
zPos	#5003	protected	current CNC position
currToolNumber	#5008	protected	[1…99]
newToolNumber	#5011	protected	[1…99]
zTouched	#5063	protected	Z where sensor touched
probeOk	#5067	protected	1 = OK
sensorStatus	#5068	protected	1 = triggered
operatingMode	#5397	reserved	1 = simulator
dialogButton	#5398	reserved	1 = OK

Konfig-Parameter

Config-Parameter sind die Parameter, die einmal eingestellt und dann konstant gehalten werden, da sie an die CNC und ihre Geometrie gebunden sind.

Die Volatilität der Parameter hängt stark von der CNC-Softwarelösung ab, die Sie verwenden, und die Anzahl der freien Parameter kann unterschiedlich sein. In meiner Software werden die Variablen im Bereich “#4000 - #4999” beibehalten, während alle anderen freien und reservierten Parameter flüchtig und/oder skaliert sind.

Variable name	Parameter nr.	Type	Comment
triggered	#4400	free, persisted	1 = normally open
currToolLength	#4501	free, persisted	[mm]
lastToolLength	#4502	free, persisted	[mm]
zSafety	#4506	free, persisted	Z position for move
xPosTls	#4507	free, persisted	tls position
xPosTls	#4508	free, persisted	tls position
zSpindleTip	#4509	free, persisted	Z zpindle on tls
zTls	#4510	free, persisted	TLS height [mm]
toolLengthEst	#4511	free, persisted	[mm]
touch	#4512	free, persisted	touch feed [mm/min]
rev	#4513	free, persisted	reverse feed [mm/min]
getToolLength	#4520	free, persisted	Flag, 1 = Yes
xToolChg	#4521	free, persisted	tool change position
yToolChg	#4522	free, persisted	tool change position

Flag-Parameter

Freie Parameter können nach Belieben verwendet werden. Es muss jedoch darauf geachtet werden, dass nicht versehentlich eine bestehende Systemvariable wiederverwendet oder überschrieben wird.

Variable name	Parameter nr.	Type	Comment
toolLengthStat	#3501	free	1 = measured
toolLengthDiff	#3502	free	[mm]
toolChangeDone	#5015	free	1 = Yes
repositionTo	#5020	free	Flag, 1 = Yes
xPosReposition	#5021	free	reposition flag
yPosReposition	#5022	free	reposition flag
toolLength	#5024	free	[mm]

PS: Damit die obigen Code-Beispiele ordentlich angezeigt werden, habe ich fürs Markup die Sprachinterpretation ruby verwendet. Hier kommt die farbige Syntax-Markierung am besten überein mit der Logik des NGC-interpreters.

CNC Teil 4.1 - Konfiguration

Schallbert — Tue, 08 Mar 2022 00:00:00 +0000

Dies ist Teil 4.1 meiner Reihe über Portalfräsmaschinen. Er hängt eng zusammen mit Teil4, konzentriert sich aber auf die korrekte Einstellung meiner Steuersoftware für die Fräse.

Hardware

EdingCnc V5A-4E Prozessorboard oder ähnlich
Interface Advanced PRO Breakout board oder ähnlich
Adapter Board falls nötig zum Verbinden von Prozessor- und Breakout board

Diese Komponenten sind notwendig, um die von der CNC-Software erzeugten Befehle in Signale der physischen Welt zu übersetzen, die mit Materie interagieren können. Die Breakout-Platine wird vom CNC-Prozessor gesteuert und bietet Relaisausgänge für die Oberfräse und meinen Staubabscheider, so dass ich sie über den Laptop einschalten kann. Es gibt auch analoge Spannungsausgänge, z.B. zur Steuerung der Spindeldrehzahl, und mehrere Eingänge, z.B. zum Ablesen des Referenzschalterstatus und zur Rückmeldung von Ereignissen an die CNC-Software.

Natürlich gibt es viele Hersteller für diese Schaltkreise. Ich verwende das oben genannte Ökosystem, so dass ich nur für dieses sprechen kann. Die zugrundeliegende Technologie ist stets ähnlich oder sogar identisch, und obwohl Sie vielleicht eine andere Benutzeroberfläche oder einen anderen Kommunikationskanal wie USB haben, wird Ihre Software wahrscheinlich ähnliche Einstellungen bieten.

Setup Bildschirm 1

Kinematik

Wie bereits ausführlich in diesem Beitrag beschrieben, zeigt der grüne Rahmen die Kinematikeinstellungen. Ein negatives Vorzeichen in Schritte/[mm] bedeutet, dass die Richtung des Schrittmotors invertiert ist. Zu beachten ist, dass das Feld “Umkehrspiel” 0 bleiben kann, wenn Kugelumlaufspindeln verwendet werden. Ich verwende einfache Kinematik, da ich keine Drehachse besitze. Also ist das Koordinatensystem kartesisch.

Referenz / Notaus

Dieser Abschnitt steuert, wie die Software die Signalpegel für die Eingangsschalter auf der Schnittstellenkarte interpretiert. Obwohl ich sicher bin, dass ich alle Eingänge “normal geschlossen” verdrahtet habe, um einen unentdeckten Kabelbruch zu vermeiden, musste ich den Eingang für den Notschalter invertieren.

Spindel

Diese Einstellungen sind sehr spezifisch für die Maschine, die Sie verwenden. Ich wollte, dass die Spindel anhält, wenn ich einen Auftrag unterbreche, und dass sie automatisch wieder anläuft, bevor ich den Auftrag fortsetze.

Der Parameter ApproachFeed ist ein wenig verwirrend, weil der Standardwert hier sehr niedrig ist. Seine Bedeutung ist die folgende: Er gibt den Vorschub der Z-Achse nach unten an, wenn ein Auftrag angehalten und die Z-Achse zuvor aufwärts bewegt wurde. Wenn Sie den Auftrag fortsetzen, wird die Z-Achse mit diesem Vorschub abgesenkt, und wenn die Zieltiefe erreicht ist, wird der Auftrag normal fortgesetzt. Ich habe 600mm/min als einen Wert eingegeben, den die meisten Schaftfräser bewältigen können sollten.

Setup Bildschirm 2

Viele Einstellungen hier lasse ich (vorerst) bei ihren Standardwerten. Auf meine Anpassungen gehe ich weiter unten ein.

Benutzeroberfläche

Ich wollte, dass das Referenzieren der Maschine Pflicht ist, bevor ich einen Auftrag laden oder die Achsen der Maschine im Eilgang verfahren kann. Außerdem musste ich “automatischer Werkzeugwechsel” anwählen, obwohl ich keinen Werkzeugwechsler habe: sonst würde mein Makro für den manuellen Werkzeugwechsel nicht aufgerufen werden.

Schnittstelle E/A

Um die Hardware-Einstellungen des Breakout-Boards zu berücksichtigen, musste ich einige Software-Ausgänge invertieren. Wenn ich z.B. PWM1 nicht invertiert hätte, würde die Spindel mit voller Drehzahl starten, obwohl ich nur 5000rpm wollte und umgekehrt. Dies liegt an teils unterschiedlicher Interpretation der Logikpegel, welche als “open collector” oder auch “open emitter” ausgelegt sein können.

Variablen-Bildschirm

Parkposition G28 / G30

Ich stelle meine Parkpositionen so ein, dass ich effizient arbeiten kann. Einer dieser Befehle bewirkt, dass die Achsen auf den XY-Nullpunkt meines Anschlags fahren, den ich auch in CAM zum Werkstück-Nullpunkt mache, so dass das Einnullen wirklich einfach wird.

Die andere Parkposition wird auf einen Punkt gesetzt, an dem die Referenzschalter aller drei Achsen ganz nah sind, so dass das Referenzieren der Maschine nach dem Hochfahren sehr schnell abläuft.

Überwachung der Variablen

Schauen wir uns das Überwachungsfenster an. Hier können Sie eine Variable aus dem Interpreterbereich der RS274 NGCeingeben und sich deren aktuelle Werte anzeigen lassen. Dies ist praktisch, wenn Sie Makros debuggen oder einfach nur interne Parameter wie die gemessene Werkzeuglänge, die Lage des aktuellen Z-Nullpunkts etc. ablesen wollen.

CNC Teil4 - Setup

Schallbert — Thu, 03 Mar 2022 00:00:00 +0000

Dies ist der vierte Teil meiner Reihe über Portalfräsmaschinen. Er konzentriert sich auf das Zusammenspiel von Hardware und Software, sodass mein fertig aufgebauter “Zerspanobert” bald im Produktivbetrieb arbeiten kann.

Kinematik

Bevor die CNC-Software auf meiner BasicLine 0607 arbeiten kann, muss sie korrekt eingerichtet werden. Sie muss die Verfahrbereiche der Maschinenachsen kennen und wissen, wo sich die Referenzschalter befinden. Außerdem ist relevant, in welche Richtung die Schrittmotoren gedreht werden müssen, um eine “positive/negative” Achsenbewegung zu erreichen.

In einem ersten Schritt muss entschieden werden, wie die Achsen der Maschine benannt werden (X, Y, Z), wo alle Achsen tatsächlich 0 sein sollen, und in welche Richtung die Bewegung gehen soll (positiv, negativ). Alle diese Koordinatenpunkte sind relativ und können willkürlich gewählt werden, aber es gibt einige Konventionen in der CNC-Welt:

Achsen:

Die X-Achse liegt auf dem Portalbett und bewegt die Y-Achse des Portals.
Die Y-Achse befindet sich oben auf dem Portal und bewegt die Z-Achsen-Baugruppe.
Die Z-Achse befindet sich an der Spindel und bewegt diese auf- und abwärts.

Maschinen-Nullpunkt

Maschinen- Nullpunkt und -Bewegungsrichtung:

X-0 befindet sich auf der “hinteren” Seite der Achse. Die Bewegungsrichtung ist negativ.
Y-0 befindet sich auf der “linken” Seite der Achse. Die Bewegungsrichtung ist positiv.
Z-0 befindet sich auf der “oberen” Seite der Achse. Die Bewegungsrichtung ist negativ.

Für meine Maschine (sie ist breiter als lang), ihre Zugänglichkeit und den Raum, den ich zur Verfügung habe, habe ich die Achsen umgelegt. Bei mir ist die X-Achse die lange Achse des Portals und die Y-Achse befindet sich parallel zur Linearschine, die das Portal hält. Vom Arbeitstisch aus betrachtet ist der Maschinen-Nullpunkt bei mir also “hinten links oben”. Also bewegt sich Z in negative Richtung, Y ebenfalls, nur X geht zu positiven Werten.

Verwirrend, nicht wahr? Ist aber kein Problem, denn später arbeitet man kaum mehr mit Maschinenkoordinaten ;)

Bewegungsrichtungen

Für die Konfiguration habe ich meine CNC-Software Link zu EdingCNC mit der Maschine verbunden. An ihr erkläre ich das Vorgehen, was bei anderen Steuerungsprogrammen im Kern aber ähnlich funktioniert. In de Setup-Ansicht gebe ich die Anzahl Schritte ein, die vom Motor zu gehen sind, bis sich die Achse um einen Millimeter bewegt: 16 Mikroschritte/Schritt multipliziert mit 200 Schritten/Motorumdrehung geteilt durch 10mm/spindelumdrehung = 320 Mikroschritte/mm. Für die Z-Achse wird der Wert durch die bei mir engere Gewindespindel verdoppelt.

Die 16 Mikroschritte/Schritt ist der Standardwert, welcher von meinem Maschinenhersteller vorgeschlagen wurde. Es gibt ein paar gute Argumente und eine tiefgehende Analyse hier darüber, dass man Microstepping so wenig wie möglich verwenden sollte. Da ich weder eine Genauigkeit von 1µm erreichen muss, noch die Schrittmotoren bei meiner Anwendung sehr hohe Drehmomente bewältigen müssen, sollte das aber kein Thema sein.

Ohne vorher eine Referenzfahrt durchzuführen (die sowieso nicht funktionieren würde), habe ich die Maschine per Pfeiltasten vorsichtig verfahren, um zu sehen, welche Taste welche Achse in welche Richtung bewegt. Da mein Setup vom “Normal” abweicht, können die von mir gewählten Werte individuell ausfallen. Wenn eine Achse nicht mit der Pfeiltaste übereinstimmt (wenn ich z.B. “rechts” drücke und erwarte, dass sich meine X-Achse nach rechts bewegt, aber die Z-Achse tatsächlich nach unten geht), so konnte ich die Motoranschlüsse am Schaltkasten vertauschen, bis die Tasten mit den erwarteten Achsen übereinstimmten.

Wenn die Tasten die Maschine nun in die falsche Richtung bewegen - ich drücke z.B: “Bild abwärts) aber die Z-Achse bewegt sich nach oben, würde ich das Vorzeichen der Motorschrittauflösung ändern - Nicht besonders intuitiv, was? Ich habe auch ein paar Foreneinträge durchsuchen müssen, bevor ich das raus hatte.

Dies kam nun dabei heraus:

X-axis -320.000
Y-axis 320.000
Z-axis -640.000

Grenzen der Maschinenbewegung

Meine Maschine hat einen nutzbaren mechanischen Verfahrweg von 0 / 732mm in X-Richtung, -654mm / 0 in Y-Richtung, und -134mm / 0 in Z-Richtung. Diese Werte habe ich in die Maske für negative limit / positive limit eingegeben und die Vorzeichen auf Basis der Bewegungsrichtung relativ zum Maschinennullpunkt eingestellt.

Referenzschalter: Triggerpegel

Die Achsen der meisten Maschinen haben einen Referenzschalter. Diese Schalter werden verwendet, um die Maschine zu “referenzieren”. Die Referenzfahrt ist bei jedem Start der Maschine erforderlich, da die Software intern nur die XYZ-Position durch Akkumulation der Motorschritte ermittelt. Sobald das System neu gestartet wird, gehen alle diese Werte auf 0 zurück, so dass die Maschine ihre Position vergisst.

Ich habe meine Schalter so angeschlossen, dass sie “normalerweise geschlossen” sind: Ihre Kontakte sind stromführend, wenn sie nicht ausgelöst werden. Auf diese Weise kann eine fehlerhafte, offene Verbindung sofort erkannt werden, da die Maschine in diesem Fall (erfolglos) mit einer ungewöhnlich niedrigen Geschwindigkeit anfahren würde: homeVelocitySlow ist in meiner Konfiguration nur 1/10 der normalen Fahrgeschwindigkeit für das Anfahren der Nullpunkte. Trotzdem müssen wir sicherstellen, dass der Referenzfahrt-Kontakt richtig interpretiert wird. Dies kann im Abschnitt “Homing and E-Stop” des “Setup”-Bildschirms eingestellt werden. Ich gebe also eine “1” für “Normalerweise geschlossen” ein.

Referenzschalter: Position

Einige CNC-Maschinen bieten eine Positioniersteuerung mit geschlossenem Regelkreis - sie benötigen keine Referenzschalter, da ihre Motoren mit Positionsgebern ausgestattet sind, die die absolute Position jeder Achse zurückmelden. Diese Maschinen verlieren keine Schritte und sind in der Lage, Positionierungsfehler zu erkennen, die z. B. durch mechanische Überlastung verursacht werden. Man nennt solche Motoren meist Servos.

Mit Hilfe des Referenzschalters kann eine Maschine ohne geregelte Positionierung - wie meine - ihre Schrittzahl an einer bekannten Position zurücksetzen, so dass die Achsbewegung wiederholbar wird. Allerdings muss die Position des Referenzschalters bekannt sein, um die Schrittzählung korrekt den Achsenpositionen zuzuordnen, und deshalb müssen wir die Positionen der Referenzschalter an den Achsen eingeben. Ich habe mit Vorsicht beobachtet, wie weit ich die Maschine nach dem Auslösen des Referenzschalters weiter verfahren kann, bevor ich an das mechanische Ende einer Achse stoße (Menü “Jog”). Dies sind die Werte, die ich schließlich für meine Maschine eingegeben habe:

Steps/AppUnit

X-axis: 10mm
Y-axis: -4mm
Z-axis: -16mm

Not-Aus

Der Not-Aus ist ein weiterer Eingang für die CNC-Software und -Hardware. Durch Drücken dieses Schalters wird die Achsenbewegung gestoppt und im Zuge dessen sowohl Spindel, Kühlschmierstoffzufuhr als auch Hilfsstromkreise deaktiviert. Er ist auch “normal geschlossen” verdrahtet, um Verbindungsprobleme zu erkennen, und kann wie ein Referenzschalter konfiguriert werden.

Wenn der Not-Aus-Schalter aktiviert wurde, müssen die Treiber der Maschine zurückgesetzt und die Maschine erneut referenziert werden, bevor sie nach dem Loslassen der Taste wieder normal arbeiten kann.

Das Not-Aus Signal wird nicht nur an die Software gemeldet, sondern sorgt auf der Steuerplatine selbst für das Abfallen der entsprechenden Relais, sodass die Maschine in den sicheren Zustand gebracht werden kann.

Bewegungsparameter der Achsen

Die CNC-Software muss wissen, wie sie die Bewegung der Maschinenachsen richtig handhaben muss: Eine schwerere und steifere Maschine mit starken Schrittmotoren wird natürlich schneller verfahren und starke Beschleunigungen sowie ruckartige Bewegungen besser bewältigen können als weichere, leichtere Maschinen. Aus diesem Grund sollten die Bewegungsparameter Ihrer Maschine sorgfältig ermittelt und in der Software hinterlegt werden.

Achsgeschwindigkeit

“Warum sollte Zerspanobert schnell sein?” habe ich mich gefragt. Mir fielen nicht allzu viele gute Antworten ein, da die normalen Vorschubgeschwindigkeiten mit den geplanten Schaftfräsern weit unter den Möglichkeiten der Maschine liegen werden. Aber egal, hier sind einige Argumente, eine Maschine schnell verfahren zu lassen:

die Arbeitszeiten sollten nicht zu lang werden
lange Verfahrwege, die mit einer großen Maschine zurückzulegen sind
beim Schneiden weicher Materialien mit geringer Dichte können die Vorschübe viel höher sein

Wollen Sie noch immer eine schnelle Maschine? Einige Berechnungen helfen uns hier weiter.

Bestimmung der Fähigkeiten der Bewegungselektronik

Die maximale Geschwindigkeit wird durch mehrere Faktoren begrenzt:

Parameter	Symbol	Wert	Einheit
maximale Antriebsfrequenz	fD	125	kHz
Mikroschritt-Einstellung des Antriebs	N	16
max. Software-Frequenz	fS	125	kHz
Schrittzahl/Umdrehung	nS	200
Schrittmotor max. Drehzahl	nSm	3300	1/min
Kugelgewindebreite	P	0,01	m
Kugelumlaufspindel max. Drehzahl	nLm	1700	1/min

Nehmen wir ein Beispiel für einen 125-kHz-Treiber und nehmen wir an, dass die Software diese Schrittfrequenz unterstützt. Nehmen wir weiter an, dass die Motoren 200 Schritte/Umdrehung haben und der Treiber auf 16 Mikroschritte/Schritt konfiguriert ist.

Damit erreicht man eine Maximaldrehzahl der Kugelumlaufspindel von $\frac{125000}{3200} = 39$ Umdrehungen pro Sekunde oder 2340 U/min, was für einen Schrittmotor echt zügig ist. Auf einer Kugelumlaufspindel mit 10mm Gewindeweite führt das zu einer theoretischen Verfahrgeschwindigkeit von 23.4m/min, was auf einer kleinen Maschine wie meiner unglaublich schnell aussieht.

Achtung! Korrekturen / Updates weiter unten

Grenzen der Mechanik

Gut, dann schauen wir mal, ob die Kugelumlaufspindeln dieses Tempo mitgehen. Die auf meiner Maschine verbaute Serie KGS16 hat eine ungestützte Strecke von ~850mm zwischen den Lagern auf der langen Achse. Aus der Online-Dokumenation des Herstellers entnehme ich hierbei eine maximale Drehzahl von 1700U/min.

Damit bleiben 70% von der anfänglichen Maximalgeschwindigkeit übrig: 17m/min. Immer noch echt flink.

Nun wissen wir aber, dass das Moment der Schrittmotore bei steigender Geschwindigkeit abnimmt. Wenden wir unseren Blick mal dorthin:

Genügend Motormoment?

Datasheet: Der Drehmomentverlauf meines Schrittmotors (Bild bereitgestellt durch Sorotec GmbH) ^[1]

Der blaue Pfeil markiert meinen Zielvorschub zum Schruppen in Holz. Hier habe ich ordentlich Drehmoment zur Verfügung um auch tiefe Nuten in einem Durchgang fertigen zu können. Selbst bei schnellen Schlichtdurchläufen oder sehr weichen Materialien (grüner Pfeil) habe ich noch fast 50% des maximalen Drehmoments zur Verfügung. Um noch genügend Luft bis zur kritischen Drehzahl der Kugelumlaufspindel zu haben, wähle ich eine maximale Geschwindigkeit für den Eilgang (G0) von 12m/min = 200mm/sek. An diesem Punkt sind von den ursprünglich 3Nm nur noch 0.7Nm verfügbar.

Mit dieser Konfiguration habe ich eine recht schnelle Maschine bei genügend Luft zu kritischen Werten.

Beschleunigungen

Stellen Sie sich vor, Sie möchten in einem Ihrer Programme einen 90°-Winkel bei einem Vorschub von 12m/min fahren. Ähnlich wie bei dem Versuch, eine sehr enge Kurve auf dem Fahrrad zu nehmen, ist dies nicht bei hoher Geschwindigkeit möglich. Man muss erst auf eine Geschwindigkeit herunterbremsen, bei der die Kurve gefahrlos genommen werden kann und danach wieder hochbeschleunigen.

Wenn wir bei der Maschine nicht bereit sind zu warten, bis eine Achse quasi zum Stillstand gekommen ist bevor die andere losfährt, schneiden wir die Ecke rund. Wenn wir jedoch bremsen, ist unsere Bahngeschwindigkeit nicht mehr konstant - ein Dilemma. Um hier einen möglichst guten Kompromiss zu erreichen, ist die Ermittlung einer passenden Maschinenbeschleunigung wichtig.

Auf dem Fahrrad vermeidet man beim Bremsen bewusst das Blockieren eines Rades, um die Stabilität nicht zu gefährden. Auf der CNC gilt wieder um Ähnliches: Hinreichend hohe Beschleunigungen erreichen, ohne Schrittverlust, unnötige Schwingungen, Verklemmung / Blockade einer Achse, starke Rucke oder Torsion zu riskieren. Zudem möchten wir Maschinenverschleiß minimieren.

Klingt schwierig? Ist machbar, benötigt aber etwas Mathematik und Gefühl.

Your browser does not support the video tag.

Kurven zeichnen: `vmax = 200mm/s`, `a=400mm/s^2`

Das Video oben illustriert den Sachverhalt: Bei Kanten und engen Kurven bremst die Maschine merklich ab um den Richtungswechsel hinzubekommen.

Motivation

Warum möchte ich, dass Zerspanobert hohe Beschleunigungswerte unterstützt? Ein paar meiner Antworten: Meine Projekte haben oft eine Menge kurzer Liniensegmente und 2.5D-Arbeiten. Die Formen sind komplex und die G-Code Dateien zumeist recht lang. Daher verwende ich auch den Look-Ahead Feed G64 mit 0.1mm erlaubter Abweichung vom Pfad.

Außerdem möchte ich möglichst lange mit konstanter Geschwindigkeit durch das Material fahren. So vermeide ich Stellen, an denen das Material heißer wird als nötig. Nicht zuletzt will ich natürlich nicht unnötig viel Zeit an der Maschine verbringen - Die Maschine arbeitet mit höheren Beschleunigungswerten einfach deutlich schneller; dies wirkt sich bei meinen Projekten sogar stärker aus als ein noch flinkerer Eilgang.

Bestimmung der maximalen Achsbeschleunigung

Dann ermitteln wir mal den maximal möglichen Wert für die Maschinenbeschleunigung.

Newtons zweites Gesetz (axiale Bewegung): $F_{ax} = m_pa$
Drehmoment an der Achse: $M_a = \frac{a J}{P}$
Trägheitsmoment der Achse (Zylinder): $J = m \frac{a}{2}r^2$
Benötigtes Motormoment für die Linearbewegung: $M_d =\frac{F_{ax} P}{2 \pi \eta} + M_a$

Wenn ich diese Formeln kombiniere, erhalte ich für die Beschleunigung:

$$a = \frac{M_d}{\frac{m_p P}{2 \pi \eta} + \frac{J}{P}}$$

In Worten: Die höchste Beschleunigung, die die Maschine theoretisch erreichen kann, ist das verfügbare Motormoment $M_d$ geteilt durch die Masse des Portals $m_p$, gewichtet mit spezifischen Parametern der Kugelumlaufspindel wie Gewindespreizung $P$ und Wirkungsgrad des bewegten Systems $\eta$ zuzüglich des Trägheitsmoment $J$ der rotierenden Komponenten, wiederung gewichtet durch die Gewindespreizung.

Konkrete Richtwerte

Setzen wir mal ein paar Werte ein - meine BasicLine 0607:

Parameter	Symbol	Wert	Einheit
Stepper torque @ vmax	Md	0.5	Nm
Portalmasse	mp	40	kg
Spreizung Gewindespindel	P	0.01	m
Radius Gewindespindel	r	0.008	m
Rotierende Masse	ma	4	kg
Wirkungsgrad der Bewegung	n	75	%

Wo ich keine exakten Werte zur Verfügung hatte, habe ich worst-case Annahmen getroffen. Beim Schrittmotor z.B. meine Maximalgeschwindigkeit bei geringster Versorgungsspannung. Auch das Gewicht der rotierenden Masse (Spindel, Kupplung, Rotor und Achse des Motors) habe ich geschätzt sowie den Wirkungsgrad von Kugelumlaufspindel, Lagern und Linearführungen.

Dies ist mein Ergebnis (Trommelwirbel):

$$a = 5.0m/s^2$$

Was dieser Wert bedeutet

Wie lange benötigt die Maschine, um auf Höchstgeschwindigkeit zu beschleunigen? Nehmen wir unser Physikwissen aus der Sekundarstufe: gleichmäßig beschleunigte Bewegung

$$v(t) = at \Rightarrow t = \frac{v_{max}}{a} = 40ms$$

Wie groß ist der Weg, den wir dabei zurücklegen (

$$s_0 = 0, v_0 = 0$$

$$s(t) = \frac{a}{2}t^2 + v_0t + s0 \Rightarrow s(t=40ms) = 4mm$$

Welche Axialkräfte wirken dabei auf das Portal ein?

$$F_{ax} = m_pa = 200N$$

Die von mir hier errechnete Beschleunigung ist mehr als eine Größenordnung über der Empfehlung des Herstellers von 300mm/s^2. Ich habe mich da deutlich verschätzt.

🤔 Ich muss etwas übersehen haben.

Zusammenfassung: Erfahrung zählt!

Die Formeln oben berücksichtigen weder die Steifheit der Maschine noch Ruck, Torsion oder auftretende Schwingungen unter dynamischer Last. Was ein “Ruck” im CNC-Kontext darstellt? Dieses kurze Youtube-Video klärt auf. Meine Steuersoftware jedoch verfügt nicht über eine Ruckbegrenzung.

Obwohl ich viel darüber gelernt habe, wie man sich mit Hilfe der Mathematik eine Einordnung der Parameter ermöglicht, läuft alles wieder auf die Erfahrung hinaus:

Wie schwer und stabil ist die Maschine?
Mit welcher Art von Material arbeite ich: Ist es nachgiebig oder steif?
Habe ich komplexe oder möglicherweise langwierige Fräsaufgaben zu erledigen?
Arbeitet meine CNC in einer Produktionsumgebung, in der die Maschinenzeit wichtig ist?
Wie klingt und fühlt sich die CNC bei hohen Beschleunigungswerten an?

Ich habe einen Wert von 800 mm/s^2 als Beschleunigung für die X- und Y-Achse eingegeben. Das schien ohne Probleme zu funktionieren. Immerhin bleibt er um den Faktor 6 unter der berechneten Fähigkeit des Bewegungssystems.

Ausprobieren

Ich weiß, das war eine lange Lektüre und viel mehr eine fundierte Vermutung als eine strenge Berechnung 😅. Trotzdem sind wir jetzt bereit, die Maschine das erste Mal in Betrieb zu nehmen. Probieren Sie es aus. Gehen Sie danach im manuellen Betrieb auf allen Achsen auf auf den Maschinennullpunkt. Hält sie an, bevor sie den mechanischen Endstopp erreicht?

Verwenden Sie dann den kontinuierlichen Tippbetrieb, um sich dem anderen Ende aller Achsen anzunähern. Bewegen Sie vorsichtig die letzten Millimeter. Sind alle Messungen und Einstellungen korrekt? Wenn ja, versuchen Sie es mit der 100%-Geschwindigkeitstaste (Shift - auf meiner Tastatur). Bewegt sich die CNC schnell und stoppt automatisch am Achsenende ohne Kollision?

Herzlichen Glückwunsch!

Rechner für maximale Bewegungseinstellungen

Sie haben tapfer den ganzen Artikel gelesen. Als Belohnung habe ich ein kleines Excel-Tool vorbereitet: CNC kinematics helper, das Sie herunterladen und verwenden können, um Schätzungen für Ihre Maschine zu berechnen. Natürlich kann ich keine Verantwortung für die Ergebnisse übernehmen, die Sie bei der Verwendung dieses Tools erhalten. Selbiges gilt für Schäden, die falsche Werte verursachen können.

Update

Ich habe nochmal mit den maximalen Geschwindigkeits- und Beschleunigungswerten für meine Maschine herumgespielt. 300mm/s war zu schnell und ich bekam Software-Limit Verletzungsfehler. Bei 240mm/s hat meine Maschine stark vibriert. Also habe ich die Höchstgeschwindigkeit bei 220mm/s belassen, was in Ordnung zu sein scheint. Außerdem habe ich die Beschleunigung auf 1200mm/s^2 erhöhen können. Das einzige Problem mit diesem neuen Wert ist, dass die Maschine bei kurzen Bewegungen ein bisschen schwingt. Wenn die Beschleunigung abgeschlossen ist, wird alles wieder ruhiger. Schauen wir mal, ob sich das auf die Bearbeitungsqualität auswirkt.

Update 2

Die obige Berechnung ist zwar mathematisch nicht falsch, aber sie ist irreführend. Sie suggeriert, dass jede Achse mit dieser Geschwindigkeit laufen könnte, was einfach nicht der Fall ist. Ich habe mir vom Anbieter der Steuerungssoftware für meine Maschine bestätigen lassen, dass die 125kHz die maximale Befehlsfrequenz des Systems sind. Wenn ich versuche, höhere Geschwindigkeiten zu fahren, erhalte ich die Fehlermeldung “Velocity was higher than max!”.

Deshalb sollte ein so hoher Geschwindigkeitswert nicht verwendet werden, wenn die Maschine mit mehreren Achsen gleichzeitig im Eilgang läuft. Ich habe einen Folgeartikel verfasst und hier zur Information verlinkt. Dort verwende ich Werte, die stabil in jeder Situation funktionieren, auch wenn alle Achsen mit voller Geschwindigkeit gleichzeitig betrieben werden.

Noch immer weiterlesen?

Einrichtung der Maschinensoftware

CNC Teil3 - Aufbau

Schallbert — Tue, 01 Mar 2022 00:00:00 +0000

"Zerspanobert" CNC assembly

Dies ist der dritte Teil meiner Artikelserie über Portalfräsmaschinen. Er konzentriert sich auf den mechanischen/mechatronischen Aufbau meiner Maschine.

Marke: Sorotec, Produkt: Basicline 0607

Meine Portalfräsmaschine wurde als Komplettbausatz geliefert. Nach einer groben Prüfung auf Vollständigkeit konnte ich voller Vorfreude auf die fertige Maschine mit dem Zusammenbau starten.

Eckdaten der Maschine

Stellfläche etwa 1m x 1m x 0.8m
Arbeitsbereich ~ 654mm x 732mm x 134mm
Gewicht ohne Spindel, Elektrosatz, Zubehör: 52kg (laut Hersteller)
Kugelumlauftriebe und Linearführungen auf allen Achsen
Schrittmotoren: 3Nm, 4.2A @48V
Empfohlene maximale Bewegungsgeschwindigkeit: 130mm/s | 7.8m/min, 400mm/s²

Zusammenbau

Der Aufbau der Mechanik und Mechatronik dauerte etwa 16h inkl. Verdrahtung der Schrittmotoren, Stecker und aller Leitungen. Nicht berücksichtigt ist die Maschinensteuerung, worüber ich hier schreibe.

Die nun folgenden Abschnitte beschreiben je eine Phase des Zusammenbaus. Ich verschweige auch nicht die Schwierigkeiten, die ich dabei hatte.

1. Vorbereitung der Lager für die Kugelumlaufspindeln

Die Kugelumlaufspindel (youtube link) ist eine mechanische Vorrichtung, die eine Drehbewegung in lineare Bewegung umwandelt. Dabei wird die mit einem Gewinde versehene Spindel gedreht und dadurch ein auf der Spindel befindlicher Schlitten verfahren. Der Unterschied zur auf demselben Konzept basierenden Trapezgewindespindel ist, dass die Spindelmutter über ein umlaufendes System von Kugeln verfügt, welche Reibung und Spiel zwischen Mutter und Spindel reduzieren. Bei meiner CNC-Maschine werden sie eingesetzt, um die Achsen mit Hilfe eines Schrittmotors zu verfahren.

Die Kugelumlaufspindeln besitzen zwei Lager. Ein Festlager auf der Schrittmotorseite (der schwarze Block auf den Bildern) und ein Loslager, das die andere Seite der Spindel an ihrem Platz hält. Die Montage des Loslagers in seine Halterung stellte sich als schwierig heraus. Ich habe keinerlei Erfahrung im Metallbau, also habe ich statt der klugen Lösung (Kugellager abkühlen, Halterung erwärmen) die einfache gewählt (Hämmern). Ergebnis: das Lager saß schief.

Your browser does not support the video tag.

Falsch eingesetztes Loslager

Glücklicherweise hatte ich eine 20mm Nuss zur Hand die Außendurchmesser des Lagers nahekam. So war ich in der Lage, das Lager erst wieder heraus zu schlagen und dann erneut - sanft und gleichmäßig - in seinem Sitz zu befestigen.

Your browser does not support the video tag.

Verhalten nach Korrektur des Lagersitzes

Ich hoffe mal, dass ich das Lager bei meinen Fehlversuchen nicht zu sehr mit Aluminiumspänen verunreinigt habe.

2. Maschinenrahmen

Der Rahmen meiner Maschine besteht aus Aluminium-Stranggussprofilen, welche mit Winkeln und Nutensteinen miteinander verbunden werden. Massive Aluminiumplatten and Vorder- und Rückseite der Maschine versteifen die Konstruktion zusätzlich. Die Linearführungen werden an der Seite des Rahmens befestigt. Sie halten später das Portal und stellen die Bewegung der X-Achse (Definition des Herstellers) sicher.

Ich habe ziemlich viel Zeit darauf verwenden müssen, den Rahmen ordentlich auszurichten. Als endlich alle Winkel 90° betrugen, konnte ich einen kleinen Luftspalt an der rechten Rahmenwange lassen, sodass die Portalbreite die Rahmenbreite vorgeben kann und ich nichts verspanne. Als ich die Schrauben jedoch anzog, schien der Rahmen sich stets aus dem rechten Winkel zu verabschieden. Als ich das Spiel ein paarmal erfolglos wiederholt hatte, begann ich, die Schrauben in mehreren Stufen gleichmäßig in 3Nm-Schritten anzuziehen.

Auf diese Weise konnte ich endlich meine 24Nm bei guter Rechtwinkligkeit 😅 erreichen

Die Montage der Front- und Rückplatte, Kugelumlaufspindel der Y-Achse sowie des Referenzschalters stellten sich als angenehm schnell und einfach heraus. Das obige Bild zeigt die fertig montierte X-Achse. Linearführungen (ebenfalls mit Kugelumlauf), die später das Portal tragen werden, sind bereits montiert. So sehen diese Dinger von innen aus:

Your browser does not support the video tag.

Linearführungen mit Kugelumlauf

3. Portal

Zuerst werden die Portalwangen an den Linearführungen der Y-Achse befestigt. Dabei vereinfachen Metallstifte, die in bereits vorhandene Bohrungen gesteckt werden, die präzise Positionierung. Anschließend werden die Führungsschienen für die Y-Achse am Querbalken des Portals befestigt und dieser dann an der Portalwange montiert. Winkel an beiden Seiten der Portalwange versteifen die Konstruktion. Um die Montage zu erleichtern verwendete ich zwischenzeitlich Schraubzwingen.

Diese Maschine arbeitet mit einem Schrittmotor für die Y-Achse, dessen Kugelumlaufspindel mittig am Portalunterzug befestigt wird. Dieser ist im Video unten gut zu erkennen. Da die Maschine langsam an Gewicht zulegte, habe ich mir einen kleine Holzkonstruktion gebaut, um die für die Montage schräg auf der Seite liegende Maschine zu sichern.

Your browser does not support the video tag.

Das Portal lässt sich ohne Kugelumlaufspindel leicht von Hand bewegen.

Nun konnte ich die Schrauben am Luftspalt des Rahmens nochmal vorsichtig lösen, das Portal ein paar mal bewegen um mögliche Verspannungen heraus zu bekommen und sie anschließend wieder gleichmäßig anziehen.

Als Nächstes waren die Kugelgewindespindel und Linearführungen der X-Achse zu montieren. Auf diesen wird - wieder mit Positionierstiften versehen - eine Flanschplatte montiert, die später die Z-Achse hält.

Zum Schluss waren noch Referenzschalter und Schrittmotorhalterung anzubringen.

4. Z-Achse

Die Z-Achse wir als eigene Baugruppe unabhängig vom Rest der Maschine montiert. Auch hier kommen wieder Passstifte zum Einsatz für die Flanschplatte. Bei meiner Maschine hält eine einzelne Linearführung die Z-Achse an ihrer Position.

Dies ist für meine Anwendungsbereiche mit kleinen Fräsern und recht geringen Vorschüben sicherlich OK, wird bei herausfordernderen Materialien, schnellen Vorschüben oder der Verwendung großer Fräser durch die viel höheren Schnittkräfte bestimmt schnell ein Problem. Was soll’s, ich mache doch eh nur in Holz und Kunststoffen…

Es ist ja immer schön wenn Dinge einfach funktionieren 🤗 - Herrlich, wie die Teile des Bausatzes satt ineinander greifen!

Your browser does not support the video tag.

Ich liebe das Geräusch, wenn gut passende Bauteile zusammenkommen.

Als die Baugruppe soweit fertig war, konnte ich sie an der Flanschplatte des Portals befestigen. Anschließend habe ich die Z-Achse mit Hilfe eines Winkels und einer Messuhr ausgerichtet, sodass sie über den gesamten Fahrweg mit nur ein paar Hundertstel Abweichung senkrecht auf dem Maschinenrahmen steht. Irgendwann muss man es bei diesem Bausatz aber gut sein lassen, da die Z-Achse mit ordentlichem Druck per Hand am unteren Teil fast 1/10mm gegen die Senkrechte wegbiegen kann. Es ist halt keine superstabile, entsprechend teure Maschine sondern ein Bausatz für den ambitionierten Hobbybereich.

Das Anbringen der seitlichen Versteifungen auf der Z-Achse stellte sich als viel schwieriger heraus als ich dachte. Die T-Nutensteine sind so klein bei der 17mm Schiene und die Schrauben so kurz, dass da kaum Platz blieb um alles an seinen Platz zu bekommen. Ich musste die Nutensteine mehrfach neu positionieren, um die Konstruktion dann einfädeln zu können. Als das endlich klappte, konnte ich den Referenzschalter montieren.

5. Mechatronik

Nun geht es an die vorher vorbereiteten Schrittmotoren . Dafür werden die Mitnehmer der Klauenkopplungen mit Vaseline eingerieben, sodass sie später keine lauten Knarzgeräusche von sich geben. Dann wird die eine Seite der Kupplung an der Kugelumlaufspindel und die andere am Schrittmotor befestigt. Zum Schluss dann montiert man die Motoren und zieht die Schrauben erst richtig fest, wenn Ausrichtung geprüft und ein leichter Lauf sichergestellt werden kann.

Auf der X-Achse hatte ich ziemliche Schwierigkeiten, die Madenschraube auf der Motorseite festzuziehen. Daher würde ich es anders als in der Anleitung angegeben direkt wie oben beschrieben mit auseinandergenommener Klauenkupplung montieren und die Motoren erst ganz zum Schluss einpassen.

Da die Motorzuleitung nicht besonders lang ist, gibt es in Nähe der Motoren kleine Klemmenkästen. Dort werden Motorzuleitung und Signaldrähte für die Referenzschalter aufgelegt. Die andere Seite der Klemmen verbindet eine schleppkettentaugliche Leitung später mit der Steuerung. Zum Schluss wird noch ein Schutzleiter zu jedem Motor gelegt.

Als das für alle drei Achsen erledigt war, machte ich mich an die Schleppketten. Hier ist es vorteilhaft, die Montagerichtung bewusst zu wählen - die Schleppketten lassen sich z.B. zur nachträglichen Verlegung einer zusätzlichen Leitung nämlich nur in eine Richtung öffnen. Wenn deren Mechanismus dann von der Maschine verdeckt wird, kann das zu einem unmöglichen Unterfangen werden.

Es ist ebenfalls empfehlenswert, die Steuerleitungen länger als berechnet zu lassen und sie erst in einem letzten Schritt zu kürzen, nämlich bevor sie an der Steuerung montiert werden. Die Zuleitung zur Z-Achse kann beispielsweise nach Führen durch alle Schleppketten gern mal in Richtung 5m Länge gehen.

6. Abschmieren

Bonusschritt: Der Wartungsanleitung zum Abschmieren aller Linearführungen und Kugelumlaufspindeln folgen. Herrlich, wenn man nochmal unter die Maschine muss…

Erwähnte ich bereits, dass ich kein Metallfritze bin? Diese Fettpressen sind echt frustrierend. Am Anfang bekam ich so gar nichts aus ihr raus und dann muss ich eine Luftblase im System gehabt haben, sodass ich nicht mehr wusste, wohin mit dem ganzen überschüssigen Schmierstoff. Immerhin habe ich jetzt einen gut gefetteten Arbeitstisch.

Und wann ist es eigentlich genug? Reicht “zwei mal drücken”, um eine Linearführung ausreichend zu schmieren? Kommt das Fett überhaupt in die Schmiernippel? Na ja, sobald es aus der Dichtung der Führungen herausquillt wird es wohl reichen 😜

7. Fehlende Teile

Wie oben beschrieben waren alle wichtigen teile der Maschine korrekt und entsprechend der Packliste geliefert worden. Allerdings fehlten ein paar KLeinigkeiten für meine Maschinenkonfiguration:

18x 18mm M5 Maschinenschrauben mit Innensechskant (Linearführungen X-Achse)
6x 0.75mm Kabelschuhe (Schutzerde für die Schrittmotoren)
4x 22mm M4 Maschinenschrauben mit Innensechskant (Montage Schrittmotoren)

Aber ich hatte auch ein paar Teile zu viel

1m extra Schleppkette
4 M5 Unterlegscheiben
9 M4x10 Senkkopfschrauben mit Innensechskant
2 Versteifungen z-Achse “standard”

Mein Vorschlag wäre, nochmal 100 Kabelbinder auf den Bausatz draufzuschlagen, sodass man alle Leitungen schön und ordentlich führen kann.

8. Kritik

Die Bauanleitung (Version 2.1.5) gefällt mir sehr gut. Sie enthält eine Teileübersicht und jeder Schritt ist sehr detailliert erklärt. Auch der Bauprozess ist gut durchdacht und ich als nicht-professioneller Mechaniker hatte keine größeren Probleme, die Maschine korrekt zusammenzubauen.

Die bearbeiteten Teile haben eine hohe Qualität und sind frei von Graten oder scharfen Ecken. Alle notwendigen Gewinde wurden im Voraus geschnitten - sogar die für den optionalen Mechatronik-Bausatz, so dass ich keine Werkzeuge kaufen oder mir Wissen darüber aneignen musste, wie und wo ich sie montieren muss.

Was mir nicht gefiel, war, dass einige Befestigungselemente fehlten, was die Fertigstellung um ein Wochenende verzögerte, und dass die erwartete Anzahl der Befestigungselemente nicht in der Anleitung abgedruckt war, so dass ich erst merkte, dass Teile fehlten, als es bereits zu spät war. Mir ist klar, dass diese Maschine in verschiedenen Größen und Konfigurationen bestellt werden kann, so dass es vielleicht zu viel verlangt ist, eine Bauanleitung für jede einzelne Kombination zu erwarten.

Einige der größeren Aluminiumteile kamen mit Kratzern an, da die Palette während des Transports irgendwie gebrochen und durch die Verpackung gerissen sein muss. Für mich zeigt das, dass entweder das Logistikunternehmen oder der Hersteller die Maschine nicht 100%ig sicher verpackt oder vielleicht das Gewicht unterschätzt hat.

Ein letzter Punkt zu diesen Schmiernippeln (bin immer noch kein Metallbauer): Der für die Y-Achse kann nicht mehr gedreht werden, wenn die Mutter der Kugelumlaufspindel am unteren Portalträger montiert ist, weil das Spiel fehlt. Das ist unglücklich, wenn die Schmierung plötzlich in einem anderen Winkel als vorgesehen erfolgen muss. Außerdem bin ich mir ziemlich sicher, dass der untere Schmiernippel der Z-Achse im Handbuch in die falsche Richtung zeigt.

Ich habe mein Bestes gegeben, um Dinge zu finden, über die ich meckern kann. Ich habe es aber nicht geschafft, mehr als die oben genannten Kleinigkeiten zu finden. Keiner meiner Kritikpunkte schränkt die Funktionalität der Maschine ein, und keiner von ihnen kostete eine beträchtliche Menge an Zeit oder Geld, um ihn zu beheben.

Bisher sieht alles so aus als hätte ich ein robustes Gerät gekauft, das mir helfen wird, meine Prototyping-Holzarbeiten präziser und schneller als je zuvor zu erledigen.

Darf ich vorstellen: Zerspanobert!

9. Dann nehmen wir sie mal in Betrieb

Weiterlesen? Gern! Einrichtung der Maschine

CNC Teil2 - Elektrik

Schallbert — Fri, 18 Feb 2022 00:00:00 +0000

Elektrik der Portalfräse

Dies ist der zweite Teil aus der Reihe Portalfräsmaschine. Hier geht es um Elektrik und Elektronik der Maschine.

AC / Netzkomponenten

Im Schaltkasten befinden sich Sicherungen für die gesamte Maschinensteuerung und ein zentraler Netzschalter. In meinem Fall enthält er auch netzgekoppelte Relais zur Steuerung von Verbrauchern wie Spindeln, Kühlung und Staubabsaugung. Für diese Stromkreise sind zusätzlich abgesicherte Strompfade und Steckdosen vorhanden.

Außerdem verfügt er über ein Netzteil für die Kleinspannungs-Gleichstromschiene. Die Ausgangsleistung ist vorrangig angepasst an die Anforderungen der Schrittmotore. Es versorgt zudem die Steuer-/Breakout-Platine und weitere Spannungswandler, die dann die CNC-Steuerplatine sowie Lüfter und andere Kleinverbraucher mit Energie versorgen.

Zudem gibt es ein Signalrelais, um einen eventuell vorhandenen Frequenzumrichter zum Betrieb von Hochfrequenzspindeln mit der Steuerung zu koppeln.

Frequenzumrichter

Ein FU ist allgemein bekannt als ein Gerät, das die Drehzahl einer 3-Phasen-Wechselstrommaschine steuert. Er wird mit 1- oder 3-phasigem Wechselstrom versorgt und puffert die Energie in einem Gleichstrom-Zwischenkreis, von wo aus sie dann an eine 3-phasige H-Brücke weitergeleitet wird, die daraus Drehstrom mit variabler Frequenz erzeugt.

Diese dreiphasige Wechselspannung wird von Transistoren im Schaltbetrieb erzeugt, was die Umwandlungsverluste im Vergleich zum linearen Betrieb enorm verringert. Die Ausgangsspannung ist allerdings zeitlich und betragsmäßig quantifiziert (“digital”), was zu unerwünschten elektromagnetischen Störaussendungen sowohl am Netzein- als auch am Ausgang des FU führt.

Fast alle professionellen CNC-Spindeln sind 3-Phasen-AC-Asynchronmaschinen, die an einen Frequenzumrichter angeschlossen sind.

FUs haben oft einen standardisierten 0...10V Analogeingang zur Steuerung der Maschinendrehzahl. Sie besitzen zudem mehrere digitale (manchmal sogar potentialfreie) Ein- und Ausgänge, die z.B. von einem Melderelais der Schnittstellenkarte der numerischen Steuerung gespeist werden, und einen Nothalt- oder Fehlersignalausgang zur CNC-Schnittstelle. Sie können auch mit moderneren digitalen Bussystemen und analogen Ausgängen ausgestattet sein, was in meinem Einsatzbereich jedoch wegen der höheren Systemkosten selten genutzt wird.

Im Moment (Feb-2022) besitze ich keinen FU. Daher kenne ich keine Details zur Einstellung, Parametrierung und Anpassung an eine bestimmte Spindel, über die ich schreiben könnte.

PELV / DC-Komponenten

Die typischen “kleinen” CNC-Schrittmotoren werden im PELV-Bereich (Protected Extra Low Voltage) mit Gleichstrom (DC) und unter 60V betrieben, so dass kein zusätzlicher Berührungsschutz erforderlich ist. Das “P” in PELV steht für “protected”, was bedeutet, dass die Geräte mit Erdungsleitungen verbunden sind. Auf diese Weise werden die Schaltkreise bei einem Kurzschluss gegen Erde durch auslösende Sicherungen abgeschaltet. Ein weiterer Vorteil der Erdung aller Komponenten ist die bessere Ableitung von Störeinflüssen, welche sonst die empfindliche Elektronik der CNC beeinträchtigen könnte.

Die Schrittmotortreiber, jeweils einer pro Achse, sind ebenfalls in der Box untergebracht. Sie sind in der Regel SELV (Safety Extra Low Voltage), so dass sie keine zusätzliche Erdung benötigen.

Dann gibt es noch eine Signalplatine, eine Breakout-Platine oder eine Relaisplatine, die Schrittmotorsignalzüge an die Treiber weiterleitet, Hilfsrelais steuert, Referenzschalter- und Notstopp-Eingänge ausliest und Signale für Spindel, Kühlschmierstoffzufuhr, Absaugung und/oder weitere Hilfssteuerungen ausgibt.

Ein Lüfter hält die Temperatur im Schaltkasten niedrig. Oft ist auch eine Schnittstellenkarte montiert, die direkt über die CNC-Software gesteuert wird, z. B. über USB oder Ethernet. Sie übersetzt und leitet Informationen an die einzelnen Komponenten der CNC und zurück an das Programm auf dem Computer, z. B. für Referenzschalter oder Not-Aus.

Schrittmotortreiber im Detail

Die Schnittstelle des Schrittmotortreibers ist recht einfach. Sie nimmt TTL-Pegel von 0V (low) und 5V (high) an und wird durch nur drei Eingänge definiert:

Signalname	Beschreibung
Enable (EN)	Schaltet die Stromversorgung der Antriebe ein. Ermöglicht z.B. aktives Halten der Position
Drehrichtung (DIR)	Auswahl der Motordrehrichtung
Pulse (PUL)	Lässt den Motor einen (Mikro-)Schritt drehen

Interessanterweise werden dieselben drei Eingangssignale benötigt, um den Lesekopf eines Diskettenlaufwerks zu steuern. Ich habe dies in einem meiner früheren Projekte ausprobiert, einer Floppy-Bass-Orgel, das auf dem Softwareprojekt moppy basiert.

Intern interpretiert der Treiber die Eingangssignale und gibt Impulse aus, die für den Antrieb des Schrittmotors geeignet sind. Zwei H-Brücken-Kanäle - Schaltungen mit je vier Schalttransistoren zur Steuerung von Richtung und Höhe der Spannung an den Motorspulen - mit den Bezeichnungen “A” und “B” liefern Energie für die Polpaare des Schrittmotors.

Ausführlichere Informationen über Schrittmotorantriebe, Mikroschrittbetrieb und andere Aspekte finden Sie z. B. hier oder auf diesem Blog.

Schrittmotoren

Schrittmotoren sind - wie 3-Phasen-Wechselstrom- oder bürstenlose Gleichstrommotoren - elektronisch kommutiert. Daher müssen dem Motor Strompulse zugeführt werden, damit er sich kontinuierlich dreht. Die meisten Schrittmotoren sind heutzutage Hybridmotoren. Diese weisen einen mehrzahnigen Rotor auf, der in zwei Hälften geteilt ist welche um einen halben Zahn zueinander versetzt sind und jeweils von einer Spule gesteuert werden. Diese Art von Motor hat mindestens vier Anschlüsse, zwei für Spule “A” und zwei für Spule “B”. Bipolare Hybridmotoren haben sogar acht Leitungen, die die Spulen wiederum in zwei Teile aufteilen - auf diese Weise können sie in Reihe, parallel und auch unipolar geschaltet werden, so dass jede der vier Spulen einzeln gesteuert werden kann.

Schrittmotoren werden meist in “bipolarer Parallelschaltung” an CNC-Schrittmotortreiber angeschlossen. Dabei werden die beiden Spulen eines Polpaares mit gleicher Ausrichtung parallel geschaltet. Die beiden Drähte dieser Parallelschaltung werden dann mit den Ausgängen A+ und A- des Treibers verbunden. Diese Verdrahtung wird für Kanal B wiederholt. Ich habe die zusammengehörenden Aderpaare mit einer Bohrmaschine verdrillt weil ich zu faul war, das von Hand zu machen. Verdrillen der spulengleichen Aderpaare A/B macht Sinn, weil die mit Pulszügen angesteuerten Motoren erhebliche elektromagnetische Störungen erzeugen können. Durch das Verdrillen gleichen sich magnetische Felder von Hin- und Rückleitung aus.

Anders als bei Drehstrom- oder bürstenlosen Gleichstrommaschinen liegt die Priorität bei der Konstruktion von Schrittmotoren nicht auf einer möglichst hohen Energieeffizienz, geringen Geräuschemissionen, hohen Drehzahlen oder einem guten Wärmemanagement für den Dauerlauf, sondern auf hohem Drehmoment, großen Haltekräften zum Sichern einer Position und einem flüssigen Betrieb bei niedrigen Drehzahlen. Schrittmotoren sind für hohe Beschleunigungen gebaut und sollen stets der Impulsgeschwindigkeit folgen, da die Positionierung der Maschine davon abhängt.

Schrittmotoren eignen sich wie Servomotoren auch zum Positionierbetrieb. Hierbei werden sie nicht über die Wellenposition geregelt, sondern die Position wird durch Zählen der Pulse in die jeweilige Richtung “geschätzt”. Solange kein Schrittverlust (durch Überlast oder zu hoch eingestellte Beschleunigungswerte) auftritt, ist diese Art der Positionssteuerung sowohl kostengünstig als auch hinreichend genau. Daher wird sie häufig verwendet.

Da die Positionsinformation bei Neustart der Maschine (meist) verloren geht, verfügen CNC-Maschinen mit Schrittmotoren über Referenzschalter an jeder Achse, die bei Inbetriebnahme angefahren werden und die Positionsinformation im Koordinatensystem der Maschine mit der der Schrittmotore verknüpft.

Der Aufbau

Your browser does not support the video tag.

Schaltkastenbau in neun Sekunden

Der Bau des von mir gekauften Bausatzes für den Schaltkasten und die Verdrahtung nahm nur etwa 8 Stunden in Anspruch. Es erwies sich als entscheidend, alle Schaltpläne und Schritt-für-Schritt-Anleitungen im Voraus gründlich zu studieren. So konnte ich Fehler vermeiden, deren Behebung sonst Abende gekostet hätte.

An dem Bausatz gefällt mir, dass die Komponenten elektrisch aufeinander abgestimmt sind und alle notwendigen Leitungen, Buchsen (bis auf eine Ethernet-Buchse) und die Dokumentationen vollständig waren. Ich habe nur Kabelkanäle und einige Kabelschuhe vermisst, um das Kabelmanagement und die Verbindungen zum Gehäuse zu vereinfachen. Das Gehäuse ist sehr robust und alle Steckdosen passen gut an ihren Platz.

Am Frickeligsten beim Aufbau waren die Lötstellen der Schrittmotor/D-Sub-Stecker und deren Isolierung. Ebenso stellte es sich als schwierig heraus, die Steuerplatine im Gehäuse montiert zu bekommen.

Ich war wirklich aufgeregt, als ich die Steuerung zum ersten Mal einschaltete. Das Geräusch des anlaufenden Lüfters und das Blinken aller möglichen LEDs waren einen Seufzer der Erleichterung wert.

Your browser does not support the video tag.

Erster Test: Quittieren des Not-Aus Schaltkreises

Sicherheitshinweise

Nein, ein geöffnetes netzbetriebenes Gerät sollte nicht eingeschaltet werden, wenn man nicht weiß, was man tut. Ja, ich habe in einen Fehlerstromschutzschalter installiert, um mich vor gefährlichen Spannungen zu schützen, und ja, ich habe alle Sicherungen doppelt überprüft, eine gründliche Sichtprüfung durchgeführt und Durchgangsmessungen an jedem einzelnen Anschluss vorgenommen, um Fehlverdrahtungen auszuschließen. Glücklicherweise bestand die Steuerung den ersten Funktionstest. Der Zustand des Notsignals wurde korrekt interpretiert und die LED der CNC-Platine blinkte mit der erwarteten 1Hz-Rate.

Aufbau einer “Mini Control / Serie C1”

Für die Maker Faire Ruhr 2024, bei der ich einer der Aussteller war, habe ich eine weitere Steuerung aufgebaut: Die einfachere “Mini Control / Serie C1”. Ein Zeitraffervideo davon habe ich hier eingebettet:

CNC electronics assembly

Vorteile:

Schnelle Montage
Kein Löten
Viele Snap-In-Teile
Kleines Gehäuse

Nachteile:

Verbindung zur Maschine erfolgt über Schraubklemmen; Trennung zur Maschine nicht vorgesehen
Lauter Lüfter, auch im Leerlauf aktiv (kann aber mit „Schallberts Fanhack“ gelöst werden)
Mehrere externe Netzteile (Schrittmotorversorgung, 24V-Versorgung, Spindel-Schaltbox)

Mit der zugehörigen kleinen CNC-Fräse habe ich viel gemacht: Tuning auf kürzere Fertigungszeiten, eine Spezialisierung für Gravuren und diverse Projekte wie Stempel, Dithering-Bilder und mehrfarbige Carves.

CNC Teil1 - Portalfräsmaschine

Schallbert — Sat, 12 Feb 2022 00:00:00 +0000

CNC Portalfräsmaschine - für Anfänger

Es ist Winter 2021, und meine erste CNC-Maschine wird bald geliefert. Es wird ein Bausatz sein, der aus einer Menge Pakete und noch mehr Einzelteilen besteht. Ich habe die Maschine bestellt, weil ich Prototypen für AnywhereAmps schneller und genauer fertigen möchte. Und natürlich um ein paar weitere Hardware-Projekte umzusetzen, die mir schon länger im Kopf herumschwirren.

Moment mal

Oh, Ok. CNC bedeutet computer numerical control und beschreibt, wie die Maschine gesteuert wird - nicht von Hand, sondern durch Instruktionen eines Computers.

Diese werden G-Code genannt, und sind in der häufig benutzten Interpretersprache RS274-NGC geschrieben, die Industriestandard für computergesteuerte Bearbeitungszentren geworden ist.

Eine Portalfräsmaschine ist einer Oberfräse nicht unähnlich. Der Fräsmotor ist auf einem Gestell montiert, das ihn in (meist) drei Achsen X, Y, Z mithilfe von Schrittmotoren oder Servomotoren bewegt. Ein Rechner steuert diese Bewegungen und ist so in der Lage, nahezu beliebige Formen zu schneiden. Die Kinematik der Portalfräsmaschine ist ähnlich zu der von 3D-Druckern, obwohl sie natürlich ganz unterschiedliche Anforderungen an die Mechanik haben - eine Portalfräsmaschine muss viel stabiler, steifer und schwerer konstruiert werden, da die Rahmenkonstruktion sämtliche Schneid- und Beschleunigungskräfte aufnehmen muss.

Natürlich sind CNC-Maschinen nicht auf 3D-Drucker und Fräsmaschinen beschränkt. Es gibt CNC-Drehmaschinen, Plotter, Laserschneider, Wasserstrahlschneider und viele mehr. Streng genommen sind sogar Industrieroboter CNC-Maschinen.

Fragen

Dies sind einige der Fragen, die ich hatte, bevor ich dieses ziemlich teure Stück Technik gekauft habe. Einige davon lassen sich leicht in ein paar Zeilen beantworten, andere würden wahrscheinlich einen ganzen Artikel für sich allein füllen.

CNC-Fräsmaschine

Beschleunigt sie wirklich meinen Prototyping-Prozess?

Ich weiß es noch nicht, aber ich hoffe es. Die Holzarbeiten für einen einzigen Prototyp nehmen etwa 8 Stunden meiner Zeit in Anspruch. Am meisten Zeit verschlingen die Vorbereitungen für den Zuschnitt, die Messungen und das Abpausen. Allein der Lautsprecheradapter von AnywhereAmps Alpha mit seiner gewölbten Oberfläche nimmt mehr als eine Stunde Fertigungszeit in Anspruch.

Mit einer CNC-Portalfräsmaschine hoffe ich, mehr wie ein Plätzchenbäcker zu werden: Alle Teile für AnywhereAmps (mit Ausnahme des zylindrischen Gehäuses) in einem einzigen Stück Sperrholz zu verschachteln, die Maschine die Arbeit machen zu lassen und nach einer Weile nur noch minimale Nacharbeiten beim Ausschneiden und Schleifen der Teile zu erledigen.

Und wenn ich einen weiteren Prototyp oder andere Lautsprecherdurchmesser haben möchte: Ich passe einige Parameter in meinem CAD-Tool an, stelle die Werkzeugwege neu ein, schicke sie an den Computer der Maschine, spanne ein neues Stück Sperrholz ein und drücke auf “Auftrag ausführen”. Fertig (in der idealen Welt).

Andererseits braucht das Einarbeiten in die ganzen Software-Tools auch seine Zeit. Mein Einführungsartikel über FreeCAD hier verlinkt ist ein Beispiel dafür.

Mehr Geld für Portalhardware oder lieber für den Spindelantrieb ausgeben?

Das ist eine Frage an die Experten, die ich selbst erst beantworten kann, wenn ich schon eine Weile eine CNC besitze. Ich habe mich dafür entschieden, mehr Geld für das Portal und weniger für die Spindel auszugeben, und zwar aus mehreren Gründen, die sich aus dem Bauch heraus ergeben:

Das Portal ist meine Maschine, die Spindel nur ein Teil davon.
Die Spindel ist günstiger, leichter auszutauschen und bei weitem nicht so aufwendig zu montieren wie das Portal, also möchte ich, dass das Portal eine Konstante ist.
Wenn ich durch die Fähigkeiten meiner Portalfräsmaschine eingeschränkt bin, müsste ich zuerst herausfinden, warum, und dann an einzelnen Komponenten herumschrauben, um sie zu verbessern. Wenn die Spindel der limitierende Faktor ist, kaufe ich mir einfach eine stärkere und gut ist.

Wie viel Spindelleistung?

Das ist meine erste schwierige Frage. Ich bin mir fast sicher, dass ich für meine Holzbearbeitung kein 2,2-kW-Monster brauche. Um anständige Vorschubgeschwindigkeiten zu erzielen und genügend Spielraum für Dichteunregelmäßigkeiten wie Astlöcher zu haben, könnte es eine gute Idee sein, sich im Leistungssegment der Handoberfräse zwischen 700W und 1200W zu orientieren, was mir immer gute Dienste geleistet hat. Ich habe mich für eine 1000W Universalmotor Maschine entschieden.

Im Gegensatz zu den oft als “HF-Spindeln” (HF = Hochfrequenz) bezeichneten Drehstrommotoren benötigen sie keinen Frequenzumrichter und keine externe Kühlung, da ihr Lüfter auf die Welle geschraubt ist. Andererseits sind sie in der Regel lauter (der Lüfter ist nicht unabhängig von der Motordrehzahl) und weniger effizient (Lüfterverluste, Kommutierungsverluste, Kupferverluste, Magnetisierungsverluste usw.) Ich habe im Internet nur grobe Zahlen zum Wirkungsgrad gefunden, also nehmen wir mal an:

1000W Universalmotorantrieb *30% Gesamtwirkungsgrad inkl. Elektronik & Lüfter: 300W @ Motorwelle

700W Asynchronmaschine *85% Wirkungsgrad *90% Wirkungsgrad Steuerung *97% external cooling: 520W @ motor shaft

Das wäre ein gewaltiger Unterschied, so dass sich eine spätere Aufrüstung doch lohnen könnte. Außerdem reichen für eine HF-Spindel im Vergleich zu einem konventionellen Antrieb geringere Wattzahlen aus.

Automatischer Werkzeugwechsler - ja oder nein?

Das hängt wohl davon ab, was ich brauche. Ich kaufe mir zunächst einen einfachen Fräsmotor mit digitaler Drehzahlregelung als Spindel. Ein “richtiger” Werkzeugwechsler - richtig bedeutet, dass ich auch Werkzeugschäfte von 10mm und größer montieren kann und gewuchtete Spannzangen, 3-Phasen-Antrieb mit eigenständiger Kühlung und Frequenzumrichter habe - würde ~10 mal so viel kosten. Außerdem kostet jedes ER20-Spannzangenfutter für den Werkzeugwechsler mal eben die Hälfte meines Fräsmotors. Davon bräuchte ich mehr als eine, wenn der Werkzeugwechsler Sinn machen soll. Und ich bräuchte eine Druckluftanlage mit Schaltkasten usw. Das alles zusammen würde die Kosten für die Portalfräse locker überschreiten!

Schlussfolgerung: Wenn ich die CNC in Zukunft sehr oft benutzen werde und wenn meine Projekte unbedingt häufige Werkzeugwechsel zum Schruppen, Glätten, Fasen, 3D usw. erfordern, dann könnte ich diesen teuren Schritt in Betracht ziehen. Vielleicht. Irgendwann.

Welche Größe ist die beste?

Idealerweise könnte man für die Bearbeitung von Sperrholzplatten eine ganze Standardplatte von “1250mm x 2500mm” oder einen Bruchteil davon, z.B. “610mm x 1250mm”, auflegen. Aber selbst die kleineren Platten würden nicht in den Keller meiner kleinen Wohnung passen. Also entschied ich mich für eine mit 840mm x 740mm Auflagefläche.

Für Ihre Wahl: Prüfen Sie, ob Sie platzmäßig eingeschränkt sind. Wenn nicht, dann machen Sie sich gründlich Gedanken darüber, was Sie mit Ihrer Maschine machen wollen. Die Größe der Maschine ergibt sich automatisch, wenn Sie wissen, wofür Sie sie hauptsächlich einsetzen wollen.

Plug-and-play oder ein Bausatz?

Dies hängt von mehreren Aspekten ab: Von Budget, der Zeit, die man zu investieren bereit ist, und natürlich davon, ob man zumindest ein bisschen Talent im Umgang mit Schraubendrehern, Muttern, Abisolierzangen und dem Lötkolben hat. Es kommt auch darauf an, ob einem jede Schraube Ihrer Maschine persönlich bekannt sein soll.

Kugelumlaufspindeln zum Bewegen der Achsen?

Flinke Eilgänge, hohe Wiederholgenauigkeit durch reduziertes oder eliminiertes Spiel oder höhere Vorschubgeschwindigkeiten? Fräsen im Gleichlauf, um die Oberflächenqualität und die Standzeit der Werkzeuge zu erhöhen? Wenn Sie einen dieser Punkte bejahen, sollten Sie das zusätzliche Geld für Kugelumlaufspindeln ausgeben.

zusätzliche Vielseitigkeit?

Wie im Abschnitt Moment mal beschrieben, wäre das Portal selbst auch für andere Zwecke geeignet. Es gibt Schleppmesser zum Plotten, 3D-Druckköpfe und sogar Gravurlaser, die bei Bedarf an das Portal angeflanscht werden könnten.

Um sich darauf vorzubereiten, ist eine Spindel, die auf den Euronorm-Hals mit einem Durchmesser von 43 mm passt möglicherweise die beste Wahl, da die meisten anderen Werkzeuge auch für diese Passform erhältlich sind. Dies erleichtert einen eventuellen Umbau. Wobei andererseits die meisten Maschinen, die etwas taugen, spezialisiert sind auf ihr Fach - ein 3D-Drucker schafft wahnwitzige Beschleunigungsvorgänge, der Plotter spart beim Platzverbrauch und die CNC-Fräse ist nunmal wegen der Schneidkräfte stabiler gebaut.

Allgemeine Fragen

Entsteht dabei viel Staub?

Ja. Besorgen Sie sich eine gute Staubabsaugung. Ich würde ein Zyklonsystem oder einen dieser riesigen Textilbeutel empfehlen, die normalerweise bei stationären Sägen verwendet werden. Wenn Sie Ihre Maschine regelmäßig benutzen, reicht die Aufnahmekapazität eines Werkstattsaugers allein möglicherweise nicht aus.

Außerdem sollten Sie den Staubsauger gut erden (z. B. indem Sie die Erdungsleitung(en) mit dem Erdungspunkt Ihres Schaltkastens verbinden) und antistatische Saugschläuche kaufen, die Sie an die Erdung des Staubsaugers oder des Staubbehälters anschließen können. Auf diese Weise vermeiden Sie, dass Sie jedes Mal, wenn Sie vakuumbezogene Dinge berühren, einen leichten Schlag bekommen, und Sie können einen schwer auszumachenden Grund dafür ausschließen, dass Ihre Maschine verrückt spielt, z. B. plötzliches Einfrieren der Software, zufälliges Erkennen von Not-Aus-Ereignissen durch die Steuerung, Falschauslösung eines Referenzschalters oder sogar Schluckauf bei Schrittmotoren. Es gibt viele Fälle in verschiedenen Foren, in denen dies die Ursache war oder gewesen sein könnte, z. B. hier.

Ist sie laut?

Ja. Der Geräuschpegel ist vergleichbar mit dem einer Handoberfräse. Sie ist schon im Leerlauf laut, und es wird noch schlimmer, wenn sie durch Material fährt. Es könnte also eine gute Idee sein die leiseren, aber teureren Hochfrequenzspindeln mit externer Kühlung zu kaufen. Darüber hinaus sollte (und je nach den örtlichen Vorschriften sogar muss) Ihre Maschine aus Sicherheitsgründen, aber auch zur Lärmminderung, eine Einhausung erhalten. Sie hilft auch dabei, Feinstaub in der Raumluft zu reduzieren.

Die Geräuschentwicklung hängt aber auch stark vom verwendeten Fräser ab. Meiner Erfahrung nach klingen kurze Planfräser mit großem Durchmesser und 10-mm-Schaft angenehmer und sind vielleicht sogar weniger laut als Fräser mit Fischschwanz oder besonders langem Schaft.

Wie sieht der Arbeitsablauf aus?

Hier ist eine vereinfachte Darstellung des Arbeitsablaufs mit einer CNC-Maschine.

Ähnlich wie beim Handwerk beginnt alles mit einer Idee. Die Zeichnungen und Bemaßungen der Teile werden nicht auf einem leeren Blatt Papier, sondern in einem Computer Aided Design-Tool erstellt. Die Zeichnung oder 3D-Modelldatei wird dann in einem Computer Aided Manufacturing Tool weiterverarbeitet, wo geeignete Fräswerkzeuge ausgewählt, die Frässtrategien festgelegt und die Werkzeugwege erzeugt werden. Die resultierende G-Code-Datei wird dann an die eigentliche CNC Software gesendet, die die Schrittmotortreiber steuert. Diese senden Stromimpulse an die Schrittmotoren, die wiederum die Maschine mechanisch verfahren, um das Teil zu fertigen.

Fragen zum Betrieb

Fräsen im Gleich- oder Gegenlauf?

Dies ist eine Entscheidung, die in der CAM-Software getroffen wird.

Fräsen im Gegenlauf = der Fräser “schnitzt” in das Material, seine Schneiden drehen sich entgegen der Materialtransportrichtung. Der Gegenlauf wird bei allen Kreissägen verwendet die ich kenne, um Rückschläge zu vermeiden oder das Werkstück auf dem Tisch zu halten. Gleichlauffräsen = der Fräser “frisst” sich in das Material, seine Schneiden rotieren mit der Transportrichtung. Der Fräser neigt dazu, sich selbst in das Material zu ziehen. Weitere Informationen z.B. auf harveryperformance oder tormachs blog.

Für welche der beiden Möglichkeiten Sie sich entscheiden sollten, hängt von der Steifigkeit und dem Gewicht Ihrer Maschine, den Drehmoment Ihres Schrittmotors, der Leistung Ihrer Schrittmotorantriebe und dem Material ab, das Sie bearbeiten. Wenn Sie eine steife, schwere, leistungsstarke Maschine (mit Kugelumlaufspindeln) haben und mit eher weichen Materialien arbeiten, sollten Sie das Gleichlauffräsen verwenden. Beobachten Sie Ihre Maschine genau, um zu sehen, ob sich alles glatt anfühlt und anhört (!). Im Zweifelsfall sollten Sie im Gegenlauf fräsen. Arbeiten Sie bei handgeführten Oberfräsen immer den Gegenlauf!

Nachtrag: Ich fräse Dibond im Gegenlauf mit guten Ergebnissen, Acrylglas und Holz jedoch bearbeite ich im Gleichlauf.

Wie spannt man das Werkstück schnell und einfach auf?

Das hängt wiederum von Ihrem Material ab:

Große Platten: Vakuumtisch oder Anschlag mit Klemmen, die die Platte gegen den Anschlag drücken
Kleine Platten: Klemmen oder Verschraubung auf dem Fräsbett
Kleine Blöcke: Schraubstock
Unregelmäßige Formen: Klemmen, die das Material auf dem Fräsbett niederhalten
Beidseitiges Fräsen: projektspezifische Vorrichtungen, die das Material in Position halten

Hmm, die Opferplatte mit Anschlag wird wahrscheinlich eins meiner ersten Projekte mit der neuen Maschine.

Mit welchen Bits / Fräsern sollte man beginnen?

Ich würde für den Anfang die folgenden allgemeinen Fräser empfehlen. Sie sollten natürlich in Herstellung, Spiralform, Nutenzahl usw. zum verwendeten Material passen.

Klassischer Schaftfräser mit 6mm oder 1/4", Spirale mit 15-30°
2mm Schaftfräser mit Freischnitt für feines Material oder kleine Löcher
60° und 90° Gravierfräser für Gravuren und Fasen
Planfräser für großflächiges Fräsen

Mein Schwerpunkt ist Holz, was sind geeignete Vorschübe und Drehzahlen?

Birkensperrholz ist hart aber nachgiebig. Die geeigneten Werte berücksichtigen immer die Stabilität der Maschine, die Drehmomente der Schrittmotoren und die Spindelleistung.

Wichtig ist, dass der Fräser Späne erzeugt und keinen Staub. Deshalb sollten niedrige Vorschubgeschwindigkeiten bei hohen Spindeldrehzahlen vermieden werden. Für den Anfang in Holz: Verwenden Sie die Hälfte Ihres Werkzeugdurchmessers als Tiefe pro Durchgang, berechnen Sie die Spindeldrehzahl mit der Formel für Vorschübe und Drehzahlen oder einem Rechner aus dem Internet, und probieren Sie diese aus. Schauen Sie sich die Späne an. Hören Sie der Maschine bei der Arbeit zu. Hört sie sich “gut” an? Erhöhen Sie die Tiefe pro Durchgang oder die Vorschubgeschwindigkeit allmählich und hören Sie an dem Punkt auf, an dem entweder Ihre Spindel gestresst klingt, Ihr Finish schlechter wird oder Sie sich mit Ihrer Maschine nicht mehr sicher fühlen. Drehen Sie wieder eine Stufe zurück, und das könnte Ihre ideale Vorschubgeschwindigkeit und Durchgangstiefe für das Material und den Fräser sein, den Sie gerade verwenden.

Für meine Maschine habe ich mich für F3500mm/min = 138in/m bei S24000U/min und einer Tiefenzustellung in Höhe des Fräsdurchmessers Z+6mm, Bahnüberlappung 10% entschieden. Für die Recherche habe ich die folgenden Websites benutzt: cnccookbook, cnc-rechner sowie Webseiten von Werkzeugherstellern wie Sorotec.

Weiterlesen?

CNC: Der Aufbau CNC Elektronik

Einschaltstrombegrenzer Teil2

Schallbert — Thu, 10 Feb 2022 00:00:00 +0000

Inhalt

In diesem Artikel konzentriere ich mich auf zwei Möglichkeiten, eine Halbleiter-Einschaltstrombegrenzerschaltung zu erstellen: Die eine kopiert den Relais-Ansatz aus Elektronikwissen: Einschaltstrombegrenzer, wobei lediglich das Relais durch einen p-Kanal-MOSFET ersetzt und eine besser definierte Zeitverzögerung hinzugefügt wird. Zum anderen stelle ich einen “linearen” Ansatz vor, bei dem die Stromversorgung schrittweise durch einen PNP-Leistungstransistor eingeschaltet wird.

Motivation: Einschaltstrombegrenzer für USB-PD

Da meine Experimente mit USB-PD für AnywhereAmps vorerst fehlgeschlagen sind, muss ich eine Schaltung erstellen, die den Einschaltstrom in meinem Verstärker begrenzt, bevor ich es erneut versuche.

Schaltungen erläutert

Die beiden Schaltungen sind sich sehr ähnlich. Sie unterscheiden sich eigentlich nur in zwei Komponenten des Leistungsteils. Im Allgemeinen wird die Verzögerungszeit durch eine Vergrößerung des Kondensators C4 oder eine Vergrößerung des Ladewiderstands R9 verlängert.

Eingangsbereich (blau)

Der Eingangsteil verfügt über eine TVS-Diode, um Verpolung oder Überspannung zu vermeiden.

Verzögerungsabschnitt (gelb)

Nach dem Einschalten wird C4 über R9 allmählich aufgeladen. Wenn die Schwellenspannung des NPN-Bipolartransistors Q2 erreicht ist, wird die Spannung hinter R11 langsam reduziert, was wiederum M2, den Leistungspfad dieser Schaltung, aktiviert. R12 wurde hinzugefügt, um einen stabilen Arbeitspunkt für Q2 zu schaffen.

Leistungsteil (grün)

Die lineare Variante hat einen PNP-Leistungstransistor Q1 im Hauptstrompfad (Bild unten). Er wird über Q2 aktiviert, und der Strom, den er liefern kann, wird über R10 gesteuert, der in diesem Fall einen relativ niedrigen Wert hat um hohe Emitter-Kollektor-Ströme zu ermöglichen.

Während die schaltende Variante einen Strombegrenzungswiderstand R8 verwendet, der durch den p-Kanal-Mosfet M2 kurzgeschlossen wird, erfordert seine spannungsgesteuerte Natur keine besondere Sorgfalt bei der Auswahl von R10. Man sollte nur darauf achten, dass seine (negative) Gate-Schwellenspannung sicher eingehalten wird.

Simulierte Last (violett)

Meine Last ist die Endstufenschaltung. Um den Ruhezustand und das Einschaltverhalten zu simulieren, habe ich einen 400Ohm-Widerstand R5 und einen gepolten 1200uF-Kondensator C3 gewählt. Die TVS-Diode schützt vor Überspannung und Rückströmen. Ich habe die Simulationen mit Kondensatorwerten von bis zu 10000uF und Lastwiderständen bis herunter auf 40Ohm ausprobiert, alle mit ähnlichen und guten Ergebnissen.

Schaltungsvergleich

Die dunkelblaue Linie im Diagramm ist wichtig: Sie beschreibt die Ausgangsspannung des Systems im Zeitverlauf. Beide Schaltungen sind so abgestimmt, dass sie die Ziel-Ausgangsspannung nach 0,2 Sekunden erreichen. Dennoch unterscheiden sich die Kurven ziemlich stark, was die unterschiedliche Natur der beiden Ansätze widerspiegelt.

P-CH MOSFET Ansatz

Aufgrund des Schaltvorgangs ist die Einschaltstrombegrenzung zwar wirksam, aber nicht ganz gleichmäßig
die Leistungsverluste sind bei dieser Variante sehr gering, da sowohl der auslösende NPN-Transistor als auch der Leistungs-MOSFET für sich genommen nicht viel Strom verbrauchen.
breiter Einsatzbereich für angeschlossene Geräte, der nur durch den maximalen Dauerstrom des MOSFETs begrenzt wird.

PNP-Leistungstransistor-Ansatz

sehr ruhiger Betrieb, die Einschaltzeit kann aufgrund des großen ohmschen Bereichs des PNP sehr gut gesteuert werden
höhere Leistungsverluste im eingeschalteten Zustand aufgrund des hohen Basisstroms durch R10.
Nicht sehr vielseitig, da hohe Lastströme einen beträchtlichen Spannungsabfall über den Emitter-Kollektor-Pfad von Q1 erzeugen.

Weitere Verbesserungen

Um die Vielseitigkeit dieser Schaltung zu behalten und gleichzeitig eine glatte Spannungskurve zu erreichen, könnte man einen Operationsverstärker verwenden, um den Laststrom zu überwachen und ihn bei Bedarf auf die zulässigen Werte herunterzuregeln. Der Leistungs-MOSFET könnte beibehalten werden, während der Nachteil des engem ohmschen Betriebsbereichs verschwinden würde. Der Preis dafür wäre zusätzliche Komplexität, wie sie in diesem Stackexchange-Beitrag beschrieben wird.

Energieversorgung per USB

Schallbert — Thu, 27 Jan 2022 00:00:00 +0000

USB Power Delivery

USB Power Delivery ist ein Standard innerhalb des USB 3.x-Protokolls, der die Stromversorgung und die Spannungspegel innerhalb des USB-Netzwerks festlegt. Mit USB-PD ist es möglich, Verbraucher in Reihe zu schalten, die dann automatisch den Strombedarf mit der/den Quelle(n) aushandeln. Der Standard hat verschiedene Versionen, von denen die neueste (2021) bis zu 5 Ampère bei 3,3...48V und maximal 240 Watt Leistung zulässt.

USB-PD-Rollen

Im USB-Power-Delivery-Standard gibt es verschiedene Rollen, die die Teilnehmer an den Enden eines USB-Kabels spielen können. Sie können Host oder Client für Datenzwecke und gleichzeitig Stromquelle, Stromsenke oder beides für andere Teilnehmer sein.

Rollenbegriffe

USB-C verwendet das Akronym DFP oder “Down-Facing Port”, um zu verdeutlichen, dass es sich um den Port eines Host handelt. UFP oder “Up-Facing Port” wird für Clients verwendet, die mit Hosts verbunden werden können. Es gibt aber noch eine dritte Rolle: DRP oder “Dual-Role Port”. Dieser Anschluss kann entweder als Host oder als Client dienen, je nachdem, wer der Verbindungspartner auf der anderen Seite der Leitung ist und was das USB-Netzwerk aushandelt.

Im USB-PD-Kontext kann jeder dieser Ports so konfiguriert werden, dass er als Stromquelle oder Stromsenke dient. Beispiel: Obwohl die Rolle des USB-C-Anschlusses eines Laptops auf “DFP” konfiguriert sein kann, kann er, wenn er an eine Stromquelle angeschlossen ist, immer noch eine Stromsenke sein. Hmm.

In diesem Beitrag verwende ich nur die “UFP”-Rolle sowohl im Sinne des USB-C- als auch des USB-PD-Wortes. Also versuche ich, eine Stromsenke für mein Gerät zu konfigurieren, damit es die benötigte Eingangsspannung und den Strom erhält.

USB-PD Version

Vor USB-PD Standard 2.0 unterstützten USB-C-Geräte nur sogenannte Power Profiles mit festen Spannungen von 5V, 12V, 20V und Strömen von bis zu 2A, 3A, oder 5A.
Zwischen USB-PD Standard 2.0 und USB-PD 3.0 haben Power Delivery Objects die alten Power Profiles ersetzt, die es erlauben, verschiedene Spannungen/Stromstärken von der Senke auszuwählen je nach Angebot der Stromquelle. Die Spannungen sind auf 5V, 9V, 15V, 20V festgelegt, mit Strombegrenzungen von 2.25A, 3A, 5A, je nach Fähigkeit der Quelle und Spannungseinstellung. PDOs erlauben Fallback-Strategien, d. h. wenn eine Quelle die höchste Leistungsanforderung nicht unterstützen kann, kann die Senke ein anderes PDO mit geringerer Spannung/Strom auswählen, das sowohl für die Quelle als auch für die Senke geeignet ist.
Mit USB-PD Standard 3.0 PPS bietet das Protokoll mit Programmable Power Supply noch mehr Flexibilität. Hier fordert eine Stromsenke einen Spannungspegel zwischen 3,3V und 21V an, der in 20mV-Schritten und 0,2 bis 5A in 50mA-Schritten wählbar ist, wobei die volle Rückwärtskompatibilität zu den Power Delivery Objects von USB-PD 2.0 erhalten bleibt.
Der neueste USB-PD Standard 3.1 erweitert sogar die Grenzen der programmierbaren Stromversorgungen und erlaubt 3,3V - 48V und bis zu 5A mit AVS - Adaptable Voltage Files. Puh.

Nicht alle Quellen (Steckdosen, Powerbanks usw.) können alle Spannungspegel oder Stromstärken liefern oder haben überhaupt nur den gleichen Standard in der Umsetzung. Aber eine Reihe von Werten ist ziemlich üblich: 5V, 9V, 12V, 15V, 20V. Einige der Produkte, die ich auf dem Markt gesehen habe, bieten bis zu 4A, aber die meisten halten es mit bis zu 3A und Spannungen bis zu 15V sind am häufigsten (im Jahr 2021).

ASICs für die Stromversorgung

ASIC steht für Application Specific Integrated Circuit (anwendungsspezifischer integrierter Schaltkreis), und in diesem Beitrag versuche ich, ASICs mit der Funktion der Stromsenke zu beleuchten, die eigenständig arbeiten können, d. h. ohne ein externes Steuergerät wie einen Mikroprozessor. Ich habe drei Typen dieser ICs gefunden:

USB-PD-Senke, Spannungs- und Stromeinstellung über eine Widerstandskaskade
USB-PD-Senke, Spannungs- und Stromkennlinie über den Datenbus programmierbar (I2C/UART/SPI) in den nicht-flüchtigen Speicher des ASIC.
USB-PD-Senke mit integriertem Mikroprozessor, der programmiert werden muss

Was alle ASICs gemeinsam haben: Sie benötigen periphere Schaltungen, um zu funktionieren - zumindest einige Widerstände, Kondensatoren und Leistungstransistoren, um die Stromversorgung zu schalten und mit angeschlossenen Stromquellen zu verhandeln.

USB-PD ist komplex: Versionierung und Vertragsverhandlungen

Sowohl die Abwärtskompatibilität als auch die Skalierbarkeit von USB-PD fordern ihren Tribut - die USB-PD-Spezifikation ist ein mehr als 600 Seiten starkes Monster und es ist nicht immer klar, welche Quelle oder Senke welche Protokollebene unterstützt.

Da sowohl die Quelle, die Senke als auch das Kabel einen Power-Delivery-Vertrag aushandeln müssen, der auf den Anforderungen der Senke, den Stromversorgungsoptionen der Quelle und den Möglichkeiten des Kabels basiert, kann man sich vorstellen, dass dieser Prozess sehr komplex ist. Dies gilt umso mehr, als dass alle Beteiligten möglicherweise einen anderen USB-PD-Standard, eine andere Revision oder eine andere Version implementiert haben. Kleiner Fakt am Rande: Der Zip-Ordner des USB-Power-Delivery-Spezifikationspakets auf der offiziellen Seite hat eine Dateigröße von >42MB. Obwohl ich dieses Thema für sehr interessant halte, habe ich nicht die Zeit, mich in die Einzelheiten zu vertiefen 😅.

Lassen wir also all dieses Zeug hinter uns und versuchen, eine einfach zu implementierende Lösung zu finden.

Beispiel-ASICs

Ich habe willkürlich drei ICs aus dem Internet ausgewählt, die von verschiedenen Firmen angeboten werden, jeweils einen pro Gerätetyp:

Cypress/Infinions CYPD3177, ein USB-PD-Sink-Controller mit Widerstandskonfiguration
STMicroelectronics’ STUSB4500, ein USB-PD-Sink-Controller mit Speicher-Konfiguration
Microchips UPD301C, ein voll programmierbarer USB-PD-Dual-Role-Controller

Ich werde mir zuerst den STUSB4500 genauer anschauen.

Chipkrise / IC-Knappheit

Für die Integration in meinen Entwurf wollte ich einige Muster kaufen. Leider war die Chip-Knappheit so groß, dass keiner der Distributoren, bei denen ich normalerweise Elektronikteile bestelle, für das nächste Jahr welche auf Lager hatte.

Deshalb habe ich mich entschlossen, eine Entwicklungsplatine zu bestellen, auf der der ASIC bereits montiert ist. Das ist zwar 10x teurer als der Chip selbst, aber hier hatte ich keine Wahl.

Integration eines STUSB4500

Der STUSB4500 verwendet den USB-PD-Standard 2.0 - also nicht den neuesten und besten - aber die Abwärtskompatibilität mit späteren Standards macht ihn zu einem schnellen und einfachen Ausgangspunkt. Das Gerät wird mit drei Power Delivery Objects vorprogrammiert:

PDO1 = 5V/1.5A
PDO2 = 15V/1,5A
PDO3 = 20V/1A

Für meine AnywhereAmps Alpha 1.1 evolution 1.2 kann ich das Ding also ohne Neuprogrammierung sofort verwenden. Wenn ich die Power-Delivery-Objekte ändern wollte, würde ich ein Arduino-Board mit I2C verwenden und die STUSB4500-Bibliothek installieren, die z. B. unter Platformio leicht erhältlich ist. Damit könnte ich sogar die programmierbare Stromversorgung von USB-PD 3.0 aktivieren, wenn ich wollte. Mal sehen, wenn ich die Zeit finde, werde ich einen speziellen Blogeintrag für die Programmierung des STUSB4500 vorbereiten.

Einschalten des Verstärkers

OK, also habe ich das Eval-Board an ein 15V-fähiges 30V USB-C-Netzteil angeschlossen. Die violette LED zeigt an, dass 15V auf der Ausgangsschiene verfügbar sind.

Jetzt habe ich meine Verstärkerschaltungen an den Ausgangsklemmen für einen ersten Test angeschlossen. Die STUSB-Auswertungsplatine leuchtet nicht mehr, Verstärker aus. Meh. Wenigstens habe ich einen Hinweis darauf, was die Ursache sein könnte: Es sind wieder kapazitive Einschaltströme! Um Geräte mit großen Kondensatoren mit Strom versorgen zu können, muss ich entweder den Strom im PDO auf abnorm hohe Werte einstellen, oder ich entscheide mich für die Konstruktion einer geeigneten, miniaturisierten Einschaltstrombegrenzerschaltung. Ich habe bereits einen Prototyp aufgebaut, den ich hier vorstelle.

Sollten Sie USB-PD für Ihre Projekte verwenden?

Die Antwort lautet eindeutig “es kommt darauf an”. Obwohl die Möglichkeiten von USB-PD großartig sind, gibt es ein paar Nachteile:

Es wird ein zusätzlicher ASIC mit Peripherie benötigt, um die “Verträge” auszuhandeln. Dies benötigt Platz auf der Leiterplatte und erhöht die Projektkosten erheblich.
Um vollständig abwärtskompatibel zu sein, ist es sinnvoll, einen ASIC zu kaufen, der sowohl den Standard 3.x unterstützt, als auch idealerweise programmierbar ist.
Wenn Sie einen programmierbaren Baustein nehmen, gibt es eine zusätzliche Lernkurve für die Softwareentwicklung, die ASIC-spezifischen Bibliotheken, die Sie verwenden werden, und möglicherweise sogar die Notwendigkeit für Programmierhardware
Sie müssen sicherstellen, dass die Stromversorgung und das Kabel mit den Anforderungen Ihrer USB-PD-Senke kompatibel sind. Zudem sind Kabel für hohe Ströme teuer
Der USB-C-Anschluss ist miniaturisiert. SMD-Löten und Einsteiger-Lötstationen werden wohl nie Freunde werden, daher solltest etwas Erfahrung in diesem Bereich mitgebracht werden.
Hochstecker sind viel einfacher in einem Gehäuse zu montieren als eine Platine mit aufgesetzter USB-C-Buchse, die zudem starken mechanischen Belastungen standhalten muss.

Andererseits ist die Verwendung von USB-PD sehr sinnvoll, wenn

ein mobiles Gerät betrieben werden soll, das mitgenommen oder häufig an verschiedenen Stromquellen betrieben werden soll
die Flexibilität batteriebetriebener Geräte gewünscht ist: Einfach eine kompatible Powerbank anschließen und los geht’s
ohnehin eine Datenverbindung zu Ihrem Gerät benötigt wird
besondere Anforderungen an Ihre Stromversorgung bestehen und ganz bestimmte Spannungen/Ströme geliefert werden sollen
ein einfacher Überstrom- und Überspannungsschutz von Haus aus gewünscht ist

Metabo / Cordless Alliance Systems

Schallbert — Thu, 09 Dec 2021 00:00:00 +0000

Energiequelle für AnywhereAmps

Status quo

Ich habe Metabo / CAS (Cordless Alliance System) Batterien für beide AnywhereAmps Alpha 1. 0 und Alpha 1.1. Letzteres verwendet bereits den Power Supervisor IC MAX17562, der sowohl die Batterie als auch die Schaltkreise vor Verpolung, Überstrom und Unterspannung schützt.

Problem

Obwohl die Verwendung des Power-Supervisor-ICs ein großer Fortschritt war, wäre es noch besser, wenn ich den Ladezustand der Batterie direkt ablesen könnte. Dies würde nicht nur einen sicheren Betrieb gewährleisten, sondern auch ein automatisches Abschalten des Verstärkers ermöglichen, wenn die Batterie schwach wird.

Diskussion mit Metabo/CAS

Metabo logo ^[1]

Deshalb habe ich mich an das Metabo-CAS-Team gewandt und gefragt, ob ich Unterstützung und die Spezifikationen für die Kommunikation mit dem Akkupack bekommen kann. Zu meiner großen Freude reagierten sie sehr schnell, und schon bald befand ich mich in einem Telefongespräch um die Angelegenheit zu klären.

Ergebnis:

Die Verwendung von CAS-Akkus in anderen Geräten als der Elektrowerkzeug-Familien der CAS gilt als “Hack” und wird daher von Metabo nicht genehmigt.
Metabo ist daran interessiert, dass Hersteller von Akku-Werkzeugen ihrer Akku-Allianz beitreten, aber meine Anwendung in einem Verstärker ist einfach zu weit weg (Metabos Slogan war einmal “Work, don’t play”)
Metabo würde von mir erwarten, dass ich mehr als 10.000 Einheiten pro Jahr produziere, bevor ich der Allianz beitreten kann - was einfach unrealistisch ist.
Ich müsse dies verstehen, denn die gemeinsame Nutzung der Spezifikationen und die Erlaubnis, die Schnittstellen zu nutzen, würde einen Teil von Metabos Ressourcen in Anspruch nehmen, während sie keine Rendite erwarten könnten

So enttäuschend 😔 dies auch ist, kam es nicht völlig unerwartet. Der Ingenieur am Telefon nahm sich Zeit für mich. Er sagte mir, dass sie meine Begeisterung für ihre Batteriesysteme sehr zu schätzen wüssten und dass ich mich nicht entmutigen lassen solle.

Nun ja. Sprechen wir über eine

Alternative.

Ich kenne nur einen weiteren Standard, der alle meinen Ansprüchen gerecht zu werden scheint:

Anforderungen

“offen genug” für meinen Gebrauch
sicher
erfüllt die Anforderungen an Spannung und Stromstärke für meinen Zweck
weithin verfügbar

USB-PD logo ^[2]

USB Power Delivery

Der Standard heißt USB Power Delivery. Obwohl ich schon früher darüber nachgedacht habe, wollte ich ihn nie wirklich nutzen, da er einen enormen zusätzlichen Entwicklungsaufwand für mich bedeutet.

USB Power Delivery verwendet ein komplexes Protokoll, um einen “Vertrag” zwischen Quell- und Senkengerät zu schließen. All dies muss designt, ein spezieller IC ausgewählt und Schaltungen müssen dafür entworfen werden, damit es mit meinem Setup funktioniert.

😱 Oh nein, sie sind nicht mehr auf Lager!

Ich werde einen separaten Blog-Beitrag schreiben, sobald ich dieses neue Thema in den Griff bekommen habe.

Konfiguration des IC MAX1756x

Schallbert — Sat, 04 Dec 2021 00:00:00 +0000

Power Supervisor Konfiguration leicht gemacht

Ich verwende MAX17562 ICs in meinem Design für AnywhereAmps Alpha 1.1. Daher habe ich eine kurze Zusammenfassung der MAX1756x-Funktionen und deren Konfiguration erstellt 🙂.

Das Datenblatt ist die Grundlage für alle Informationen, die ich hier bereitstelle. Ich füge lediglich einige Überlegungen zur Gestaltung, Details zu meiner Art der Nutzung und Anwendungsvorschläge hinzu.

Was ist dieser Chip nochmal?

MAX1756x ist ein einstellbarer Überspannungs-/Unterspannungs- und Überstromschutz-IC. Er ist in drei verschiedenen Versionen für die Behandlung von Überstromereignissen erhältlich:

MAX17561: Schaltet sich bei einem Überstromereignis aus und stellt sich nach typischerweise 600ms selbsttätig ab.
MAX17562: Schaltet sich bei einem Überstromereignis ab; Neustart nach Freigabezyklus
MAX17563: Setzt den normalen Betrieb mit aktivem Strombegrenzer fort (führt Wärme ab)

Beide Versionen begrenzen Überstromereignisse auf die konfigurierte Stromgrenze.

Mein MAX1756x-Anwendungstool

Um die Verwendung des Max1756x IC in Ihrer Anwendung zu vereinfachen, können Sie meine Max1756x Kalkulationstabelle verwenden.¹

MAX1756x Strombegrenzer / Überlastdetektor

Courtesy of Maxim Integrated: SETI resistor config ^[1]

Der IC verfügt über einen einstellbaren Strombegrenzer und eine Überstromerkennung (SETI). Wenn der Strom über den SETI-Schwellenwert ansteigt, wird er auf den eingestellten Wert begrenzt. Für MAX17561 und MAX17562: Bleibt diese Bedingung länger als die typische 20.7ms Tastzeit bestehen, schaltet der Baustein den Lastkreis ab. Da der MAX17563 seinen normalen Betrieb fortsetzt, kann seine Verlustleistung irgendwann zu einer Übertemperaturabschaltung führen.

So konfiguriert man den Strombegrenzer / die Überlasterkennung über den Eingang SETI: Einen Widerstand entsprechend der Kurve auf der rechten Seite (aus dem Datenblatt) auswählen und verbinden mit SETI und GND verbinden. Für AnywhereAmps Alpha 1.2 verwende ich einen 3k3-Widerstand, um eine Stromgrenze von ~3.5A zu erreichen.

MAX1756x Unterspannungskonfiguration

Der IC verfügt über eine Unterspannungsabschaltung (UVLO). Wenn die Spannung für etwa 16,7ms unter den UVLO-Schwellenwert sinkt, schalten die Leistungstransistoren des Bausteins den Lastkreis ab. Intern vergleicht der IC die Eingangsspannung am UVLO-Pin mit der Referenzspannung “Vbg = 1,2V”. Um den Schwellenwert für die Unterspannungsabschaltung einzustellen, verwenden Sie einen Spannungsteiler, um den UVLO-Pegel während des normalen Betriebs über Vbg zu halten.

MAX1756x Überspannungskonfiguration

Der IC verfügt über eine Überspannungsabschaltung (OVLO). Wenn die Spannung für etwa 16,7ms über den OVLO-Schwellenwert steigt, schalten die Leistungstransistoren des Bausteins den Lastkreis ab. Die Funktionsweise ist identisch mit der Unterspannungsabschaltung, mit dem einzigen Unterschied, dass die Spannung am OVLO-Pin unter normalen Betriebsbedingungen unter Vbg bleiben sollte.

MAX1756x Verpolschutz

Der Verpolschutz des ICs kann durch Ziehen des *RIEN-Pins nach GND aktiviert werden. Soll diese Funktion genutzt werden ist zu beachten, dass ungepolte Bypass-Kondensatoren am Eingang des ICs verwendet werden müssen. Nutzt man wie ich es getan habe Elkos, so explodieren diese, sollte die Betriebsspannung verpolt werden.

Fehler *FLAG Ausgang

Der MAX1756x zeigt unter den folgenden Bedingungen einen Stromversorgungsfehler über seinen *FLAG-Port an:

Thermische Überlast
Überspannungsereignis definiert durch OVLO
Verpolung: wenn der Verpolschutz *RIEN aktiviert wurde
Überlaststrom, definiert durch SETI

Empfehlung: TVS-Dioden verwenden

Wie das Datenblatt empfiehlt und meine Erfahrung aus früheren Vorfällen zeigt, würde ich 27V Transient Voltage Suppressor diodes parallel zu den beiden Eingangs- und Ausgangsports des MAX1756x verwenden. Sie schützt (alle induktiven) Lastschaltungen vor negativen Spannungsspitzen beim Abschalten und den IC selbst vor Überspannungen beim Anschluss einer spannungsführenden Stromversorgung. Außerdem begrenzt er die Eingangsspannung in umgekehrter Richtung auf unbedenkliche Werte.

Empfehlung 2: Verwenden Sie nicht polarisierte Eingangskondensatoren

Um Probleme beim Neustart des IC zu vermeiden, wenn er an “schwache” Stromversorgungen oder hochohmige Eingangsleitungen angeschlossen ist, sollten größere nicht-polarisierte Eingangskondensatoren als üblich verwendet werden (nein, “100nF” sind eher nicht genug!) - insbesondere, wenn kapazitive oder andere Lasten betrieben werden, die Eingangsstoßströme verursachen.

Für weitere Informationen zur Vermeidung von Problemen in diesem Bereich bitte in meinen Blog-Eintrag über Einschaltstrombegrenzer weiterstöbern.

Zu beachten: Obwohl ich das Datenblatt gründlich gelesen und die Daten sorgfältig hinzugefügt habe, kann ich natürlich keinerlei Garantie für die Ergebnisse übernehmen, die Sie mit diesem Tool erzielen. ↩︎

Einschaltstrombegrenzer - Teil1

Schallbert — Sun, 14 Nov 2021 00:00:00 +0000

Elektronikwissen: Einschaltstrombegrenzer

Your browser does not support the video tag.

Einschaltstrombegrenzer in Aktion.

Was ist das?

Ein Einschaltstrom ist der Stromstoß, der direkt nach dem Einschalten durch einen Stromkreis fließt, bis der Stromkreis seinen stabilen Zustand erreicht hat. Hohe Einschaltströme sind oft unerwünscht, da sie Schaltungsteile überlasten und deren Lebensdauer verkürzen können, elektromagnetische Störungen verursachen und einen kurzzeitigen Spannungsabfall bewirken, der zu ständigen Neustarts eines gesteuerten Geräts wie hier beschrieben oder zu anderem unerwünschten Verhalten führen kann.

Beispiel

Oszillograf: Einschaltstrom einer Lampe mit Glühfaden ^[1]

Glühlampe: Die rosa Linie ist die Ausgangsspannung des Netzteils, die gelbe Linie zeigt den Strom. Man kann erkennen, dass das Netzteil die Ausgangsspannung verringert, um die Stromaufnahme während des Starts zu reduzieren. Nach etwa 100ms stabilisiert sich die Spannung, da der Stromfluss durch die Lampe immer noch ein wenig abnimmt, während der Glühfaden langsam seine Temperatur erreicht.

Hintergrund

Der Glühfaden des Leutmittels wirkt wie ein Widerstand mit positivem Temperaturkoeffizienten (PTC): Bei Raumtemperatur hat er einen sehr niedrigen Widerstand, bei seiner normalen Betriebstemperatur von ~3300K einen viel höheren. Ein kleines Experiment beweist dies: Nehme ich eine “116W”-Halogenglühbirne, so beträgt ihr Widerstand im “eingeschwungenen Zustand” bei 230V etwa $R_{steady} = \frac{U^2}{P} = 456{Ohm}$. Wenn ich den Widerstand der Lampe im kalten Zustand mit einem Multimeter messe, liegt der Wert bei $R_{off} = 38.6{Ohm}$. Während durch die Glühlampe im eingeschalteten Zustand ein Strom von $I_{steady} = 0.5A$ fließt, liegt ihr Einschaltstrom bei etwa $I_{inrush} = 6A$ - also zwölf mal so hoch!

Einschaltstrombegrenzer-Schaltungen

Einschaltstrombegrenzer werden häufig in Geräten mit großen induktiven oder kapazitiven Lasten eingesetzt. Beispiele (Link zu Texas Instruments) sind Transformatoren, Motoren (induktiv), Leistungsverstärker, Schaltnetzteile (kapazitiv) usw.

Es gibt verschiedene Arten von Einschaltstrombegrenzern (TI application note) mit unterschiedlicher Komplexität.

Widerstand mit negativem Temperaturkoeffizient (NTC) / Heißleiter / Thermistor

Ein Einschaltstrombegrenzer als NTC-Widerstand in Reihe zur Last ist die einfachste Schaltung in dieser Aufzählung. Sie besteht aus nur einem zusätzlichen Bauteil. Das Verhalten des NTC-Widerstands gegenüber der Temperatur ist dem des obigen Glühbirnenbeispiels entgegengesetzt: Sein Widerstand nimmt mit steigender Temperatur ab, so dass mehr Strom durch den Stromkreis fließen kann.

Bei den meisten NTCs verhält sich der Widerstand logarithmisch zur Temperatur, er sinkt also sehr stark bei zunehmender Temperatur. So kann er Einschaltstrompulse sehr effektiv unterdrücken. Nachteilig ist der Eigenenergiebedarf, der den Widerstand auf Betriebstemperatur hält. Diese Schaltung wird dort verwendet, wo geringe Kosten wichtig sind, das System einfach gehalten werden soll und der zusätzliche Energieverbrauch kein Problem darstellt.

Widerstand mit Bypass-Relais

Diese Schaltung vermeidet die Nachteile eines zusätzlichen Serienwiderstands zur Last durch Hinzufügen eines Leistungswiderstands und eines Relais. Sie wird typischerweise in Gleichstromversorgungen mit hoher Leistung oder empfindlichen Geräten wie Verstärkern verwendet. Der Relaiskontakt ist im unbestromten Zustand offen und parallel zum Leistungswiderstand verdrahtet, der je nach Last einen Wert von typischerweise “1…22 Ohm” hat. Dahinter wird die Last angeschlossen, die den Einschaltstrom verursacht. Für dieses Beispiel nehme ich die Glühbirne eines Autos als Last. Beim Einschalten des Geräts begrenzt der Widerstand den Stromkreis und die Spannung auf der Lastseite steigt allmählich an. Sobald die Spannung an der Basis des NPN-“BC337”-Transistors hoch genug ist, schaltet er sich ein und lässt Strom durch die Relaisspule fließen, die dann den Leistungswiderstand kurzschließt, so dass die Last ihren Nennstrom ziehen kann.

Die Werte von R2, R3 hängen von der Spannung hinter R1 ab, wenn sich die Schaltung bei ausgeschaltetem Relais im eingeschwungenen Zustand befindet. Des Weiteren ist die Charakteristik des Transistors und der Betriebsstrom der Relaisspule zu berücksichtigen. In meinem Beispiel wählte ich R2 = 1kOhm, da der Transistor ~40mA für den Betrieb des Relais durchlassen muss. Diesen Wert habe ich dem Datenblatt des BC337, Parameter Stromverstärkung, entnommen. Da ich das Relais nicht zu früh schalten lassen wollte, habe ich R3 hinzugefügt. Je höher sein Widerstand, desto früher wird das Relais aktiv. Ein zu geringer Widerstand hingegen reduziert die Basisspannung des BC337 so weit, dass er das Relais nicht mehr treiben kann - hier muss ein wenig experimentiert werden.

In diesem Anwendungsbeispiel für den “Soft Start” eines Ringtrafos (Elektronik-Kompendium) kommt eine ähnliche Schaltung zum Einsatz.

Und so verhält sich der Schaltkreis in der Realität:

Ich habe mir die Freiheit genommen, einen Schalter hinzuzufügen, damit die Steuerung der Stromversorgung für mich bequemer wird. Das Relais ist mit einer Freilaufdiode ausgestattet, um den Transistor vor negativen Spannungsspitzen zu schützen.

Das Problem des Einschaltstroms ist tatsächlich gelöst. Der Vergleich (gelbe Linie) zeigt einen ungeregelten Einschaltstrom von 3.5A, während der Begrenzer ihn auf 0.8A reduziert, was nur knapp über dem Nennstrom liegt. Ein Leistungswiderstand mit kleinerem Wert hätte diesen Strom noch weiter reduziert.

Die grüne Linie zeigt die Basisspannung des BC337 an. Man erkennt, dass sie langsam ansteigt (die Genauigkeit des Oszilloskops ist bei 40VPP nicht die beste) und das Relais einschaltet, wenn sich der Stromfluss (gelbe Linie) stabilisiert hat.

Sanftanlauf / konfigurierbare Strombegrenzung

Es gibt spezielle ICs, die den Sanftanlauf eines Systems unterstützen, je nach

Leistungsbedarf
Hochlaufzeit
Beschränkungen der Anstiegsgeschwindigkeit
Maximalstrom

Darüber hinaus gibt es verschiedene Arten von Einschaltstrombegrenzern, die je nach Anwendung ausgewählt werden können:

Zeitgesteuert: Das System wird nach einer bestimmten Zeit vollständig eingeschaltet (einfach, aber dumm)
Spannungsgesteuert: Das System wird oberhalb eines Spannungsauslösepegels vollständig eingeschaltet (immer noch einfach, mittlere Kosten)
Stromgesteuert: Begrenzt den Systemstrom oder schaltet das System auf der Grundlage eines Stromauslösepegels vollständig ein (wahrscheinlich teurer) Hinsichtlich der Anforderungen des Systems muss dann ein passender IC gewählt werden. Typische Namen sind hier Power Supervisors, IC soft starter, Supervisor & Reset IC oder ähnlich. Sie können intern sogar mit Leistungstransistoren ausgestattet sein und selbsttätig schalten, wie z.B. MAX17562 (Analog Devices) für meine Evolution von AnywhereAmps.

Weiterlesen: Einschaltstrombegrenzer - Teil2

TVS-Dioden

Schallbert — Sat, 13 Nov 2021 00:00:00 +0000

Elektronikwissen zur TVS-Diode

Was ist das?

Eine Transient voltage suppressor diode schützt eine Schaltung vor Spannungsspitzen, die deutlich über der Nennspannung des Schaltkreises liegen. Sie sind für verschiedene Auslösespannungen und Ableitströme verfügbar. Zudem gibt es unterschiedliche Typen, wovon einige sogar sowohl vor positiven als auch vor negativen Spannungsspitzen schützen können.

Unterschiede zwischen TVS- und Zenerdioden

Wie Zener-Dioden, werden TVS-Dioden in Sperrrichtung eingebaut. Sie haben sogar dasselbe Symbol.

Doch währen Zenerdioden ihren Arbeitspunkt sehr nahe der Durchbruchspannung haben, werden TVS-Dioden üblicherweise weit darunter betrieben. Somit schließen sie Überspannungsspitzen kurz (Link zu Toshiba) auf für den Schaltkreis ungefährliche Spannungen und sind dafür ausgelegt, sehr hohe Pulsströme ableiten zu können.

Abgrenzung zwischen TVS- and Schottkydioden

Das Symbol für Schottkydioden unterscheidet sich nur geringfügig von Zener/TVS-Dioden. Sie haben in der Regel eine niedrigere Durchlassspannung als ihre Siliziumpendants und sind für ihre schnelle Schaltgeschwindigkeit bekannt. Deshalb werden sie neben Gleichrichterschaltungen auch häufig in Verpolungsschutzschaltungen eingesetzt. TVS-Dioden haben das gleiche schnelle Schaltverhalten und die niedrige Vorwärtsspannung, aber im Gegensatz zu Schottkys haben sie einen genau definierten Schwellenwert für die Sperrspannung und vertragen besonders hohe Pulsströme.

Auswahl der richtigen TVS-Diode

Für Gleichstromanwendungen sollte eine unidirektionale TVS-Diode verwendet werden. Ihre Durchbruchspannung ist so zu wählen, dass sie etwas über der normalen Betriebsspannung liegt. Des Weiteren ist die Klemmspannung relevant, die weiter “unten” auf der Linie des zugehörigen Diagramms abzulesen ist. Liegt sie immer noch unter den “absoluten Maximalwerten” Ihrer zu schützenden Schaltung Schaltung? Wenn nicht ist eine andere TVS-Diode zu wählen oder ein Kompromiss bei der Spannung einzugehen (dabei nicht die Durchbruchspannung des TVS überschreiten). Alternativ kann auch eine andere Vorrichtung zur Unterdrückung von Spannungsspitzen wie einen spannungsabhängiger Widerstand oder ähnliches verwendet werden.

Strom/Spannungs-Diagramm einer typischen TVS-Diode ^[1]

Power supervisor MAX1756x bei kapazitiver Last

Schallbert — Tue, 02 Nov 2021 00:00:00 +0000

Argh, ich habe Teile meiner Power&Preamp Schaltung für AnywhereAmps Alpha hochgejagt. Beim Testen.

Vorfall

Ich habe versehentlich VBat und GND auf meiner Platine vertauscht. Man sollte meinen, dass so etwas gar nicht passiert, doch ich muss nicht richtig aufgepasst haben. Der Kondensator für Entkopplung der Spannungseingangs explodierte sofort, aber mein Supervisor-Chip schützte den Rest der Schaltung.

Reparatur und Tests

Nach der Reparatur mit einem Keramikkondensator habe ich einige Tests durchgeführt.

Verpolungstest - BESTANDEN
Harter Kurzschluss gegen Masse - BESTANDEN
Unterspannungsabschaltung - BESTANDEN
Wiederholung der normalen Spannung - …

Unregelmäßigkeit

Als ich dann aber die Spannung langsam erhöhte, um die Unterspannungssperre zu umgehen, ließ sich das System nicht einschalten. Der Stromverbrauch stieg aber trotzdem an. Zur Analyse schloss ich ein Oszilloskop an, um zu sehen, was vor sich ging. Man kann sehen, dass die Kapazität der Endstufe (>1400µF) wie ein weicher Kurzschluss gegen Masse wirkt, so dass die Versorgungsspannung innerhalb von 50µs um 2V auf den Auslösepegel der Unterspannungsabschaltung abfällt. Der Supervisor-IC schaltet dann die Last ab, so dass die Versorgungsspannung wieder ansteigt. Ich vermute, dass der Regler des Netzteils deswegen so komische Geräusche macht.

Nach Ablauf der Wartezeit nach Abschalten durch Fehler (Datenblatt MAX1756x) versucht er erneut, sich einzuschalten, und der ganze Vorgang beginnt von vorne.

Vorfall #2

Als ich die Spannung an der VCC-Schiene, die den Vorverstärker, die Endstufe und den 9-V-Spannungsregler versorgt, während des erfolglosen Einschaltens gemessen habe, war mir aufgefallen, dass negative Spannungsspitzen bei etwa -4V auftreten, wenn das Supervisor-IC abschaltet. Dies wird durch die Induktivitäten in den Versorgungsleitungen der Endstufe verursacht. Während ich mich noch wunderte, dass diese ständigen Resets nicht gut sein könnten, explodierte mein Vorstufen-IC. Doof.

Was ich gelernt habe

Niemals einen gepolten Kondensator als Masse/Bypass “vor” den Schutzschaltungen verwenden!
Bypass-Kondensatoren größer als 100nF direkt an Spannungsdetektoren verwenden, wenn die geschalteten Lasten kapazitiv sind. Sie helfen, die Spannung lokal zu stabilisieren und wiederkehrende Neustarts zu vermeiden.
Zum Schutz der Ausgangsseite eines Leistungsschalters eine Schottky- oder TVS-Diode (Transient Voltage Suppressor) hinzufügen, die potenziell schädliche Spannungen abfangen kann.
Vorsichtshalber den Einschaltstrom (Folgeartikel) begrenzen. Bei der nächsten Überarbeitung der Schaltung werde ich auf MAX17563 umsteigen. Er hat eine programmierbare Strombegrenzung, damit die Eingangsspannung gar nicht erst zu niedrig wird.

Schutz vor negativen Spannungsspitzen

Für meine Anwendung reicht eine schnell schaltende Klemmdiode in Schottky-Bauweise aus, da die Schaltung hinter dem MAX1756x-IC keine Überspannungsspitzen, sondern nur Rückwärtsspannungsspitzen (aufgrund der Induktivitäten im Schaltregler- und Verstärkerdesign) abbekommen wird. In diesem Artikel, erkläre ich Transient Voltage Suppressors im Detail.

Videos mit dem VLC player konvertieren

Schallbert — Wed, 27 Oct 2021 00:00:00 +0000

Website: Medienerstellung

Für diese Website habe ich viele Mediendateien konvertiert. Die selbstgemachten Fotos sind sehr groß, was zu langen Ladezeiten der Seite und bildschirmfüllenden Bildern führt. Während es recht einfach ist, ihre Größe zu reduzieren und die JPEG-Komprimierung zu erhöhen, ist dies bei Videos schwieriger.

Das Problem

Hä, VLC?! Ich verwende den beliebten vlc player und irgendwie habe ich einige Grundkonzepte nicht richtig verstanden. Entweder wird mein Video nicht wie geplant in Graustufen angezeigt, die Ausgabedatei ist leer (Verwendung von H.264 statt H.265 behebt das Problem), das Seitenverhältnis scheint verzerrt zu sein, oder das Video hat sich plötzlich gedreht, was ich weder wollte noch erwartet habe.

In diesem Beitrag

Eine Reihe von Schritten hilft mir, wie man einfache Aufgaben zur Konvertierung und rudimentäre Bearbeitung von Videos mit vlc umsetzt.

Wie funktioniert das mit den Filtern?

Vorschau der Filter

VLC verfügt über eine Schnellvorschau für die gängigsten Filter im Menü “Werkzeuge -> Effekte und Filter”. Dies wirkt sich direkt auf das Video aus, das Sie ansehen, aber nicht auf Ihre gespeicherte Datei. Sie dient lediglich dazu, eine Vorschau zu erstellen und die Auswirkungen dieser Filter auf Ihr Video zu kontrollieren. In diesem VideoProc-Blogeintrag finden Sie ausführliche Anleitungen - und, was noch wichtiger ist, viele Bilder, die Sie dabei unterstützen. Für die ungeduldige Fraktion: weiterlesen 😉

Gefiltertes Video in Datei speichern

Um einen Filter zu speichern, den Sie für Ihre Vorschau ausgewählt haben, müssen Sie ihn zum Konvertierungsprofil hinzufügen. Solange sie angekreuzt bleiben, wird jedes Speichern mit diesem Profil Ihr Video verändern, auch wenn Sie alle Änderungen, die Sie in der Vergangenheit an den Vorschaufiltern vorgenommen haben, rückgängig gemacht haben!

Wie kann ich die Farben in meinem Video ändern?

Öffnen Sie die Videodatei, die Sie ändern möchten.
Klicken Sie auf “Werkzeuge -> Effekte und Filter” (oder drücken Sie “Strg+E”)
Es öffnet sich ein Dialogfeld mit drei Registerkarten. Wählen Sie die Registerkarte “Videoeffekte”.
Markieren Sie unter “Essentials” die Option “Bildanpassung”.
Nehmen Sie Ihre Änderungen vor und klicken Sie auf “Speichern” und dann auf “Schließen”. Eine Vorschau des Effekts wird im Hauptfenster angezeigt.
Öffnen Sie die Wiedergabelistenansicht durch Drücken von “Wiedergabeliste umschalten” (Strg+L).
Klicken Sie mit der rechten Maustaste auf Ihr Video und wählen Sie “Speichern…” im Kontextmenü.
Drücken Sie das Schraubenschlüssel-Symbol “Ausgewähltes Profil bearbeiten” und wählen Sie auf der Registerkarte “Videocodec” die Unterregisterkarte “Filter”.
Markieren Sie den Filter “Bildeigenschaften”. Dadurch wird Ihre Änderung durchgeführt, sobald Sie Ihre Datei speichern.
Geben Sie eine Zieldatei ein und klicken Sie auf “Start”.
Vergessen Sie nicht, den Filter “Bildeigenschaften” in Ihrem Profil zu deaktivieren, wenn Sie damit fertig sind. Nehmen Sie auch die Änderungen zurück, die Sie auf der Registerkarte “Videoeffekte” vorgenommen haben (Schritt 4).

Wie drehe ich mein Video?

Öffnen Sie die Videodatei, die Sie ändern möchten.
Klicken Sie auf “Werkzeuge -> Effekte und Filter” (oder drücken Sie “Strg+E”)
Es öffnet sich ein Dialogfeld mit drei Registerkarten. Wählen Sie die Registerkarte “Videoeffekte”.
Wählen Sie unter “Geometrie” die Option “Transformieren”.
Nehmen Sie Ihre Änderungen vor und klicken Sie auf “Speichern” und dann auf “Schließen”. Eine Vorschau des Effekts wird im Hauptfenster angezeigt.
Öffnen Sie die Wiedergabelistenansicht durch Drücken von “Wiedergabeliste umschalten” (Strg+L).
Klicken Sie mit der rechten Maustaste auf Ihr Video und wählen Sie “Speichern…” im Kontextmenü.
Drücken Sie das Schraubenschlüssel-Symbol “Ausgewähltes Profil bearbeiten” und wählen Sie auf der Registerkarte “Videocodec” die Unterregisterkarte “Filter”.
Markieren Sie den Filter “Videotransformation”. Dadurch wird Ihre Änderung durchgeführt, sobald Sie Ihre Datei speichern.
Geben Sie eine Zieldatei ein und klicken Sie auf “Start”.
Vergessen Sie nicht, das Häkchen beim Filter “Bildeigenschaften” in Ihrem Profil zu entfernen. Nehmen Sie auch die Änderungen zurück, die Sie auf der Registerkarte “Videoeffekte” vorgenommen haben.

Wie kann ich mein Video zuschneiden?

Öffnen Sie die Videodatei, die Sie ändern möchten.
Klicken Sie auf “Werkzeuge -> Effekte und Filter” (oder drücken Sie “Strg+E”)
Es öffnet sich ein Dialogfeld mit drei Registerkarten. Wählen Sie die Registerkarte “Videoeffekte”.
Spielen Sie unter “Zuschneiden” mit den Pixelwerten herum und beobachten Sie das Vorschaufenster genau, bis Sie mit dem Zuschnitt zufrieden sind. Notieren oder merken Sie sich die Einstellungen, die Sie anwenden möchten. Schließen Sie den Dialog.
Klicken Sie auf “Werkzeuge -> Voreinstellungen” (oder drücken Sie “Strg+P”)
Wählen Sie auf der Registerkarte Interface (Start) die Optionsschaltfläche Show Settings - All.
Scrollen Sie nach unten zum Element “Video” und öffnen Sie “Filter”.
Wählen Sie den “Video-Zuschneidefilter”.
Suchen Sie das Element Cropadd in der Filterliste auf der linken Seite. Geben Sie die Werte ein, die Sie sich in der Vorschau gemerkt/aufgeschrieben haben. Klicken Sie auf “Speichern”.
Öffnen Sie die Wiedergabelistenansicht, indem Sie auf “Wiedergabeliste umschalten” (Strg+L) drücken. Klicken Sie dann mit der rechten Maustaste auf Ihr Video und wählen Sie “Speichern…” aus dem Kontextmenü.
Drücken Sie das Schraubenschlüssel-Symbol “Ausgewähltes Profil bearbeiten” und wählen Sie auf der Registerkarte “Videocodec” die Unterregisterkarte “Filter”.
Aktivieren Sie den Filter “Videoschnitt”. Dadurch wird die Änderung durchgeführt, sobald Sie Ihre Datei speichern.
Geben Sie eine Zieldatei ein und klicken Sie auf “Start”.
Vergessen Sie nicht, das Häkchen bei “Video-Zuschnittfilter” in Ihrem Profil zu entfernen. Nehmen Sie auch die Änderungen zurück, die Sie in den Einstellungen unter “Filter” vorgenommen haben.

Wie kürze ich mein Video?

Hinweis: Eine ausführlichere Version dieses Themas findet sich in diesem Beitrag von movavi.

Öffnen Sie die Videodatei, die Sie ändern möchten.
Zeigen Sie die Schaltfläche “Aufnehmen” im VLC Player an (markieren Sie “Ansicht->Erweiterte Steuerelemente”).
Springen Sie an die Stelle, an der das geschnittene Video beginnen soll.
Drücken Sie die rote Schaltfläche “Aufnehmen”.
Spielen Sie die Videosequenz ab. Halten Sie an der Stelle an, an der der Zuschnitt enden soll.
VLCs Standardspeicherort für die Videoausgabe: C:\Benutzer\Benutzername\Video

Wie ändere ich die Videoauflösung?

Öffnen Sie die Videodatei, die Sie ändern möchten.
Öffnen Sie die Wiedergabelistenansicht, indem Sie “Wiedergabeliste umschalten” (Strg+L) drücken. Klicken Sie dann mit der rechten Maustaste auf Ihr Video und wählen Sie “Speichern…” aus dem Kontextmenü.
Drücken Sie das Schraubenschlüssel-Symbol “Ausgewähltes Profil bearbeiten” und wählen Sie auf der Registerkarte “Videocodec” die Unterregisterkarte “Auflösung”.
Geben Sie die Videogröße ein, in die Sie konvertieren möchten, und klicken Sie auf “Speichern”.

Meine Platinen sind angekommen!

Schallbert — Sat, 16 Oct 2021 00:00:00 +0000

Fortsetzung des Artikels PCB Hardware Design

Lieferung

Nach weniger als zwei Wochen sind meine Platinen endlich angekommen. Zusammen mit allen Teilen, die zum Löten benötigt werden. Ich finde, sie sehen wunderschön aus 🙂

Löten: Schritt-für-Schritt

Ich beschloss, die Platine in Abschnitten zu löten, beginnend mit dem Stromversorgungsbereich. Auf diese Weise kann ich die Abschnitte unabhängig voneinander testen und gegebenenfalls Fehler korrigieren. Der SOIC (Small Outline Integrated Circuit)-Umriss kann immer noch leicht von Hand gelötet werden, wenn man viel Flussmittel und eine Lupe für die optische Inspektion verwendet. Das einzige Problem war, dass der IC ein “exponiertes Pad” hat, d.h. es gibt eine Massefläche an der Unterseite des ICs zur besseren Wärmeableitung. Das zu löten war ein Albtraum. Schließlich gelang es mir, durch eine der unteren Durchkontaktierungen zu löten, während ich den Lötkolben fast eine Minute lang an einer anderen Durchkontaktierung hielt, bis es endlich klappte. Mit dem Ergebnis bin ich aber sehr zufrieden. Das System kann durch Ziehen von *HVEN nach Masse aktiviert werden, wodurch die LED aufleuchtet. Die Tests auf Unterspannung/Kurzschluss verliefen sehr gut - der Akku ist jetzt geschützt.

Auch die Vorverstärkersektion war leicht zu löten. Nur die gepolten Kondensatoren erwiesen sich als so groß, dass sie einen großen Teil des Lötpads verdeckten - das ist ein Problem, weil das Lötzinn nicht sowohl Kondensator als auch Pad verbinden wollte, sondern nur an einem der beiden Kontakte hängen blieb. Ich half schließlich mit einem winzigen Stück Brückendraht nach.

Der 9V-Schaltregler-Teil - nun ja… Ich habe es überhaupt nicht geschafft, ihn von Hand zu löten. Quadruple Flat Packs ohne Pins (QFN) sind schon schwer genug zu löten. Aber dieses Teil hier hat auch noch ein freiliegendes Pad auf der Unterseite und ich musste viel Massefläche vorhalten, um die Hitze von diesem Bauteil weg zu bekommen. Also konnte ich nicht einmal die Temperatur für den Lötvorgang hoch genug bekommen. Also habe ich mir eine Heißluftstation geliehen, und nach einigen ängstlichen Versuchen und dem Ertränken der Komponenten in Flussmittel habe ich es schließlich geschafft.

Mit einem Makro-Objektiv auf meiner Kamera habe ich die Lötstellen dann geprüft.

Funktionstest

Ich habe einen Tiefpass und einen Hochpass in das Design eingebaut, um 2-Wege-Lautsprechersysteme zu unterstützen. Um die drei Vorverstärkerausgänge (Fullrange, Tiefpass, Hochpass) zu testen, habe ich den Vorverstärker direkt an meinen Lautsprecher angeschlossen. Das ist keine gute Idee, denn die Impedanz des Lautsprechers ist viel niedriger als die des OP-Verstärkers, so dass die Ausgangsleistung sehr gering ist. Außerdem verbrauchen die unteren Frequenzen die meiste Leistung, so dass der Klang, den man hört, bereits ein “Hochpass” ist und die Lautstärke des Tiefpasses wesentlich geringer ist. Trotzdem funktioniert es, und ich kann die Verstärkung wie vorgesehen einstellen.

Your browser does not support the video tag.

Preamp test

Das war alles, mein Design funktioniert! Da das alles quelloffen ist, steht es jedem frei zum Download auf meinem Github Repo zur Verfügung.

Lektionen

Hier sind die Designfehler, die in Revision2 korrigiert werden sollten:

Alle Komponenten in der gleichen Ausrichtung platziert werden (z.B. horizontal)
“Thermische Entlastungen” (kurze Abschnitte, an denen die Leiterplan einen geringeren Querschnitt aufweist) sollten häufiger verwendet werden, um Lötprobleme aufgrund von zu starker Wärmeleitung zu vermeiden.
Freiliegende Pads: Beim Handlöten müssen die entsprechenden Lötpads zu den Seiten des ICs hin erweitert werden, um die Wärmeleitung des Lots zu verbessern
QFN-Fußabdrücke sind beim Handlöten falls möglich zu vermeiden. Sie sind lästig.
Wenn möglich, keine Bauteile mit “exposed pad” oder “power pad” verwenden. Eine Heißluftstation könnte ansonsten unumgänglich werden.
Schön viel Platz zwischen den Bauteilpads lassen, vor allem bei horizontaler Anordnung.
Da SMD-Kondensatoren mehr Höhe haben, sollten Sie größere Lötpads vorsehen.

Arbeitsabläufe mit FreeCAD

Schallbert — Tue, 12 Oct 2021 00:00:00 +0000

Motivation

FreeCad logo ^[1]

Ich habe gerade eine zweite Bestellung für AnywhereAmps Alpha erhalten. Mein erster Prototyp hat bereits ein neues Zuhause, also werde ich mindestens drei weitere Exemplare bauen. Alle Holzarbeiten, die von Hand ausgeführt werden, würden 4-5 Stunden pro Exemplar in Anspruch nehmen, also habe ich mich entschlossen, sie auf den eigentlichen Bauprozess zu beschränken, der - hoffentlich - nur eine Stunde dauert. Dies möchte ich erreichen, indem ich die Holzteile mit einer CNC-Maschine fräsen lasse.

CAD-Werkzeug

Eine solche Maschine würde die Pläne, die ich von Hand skizziert habe, nicht verarbeiten. Also musste ich mich mit einer Software vertraut machen, die 2D-Skizzen in ein 3D-Modell umwandeln kann, und schließlich mit einem weiteren Werkzeug, das die Komponenten des 3D-Modells in eine Bahnsteuerung für die CNC-Maschine übersetzt, mit der ich meine Teile fräsen will. Für die 3D-Arbeiten habe ich die Software FreeCAD gewählt.

Aller Anfang ist schwer

Aber FreeCAD ist… naja, ich bin halt kein CAD-Designer oder Maschinenbauingenieur. Daher ist der Einstieg in dieses Tool für mich ziemlich schwierig. Glücklicherweise gibt es einige gute Tutorials wie dieses: youtube link, dennoch habe ich einige Stunden gebraucht, bis ich mein erstes Teil gezeichnet hatte. Außerdem ist das, was auf dem Bild rechts zu erkennen ist, noch lange nicht der fertige Entwurf.

FreeCAD Arbeitsablauf

FreeCAD ist meiner Meinung nach (Stand Ende 2021) kein selbsterklärendes Werkzeug. Es ist sehr vielseitig und daher komplex und umfangreich. Da ich es zum Zeichnen von 3D-Teilen und/oder zur G-Code-Generierung verwenden möchte, werde ich nur eine Handvoll seiner Arbeitsbereiche benötigen.

Natürlich können die folgenden Zeilen nicht mehr als eine Schnellstartanleitung sein. Es gibt tonnenweise hilfreiches Material wie ein FreeCad Wiki, ein Forum, und viele, viele Tutorial-Videos usw., die die Dinge besser und ausführlicher erklären als ich es kann. https://wiki.freecad.org/Getting_started

Erst die Abmessungen - das Modul “Spreadsheet”

Schaffen wir zuerst einen zentralen Ort, an dem wir alle Maße unseres Projekts aufbewahren. Wir werden sie später in den Zeichnungen, 3D-Modellen und Baugruppen verknüpfen, so dass sich geänderte Werte in der Kalkulationstabelle automatisch auf alles andere angewendet werden (für mich übrigens der Vorteil dieses CAD-Programms gegenüber vielen anderen, bei denen quasi von Vorn begonnen werden muss, wenn man die Größe des Bauteils anpassen möchte).

Wählen Sie das Modul “Spreadsheet” an. Erstellen Sie ein Arbeitsblatt und benennen Sie es z. B. in “Abmessungen” um.
Tragen Sie Namen Ihrer Dimensionen ein. Ich habe festgestellt, dass es gut lesbar ist, wenn Sie für jede Dimension die Namenskonvention Teil_Beschreibung_Attribut verwenden.
Nachdem Sie den Wert Ihrer Dimension eingegeben haben, klicken Sie mit der rechten Maustaste auf die Zelle und wählen Sie “Eigenschaften”.
Im folgenden Dialog wählen Sie die “Alias”-Leiste und geben den Namen des Maßes dimensionName ein.
Nun sind Sie in jeder Skizze in der Lage, diese Maße unter ihrem Alias auszuwählen. Klicken Sie “Save”, um den Dialog zu schließen.

Skizze anfertigen - scetcher in der “Parts Design Workbench”

Nun erstellen wir die erste Skizze des Teils, wobei die soeben erstellten Maße verwendet werden. Am besten beginnt man mit sogenannten Master-Skizzen, die alle Elemente einer Zeichnung in einer bestimmten Ansicht, z.B. auf der XY-Ebene, enthalten. Von ihnen werden dann die für dreidimensionale Modelle erforderlichen Grundriss-Skizzen der jeweiligen Achsenpaare abgeleitet.

Aktivieren Sie das Konstruktionsmodul “Part Design”.
Erstellen Sie einen neuen Körper mit dem blauen Baustein-Symbol.
Erstellen Sie eine neue Skizze für diesen Körper mit dem Skizzen-Symbol. Wählen Sie z.B. die XY-Ebene.
Benennen Sie Ihre Skizze um, damit Sie sich ihren Zweck leicht merken können. Da Ihre ersten Skizzen die “Master”-Skizzen sind, schlage ich vor, sie “Master_IhrTeilename_xy” zu nennen.
Doppelklicken Sie auf die Skizze und beginnen Sie mit dem Zeichnen Ihrer Formen.
Stellen Sie sicher, dass Sie Ihre Skizze vollständig definieren (youtube link). Verwenden Sie die Abmessungen, die Sie in die Kalkulationstabelle eingegeben haben, als Hilfe: Doppelklicken Sie auf Ihre Maßeinschränkung und geben Sie “=” ein oder drücken Sie die kleine runde Schaltfläche “fx”. Geben Sie den Namen Ihrer Kalkulationstabelle ein (zum Glück gibt es hier die Autovervollständigung) und dann den Alias der Dimension, die Sie in der Definition widerspiegeln wollen.
Wiederholen Sie diesen Vorgang für jede Bemaßungsabhängigkeit Ihrer Zeichnung.

Mit Ihren fertigen Master-Skizzen (je eine für jede Achsenkombination) stehen alle Informationen für jeden Drittanbieter zur Verfügung, der Ihre Teile fertigen kann. Wenn Sie das tun möchten, können Sie Ihre Skizzen hier in DXF-Dateien exportieren, und schon sind Sie fertig. Andernfalls: Lesen Sie unten weiter.

3D-Teile erstellen - Teile Design Workbench

Um ein echtes 3D-Teil aus Ihren Master-Skizzen zu erstellen, müssen Sie davon abgeleitete Skizzen erstellen, die extrudiert oder ausgeschnitten werden können. Sie müssen zunächst verstehen, wie FreeCAD Teile und Skizzen baumartig ausrichtet: Jedes extrudierte (3D)-Teil hat eine zugrunde liegende Skizze, die definiert, wie es aussieht. Seine Extrusionsrichtung hängt direkt von der Ebene der Skizze ab. Jedes Teil kann eine oder mehrere Bezugsebenen haben, an denen andere Teile befestigt werden können, die wiederum Teile, Löcher oder Taschen auf dieser spezifischen Fläche bilden.

FreeCAD zeigt nur das “letzte” Mitglied des Bauteilbaums an, das alle abhängigen Teile enthält, die Sie zuvor entworfen haben. Um die Sichtbarkeit umzuschalten, drücken Sie einfach die Leertaste.

Erstellen Sie eine neue Skizze in der Baumstruktur Ihres Teils. Dies wird Ihr erstes “Pad” sein, d.h. Ihr eigentliches 3D-Teil.
Wählen Sie das Werkzeug create an edge linked to an external geometry (Hotkey “X”) und wählen Sie das Basisteil Ihrer ursprünglichen Master-Skizze aus.
Zeichnen Sie Ihre Form so, dass sie mit dieser Form übereinstimmt, und legen Sie ihre Maße fest, wiederum unter Verwendung der zuvor erstellten Bemaßungstabelle. Sie sollten dies jedoch nicht allzu oft benötigen, da Sie alle möglichen Kanten, die Sie finden konnten, bereits mit Ihrer Musterskizze verknüpft haben.
Jetzt kommt der spaßige Teil: Schließen Sie die Skizze, klicken Sie dann auf das Symbol pad a selected sketch und geben Sie die gewünschte Höhe des Teils ein.
Das war’s!
Um ein weiteres Teil, eine Tasche oder ein Loch auf einer der Flächen Ihres Teiles zu erstellen, erstellen Sie zunächst eine neue Skizze und geben Sie ihr einen aussagekräftigen Namen. Klicken Sie dann auf die Fläche, auf der diese Skizze basieren soll. Wählen Sie schließlich das Werkzeug set the Support of a scetch und wählen Sie die zuvor erstellte Skizze aus. Wiederholen Sie den Vorgang ab Schritt 2, bis Ihr Teil vollständig ist.

Hm, Ihr neues Teil sitzt direkt auf dem Master-Sketch, so dass Sie es nicht mehr sehen können? Keine Panik, lesen Sie einfach weiter.

3D-Teile anordnen - das Modul “Draft”

Meiner Meinung nach ist es sehr mühsam, Teile in der Konstruktionswerkbank neu anzuordnen. Es wird viel einfacher, wenn Sie die Werkbank “Entwurf” (Draft) für diese Aufgabe verwenden. Auch hier können Sie Teile einfach klonen und nach Ihren Vorstellungen anordnen.

Aktivieren Sie das Modul “Draft”.
Wählen Sie das Pad/Teil, an dem Sie zuvor gearbeitet haben, im Teilebaum aus.
Klicken Sie auf das Schaf-Symbol, um Ihr Teil zu klonen.
Machen Sie das ursprüngliche Pad unsichtbar, indem Sie die Leertaste drücken, während das Teil aktiv ist.
Wählen Sie das geklonte Teil aus und benennen Sie es sinnvoll um, z.B. derGerät_part.
Wählen Sie das “Verschieben”-Symbol (im obigen Bild grün markiert).

Eine Verschiebe-Operation besteht aus zwei Schritten: Zuerst müssen Sie die Referenzposition für Ihre Verschiebung eingeben. Entweder wählen Sie den Punkt aus, indem Sie irgendwo in der 3D-Ansicht klicken und dann den Cursor ein wenig bewegen (meine Empfehlung), oder Sie geben den Bezugspunkt in die Felder auf der linken Seite ein und bestätigen jede Achse mit “Enter”. Der zweite Schritt ist die eigentliche Bewegung gegenüber Ihrem Referenzpunkt. Ich empfehle, diese Werte mit der Tastatur einzugeben, da es unglaublich schwierig ist, mit der Maus eine exakte Position anzufahren. Bestätigen Sie mit “Enter”, und die Verschiebung sollte abgeschlossen sein.

Cool, jetzt haben Sie ein Bemaßungsblatt, Master-Skizzen, die Ihre Teile vollständig spezifizieren, die Teile selbst als 3D-Körper und das alles ordentlich sortiert in Ihrer Ansicht!

TechDraw: Erstellen Sie eine klassische “Papier 2D” Zeichnung als PDF

Abschließend möchten Sie vielleicht eine klassische 2D-Zeichnung Ihres Teils exportieren? Zum Glück ist keine schwere Aufgabe.

Aktivieren Sie das TechDraw-Modul.
Drücken Sie das Symbol “Standardseite einfügen”.
Wählen Sie im Teilebaum das 3D-Teil aus, das Sie zeichnen lassen möchten.
Drücken Sie auf das Symbol “Mehrere Ansichten von zeichnungsfähigen Objekten einfügen” und wählen Sie die Ansichten aus, die vorhanden sein sollen.
Fügen Sie mithilfe der Symbolleiste Maße, Anmerkungen usw. hinzu.
Verwenden Sie die Funktion “Ansichtsrahmen ein-/ausschalten”, wenn sich Ihre Geometrien überschneiden, damit Sie sie wieder auswählen können.
Fügen Sie bei Bedarf kosmetische Linien ein, z. B. um Symmetrielinien zu zeichnen.

Das resultierende Dokument könnte wie folgt aussehen:

Weitere Informationen zu diesem Modul sind auf dem FreeCAD Wiki verfügbar.

Tipps für besseres Hardware Design

Schallbert — Tue, 21 Sep 2021 00:00:00 +0000

Motivation

Ich habe meine erste Anfrage für die Fertigung eines AnywhereAmps Alpha. Da ich nicht noch einmal 10h für den Bau aufwenden möchte, habe ich beschlossen, die Zeit in die Beschleunigung des Herstellungsprozesses zu investieren. Ich fand heraus, dass ich etwa eine Stunde pro Verstärker sparen könnte, wenn ich die Platine für mich herstellen lassen würde. Leider hat mich die Umstellung der Platine von manuellem Schneiden, Fräsen, Bohren und Löten auf ein PCB-Design doppelt so viel Zeit gekostet, als wenn ich sie bereits komplett gebaut hätte. Und ich weiß noch nicht einmal, ob das funktioniert. Aber fangen wir von vorne an.

Anforderungen an die neue Leiterplatte

Die Platine soll enthalten

die Vorverstärkerschaltung, wie sie für AnywhereAmps Alpha entworfen wurde
die Zwei-Wege-Weichenschaltung, wie sie für zukünftige AnywhereAmps Beta entwickelt wurde
einen schaltenden Abwärtswandler zur Bereitstellung von 9V DC für Aux-Effekte
eine Stromüberwachungsschaltung, die sowohl Batterie als auch Platine vor Überlastung, Kurzschluss, Unterspannung und Rückspannung schützt

Auf diese Weise möchte ich die Elektronik schrittweise professionalisieren. Ich beabsichtige, die gleiche Platine für alle Varianten der AnywhereAmps zu verwenden. Außerdem würde ich einige externe Komponenten loswerden, die ich von Hand herstellen und platzieren musste: Sicherung, hochstromfähiger Netzschalter, 9V-Regler und seine Kühlung, sowie einige Kabel.

Bauteilauswahl

Abwärtswandler

Ich habe im Internet nach einem Abwärtsschaltwandler mit geringer elektromagnetischer Interferenz (EMI) und einem Ausgang von >1A bei 9V gesucht. Ein Linearregler hätte zwar weniger Störungen ausgesendet, aber bei einer Batterie-Nennspannung von 18V hätte ich im schlimmsten Fall um 9W thermische Verluste in Kauf nehmen müssen. Daher wäre diese Lösung überhaupt nicht batterieschonend gewesen. Ich entschied mich für ein (teures) Design, das alle notwendigen Komponenten in einem Baustein enthält, so dass ich nur noch das PCB-Layout richtig hinbekommen musste, um die EMI zu reduzieren. Ich fügte ein paar Bypass-Kondensatoren und einen Spannungsteiler für den Zielspannungs-Sollwert hinzu. Das war’s! (Dachte ich damals noch. So sah es tatsächlich aus)

Power Supervisor

Der einzige Schutz für meine Verstärker war bisher eine Sicherung, deren Wert auf den höchsten Betriebsstrom eingestellt war, den ich in den Schaltkreisen erwartete. In den frühen Prototypenphasen habe ich einige Operationsverstärker durch versehentliche Verpolung zerstört. Außerdem möchte ich vermeiden, dass der Akku völlig entladen wird, wenn ich vergesse, auf die Ladeanzeigen zu achten. Deshalb habe ich einen Power Supervisor IC ausgewählt, der Über- und Unterspannung und weitere Fehler erkennt und sowohl die Schaltkreise als auch den Akku vor Schäden schützt.

Gruppierung passiver Bauteile

Ich habe gelernt, dass die Herstellung einer Leiterplatte mit vielen verschiedenen Bauteilen teurer und fehleranfälliger ist als bei Verwendung weniger unterschiedlicher Bauteile, auch wenn ihre Gesamtzahl auf diese Weise steigt. Also habe ich viele Werte überarbeitet und die Simulation für den Audio-Vorverstärker mit diesen neuen Werten erneut durchgeführt. Schließlich gelang es mir, die Schaltung von 8/5 auf 3 verschiedene Widerstands- und 3 verschiedene Kondensatorwerte zu reduzieren!

Kondensatoren - mal wieder

Ich habe zunächst MLCC (Multilayer Ceramic Capacitors) in meinem Design verwendet, sowohl für den Bypass als auch für die Audio-Entkopplungskondensatoren. Nach erneuter Lektüre der Dokumente, auf die ich in meinem Beitrag preamp-design-considerations/ hingewiesen hatte, stellte ich fest, dass dieses Kondensator-Design Probleme mit Verzerrungen bei Audiosignalen zu haben scheint. Das Bild unten zeigt einen Vergleich verschiedener Kondensatortypen und -größen. Man erkennt, dass Folienkondensatoren hier am besten und MLCCs am schlechtesten abschneiden. Da ich keine Folienkondensatoren in der von mir benötigten Größe auf SMD-Basis finden konnte und Aluminium-Elektrolytkondensatoren zu groß waren, habe ich gepolte Tantalkondensatoren gewählt. Für die Bypass-Kondensatoren wählte ich low-ESR Typen.

TI Audio Design Journal: Vergleich verschiedener Kondensatortypen ^[1]

Schaltungsentwurf

Ich wählte die Open-Source-Software KiCad als Werkzeug zum Schaltungsentwurf und zeichnete alle meine bestehenden Schaltpläne neu, wobei ich die oben beschriebenen Komponenten hinzufügte. Man erkennt gut, dass der Verstärkerteil nur die rechte Hälfte des Schaltplans füllt, während die linke Hälfte der Stromversorgung und der Überwachungsschaltung gewidmet ist.

Ich habe versucht, die Schaltpläne so übersichtlich wie möglich zu gestalten, damit sie leicht zu lesen sind. Ich habe häufig globale Bezeichnungen verwendet und Steckverbinder zur einfacheren Montage hinzugefügt.

PCB-Design

Dies war der schwierigste Teil für mich. Ich habe noch nie eine Leiterplatte für Audioanwendungen entworfen, also musste ich eine Menge Richtlinien lesen, bevor ich anfing.

Anleitungen und Tutorials

Ich liste einige davon unten zur Information auf:

AnywhereAmps PCB erklärt

Das Ergebnis nach ein einigen Stunden Arbeit:

Die Platine ist in zwei Lagen vollständig geroutet.

Ich habe die Leiterplatte in drei Bereiche unterteilt.

Links: der 9V-Schaltregler, der seinem Referenzdesign (Datenblatt) folgend mit Hilfe der Bypass-Kondensatoren einen Stromkreis um sich selbst bilden und den größten Teil der elektromagnetischen Störaussendung auslöschen würde. Das thermische Design, lässt viel Platz für Kupfer und einige Durchkontaktierungen, sodass die Wärme vom Chip gut abgeführt werden kann.
Mitte: Die Stromanschlüsse und die Überwachungsschaltung. Ich habe Lötbrücken gesetzt, um die Nennspannung der Batterie für die Unterspannungserkennung auszuwählen.
Rechts und oben: Vorverstärker und analoge Signalschaltung, getrennt von der übrigen Elektronik durch eine dicke Massebahn auf der oberen Ebene und eine eigene Massefläche auf der Unterseite. Ich hoffe, das ist genug.

Da ich die ersten Prototypen von Hand löten werde, um zu prüfen, ob alles gut funktioniert, habe ich “große” 0805 SMD-Bauteile verwendet. Ich habe den Abstand zwischen den Bauteilen größer gemacht, als es die PCB-Spezifikation verlangt. Leider waren die hochintegrierten Leistungs-ICs nicht in “Hobby-Löt-Elektronik”-Größen erhältlich, so dass ich hier noch einige Mühen auf mich nehmen muss.

So wird es also aussehen. Die Leiterplatte wird 45mm x 69mm groß sein.

Herunterladen oder eigene Beiträge erwünscht?

Alle meine Zeichnungen in CAD sowie Stromlaufpläne sind quelloffen und zum Download auf meinem eigens dafür angelegten Github Repo verfügbar.

Nächste Schritte: Platinen geliefert und verlötet

Vorverstärker-Design

Schallbert — Wed, 25 Aug 2021 00:00:00 +0000

Auswahl der Entkopplungskondensatoren

Einige technische Hintergrundinformationen über die Auswahl der Komponenten für meine Vorverstärkerplatine.

Warum Entkopplung nötig ist

Mit Entkopplung meine ich in diesem Fall speziell die Gleichstromentkopplung (DC-Entkopplung). Der Vorverstärker muss sowohl von der Quelle (dem Musikinstrument) als auch von der Senke (dem Endverstärker) entkoppelt werden. Dies hat mehrere Gründe:

die Versorgungsspannungen der drei Partner können unterschiedlich sein (z.B. 9V Gitarrenspeisung, 18V Vorverstärker, 52V Endstufe) und ich möchte nicht versehentlich einen von ihnen kurzschließen
Ausgangsimpedanz, d.h. die Belastbarkeit der Ausgangsstufe könnte begrenzt sein. Wenn ich einen niedrigen Eingangswiderstand z.B. direkt an den Tonabnehmer einer Gitarre anschließe, kann es sein, dass ich überhaupt kein Signal herausbekomme, weil die Quellenspannung zu stark einbricht.
Rauschunterdrückung durch elektrische Entkopplung

Warum Kondensatoren die Aufgabe übernehmen können

Es gibt mehrere Möglichkeiten, Schaltungen elektrisch zu entkoppeln. Man kann einen Optokoppler verwenden, um zwei Schaltkreise vollständig (d.h. galvanisch) voneinander zu trennen. Damit wird nur das erwünschte Signal zwischen den Schaltkreisen durchgelassen. Oder man verwendet - wie in meinem Fall - einen Kondensator, um nur Wechselströme durchzulassen und Gleichstrom zu unterdrücken.

Wie funktioniert das?, fragen Sie? Nun, ein Kondensator funktioniert ein bisschen wie ein Wassertank. Wenn man eine konstante Spannung (Druck) anlegt, füllt sich der Tank bis zu einem gewissen Grad. Wenn dieser Pegel erreicht ist, fließt kein Volumenstrom mehr, weder rein noch raus. Variiert man nun aber die Spannung um einen statischen Pegel (Wasserdruckschwankung), so wird man wieder einen Volumenstrom messen, der in den Tank hinein- und herausfließt.

Genauso verhält es sich mit dem Kondensator. Wenn man ihn in Reihe mit einer Senke schaltet, wird er nur dann Strom durchlassen, wenn sich der die Eingangsspannung ändert.

Typ des Entkopplungskondensators

Keramik-Vielschichtkondensator, Polypropylen-Kondensator, Elektrolytkondensator…? Nach Lektüre dieses Leitfadens von Texas Instruments habe ich verstanden, dass es in diesem Dokument nur um Verzerrungen geht. Die Verzerrung würde am stärksten am Instrumenteneingang vor dem Vorverstärker Einfluss ausüben, da dieser von beiden Verstärkerstufen verstärkt wird. Bei der Verwendung eines Elektrolytkondensators sollte eine Vorspannung angelegt werden, um die Verzerrung im unteren Frequenzbereich zu verringern. Bei meinem Design ist die Vorspannung 1/2 von VCC, also noch höher als die in der Anleitung verwendeten 5V - ich denke, ich werde mit einem “billigen” polarisierten Aluminiumkondensator auskommen um die Verzerrungen THD+n gering zu halten.

Es gibt noch eine andere Sache, die ich bei Mehrschicht-Keramikkondensatoren (MLCCs) festgestellt habe: Wenn die Lautsprecher bei hoher Vorverstärkung nicht angeschlossen sind, spielen die von mir verwendeten Endstufen immer noch Musik! Wie kommt das? Die Endstufenplatine verwendet MLCCs, die wie Piezoaktoren wirken. Ihre Vibration wird durch die Platine, auf der sie montiert sind, verstärkt, was einen gewissen Schallpegel ergibt. Verrückt. Weitere interessante Details finden Sie im EDN-Blog oder - in einem weiteren Texas Instruments-Leitfaden.

Kondensatorgröße

Um die Größe des Kondensators zu beurteilen sind einige Aspekte zu berücksichtigen:

Ein größerer Kondensator senkt meine untere Grenzfrequenz
Ein größerer Kondensator belastet die Eingangsquelle aufgrund von Ladungsverlusten stärker
Ein größerer Kondensator kostet mehr, insbesondere die hochwertigen Kondensatoren.
Ein größerer Kondensator kann einen größeren Platzbedarf haben.

Ich wollte eine untere Grenzfrequenz von <20Hz für volle HiFi-Fähigkeit. Da dies bereits der -3dB-Punkt ist, wählte ich einen noch niedrigeren Wert von 15Hz, berechnet über $f=\frac{1}{2 \pi RC}$. Bei einer Eingangsimpedanz von 10kOhm (der Wert des Widerstandes, der an die virtuelle Masse geklemmt wird) ergebe ich eine Zielgröße des Eingangskondensators von 1µF. Bei diesem Kondensator wird die Eingangsquelle wesentlich stärker durch den Eingangswiderstand von 10kOhm beeinflusst als durch den Kondensator mit seinem niedrigen Serienwiderstand (ESR) von einigen hundert mOhm, so dass der gewählte Wert in Ordnung ist.

Für den Ausgangskondensator ist die Berechnung ähnlich. Die Endstufe hat eine Eingangsimpedanz von 20kOhm, so dass die untere Grenzfrequenz von 17Hz bereits mit einem 0.47uF Kondensator erreicht wird. Um die Wertunterschiede in Grenzen zu halten, habe ich mich auch hier für den 1µF entschieden.

Zurück zur Projekt-Hauptseite

Shelly13 - Teil2

Schallbert — Fri, 09 Jul 2021 00:00:00 +0000

Shelly13: Projektstatus, Prototypenskizzen

Ich denke immer noch viel über Shelly13 nach und darüber, wie ein größerer Lautsprecher, ein homogener Klang mit etwas Punch und ein versiegeltes Gehäuse, das sich zusammenklappen lässt, umsetzbar wäre.

Gehäuse: Dimensionierung und Volumen

Die letzten Entwürfe in meinem Kopf benötigen 12x10 und 14x10 Zoll Kessel. Der Combo wird aufgeklappt ein bisschen wie eine Torte aussehen, mit einem Gesamtvolumen von ca. 38l inkl. Lautsprecher und Verstärker im Inneren. Die Gesamthöhe wird mit ausgeklappten Füßen ca. 75cm betragen, zusammengeklappt ist er ca. 29cm hoch.

Lautsprecher

Während mein erster Entwurf einen 10"-Lautsprecher an der Vorderseite des Gehäuses vorsieht, werde ich höchstwahrscheinlich zu einem Zwei-Wege-Design wechseln, um die Montage zu vereinfachen und die Probleme mit dem Fräsen einer großen gewölbten Fläche und der Herstellung einer Adapterplatte zu verringern. Ich werde also einen 8"-Basslautsprecher in einem Downfire-Setup und einen 3"-Mittelhochtonlautsprecher an der Front wählen.

Verstärkung

Ich denke darüber nach, einen Car-Hifi-Verstärker zu verwenden, der sein Signal von einer aktiven Frequenzweiche mit getrennten Ausgängen für tiefe und hohe Frequenzen erhält, wodurch ein Bi-Amp-Design mit gebrückten Anschlüssen entsteht.

Klappmechanismus

Das Zusammenklappen erfolgt mit Hilfe von Teleskopschienen, die zwischen den Kesseln montiert werden. Es ist wichtig, dass das Gehäuse im aufgeklappten Zustand luftdicht verschlossen ist. Deshalb muss ein Dichtungsring vorhanden sein, der einrastet, wenn der untere Holzring des 12"-Kessels auf den oberen Ring des 14"-Kessels trifft.

Nein, das ist zu komplex!

Ok, vereinfachen wir das Konzept. Lassen wir die Faltbarkeit für den ersten Prototyp weg. Reduzieren wir stattdessen die Gehäusegröße. Konzentrieren wir uns zunächst auf die Elektronik und die Herstellbarkeit. Das Ergebnis dieser Umfangsänderung ist: AnywhereAmps Alpha!

Shelly13 - Teil1

Schallbert — Mon, 28 Jun 2021 00:00:00 +0000

Nachdem ich eine Weile mit MobFobAmp gespielt hatte, wollte ich einen weiteren Schritt in der Entwicklung zu einer wirklich guten tragbaren Lösung gehen. Mit diesem Design versuche ich, die Unzulänglichkeiten der vorherigen Prototypen zu beheben:

Die Ausgangsleistung könnte höher sein
Mehr Volumen in den tiefen Tönen wäre schön
Der Klappmechanismus ist ein bisschen fummelig.
Ich hätte gerne eine Entfaltung in einem Schritt, am besten mit einer Hand möglich
Mechanische Stabilität und Robustheit könnten verbessert werden
Empfindliche Bauteile an der Außenseite, die mit Vorsicht zu behandeln sind

Ein erster Entwurf

Unter Berücksichtigung der oben genannten Punkte habe ich herausgefunden, dass ich bei der Faltbarkeit einige Kompromisse eingehen muss, um alle empfindlichen Komponenten einschließlich der Lautsprecherchassis in das Innere des Gehäuses zu bringen. Ein kugelförmiges Design wäre ideal für ein optimales Verhältnis zwischen Abmessungen und Volumen, aber ich wüsste nicht, wie man ein solches Design herstellt. Also entschied ich mich für einen zylindrischen Ansatz. Ich möchte, dass der Lautsprecher “aufklappt”, damit er beim Zusammenklappen vor mechanischen Schäden geschützt ist. Meine erste Idee sieht also so aus:

Einschränkungen

Ich kann die Zylinder nicht selbst herstellen, also müsste ich einen Schlagzeughersteller bitten, mir ein paar unfertige Tom-Toms in Sondergröße zu schicken. Selbst wenn ich diese bekomme, muss ich auf einer gekrümmten Oberfläche schneiden, was ich noch nie gemacht habe, und ich müsste etwas 3D-Drucken / Fräsen, um eine Adapterplatte zwischen Lautsprecher und Zylinder herzustellen… Oder werde ich den Lautsprecher einfach oben/unten anbringen? Außerdem müsste ich mir überlegen, wie ich einen leistungsfähigeren Verstärker in mein Design einbauen kann - es gibt einige Ideen wie diesen Pioneer-Auto-Verstärker oder den spezialisierten Hi-Fi-Verstärker von DIY Class D, aber die haben sehr unterschiedliche und möglicherweise hohe Anforderungen an die Stromversorgung…

Fazit

Es gibt also einige offene Baustellen. Ich lasse die Punkte mal auf mich wirken und schaue dann, wie ich mit diesen Problemen am besten umgehe.

Favicon und Sammlungsgenerator

Schallbert — Sun, 13 Jun 2021 00:00:00 +0000

Hinzufügen eines “Tab”-Symbols - Favicon

Ich war besorgt über eine merkwürdige Fehlermeldung, die Jekyll bei jedem Refresh meiner Seite ausgab: [2021-06-13 22:07:43] ERROR '/favicon.ico' not found. Einige Online-Recherchen ergaben, dass dies weder ein Jekyll- noch ein Theme-Fehler ist, sondern ein Dateifehler. Siehe hier wie ich das Icon für diese Seite implementiert habe.

Erzeugung von Kollektionen

Ich habe herausgefunden, dass irgendwie die Sammlungserzeugung auf meiner Seite nicht funktioniert. Trotzdem geht das Layouting-Skript aber davon aus, dass es die Seiten vorbereitet hat. Wenn ich nun versuche, die Seite durch Drücken der Schaltfläche “Zurück” aufzurufen, erhalte ich einen 404-Fehler. Bis jetzt war ich nicht in der Lage, dies zu beheben, weil die Erzeugung stillschweigend fehlschlägt und ich nicht weiß, wo. Ich schalte sie vorerst komplett ab.

MobFobAmp

Schallbert — Thu, 10 Jun 2021 00:00:00 +0000

Pläne

Plans for my Mobile Foldable Amplifier.

Front and side view scetch with dimensions

Top and bottom view scetch with dimensions, shows the mounting side of the panels

Minimal added circuitry: Switch, fuse, LED, 1k Resistor to set amp gain to max

Listen

Werkzeuge

Benötigte Werkzeuge
Bohrmaschine
Oberfräse, Kopierring, Parallelanschlag
Multitool: Schleifen, Holzschnitt, Schneidkopf, Zirkel
Optional: Handkreissäge mit Schutzbügel
Handsäge, fein
Zwingen
Stechbeitel, 12mm
Hammer
Schraubendreher, Bits
Holzbohrer: 3mm, 5mm, 6mm, 8mm, 12mm, Senkbohrer 45°, Forstner 30mm
Stahlbohrer: 3mm, Senkbohrung 45°
Messerköpfe: 8mm gerade, 12mm gerade, 45° optional
Lötkolben, Lötzinn, Schrumpfschlauch, 1m 1x0,75mm² Leitung

Materialliste

Artikel	Größe [mm]	Anzahl	~ Kosten [€]
Vorder-/Rückseite: Birke Multiplex	L 500 B 260 B 12	2	12
Oben/Unten: Birke Multiplex	L 260 B 248 B 12	2	4
Seiten: Birke Multiplex	L 500 B 110 B 12	4	8
Verstärkung & Halterungen	L 260 B 236 W 12	1	2
Schrauben (vorzugsweise Torx)	12 x 3	100	5
Schrauben (Batteriehalter, Lenker)	35 x 4	4	0,20
Schrauben & Muttern (Lautsprecher)	15 x M4	3	0,20
Platinenhalter	d5 x 16	14	3
Klavierband	500 x 32	6	18
Verschlüsse	50 x 12	2	9
Fahrradschlauch (Flexible Scharniere & Riemen)	28"	1	6
“P-Typ” Schaumstoff- oder Gummidichtung	500 x 9 x 7	6	8
P-Typ" Schaumstoff- oder Gummidichtung	260 x 9 x 7	4	4
Schaumstoff- oder Gummidichtung vom Typ “P”	236 x 9 x 7	4	4
I-Typ" Schaumstoffdichtung (Lautsprecher)	600 x 9 x 2	1	2
Aluminiumschiene	260 x 12	4	2
Abstandhalter (Auto-unfold Funktion)	do 30 di 4	4	2
Tragegriff	Was Sie bevorzugen	1	?
Verstärker (z.B. Adafruit 20W Class-D Verstärker)		1	20
Lautsprecher (z.B. Visaton W 170S 4Ohm)	d170, W 81	1	35
Batterie, 10V - 14V	Was Sie bevorzugen	1	?
Sicherung, Schalter, LED, Widerstände: Siehe Schaltplan	Was Sie bevorzugen	1	?
Ersatzholz z.B. als Maske	z.B. 300 x 300	1	0
Gummikleber oder Heißkleber (luftdichte Lücken)	20g	1	3

Der Bau

Verlegung

Zuerst werden alle Falze gefräst damit die Dichtungen in das Gehäuse montiert werden können.

Montieren Sie den geraden 8mm-Fräser. Bei einer Schnitttiefe von 3mm setzen Sie den Parallelanschlag so ein, dass die Mitte der Fräse 7mm vom Anschlag entfernt ist. Achten Sie darauf, dass Sie die Oberfräse gut führen, damit Ihre Schnitte gerade und sauber werden.
Fahren Sie mit den vorderen und hinteren Platten fort (500x260x12). Fräsen Sie die langen Außenseiten der beiden Bretter.
Schneiden Sie nun die klappbaren Seiten des Schrankes zu. Nehmen Sie dafür zwei der vier Teile “500x110x12”. Die langen Seiten müssen nach oben zeigen. Verwenden Sie Ihre Oberfräse, um die Innenseiten dieser Bretter wie folgt zu schneiden:
Nun ist es an der Zeit, die umlaufenden Dichtungen von Deckel und Boden zu fertigen. Nehmen Sie die Pläne zur Hilfe.
Montieren Sie den 12mm-Fräser auf die Oberfräse. Stellen Sie den Parallelanschlag neu ein, damit die Oberfräse ohne Abstand zum Anschlag fräst. Fräsen Sie einen Falz von etwa 4mm Tiefe an eine Seite von Deckel und Boden, damit hier später das Gummischarnier montiert werden kann. Schleifen Sie überstehende Fasern vorsichtig mit einem 180er-Papier ab.
Verwenden Sie einen an der Oberfräse angebrachten Zirkel oder das Multitool, um den Innenring mit einem Durchmesser von 148mm für die Lautsprecheröffnung zu schneiden. Drei Durchgänge auf der Oberfräse sollten genug sein.
Fertigen Sie eine Schablone an. Nehmen Sie dafür ein Reststück, z.B. aus Sperrholz. Der Lochkreis der Schablone sollte wie folgt berechnet werden: Außendurchmesser des Lautsprechers plus Differenz aus Abstand Kopierring zu Achsmitte und Fräserradius. So erreichen Sie einen Enddurchmesser der Falz von 170mm. Es sollte jetzt so aussehen:
Zentrieren Sie die Schablone auf dem 148mm Ausschnitt an der Vorderseite und befestigen Sie sie (z.B. mit doppelseitigem Klebeband). Montieren Sie den Kopierring an der Oberfräse. Stellen Sie sicher, dass Sie den 12mm Fräskopf verwenden und eine Fasen-Tiefe von nicht mehr als 8mm verwenden - der Lautsprecher hat 7mm Tiefe, fügen Sie 1mm für die Dichtung hinzu.
Schleifen Sie die Kanten ein wenig ab. Verwenden Sie das Multitool, um kleine Unebenheiten zu korrigieren, die eventuell noch vorhanden sind. Wiederholen Sie den Vorgang, bis der Lautsprecher gut sitzt.
Schneiden Sie nun die Aussparungen für die Gegenstücke der Verriegelungen. Stellen Sie die Oberfräse auf die Tiefe des Materials + Tiefe der Dichtungsnut ein (damit sie hinter der Dichtung sitzen kann) und verwenden Sie den Parallelanschlag, um die Mitte der oberen und unteren Teile anzupassen. Beachten Sie, dass Sie orthogonal durch die Nuten für die Dichtungen schneiden, die Sie zuvor hergestellt haben.

Beschläge

Die Beschläge werden vor dem Zusammenbau des Gehäuses montiert, da der Gegendruck der Dichtungen das Schließen erschwert.

Montieren Sie die Haken an der oberen und unteren Platte mit je zwei Schrauben 3x12.
Verwenden Sie Heiß- oder Gummikleber, um die Metallkanten gegen den Ausschnitt abzudichten.
Schneiden Sie ein Stück aus dem Fahrradschlauch, Länge: 260mm .
Schneiden Sie dieses Stück parallel zur langen Seite in zwei Hälften, so dass zwei Riemen entstehen.
Bohren Sie 5 Löcher in gleichem Abstand in jede Aluminiumstange und benutzen Sie die 45° Senker um später die Schraubenköpfe dort einpassen zu können.
Legen Sie einen Gummiriemen unter die Alustange und befestigen Sie ihn an der oberen Rückseite der Deckelplatte.
Wiederholen Sie Schritt 6 mit der Bodenplatte.
Legen Sie das vordere, obere und untere Brett zusammen auf den Tisch, so dass sie ein großes C bilden.
Bringen Sie die Verschlüsse mittig am vorderen Brett an und stellen Sie sicher, dass sie die oberen/unteren “Deckel” fest geschlossen halten und die oberen/unteren Bretter in einem 90°-Winkel zur Vorderseite stehen.

Positionierstücke

Montieren Sie nun die Fixierungselemente, die eigentlich Regalböden an ihrem Platz halten, an der Ober- und Unterseite des Gehäuses. Sie fixieren die Seitenteile an ihrem Platz und versteifen das Gehäuse.

Markieren Sie die Stellen, an denen die Regalbodenhalter am Rand der Nut angebracht werden sollen. Die Abstände finden Sie in den Plänen.
Verwenden Sie einen 5mm Holzbohrer und markieren mit Klebeband eine Tiefe von 8mm, damit nicht ganz durch das Brett gebohrt wird.
Bohren Sie die 6 Löcher in Deckel- und Bodenplatte und stecken dann die Positionierstücke dort hinein.
Stellen Sie sicher, dass die Kragen der Positionsstücke auf gleicher Höhe sind wie die Oberfläche der Platte (und nicht in der Nut versenkt sind).
Entfernen Sie vorerst die Fixierungen wieder, denn die Dichtungen müssen vorher montiert werden.

Dichtungen

Sie machen das Gehäuse schließlich luftdicht, werden aber bei Klappvorgängen recht stark beansprucht.

Achten Sie darauf, dass die gefrästen Vertiefungen sauber und trocken sind, damit das Klebeband die volle Haltekraft entfalten kann.
Beginnen Sie mit je 4 Dichtungen für Boden- und Deckelplatte. Sie könnten etwas breiter sein als die Vertiefung, verwenden Sie in diesem Fall eine Plastikkarte oder ein ähnliches, weiches Werkzeug, um sie einzupassen.
Nehmen Sie ein Rasiermesser oder ein Messer mit einer spitzen Klinge zur Hand um Löcher in die Dichtungen zu schneiden, in die die Fixierstücke hineingedrückt werden können Orientieren Sie sich dabei an den Markierungen für die Löcher, die Sie zuvor angebracht haben.
Benutzen Sie einen Hammer, um die Positionierungselemente vorsichtig durch die Dichtungen zu drücken.
Nehmen Sie zum Schluss einen kleinen Schraubenzieher oder eine Klinge, um die Dichtung wie einen kurzen Kragen um die Fixierungen herum anzuheben - das Gehäuse muss luftdicht verschlossen werden.
Bringen Sie die Dichtungen an den beiden Seitenteilen an.
Bringen Sie zwei Dichtungen pro Vor/Rückwand an.

Automatisches Auffalten

Dies ist eine optionale Funktion. Mit ihrer Hilfe klappt sich das Gehäuse von selbst auf, sodass das Fixieren mittels Boden- und Deckelplatte leichter fällt.

Nehmen Sie die vier Seitenteile zur Hand. Bohren Sie mit einem Forstnerbohrer einen 3mm tiefen Kreis genau in die Mitte der Innenseiten der Seitenteile.
Schneiden Sie zwei 70mm lange Stücke aus dem Gummischlauch.
Befestigen Sie die erhaltenen Riemen an zwei zusammengehörigen Seitenteilen mit Hilfe der 30mm Unterlegscheibe und einer Schraube genau in dem Kreis, der vorher ausgeschnitten wurde.

Die Unterlegscheiben werden benötigt, um den Bereich zu vergrößern, in dem das Gummiband am Holz befestigt ist. Ohne sie würde das Gummi um die Schraube herum reißen.

Scharniere

Die Montage der Scharniere mit den Dichtungen ist etwas fummelig. Sie könnten ein weiteres Paar Hände oder einige Klammern benötigen.

Legen Sie die Frontplatte auf den Tisch. Setzen Sie die beiden Seitenteile mit den Dichtungen so auf der Frontplatte auf, dass sie auf der Dichtung “stehen”.
Während die Seitenteile gegen die Dichtungen der Frontplatte gedrückt werden (orange), setzen Sie die Scharniere (rot) ein und markieren die Positionen der Löcher.
Montieren Sie die Scharniere. Achten Sie darauf, dass kein Spalt zwischen den Seiten und der Frontplatte entsteht.
Wiederholen Sie den Vorgang mit den anderen beiden Seiten und der Rückwand.
Setzen Sie die beiden Hälften zusammen. Sie werden sich aufgrund des Drucks der Dichtung nach innen bewegen wollen, verwenden Sie also die Verstärkungsplatte, um das Gehäuse vollständig aufgeklappt zu halten. Ich habe für diesen Schritt ein Stück Holz mit den Maßen 236 x 27 x 12 verwendet.
Wenn Sie die Auto-Unfold-Funktion vorbereitet haben, ist es jetzt an der Zeit, die losen Enden des Gummibandes auf Spannung zu bringen und sie auf der gegenüberliegenden Seite zu befestigen.
Montieren Sie schließlich die beiden Scharniere auf beiden Seiten der Schrankaußenfläche. Achten Sie darauf, dass kein Spalt zwischen den Seitenteilen entsteht.
Probieren Sie den Mechanismus aus. Wenn Sie das Gehäuse zusammenklappen, sollte er sich von selbst entfalten, wenn Sie die Scharniere richtig montiert haben.

Oben und unten

In diesem Schritt werden die Fixierlöcher gebohrt und das Gummischarnier montiert. Auf diese Weise werden nur zwei statt acht Verriegelungen benötigt und der mechanische Druck auf die Dichtungen bleibt hoch genug.

Halten Sie das Gehäuse aufgeklappt.
Tragen Sie etwas Farbe auf die bereits in Deckel- und Bodenplatte montierten Fixierungen auf.
markieren Sie die Stellen zum Bohren der Löcher auf der Ober- und Unterseite des Gehäuses, indem Sie diese ausrichten und dann die aufgeklappte Gehäuseschale und die Ober- und Unterteile zusammenpressen.
Benutzen Sie den 5mm Bohrer, um die Löcher an den Stirnseiten des Gehäuses entsprechend der markierten Punkte zu bohren, Tiefe wiederum 8mm.
Legen Sie Boden- und Deckelplatte auf und prüfen, ob alles gut passt. Probieren Sie die Verschlüsse aus. Wenn die Riegel nicht 100%ig passen, kann man mit der Bohrmaschine vorsichtig nachhelfen.
Befestigen Sie die obere und untere Platte mit den beiden verbleibenden Aluminiumstangen (grün) und dem losen Ende des Gummischarniers (schwarz) an der Rückseite des Gehäuses, wie in der Skizze gezeigt.

Funktioniert alles?

Wow, der Verstärker ist fast fertig! Das Zusammen- und Auseinanderklappen sollte jetzt funktionieren.

Montieren Sie den Lautsprecher, aber vergessen Sie nicht, zuerst die Dichtung einzubauen.

Drei Maschinenschrauben M4x15 mit Muttern sorgen für eine sichere Befestigung des Lautsprechers.
Um den Verstärker zu konfigurieren sind ein paar Brücken zu verlöten. Befolgen Sie dafür die Anleitung von Adafruit für eine analoge Steuerung der Verstärkung. Montieren Sie das Potentiometer oder stellen den Verstärker gleich auf 100% Verstärkung, dem Schaltplan folgend.
Sicherung und Schalter werden eventuell noch nicht benötigt. Anstelle einer Batterie kann ein Netzteil mit Stromregelung angeschlossen werden, zum Schutz vor Kurzschlüssen auf 12V @ 1A einstellen.
Für einen Funktionstest löten Sie eine 6,3mm-Eingangsbuchse an ein paar Drähte oder ein altes Instrumentenkabel und stecken es in die Klemmen des linken Kanals des Verstärkers.
Schließen Sie Ihr Instrument an und probieren den Verstärker aus.
Hinweis: Wenn Ihr Instrument passiv ist, d.h. keinen eingebauten Vorverstärker hat, benötigen Sie höchstwahrscheinlich einen zusätzlichen Vorverstärker oder eine aktive DI-Box, um eine akzeptable Ausgangslautstärke zu erzielen. Z.B. dieses Ding wird die Aufgabe gut erfüllen. Die meisten Effektpedale haben aber ebenfalls Vorverstärker eingebaut - ich habe eines dafür verwendet.

Fertigstellung des Projekts

Schauen Sie sich an, wie schlank, leicht und einfach zu transportieren Ihr Verstärker ist, wenn er zusammengefaltet ist!

Einige zusätzliche Schritte, die ich unternommen habe, waren, dem Verstärker ein angemessenes Gehäuse zu geben (das leere Schraubengehäuse…), Sicherung, Eingangsbuchse(n), Schalter, LED und die Batterie hinzuzufügen. Wird der Akku eines Elektrowerkzeugs verwendet, sind die Pole des Akkus mit normalen Kabelschuhen anzuschließen. Mit etwas Holz und einer Oberfräse ist es ein Leichtes, eine Halterung zu bauen in die man den Akku einfach einklicken kann, wie ich es bei meinem Entwurf getan habe.

Ein Griff könnte eine gute Idee für den Transport sein, und ein Gummiband könnte das Gehäuse in einer gefalteten Position halten und Boden sowie Deckel an der Rückseite fixieren.

Ich hoffe sehr, dass Sie die Lektüre / den Bau genossen haben und dass Sie so viel Spaß haben werden, dieses kleine Ding überall zum Spielen mitzunehmen, wie ich es tue.

Schallbert

Zurück zur Projekt-Hauptseite

Markdown zu PDF konvertieren

Schallbert — Wed, 09 Jun 2021 00:00:00 +0000

Die Software

Ich habe die Visual Studio Code-Erweiterung Yzane’s Markdown PDF gewählt. Einfach zu installieren, einfach zu benutzen, gute Dokumentation. Nur die Bilder… naja… wurden nicht angezeigt.

Auch die Bilder werden konvertiert

Die relativen Links zu den Bildern unterscheiden sich zwischen Jekylls Interpretation und der Vorstellung des PDF-Generators. Ich musste die Markdown-Zieldatei in das Stammverzeichnis der Website verschieben und ein . vor meinem /assets hinzufügen, damit es funktioniert. Die Seitenumbrüche sind … meh… aber ich bin im Moment nicht bereit, mehr Arbeit hineinzustecken, also ist das gut genug für meine Zwecke.

Ein Problem mit Posts, die nicht angezeigt werden?

Gerade als ich diesen sechsten Beitrag von mir veröffentlicht habe, sehe ich, dass irgendwie nur Seite 2 der Beitragsübersicht angezeigt wird (sieht aus wie 5 Beiträge pro Seite) und ich kann nicht zu Seite 1 mit den “neuesten” Beiträgen wechseln:

. Hm.

Jekyll: Bilder

Schallbert — Mon, 07 Jun 2021 00:00:00 +0000

Der Trick

Als ich einige Bilder zu meinen Inhalten hinzufügte, war alles in Ordnung, bis ich sie auf GitHub veröffentlichte. Die meisten Bilder waren verschwunden und ich konnte nicht herausfinden, warum. Eine Suche ergab, dass Github zwischen Groß- und Kleinschreibung unterscheidet und einige meiner Bildpfade nicht alle kleingeschrieben waren. Dahinter vermute ich Unterschiede zwischen Windows/Unix, da sich die beiden Betriebssysteme hier unterschiedlich verhalten.

Ändern von Ordnernamen in Git

Es funktionierte danach immer noch nicht, weil Git meine Umbenennung nicht erkannte. Ich musste zuerst den umbenannten Ordner in einem anderen Unterverzeichnis erstellen, git mv folder/tArGet* target verwenden, um diesen an einen temporären Ort zu bringen, tArGet löschen und target an die Stelle verschieben, an der tArGet vorher war. Nur dies hat das Problem behoben und jetzt sind github und meine lokalen Dateien wieder synchron.

Jekyll Inhaltsverzeichnis

Schallbert — Sun, 06 Jun 2021 00:00:00 +0000

Inhaltsverzeichnis

Es gibt eine einfache Lösung, um das Inhaltsverzeichnis der Seite zu fixieren: toc_sticky: true zu den Standardeinstellungen oder dem Inhaltsverzeichnis der jeweiligen Seite hinzufügen. Wie ich das Schlüsselwort gefunden habe? Durch die Suche nach “toc” im Stammverzeichnis des Themes und ein wenig Scrollen durch die Layout-Skizzen. Ich änderte die ursprüngliche Seitennavigation in der linken Seitenleiste und tauschte sie gegen eine Dummy-Implementierung einer Galerie / Audio / Video-Inhaltsanzeige aus.

ToC auf der linken Seite

Um zu verstehen, wie man das Inhaltsverzeichnis anders als in diesem Theme vorgegeben auf der linken Seite erstellt, lesen Sie bitte dieses Kapitel des mySite-Projekts weiter.

Profil des Autors

Ich habe beschlossen, dass mein author_profile nur auf Seiten wie about, legal info und nicht auf den typischen Inhaltsseiten angezeigt werden soll. Also schrieb ich author_profile: false für die Seiten, auf denen es nicht angezeigt werden sollte - ohne Erfolg. Warum? Ich hatte es in der config.yml, Abschnitt type defaults gesetzt, aber es sollte eigentlich in der Frontmatter der einzelnen Dateien stehen.

Jekyll `-incremental` Option

Schallbert — Thu, 03 Jun 2021 00:00:00 +0000

die Kategorie “Neueste Beiträge”

Ich habe den Grund herausgefunden, warum mein letzter Artikel auf der Landing Page auf meinem lokalen Rechner nicht angezeigt wurde, aber auf dem Server problemlos funktionierte. Es liegt daran, dass ich lokal den Befehl $ bundle exec jekyll serve --incremental mit der aktiven --incremental build Option verwende, um die Rebuilds für schnellere Testläufe zu beschleunigen. Aber das Problem liegt hier:

Bei einer inkrementellen Ausgabe scheint Jekyll den Ordner _posts nicht nach neuen Einträgen zu durchsuchen, da die Seite, auf der sie erscheinen, nicht geändert sondern neu angelegt wurde. Mein Fazit ist, dass ich die Option --incremental in Zukunft mit Vorsicht und nur für Änderungen bereits bestehender Artikel verwenden werde.

Die Bilder

Ich habe an meinen Bildern unter assets/images gearbeitet. Sie benötigen recht viel Speicherplatz, so dass die Ladezeiten der Seite zu lang werden. Ich benutze paint.net, um sie auf eine Größe zu schrumpfen, die ich für vertretbar halte, und speichere sie als .jpg mit maximaler Kompression und einigen Kompromissen bei der Bildqualität. Auf diese Weise benötigen die meisten meiner Bilder weniger als 10% der ursprünglichen Größe in kB.

MinimalMistakes theme - Seitendesign

Schallbert — Wed, 02 Jun 2021 00:00:00 +0000

Die “Landing Page”

Endlich. Indem ich den Layout-Typ auf single änderte, konnte ich ein Header-Bild als Typ overlay einfügen! Die Schaltflächen werden jetzt innerhalb des Bildes angezeigt. Das Bild ändert sich automatisch mit der Displaygröße und -ausrichtung aufgrund der im Ordner _sass definierten visuellen Designs.

Bild der Hauptseite

Ich war dabei zu verzweifeln: meine “Landing Page” zeigte einfach kein Bild mehr an, egal wie sehr ich versuchte, die home.md Datei zu ändern. Der Grund dafür war, dass es eine Standard-“index.html”-Datei gab, die mit der Vorlage geliefert wurde und die anscheinend Vorrang hatte. Nun habe ich meine Änderungen einfach direkt dort eingefügt - funktioniert einwandfrei. Übrigens, die Höhe des Overlay-Bildes wird automatisch in Abhängigkeit von Inhalt und Höhe des Overlay-Textes gewählt.

Hinzufügen einer Seitennavigation

Einfache Lösung:toc: true in die YAML-Struktur des Markdown-Dokument für den gewünschten Artikel einfügen. Leider wird das Inhaltsverzeichnis statisch auf der Webseite angezeigt, sodass es beim Herunterscrollen verschwindet.
Schwierige Lösung: Fügen Sie die Seitennavigation in die linke Seitenleiste ein. Wie das geht? Siehe hier.

Neueste Beiträge

Im Moment erscheinen meine Artikel nicht in der Spalte “Neueste Beiträge” auf der Hauptseite. Das liegt daran, dass ich den Dienst neu starten müsste, weil die Beiträge statisch generiert werden Richtig, Jekyll ist ein statischer Seitengenerator.

🎄 Steckbrett-Lagerfeuer

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeit: Anfänger 1/5
Kosten: 8…25€
Zeit ~1h

Überblick

Dies ist ein schnelles und einfaches Projekt, das zeigt, wie man mit einem Microcontrollerboard und einigen LEDs eine warme und gemütliche Wohnzimmeratmosphäre schaffen kann. An eine Powerbank angeschlossen, wird diese kleine Bastelei den ganzen Abend leuchten und eine warme und gemütliche Atmosphäre schaffen. Ich habe Teile der Idee für dieses Projekt dem Buch “Tiny AVR for the evil Genius” entliehen, in dem ich viel gelesen habe, als ich vor Jahren mit dem Entwurf eingebetteter Software in C begann.

Die Projektkosten hängen von den gewählten Komponenten ab. Wenn ein original Arduino verwendet wird, liegen sie am oberen Ende des Bereichs. So kann man den hart arbeitenden Entwicklern und Ingenieuren von Arduino Anerkennung zollen, die Open-Source-Lösungen für uns alle schaffen 🥳.

Die Hardware

Natürlich kann man jedes Mikrocontroller-Board verwenden, das mindestens 8 digitale Ausgänge und 1 analogen Eingang unterstützt. In meinem Beispiel verwende ich ein Arduino Nano (Nachbau), das ich irgendwo herumfliegen hatte. Zeit für ein Upgrade auf das “Original”… Des Weiteren benötigt man ein Steckbrett, ein paar Drähte und acht LEDs. Ich empfehle, 5 warmweiße LEDs, 2 gelbe LEDs und 1 rote LED mit ähnlicher Helligkeit (Lumenzahl) zu verwenden, um Farben zu erhalten, die einem echten Feuer ähnlich sind.

Die Software

Die Software erzeugt einen flackernden Lichteffekt mit unterschiedlicher Geschwindigkeit.

Einrichtung

Beim Start definiere ich in setup() die Pins, an die die LEDs angeschlossen sind, als Ausgänge. Ich lasse einen offenen Analog-Pin einmal auslesen und nehme dessen (undefinierten) Wert als Seed für den später besprochenen Pseudo-Zufallszahlengenerator.

Schleife

In der Endlosschleife berechnet das Programm eine neue Zufallszahl und übergibt diese dann an die nachgeschalteten Funktionen. Hier erzeugt ein Zufallszahlengenerator einen Wert, der dann verwendet wird, um

zu bestimmen, welche der acht LEDs leuchten soll
die Zeit festzulegen, für die dieser LED-Status beibehalten werden soll.

Schließlich werden die LEDs entsprechend gesetzt und die Schleife wiederholt sich am Anfang.

Linear rückgekoppeltes Schieberegister

Der Zufallszahlengenerator ist als sogenanntes linear feedback shift register (LSFR) mit einer Länge von 32bit implementiert (wiederholt sein Muster nach max. 2^32 Schritten). Diese Implementierung verwendet den “Galois-Typ” von LFSRs.

Galois LFSR Implementierung

void loop() 
{
 iRandNum = (iRandNum >> 1) ^ (-(iRandNum & 1u) & 0xd0000001u);
 [...]
}

In dieser Codezeile passiert eine Menge, also schauen wir sie uns mal genauer an.

Wesentlich für diese Art von Zufallszahlengeneratoren ist die XOR-Operation, die durch ein ^ in der Mitte der Codezeile angezeigt wird. XOR" bedeutet “eXclusive OR”, das nur dann eine logische 1 ausgibt, wenn die logischen Eingänge A und B unterschiedlich sind. Wenn “A” und “B” beide “0” oder beide “1” sind, wird dieses Gatter “0” ausgeben.

Beispiel für binäres XOR:

 A B Ergebnis
0b00001111 ^ 0b00110011 = 00111100

Links vom XOR-Operator wird die aktuelle Zufallszahl um 1 nach rechts verschoben (>>). Dabei wird ihr gesamter Inhalt wird um ein Bit geschoben. In numerischer Hinsicht bedeutet dies, dass der Wert ganzzahlig durch zwei dividiert wird.

Beispiel für binäres SHIFT:

 A B Ergebnis Als Zahl:
0b00001111 >> 1 = 0b00000111 15 >> 1 = 7

OK, analysieren wir die obige Zeile Code weiter. Direkt neben dem XOR-Operator findet eine weitere Operation statt: Ein logisches AND (&) zwischen unserer aktuellen Zufallszahl und 1u, was “unsigned 1” bedeutet. Dabei werden alle höheren Bits des Zufallszahlengenerators maskiert. Das Ergebnis dieser Aktion ist eine einfache “0”, wenn die Zahl eine “0” als niedrigstwertiges Bit hat usw.

Beispiel für binäres UND:

 A B Ergebnis 
0b00001111 & 1 = 0b00000001

Die Negation am Anfang dieses Terms bedeutet, dass, wenn das Ergebnis des vorherigen & 0 war, der gesamte Term wieder 0b00000000... sein wird. Wenn das Ergebnis -1 lautet, sieht der 2er-Komplement-Binärcode stattdessen wie folgt aus: 0b1111111....

Dies ist eine einfache Möglichkeit, einen einzelnen booleschen Wert auf einen beliebigen längeren Datentyp anzuwenden, ohne eine Verzweigungslogik wie bei einer if()-Klausel zu verwenden.

Und schließlich gibt es ein weiteres logisches AND zwischen diesem Begriff und einer festen Bitmaske 0xd0000001u. Letztere sind die “Anzapfungen” des LFSR, d.h. welche Bits des aktuellen Wertes in das System zurückgeführt werden. Die Aufschlüsselung dieses Hex-Wertes in Boolesche Werte zeigt: 0xd = 0b1101", d.h. die Bits 32, 31, 29 und 1 werden mit der aktuellen Zufallszahl maskiert, so dass nur ihre Werte unberührt bleiben, während alle anderen auf “0” gesetzt werden.

Galois LFSR Zusammenfassung

Puh, das war eine Menge. Es ist Zeit für ein paar Minuten Pause.

Gut, fassen wir die Codezeile oben nochmal zusammen:

iRandNum = (iRandNum >> 1) ^ (-(iRandNum & 1u) & 0xd0000001u);

Bedeutung: “Wenn das niedrigstwertige Bit der aktuellen Zufallszahl Null ist, dann verschiebe die Zufallszahl einfach nach rechts. Andernfalls XOR anwenden mit den abgegriffenen Bits der aktuellen Zufallszahl.”

LFSRs sind weit verbreitet in der drahtlosen Kommunikationstechnik, sie sind interessant für Prüfsummenberechnungen, [Kryptographen](https://medium. com/@czapfel/an-introduction-to-lfsrs-for-cryptography-bf2602640e91) und können sogar bei Programmierspielen nützlich sein, z.B. bei der Erstellung prozeduraler Karten. LFSRs sind einfach zu implementieren (wie man oben sieht, benötigen sie im Extremfall sogar nur eine einzige Codezeile!) und verbrauchen nicht viele Ressourcen. Hier ist ein hervorragender Blogpost, der sich eingehend mit LFSRs beschäftigt, wenn Sie eher der visuelle Typ sind (und weniger der logische). Nachteilig ist, dass ihre “Zufallsqualität” schlecht ist, weil sie deterministisch sind.

Alles in allem fand ich das Thema so interessant, dass ich mich entschlossen habe, hier einen LFSR manuell zu implementieren, anstatt die Arduino-Funktion random() zu verwenden.

Pitfall! Spielszene: prozedurales Leveldesign mittels LFSR ^[1]

Ein Problem bleibt

Nun, wenn Sie die Codezeile vollständig verstanden haben, sehen Sie, was passiert, wenn die Zufallszahl nur Nullen enthält.

Er wird nie wieder aus diesem Zustand herauskommen 💀.

Deshalb sollte man diese Art von LFSR niemals mit “0” initialisieren.

Ansteuerung der LEDs

Der Rest der Software hat viel mehr Zeilen, macht aber auch viel mehr langweilige Sachen. Sie nimmt den generierten 32-Bit-Zufallswert und lässt ihn an den 8 LED-Ausgängen vorbeilaufen, d.h. jede LED “sieht” jedes Bit des Wertes. Zwischen jeder dieser Iterationen wird eine zufällige Verzögerung verwendet, so dass die Flackergeschwindigkeit auf eine Änderungsrate begrenzt ist, die wir Menschen noch wahrnehmen können.

Die Hardware

Zum Glück ist die Hardware einfacher zu erklären als die Software:

Ein Arduino Nano-Board ist mit einem Prototyping-Board verbunden.
Anoden der acht LEDs (+) sind mit den digitalen Ausgängen D2...D9 verbunden.
Ihre Kathoden werden mit Jumpern gebrückt und mit dem “GND” des Arduino verbunden.

Dies ist die einfachste Konstruktion, die mir für diese Aufgabe einfiel.

Verbesserungen

Jede LED sollte einen Vorwiderstand bekommen.
- In meinem Design ist der Strom nur durch den maximalen Strom begrenzt, den der Arduino Pin treiben kann.
- Entweder kann die LED deutlich mehr als 40mA Spitzenstrom verkraften oder sie wird unweigerlich irgendwann durchbrennen.
- Bei der Berechnung des Widerstands sollte man sich an das Datenblatt der LED halten, da verschiedene LED-Farben unterschiedliche Spannungen haben.
- Beispiel für eine Widerstandsberechnung bei einer Versorgungsspannung von 5V für eine Warmweiße LED: 20mA @ 3.1V --> R = U/I = (Usup-Uled) / I = 1.9 / 0.02 = 95Ohm. Nächster Widerstand aus der E6-Reihe 100Ohm.
Jede LED könnte einen Parallelkondensator erhalten.
- Dies würde den Flackereffekt glätten.
- Man könnte Videos aufnehmen, in denen die Kamera nicht durch das Flackern der LEDs gestört wird. Das wäre doch schön.
- Beispiel Kondensatorberechnung: Durchschnittlicher Strom im ausgeschalteten Zustand 20mA, erlaubter Spannungsabfall 0.6V innerhalb von 1ms. Vorgeschlagene Kapazität ist dann 20mA * 1ms / 0.6V = 33uF

Zeit für eine DIY-Replik?

Bitteschön!

Steckbrett-Lagerfeuer DIY Anleitung

1 Jahr CNC 🎂

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Ein Jahr ‘Zerspanobert’, meine Portalfräsmaschine

Wir schreiben März 2023. Meine CNC-Maschine ist seit einem Jahr in Betrieb. Es war ein gutes Jahr. Ich habe eine Menge gelernt und hatte viel Spaß beim Schreiben von Artikeln über meine Fortschritte. Natürlich konnte ich nicht jedes Projekt das ich in dieser Zeit durchgeführt habe dokumentieren bloggen, dennoch soll dieser Artikel das Jahr ein wenig Revue passieren lassen

Die Maschine

Ich kann inzwischen sagen, dass ich die richtige Maschine für meinen Bedarf ausgewählt habe. Es handelt sich um die zweitgünstigste Maschine von Sorotec. Sie bietet viele Eigenschaften “gehobenerer” Portalfräsmaschinen, wie z.B. Kugelumlaufspindeln, 3Nm Stepper, 48V Kleinspannungsschiene, vorgespannte Linearführungen. Um den Preis moderat zu halten, wurde allerdings auf andere Dinge verzichtet. So besitzt sie weder Riemenantriebe für die Schrittmotoren um Platz zu sparen noch doppelte Linearführungen an der Z-Achse oder zusätzliche Versteifungen für Portal, Z-Achse und Hauptrahmen.

Deshalb muss man wissen, welche Lasten grenzwertig sind und sich etwas zurückhalten. Aber das gilt wahrscheinlich auch für steifere Maschinen - sie heben nur die Grenzen an. Was bei meiner Einstellung schnellere Vorschübe oder höhere Schnitttiefen verhindert, ist der Oberfräsenmotor und die Art und Weise, wie er an der Z-Achse befestigt ist.

Der Motor ist eindeutig überfordert mit

Birke Multiplex, Vollnutenfräsen, 6mm Fräser 2-schneidig, S24000, Z+12mm, F4000
HPL, Vollnutenfräsen, 6mm Fräser 2-Schneide, S24000, Z+6.5mm, F3500
Aluminium AlMg1, Vollnutenfräsen, 6mm Fräser einschneidig, S24000, Z+3mm, F1600

Wenn jedoch Schnitttiefe und/oder den Vorschub reduziert wird, kann die Maschine die Arbeit sehr gut ausführen. Die Genauigkeit der Maschine ist ziemlich gut; die wirklich begrenzenden Faktoren sind hier die manuelle Bestimmung des Werkstücknullpunkts sowie der Werkzeuglängensensor aber nicht die Maschine selbst.

Der Vakuumtisch eröffnete die Welt der feinen Gravuren mit Graviersticheln und V-Fräsern. Das Problem war vorher, dass die Verformung des Werkstücks und Ungenauigkeiten des Arbeitstisches dazu führten, dass die Gravuren von sehr unterschiedlicher Qualität waren und größere Toleranzen in der Breite aufwiesen, als ich erwartet hatte. Diese Probleme gibt es jetzt nicht mehr, ebenso wenig wie die zusätzliche Arbeit, Vorrichtungen für kleine oder sperrige Werkstücke herzustellen. Das Halten und Spannen wurde um ein Vielfaches einfacher. Außerdem konnte ich die Z-Sicherheitshöhe reduzieren, was Fräsarbeiten um bis zu 20 % beschleunigte.

Ich konzentrierte mich darauf, die Bearbeitungszeit so weit wie möglich zu reduzieren, damit ich nicht mehr Zeit als nötig mit der Überwachung der Maschine in der kalten Werkstatt verbringen musste. Deshalb habe ich die Maschine und die Fräser absichtlich an ihre Grenzen gebracht was Eilganggeschwindigkeit, Vorschub und Schnitttiefe angeht. Als ich diese Grenzen herausgefunden hatte, drosselte ich die Parameter um 20-30 %, um auf Nummer sicher zu gehen und die Wiederholgenauigkeit hoch zu halten.

Upgrades

Ich habe die Maschine mit einem Vakuumtisch aufgerüstet und konnte viel über Haltekräfte und Volumenstrom lernen, was zü meinem Artikel zur Auswahl der geeigneten Vakuumlösung führte. Ich habe Schwerschaummatten zur Vibrations- und Schalldämmung installiert. Man kann sie im Bild unten etwas schlecht erkennen, aber der gesamte Arbeittisch ist mit Dämmmatten unterfüttert.

Außerdem habe ich eine Absauganlage mit Zyklonabscheider installiert, die während des Fräsvorganges läuft. Die Menge an Spänen, die die Fräse produziert ist wirklich erstaunlich und so bin ich froh, dass ich die Anlage bereits seit Beginn meiner Arbeiten zur Verfügung habe.

Bald werde ich eine HF-Spindel statt meinem Oberfräsmotor einbauen und so Vibrationen, Toleranzen und Geräuschpegel weiter verringern. Letztendlich sollte ich damit die Vorschubwerte erreichen, die ich oben angegeben habe.

Materialien

Ich habe mit Hartholz, Multiplex, MDF, Acrylglas (PMMA), Polystyrol, Hochdrucklaminaten (HPL) und Aluminium-Komposit gearbeitet.

Bei all diesen Werkstoffen musste ich lernen, wie sich die Materialien verhalten und mit welchen Parametern die Fräser betrieben werden müssen, um qualitativ hochwertige Ergebnisse zu erzielen. Einige Materialien waren so anspruchsvoll, dass meine Maschine überlastet war, bei anderen hatte ich Vibrationsprobleme oder Probleme, die gewünschte Qualität zu erreichen. Aber ich konnte immer aus Fehlschlägen lernen und meine Abläufe verbessern, um sie in Zukunft zu vermeiden.

Das Bild oben zeigt eine Absaugschlauchklemme aus PMMA (Acrylglas), die ich an der Z-Achse meiner CNC angebracht habe. Ich habe recht lange dafür gebraucht, die minimalen Fasen genau richtig hinzubekommen und Schlichtvorgänge angewendet, wo ich glaubte, dass sie eine bessere Oberflächengüte bieten könnten.

Software

Bild: Hauptbildschirm der Qr-codengrave-App{: .align-right} Ich habe die Makros der Maschine sowie die Kinematikparameter optimiert, und sogar eine vollständige Anwendung, mit der die CNC QR-Codes in praktisch jedes Plattenmaterial gravieren kann, programmiert. Diese QR-Codes werden von Handykameras bestens erkannt.

Als meine Gravurprojekte immer komplexer wurden, stürzte mein CAM-System bei der Berechnung der Pfade für die Bearbeitung mehrerer Exemplare ständig ab. Daher musste ich die Aneinanderreihung manuell durchführen, was mich dazu brachte, mich mit Koordinatenverschiebungsbefehlen wie G54...G59.3, G68 und G92 zu beschäftigen, die, wenn sie nicht richtig verstanden werden, die Werkstücke arg in Mitleidenschaft ziehen. Dies half mir, die numerische Steuerung und ihre Interpretersprache besser zu verstehen.

Nicht zuletzt war die Lernkurve, die ich durch die Arbeit mit FreeCAD und Estlcam durchlaufen musste, ziemlich steil. Aber da musste ich durch, sonst hätte ich meine Teile nicht fertigen können.

Hilfe und Unterstützung

Zum Glück hatte ich immer Leute, die mir helfen wollten und konnten. Meine Frau war immer für mich da und erlaubte mir, mir Zeit dafür zu nehmen, und meine Kinder besuchten mich häufig im Keller, so dass ich nie einsam war. Mir meiner Frau und einigen guten Freunden konnte ich immer reden, mir Rat geben lassen, wenn die Arbeit frustrierend wurde. Aber auch von kommerzieller Seite hatte ich hervorragende Unterstützung:

Vielen Dank an Willy, Roy und Alex von Sorotec für Ratschläge, Tipps und Tricks, die mir geholfen haben, meine Maschine zu handhaben und eine bessere Lebensdauer aus den Fräsern herauszuholen. Ich habe den direkten Telefonsupport und die schnellen Bearbeitungszeiten für Fräserlieferungen und Garantiereparaturen geschätzt. Ich besuche auch gerne das hobbyline CNC forum für Diskussionen und um meine Geschichten dort zu veröffentlichen und zu diskutieren. So kann ich der Gemeinschaft etwas zurückgeben.

Auch Dank an das Team von EdingCNC, vor allem an Iwona und Pim für Ihre schnellen und ausführlichen Antworten auf Support-Tickets und Controller-Software bezogene Fragen.

Vielen Dank an Jo von Stritzelberger für stundenlange Diskussionen über gute Lösungen für meinen Vakuumtisch und Zubehör.

Von vhf möchte ich mich bei Frau Dressner für die Zeit und die häufigen Gespräche über Schnittqualität, Optimierung der Vorschübe und Geschwindigkeiten für Schaftfräser des Unternehmens sowie Beratung über Materialfrässtrategien bedanken.

Ein weiterer Dank geht an Nicolas von Benezan Electronics für seine Unterstützung bei der Analyse eines Problems mit dem Signal-Breakout-Board und schließlich dessen Austausch.

Dank an Herrn Leibold von Gossen Metrawatt für seine Hilfe bei der Auswahl eines guten Instruments zur Messung von Spannungsspitzen und der Leistungsaufnahme des Systems.

Vielen Dank an Dominik von Spinogy, mit dem ich über ein halbes Jahr lang telefoniert habe, um ein geeignetes Spindel-Upgrade und Zubehör für meine Maschine auszuwählen.

Abschließend möchte ich mich bei Achim von CadAsCam bedanken, für die freundliche Aufnahme von Software-Verbesserungsvorschlägen, die Beantwortung grundlegender Fragen und die extrem schnelle Reaktion mit Software-Updates und Korrekturen. Außerdem war euer kostenloser 2-Tages-Workshop große Klasse!

Laufzeit und Aufträge

Innerhalb eines Jahres habe ich 200 Aufträge mit einer Gesamtlaufzeit von knapp 18 Stunden gefertigt. Wenn ich Einrichten der Fräse auf die Jobs, Montage des Werkstücks und so weiter einbeziehe, kann man die Stundenzahl verdreifachen. Bezieht man zusätzlich meine Arbeitsstunden in CAD und CAM mit ein, wäre die Zahl locker nochmal zu verdoppeln - Man sieht also, dass so ein Hobby zu einem wahren Zeitfresser werden kann - umso wichtiger ist es dann, dass es Spaß macht.

Wie viel Zeit mich Aufbau, Wartung und Pflege der Maschine gekostet haben? Ich weiß es nicht genau. Aber ich schätze, dass es auf Augenhöhe liegt mit dem Betreiben dieser Website, wo die Erstellung von Inhalten für eine Minute Lesedauer mich in etwa eine Stunde in Beschlag nimmt.

Außerdem habe ich viele Stunden damit verbracht, online nach Materialmessgeräten und Fräsern zu suchen, Ratschläge in Foren einzuholen und zu erteilen, nach Maschinen-Upgrades zu suchen und Videos darüber anzusehen, wie andere Leute ihre CNCs benutzen.

Mein derzeitiger Favorit (Stand: März 2023) ist übrigens von CNC Connect (youtube link). Ich werde nicht versuchen, mich damit zu vergleichen - denn ich bin ja kein Profi - aber ich bin immer wieder beeindruckt von Menschen und Herstellern, die ihr Handwerk verstehen.

Kosten

Das CNC-Hobby ist teuer, sowohl in Bezug auf Geld als auch auf Zeit. In meinem Fall habe ich fast 13.000,00€ 😨 in die Maschine, ihr Zubehör, die Spindel, den Maschinentisch, die Stromversorgung und die Schutzausrüstung, die Beleuchtung, die numerische Steuerung, den Laptop, die CAD/CAM/CNC-Software, die Schalldämmung, die Werkzeuge zum Bau der Maschine, die Absauganlage, die persönliche Sicherheitsausrüstung usw. investiert.

Und dabei habe ich noch nicht einmal die Kosten für Schaftfräser erwähnt.

Kurz vor dem Kauf denkt man: “Die Maschine an sich ist nicht allzu teuer”. Aber sobald man sich zum Kauf entschließt, werden sofort weitere Dinge erforderlich. Ich habe fast immer “B” gesagt nachdem ich “A” rief, bin nur wenige Kompromisse bei der Qualität der Ausrüstung eingegangen und habe mich nicht auf ein Material spezialisiert, was die Kosten geringer gehalten hätte.

Ich war fasziniert von den verschiedenen Materialien und ihren Eigenschaften, und es war immer eine Freude, wenn ein Teil wirklich gut wurde, unabhängig von dem Material, aus dem es bestand.

Misserfolge und Lösungen

Hier ist eine Liste größerer Probleme, die ich im letzten Jahr erlebt habe.

Oberfräsenmotor fällt aus bzw. Wackelkontakt im Betrieb. Ⓜ️

Dieses Problem war in Hartholz und Multiplex nach nur 8h Spindelbetrieb reproduzierbar. Die Lösung war der Einbau einer neuen Elektronikplatine, die Maffell kurzerhand lieferte.

Die Geschwindigkeit des Oberfräsenmotors fällt mitten im Auftrag auf die Mindestdrehzahl Ⓜ️

Dieses Problem war ebenfalls reproduzierbar und hatte zwei Ursachen:

Der Not-Aus-Schalter hatte einen geringen Auslöseweg, so dass kurze Kontaktprellungen möglich waren. Der Schalter ist auf dem Maschinentisch montiert und konnte durch Maschinenvibrationen ausgelöst werden. Ich habe dies behoben, indem ich die Position des Mikroschalters im Gehäuse so verändert habe, dass der Schalter nicht vorzeitig ausgelöst wird.
Auf der Breakout-Platine, die das analoge 0-10V-Signal aus dem Pulsbreitenbefehl der CNC erzeugt, war ein falscher Operationsverstärkertyp montiert (nicht RTR). Unter noch unbekannten Umständen (vielleicht Kontaktprellen des Notschalters?) kam es bei diesem Teil zu einem “Latch-up”, so dass die Geschwindigkeit des Oberfräsenmotors auf die niedrigste Einstellung fiel. Ein neues Signal-Breakout-Board wurde montiert und das Problem war damit behoben.

CNC Meldung: “The Velocity was higher than max!” ⚠️

Dieser Fehler trat bei einigen Gelegenheiten auf. Sie waren alle unangenehm. Einmal habe ich meine Maschine zu schnell bewegen lassen (gleichzeitig 240mm/s auf XY, 110mm/s auf Z), was dazu führte, dass sie quietschte und eine Menge Schritte verlor, die sich in den Zentimeterbereich summierten.

Ein anderes Mal, als ich weniger hohe (aber im Nachhinein immer noch zu hohe) Geschwindigkeitswerte eingegeben hatte, machte ich einen Fehler, indem ich Eilgang “G00 Xxx Yyy Zzz” für alle Achsen gleichzeitig befahl, was dazu führte, dass die Maschine beim Abbremsen Schritte verlor und auf der Z-Achse an den mechanischen Endanschlag stieß. Glücklicherweise war es die obere Anschlag, so dass weder die Spindel noch die Maschine bzw. Maschinenbett beschädigt wurden. Nur die Schrittmotorkupplung rutschte durch. Uff.

Der Grund dafür: Die maximale Impulsfrequenz für kombinierte Achsenbewegungen beträgt bei meinem Controller 125kHz. Ich dachte, das sei pro Achse. Das ist falsch. Ich habe das mit dem Hersteller der numerischen Steuerung abgeklärt. Ich musste die Geschwindigkeitswerte der Achsen neu einstellen, um kombiniert unter 125kHz zu bleiben.

Um neue Werte zu finden, habe ich mir meine bisherigen Aufträge angesehen. Ich verliere mehr Zeit bei schnellen Bewegungen der Z-Achse als bei den anderen beiden Achsen. Deshalb habe ich das Hauptaugenmerk auf die Z-Achse gelegt, um sie schnell und mit hoher Beschleunigung zu fahren, während ich die Werte für die X- und Y-Achse reduziert habe. Dabei ist zu beachten, dass die Z-Achse aufgrund ihres kürzeren Kugelumlaufgewindes auf meiner Maschine die doppelte Auflösung hat, so dass die Werte verdoppeln müssen, um sie mit den anderen Achsen vergleichen zu können.

Dies alles geschah nach der Verbesserung der Fertigungsqualität, die ich hier dokumentiert habe. Diese Werte liefern also nachweislich gute Ergebnisse und werden von mir nicht mehr leichtfertig verändert.

Kollision der Maschine mit dem Vakuumtisch 💥

Nun, das hat mich wirklich verärgert. Ich hatte den Tisch noch nicht einmal zwei Wochen, und schon jetzt hatte ich ihn beschädigt. Das Schlimmste war, dass ich nicht verstand, warum.

Alles, was ich wollte, war 18mm Birke Multiplex zu fräsen. Ich ließ den Schruppfräser den Umriss erstellen, sah mich aber mit einem Problem konfrontiert, das mich dazu brachte, den Not-Aus zu drücken, als der Vorgang bereits abgeschlossen war (beim Zurückfahren zu XY0 wäre der Fräser auf ein Hindernis gestoßen). Ich korrigierte den Pfad und setzte die Maschine zurück. Ich wechselte das Werkzeug zum Schlichten und startete den Auftrag.

Als ich merkte, dass die Maschine ungewöhnliche Geräusche von sich gab, betätigte ich den Not-Aus. Aber bei über 4000mm/min zum Schlichten war ich nicht schnell genug, um zu verhindern, dass die Maschine durch den Vakuumtisch fräst.

Ich schaute mir den Arbeitsversatz für die Z-Achse im Variablenspeicher für G92 an. Er war korrekt. Ich suchte in den flüchtigen Variablen der CNC. Alle stimmten mit meinen Erwartungen überein. Dann begann ich, in den Logdateien der Maschine zu suchen. Glücklicherweise habe ich das obige Bild direkt nach diesem Vorfall gemacht, so dass es nicht schwer war, die richtigen Protokollzeilen herauszufinden.

Man kann erkennen, dass die Werkzeuglänge sowohl für den Schrupp- als auch für den Standardfräser gemessen wurde. Der Standardfräser ragt um etwa 3,4 mm weiter heraus. Das ist genau die Tiefe, die mir jetzt auf meinem Vakuumtisch fehlte.

Dennoch hatte ich keine Ahnung, warum die Maschine die aktualisierte Werkzeuglänge nicht berücksichtigte. Also habe ich mir das Makro für den Werkzeugwechsel angesehen.

Man kan sehen, dass Variable #3501 speichert, ob bereits eine Werkzeuglänge gemessen wurde. Wenn dies der Fall ist, kann einfach die neue Werkzeuglänge gemessen und die Differenz zwischen den beiden Werten als Z-Achsen-Korrektur gespeichert werden. Dann wird das Programm mit dem neuen Werkzeug fortgesetzt.

Das Problem ist, dass die Variable #3501 flüchtig ist, wie ein Blick in das Handbuch der Steuerung zeigt. Und es scheint, dass flüchtige Variablen nicht nur zurückgesetzt werden, wenn die Anwendung geschlossen wird, sondern auch, wenn der Not-Aus gedrückt wird.

Ausgehend von meinen vorherigen Aussagen hatte ich das folgende Problem: Das Drücken des Not-Aus löschte den Wert dieser Variablen, behielt aber die ursprüngliche Z0-Höhenmessung bei, die ich ganz am Anfang vor dem Einsatz des Schruppwerkzeugs vorgenommen hatte. Anstatt also die Höhenkorrektur mit dem neuen Werkzeug zu aktualisieren, um der neuen Werkzeuglänge Rechnung zu tragen, dachte das Makro, dass dies das erste verwendete Werkzeug sei und speicherte einfach dessen Länge in der Variablen #4501 (weil man - logisch - keine Differenz nehmen kann, wenn man vor dem ersten Werkzeug kein Werkzeug vermessen hatte).

Das allein hätte den Vorfall gar nicht verursacht, wenn der neu eingesetzte Fräser nicht zufällig weiter aus der Spannzange herausgeragt hätte als der vorherige.

Ich löste das Problem, indem ich dem Makro eine Meldung hinzufügte, wenn es nur die Werkzeuglänge speicherte, aber nicht den Versatz der Z-Achse änderte. Auf diese Weise habe ich zumindest einen Hinweis darauf, dass etwas schief gehen könnte.

Schlussfolgerung

Zusammenfassend kann ich sagen, dass ich die CNC weiterhin benutzen werde. Ich werde nach und nach weiter dazulernen. Und ich werde mein Wissen darüber vertiefen, wie Software mit Mechatronik interagiert, die physikalische Materie verändert, wie es ‘Zerspanobert’ tut. Ich werde versuchen, aufzuschreiben, was ich gelernt habe, damit andere meinen Spuren folgen können, wenn sie wollen.

Ich hoffe, dass ich einen guten Kontakt zu anderen Bastlern, Herstellern und zu den Firmen, mit denen ich bisher zusammenarbeiten durfte, aufrechterhalten kann (und vielleicht noch einige weitere zu meiner Liste hinzufügen können werde).

Bis bald! Schallbert

AnywhereAmps - Alpha

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Mobiler Instrumentenverstärker/Combo-Prototyp basierend auf Shelly13. AnywhereAmps Alpha zeichnet sich durch einen geringen Stromverbrauch und eine kleine Stellfläche aus. Er ist als sehr tragbarer Vollbereichs-Übungsverstärker mit einem Gesamtgewicht von nur 3,1 kg konzipiert. Er verfügt über eine einstellbare Verstärkung und eine 9V DC-Versorgung für externe Effektpedale.

Projekt-Statistiken

Schwierigkeit: Amateur 3/5
Kosten: ~170€
Zeitaufwand: 10h

Impressionen

Impressionen vom Einsatz meines AnywhereAmp Alpha.

Alpha kann auch aufrecht gespielt werden, ideal in kleinen Räumen

9V Spannungswandler für Bodeneffektpedale

Minimalistische Bedienelemente: Ein/Aus Schalter, Verstärkung, 6,3mm Klinke Eingang, 9V Ausgang

31cm Durchmesser, 9l Volumen

Akku auf der Rückseite montiert, zum Abnehmen nach oben ziehen, Restkapazität leicht ablesbar

Vor- und Endstufe sind übereinander angeordnet

Klangbeispiele

Bass samples

Your browser does not support the audio element.

Hauptsächlich höhere Töne

Your browser does not support the audio element.

Hart angeschlagen

Your browser does not support the audio element.

Leersaiten & Flageoletts

Alle Beispiele aufgenommen mit dem H4n von Zoom, Bass: Ibanez SR1500PD gebaut 1992, Tonblende auf Hals-Pickups, Lautstärke-Potentiometer voll aufgedreht.

Abmessungen

Trommelkessel: 12 "x6". Die Gesamthöhe beträgt etwa 17 cm, die Breite 30 cm und die Tiefe (ohne Batterie) 32 cm. Das umschlossene Volumen inkl. Verstärker und Lautsprecher beträgt ~9l. Ich verwende geschlossenes Gehäusedesign.

Sound Hardware

Lautsprecher: 4" Basslautsprecher und zwei Piezo-Hochtöner
Class D-Verstärker mit 30W Leistung (gebrückt)
14,4V Li-Ion Werkzeugakku
Alle empfindlichen Teile befinden sich im Inneren des Gehäuses
Speziell angefertigter Vorverstärker mit 0...27dB einstellbarer Verstärkung

Simulation

Die Simulation zeigt, dass die Lautstärke des ~9l gedämpften Gehäuses perfekt zu dem gewählten 4" Lautsprecher passt. Sie reicht bis auf 44Hz hinunter (F#1, ein Ganzton oberhalb der tiefsten offenen Saite eines (4-Saiter) Basses, E1). Es gibt druckvolle Bässe bei noch guter Präzision. Der Nachteil ist der geringe Wirkungsgrad von nur 78 dB/W/m, so dass die zu erwartende Maximallautstärke bei der Leistungsaufnahme eher gering ist und der Lautsprecher früh an seine Auslenkungsgrenzen kommt.

Vorverstärker im Eigenbau

Der von mir gewählte Class-D-Verstärker benötigt einen Line-Pegel-Eingang, so dass ich einen Vorverstärker in mein Design einbauen musste, um eine ausreichende Lautstärke aus der Endstufe zu erhalten. Selbst die billigsten Vorverstärker wie dieser von Art Pro Audio würden das Design erheblich verteuern. Sie bringen recht viel auf die Waagen und benötigen recht viel Energie, vor allem, wenn es sich um Röhrenvorverstärker handelt. Sie haben oft spezielle Anforderungen an die Eingangsspannung (z. B. nur Wechselstrom). Außerdem würde sich ihr Design nicht in meins einfügen.

Also beschloss ich, selbst eine Verstärkerstufe mit geringem Stromverbrauch aus möglichst wenigen Bauteilen zu entwickeln. Hier klicken um die technischen Details zu überspringen

Spannungsschienen

Da der Vorverstärker Wechselspannungssignale verstärken soll, ich aber nur eine Batteriespannungsschiene zur Verfügung habe, musste ich mir zunächst überlegen, wie ich ein virtuelles Massepotenzial schaffen kann, das den Nullpunkt des Signals für die Verstärkungsstufe darstellt. Glücklicherweise gibt es eine Menge Design-Richtlinien darüber, wie man den Verstärker mit einer einzigen Spannungsquelle betreibt, so dass ich nicht bei Null anfangen musste.

Verstärkungsstufe

AnywhereAmps Alpha sollte ein Mehrzweck-Instrumentencombo sein, so dass ein breiter Verstärkungsbereich zur Verfügung stehen sollte, um alles von einer passiven Gitarre bis zu einem Line-Level-Keyboard auf Spannungspegel zu bringen, mit denen die Endstufe umgehen kann. Deshalb habe ich mich für einen 0-27dB Verstärkungsbereich entschieden und als Widerstände für die Rückkopplungsschleife 10kOhm und ein 250kOhm logarithmisches Potentiometer gewählt.

Schaltungssimulation

Ich habe LTspice von Analog Devices verwendet um zu simulieren, wie sich diese Schaltung bei einem typischen Audiosignal zwischen 20Hz und 20kHz verhalten könnte. Aus meinem Studium erinnere ich mich daran, dass mich ein so genannter Bode-Plot am meisten interessieren müsste. Dieser kann sowohl Amplitude als auch Phasenlage über der Frequenz in einer doppelt-logarithmischen Skala darstellen. Praktischerweise bietet LTspice eine solche Funktion. Wie man sieht, bleibt der Ausgang des Vorverstärkers - grün - bis in den 10kHz-Bereich flach und die Phase verschiebt sich nur geringfügig, während das Eingangssignal - blau - ~27dB darunter bleibt.

Op-Amp Auswahl

Tja. Ich habe dieses Design auf meinem Steckbrett mit einem Mehrzweck-Operationsverstärker den ich herumliegen hatte, aufgebaut. Das klappte… nicht besonders gut. Als ich einen Funktionsgenerator am Eingang anschloss und am Ausgang des LM324 eine Sinuswelle erwartete, erhielt ich am Ausgang überhaupt keine Sinuswelle, sondern einen Halbsinus mit einigen Stufen und entladungsähnlichen Kurven um 0, gefolgt von einem negativen Halbsinus… Nach einiger Suche fand ich heraus, dass dies “Übergabeverzerrung” genannt wird und durch die asymmetrische Ausgangsstufe dieses speziellen Operationsverstärkertyps verursacht wird. Ich konnte den Effekt ein wenig reduzieren, indem ich einen höheren Laststrom am Ausgang anlegte. Aber letztendlich wollte ich einen Operationsverstärker nehmen, der für meine Audioanwendung ohne Rail-to-Rail-Fähigkeit und mit höherem Rauschabstand besser geeignet war. Zum Glück gibt es einige Seiten zu diesem Thema wie Cicfy Research’s Op-Amp shootout. Unter Abwägung eines vernünftigen Stückpreises und der Verfügbarkeit bei meinem Elektronikhändler habe ich mich für den NE5532P entschieden. Das folgende Video zeigt, was ich mit der aktualisierten Op-Amp-Auswahl erreicht habe.

Your browser does not support the video tag.

Sinuswelle am Vorverstärker

Schaltungsentwurf

Ich wollte, dass meine Platine so wenig Platz wie möglich beansprucht, während die Leiterbahnen für die Gleichspannungsversorgung wie ein Rahmen an den Außenseiten der Platine liegen. Die linke Hälfte der Platine ist für die Erzeugung des virtuellen Massepotentials zuständig, während die rechte Hälfte den Verstärkungsteil übernimmt. Das Design ist minimalistisch und verwendet nur vier Widerstände und drei Kondensatoren.

Einen tieferen Einblick in die Technik erhalten Sie in meinen Design-Überlegungen.

Klangqualität

Der AnywhereAmps Alpha ist im Leerlauf absolut leise, selbst bei voll aufgedrehter Verstärkung ist nur ein leichtes Zischen der Hochtöner zu vernehmen. Kein Brummen, kein Kratzen beim Drehen des Gain-Reglers. Dank des weiten Gain-Bereichs von 0dB für Line-Pegel wie Keyboards, Preamp-Instrumente, Mobiltelefone und bis zu +27dB für passive Bässe oder Gitarren-Direkteingänge funktioniert er mit jedem Instrument. Die maximale Lautstärke ist in Ordnung, obwohl die tiefen Töne zu früh “abflachen”, was den nutzbaren Lautstärkebereich z.B. für Orgeln und 5-saitige Bässe einschränkt. Für Frequenzen im Bassbereich bei hoher Lautstärke kommt es immer noch auf die Physik an - je größer, desto besser. Einige Klangbeispiele finden Sie oben.

Zusammenfassung

Für das Gehäuse habe ich bei Cube Personal Drums einige rohe Tom-Tom-Kessel in Sondergröße bestellt. Das Bohren und vor allem das Fräsen einer gekrümmten Oberfläche von Hand erwies sich als schwierig, und die Tatsache, dass ich keine richtige Holzwerkstatt besitze und die ganze Arbeit auf dem Balkon meiner Wohnung erledigte, machte es nicht einfacher. Aber nach ca. 10 Stunden inkl. Löt- und Elektronikarbeiten habe ich jetzt mehr als nur eine super-portable Instrumentenkombination.

Es ist ein Möbelstück.

Ich werde viel darüber spielen. Außerdem motiviert mich der gute Klang mehr denn je, den nächsten Schritt zu tun und die Wiedergabe des Tieftonbereichs mit einem weiteren, größeren Prototyp zu verbessern.

Vorteile:

Ich mag das Design.
Passt in Standard-Tom-Taschen!
Leichtgewicht, 3.1kg inkl. Batterie, 2.6kg ohne
Ladezustand der Batterie kann auf einen Blick abgelesen werden
Verdeckte Bedienelemente: Vermeidet ungewollte Bedienung
Noch robuster: Die gesamte Elektronik und das Lautsprecherchassis sind im Inneren montiert
Inklusive “9V, 1.6A”-Stromversorgungsbuchse für Effekte, Pedale, etc.
Klingt gut für jedes Instrument, da es fast das gesamte hörbare Frequenzspektrum wiedergibt
Läuft >20h mit einer Batterieladung (14,4V, 4Ah) als Übungsverstärker bei moderater Lautstärke
Läuft >3 Stunden mit einer Batterieladung bei maximaler Lautstärke

Unvollkommenheiten:

Zu klein für Subbass-Wiedergabe.
Keine automatische Stummschaltung beim Ein- und Ausschalten des Verstärkers -> Pop-Noise
Natürlich nicht genug Lautstärke, um ein Schlagzeug oder ein Plugged-Band-Setup zu bedienen.
Sieht komisch aus mit den großen Batteriepacks auf der Rückseite. Die Verwendung eines “Flat Pack” wäre schön

AnywhereAmps Alpha: DIY Replik

Eigenbau? Klar, gern. Unten ist die Schritt-für-Schritt-Anleitung verlinkt! AnywhereAmps Alpha DIY Anleitung

Your browser does not support the video tag.

Alpha live!

AnywhereAmps - Alpha 1.1

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Mobiler Instrumenten-Verstärker/Cabinet-Kombi-Prototyp Version 1.1, entwickelt aus AnywhereAmps Alpha.

Projekt-Statistiken

Schwierigkeit: Amateur 3/5
Kosten: ~200€ plus Batteriesystem
Zeitaufwand: 3h

Aktualisierungen gegenüber Alpha 1.0:

Hinzufügen einer Stromüberwachungsschaltung, um sowohl den Verstärker als auch das Akkupack vor abnormalen Spannungen / Strömen zu schützen
Integrierter Ein/Aus-Schalter im Potentiometer
Geringere Komplexität durch Verwendung eines hocheffizienten Breitbandlautsprechers anstelle eines 2-Wege-Systems mit 3 Lautsprechern
Hinzufügen eines hocheffizienten Abwärtswandlers zur Erzeugung einer 9-V-Effektspannungsschiene
Geringere Bauzeit durch Verwendung einer kundenspezifischen Leiterplatte mit Vorverstärker, Abwärtswandler und “Power Supervisor”
Reduzierte Bauzeit, da Großteil der Holzarbeiten an eine Portalfräse (CNC¹) ausgelagert werden konnte
Einschaltknackgeräusche eliminiert durch Hinzufügen eines RC-Filters zum Standby-Eingang der Endstufe

Bauvarianten

Um den Klang meines Prototyps weiter zu verfeinern, habe ich dieses Mal verschiedene Varianten gebaut. Ich habe die Chassis ausgetauscht und den Klang bewertet:

Alpha 1.0: 30W gebrückter Verstärker, 4" Bass und 2x Piezo-Hochtöner: HiFi-ähnlicher Sound mit druckvollen Bässen und klaren Höhen, limitiert in der maximalen Lautstärke
Alpha 1.1 v1: 30W gebrückter Verstärker, 4" PA-Treiber, gute Lautstärke und hohe Präsenz, aber unterrepräsentierte Bässe und Höhen
Alpha 1.1 v2: 30W gebrückter Verstärker, 4" PA-Treiber und Passivmembran, satte Bässe aber etwas dumpf in den Höhen

Meine eigene Platine für Vorverstärker und Zusatzfunktionen

Die AnywhereAmps 1.1 PCB bietet neben dem reinen Vorverstärker plus Tiefpass und Hochpass für Bi-Amping noch einige Zusatzfunktionen. Die Details sind in den folgenden Abschnitten beschrieben.

Power Supervisor

Ich habe eine Power Supervisor-Schaltung hinzugefügt, um zu verhindern, dass die Batterie komplett leer gezogen wird. Außerdem wollte ich die Risiken durch Kurzschlüsse und andere Fehlerzustände, die die Batterie beschädigen könnten, verringern. Die Integration dieser Technologie funktionierte auf Anhieb (was ich nicht erwartet hatte). Der einzige Nachteil ist, dass der Verstärker bei einer Entladung der Batterie auf z. B. 10 % manchmal neu startet, wenn die Versorgungsspannung unter die Auslösespannung des Überwachungsgeräts fällt. Da die Batteriespannung wieder ansteigt, wenn die Last abfällt, schaltet er sich eine Sekunde später wieder ein.

Dies ist eindeutig ein unerwünschtes Verhalten und muss in einem weiteren, verbesserten Prototyp behandelt werden. Ein weiterer Punkt, der diesen Folgeprototypen notwendig macht, ist die Tatsache, dass ich in meinen zukünftigen Entwürfen keine Batterien des Werkzeugherstellers verwenden darf wie hier diskutiert.

9V Abwärtswandler

Zur Erzeugung von zusätzlichen 9V für Geräte wie Effekte, Looper usw. verwende ich einen Schaltregler. Ich wollte das Rauschen reduzieren, indem ich einen “leisen” Schaltregler wählte. Der von mir gewählte Regler wurde für Anwendungen im Automobilbereich entwickelt und hat die Induktivitäten in seinem Gehäuse integriert. Von Nachteil ist, dass der Baustein kaum von Hand gelötet werden kann. Außerdem ist er sehr teuer.

Der Wandler schaltet sich ein, wenn ein Gerät in die entsprechende Buchse eingesteckt wird, so dass es keinen Standby-Strom gibt. Er arbeitet leise (aber nicht ganz rauschfrei) und bietet mehr als genug Leistung für die Anwendungen, die ich bisher habe - ein Looper, ein Kompressor und ein Tuner können problemlos parallel betrieben werden.

Holzbearbeitung

Ich habe ein Portalfräsmaschinen-Set gekauft, um die Holzbearbeitung für AnywhereAmps zu delegieren. Ich wollte weniger Zeit für Sägen und Schleifen aufwenden und die Verarbeitungsqualität sowie die Wiederverwendbarkeit verbessern. Aber um die manuelle Holzbearbeitung durch eine mehr oder weniger automatisierte Bearbeitung zu ersetzen, musste ich zunächst meine Pläne in die digitale Welt übertragen.

Computer Aided Design

Ich wählte FreeCAD als Konstruktionswerkzeug, um Zeichnungen zu erstellen. Die Arbeit damit habe ich in einigen posts dokumentiert und meinen Arbeitsablauf z.B. hier weiter verbessert. Meine erste Skizze zur Herstellung sah so aus.

Mit der Aufteilung der Holzplatte war ich noch nicht ganz zufrieden. Ich fand die Beine zu lang und habe noch einige Stunden in die Verfeinerung des Entwurfs investiert, um weniger Platz zu benötigen, da die Kapazität meiner Portalfräse begrenzt ist.

Computer Aided Manufacturing

Als ich fertig war, exportierte ich die Skizzen als *.dxf-Dateien (Drawing Interchange File Format (DXF), 1982 von AutoDesk eingeführt. Es wurde schließlich zum Industriestandard für den Austausch von 2D-Zeichnungen) und öffnete sie in meinem CAM-Werkzeug, um Werkzeugwege zu definieren, den XY-Nullpunkt und die Z-Tiefe pro Durchgang festzulegen.

G-Code

Am Ende erhält man G-Code-Dateien, die so nachbearbeitet waren, dass sie zur Maschine passten, mit einer geschätzten Bearbeitungszeit von 32 Minuten pro Exemplar. Ich verwendete nur drei Werkzeuge: einen 6-mm-Fräser für die Ausschnitte, einen 2-mm-Fräser für kleinere Löcher und Strukturen und ein Gravierwerkzeug für Fasen und das Logo. Ich teilte die Arbeit in drei Aufträge auf:

job00_clamping, um Löcher und Senkungen zu schneiden, damit das Werkstück am Maschinenbett befestigt werden kann
job01_nesting, um alle Ausschnitte zu fertigen und Gravuren auf dem Verstärkerträger zu machen, aber Anbindungen stehen zu lassen, damit sich die Teile nicht losreißen
job02_finishing, der das Logo auf die (bereits gefärbte) Oberseite graviert und Fasen hinzufügt, wo es nötig ist

Für die Endbearbeitung musste ich die CAD- und CAM-Dateien aktualisieren, damit sie eine gespiegelte (und um -90° gedrehte) Ansicht des Werkstücks liefern. Dies ermöglicht das zweiseitige Fräsen mit demselben XY-Nullpunkt und den exakt gleichen Seiten, die den Anschlag berühren, um minimale Toleranzen zu erzielen.

Nacharbeit

Ich musste noch ein wenig Handarbeit leisten, z. B. Gewindebohrungen abschleifen, Wachs für eine bessere Oberfläche auftragen, und einige Löcher für Streben und Ständer schneiden, die meine CNC nicht fertigen konnte.

Mit der CNC habe ich Adapter für meine Handoberfräse hergestellt, damit sie über die gebogene Oberfläche des Zylinders gleiten kann. Auf diese Weise konnten die Löcher, die ich zuvor für die Lautsprecher geschnitten hatte, richtig abgeschrägt werden.

Außerdem ließ ich von der CNC eine Halterung für das Gehäuse im 3D-Modus anfertigen (mit *.STL-Dateien). Auf diese Weise wird der Kessel an seinem Platz gehalten, wenn ich mit meiner Handbohrmaschine Löcher für die Lautsprecher bohre. Übrigens: 3D-Fräsungen brauchen viel Zeit, da die Nachbearbeitung in kleinen Schritten erfolgt, um eine glatte Oberfläche zu erhalten.

Das Bohren von Löchern mit einem Durchmesser von mehr als 100mm von Hand lässt keine gute Oberflächenqualität auf der Innenseite des Gehäuses zu und die Handhabung des riesigen Bohrers ist immer noch eine Qual. Leider ist meine CNC nicht in der Lage, diese Aufgabe für mich zu übernehmen, daher wird das wohl weiter ein manueller Prozess bleiben.

Eindrücke

Eindrücke meines AnywhereAmps Alpha V1.1

Battery attached and switched on

Front view, initial version of speaker protective grille

A view from below shows the passive radiator, extending the speaker's low-end

Preparing final assembly

A view inside: Ampcarrier and circuits

Allowing the wax to dry before final assembly

Computerized Numerical Control ↩︎

AnywhereAmps - Alpha 1.2

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Alpha 1.2 v1: 2x15W bi-amped, 2x3.2" Hochmitteltöner, 8" Subwoofer: Sehr gut balancierte, trockene Bässe und gute Höhen, in den Mitten etwas zu kräftig, die höchsten Höhen dafür etwas stumpf. Sehr hohes Gewicht.
Alpha 1.2 v2: 2x15W bi-amped, 4" PA Treiber, 5.5" passive membrane, 2x piezo tweeters: Sehr ausgeglichener Sound mit guten Lautstärkereserven, dafür ziemlich aufwändig in der Herstellung

I’ll continue writing here once I selected the best variant.

CarSubAmp

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeit: Anfänger 1/5
Kosten: ~50€ ohne Akku
Zeitaufwand: ~2h

Der CarSubAmp war mein erster Prototyp für einen wirklich tragbaren Basscombo (Lautsprecherbox + Verstärker), der nicht einmal eine Steckdose braucht.

Motivation

Während der Covid19-Pandemie habe ich gerne draußen im Park oder auf dem Balkon Bass gespielt und geübt. Das ist kein Problem, wenn man Kopfhörer trägt und einen kleinen Vorverstärker dabei hat. Aber es gab Gelegenheiten, bei denen ich z.B. mit einer Akustikgitarre zusammen spielen wollte, oder jemand brachte eine Synth-App mit einem MIDI-Keyboard mit - und ich war gezwungen, einen Bluetooth-Lautsprecher zu benutzen, der nicht die Ausgangsleistung hatte um akustisch mitzuhalten. Zu allem überfluss verzögert die interne Signalverarbeitung den Sound so sehr, dass sich das Spielen total abgekoppelt anfühlt.

Problem

Mein richtiger Bassverstärker ist alles andere als mobil. Gewicht: 18kg, Größe: riesig, außerdem: Ohne Steckdose in der Nähe ist er unbrauchbar.

Sackgassen

Anstelle eines Class-D-Verstärkers habe ich den Aux-Eingang eines alten Autoradios verwendet, aber der scheint “Line”-Pegel erwartet zu haben, den mein Bass nicht liefern konnte. Somit war er kaum hörbar. Außerdem war die Stromaufnahme im Leerlauf >0,5A, sodass die Batterie einfach zu schnell leer war.
Ich habe die Stromversorgung zunächst mit einer Powerbank (Power-Delivery) ausprobiert, aber der integrierte Aufwärtswandler schien nicht mit Stromstößen bei voller Lautstärke umgehen zu können, so dass die Versorgungsspannung abfiel, was zu hörbaren Verzerrungen führte.

Lösung

Nach einigem Grübeln kam ich auf die Idee, einen Li-Ion-Akku für ein kabelloses Multitool zu verwenden, der in der Lage ist, Stromstöße problemlos zu bewältigen, ein geringes Gewicht hat, über eine Akkustandsanzeige und die typischen Schutzschaltungen zur Vermeidung von Überlast, Kurzschluss, Übertemperatur, Tiefentladung usw. verfügt. Ich wollte einen Class-D Leistungsverstärker verwenden, der auf den Spannungsbereich dieser Batterie abgestimmt ist, um möglichst energieeffizient und leicht zu sein wie möglich.

Der “CarSubAmp”

Um zu prüfen, ob das Konzept realisierbar war, entnahm ich die Subwoofer-Baugruppe, die normalerweise in der Reserveradmulde sitzt, aus unserem Auto. Ich kaufte eine 20-W-Verstärkerentwicklungsplatine und nachdem ich einige Komponenten angelötet, eine Sicherung und eine 6,3-mm-Eingangsbuchse hinzugefügt hatte, war mein erster Prototyp bereit zum Ausprobieren.

Zusammenfassung

Sehr leicht, <5kg
4Ohm Subwoofer-Baugruppe bereits fertig
belüftetes Design für bessere Lautsprechereffizienz
Der Klang ist in Ordnung. Die Baugruppe ist allerdings nicht als Vollbereichslautsprecher verwendbar, da die Höhen fehlen.
Bei tiefen Tönen (d.h. bei oder unter g1) wird das System merklich leiser
Entwicklerplatine wird ohne Vorverstärker geliefert, daher ist die maximale Lautstärke bereits etwas niedrig
Bei hoher Belastung führt die belüftete Konstruktion (Bassreflex) zu hörbaren Flattergeräuschen
Aufgrund des geringen Durchmessers würde der Lautsprecher bei Hammer-ons auf tiefen Saiten an die Grenzen der Auslenkung stoßen
Alle Komponenten sind mit Heißkleber oder Klebeband befestigt, daher nicht sehr haltbar
Der Aufbau ist mit Klebstoff versiegelt. Es gibt keine einfache Möglichkeit, dafür ein Gehäuse zu bauen.

Obwohl diese Konstruktion eindeutige Nachteile hatte, gefiel sie mir sehr gut. Denn zum ersten Mal konnte ich buchstäblich überall und jederzeit spielen, wann ich wollte. Ich erwischte mich sogar auf der Couch mit diesem kleinen Verstärker, obwohl der “richtige” Verstärker nur einen Raum weiter stand.

Nach einigen Monaten, in denen ich das Ding mit mir herumtrug, 3 Mal kaputte Verbindungen nachlötete und die Batterie immer wieder neu einklebte, beschloss ich, diesem Projekt ein Upgrade zu gönnen.

ClickEncoder

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Mittel 3/5
Kosten: 0€
Zeitaufwand: ~6h

Überblick

Bibliothek für das Arduino Framework, geschrieben in C++.

Der Quellcode selbst besteht nur aus ein paar hundert Zeilen. Er ist leichtgewichtig und leistungsfähig, da der verbesserte Algorithmus weniger Berechnungen benötigt und gleichzeitig eine bessere Zustandsinterpretation bietet als das ursprüngliche Projekt, von dem sie abgezweigt ist. Die Bibliothek ist offiziell auf PlatformIO IDE veröffentlicht und wird auf Github gehostet und gepflegt. Sie enthält Beispiele sowohl für Arduino- als auch für PlatformIO-IDEs und bietet Unittests, die nach der Anpassung an die spezifische Anwendung ausgeführt werden können.

Motivation

Ich habe zunächst die von 0xPIT veröffentlichte Originalbibliothek verwendet, aber diese verursachte bei mir einige Compiler-Warnungen, außerdem waren die Messwerte des Encoders nicht einwandfrei und manchmal gab es Jitter oder zurückspringende Werte, was ich nicht akzeptieren wollte.

Lösung

Da das Archiv ungepflegt aussah und meine Anfrage für Verbesserungen nicht beantwortet wurde, beschloss ich, diese Probleme selbst zu beheben. Ich habe also behutsam einen Teil des Codes umgeschrieben. Für mein damaliges Projekt benötigte ich auch ein “Wiederholungssignal”, wenn eine Taste kontinuierlich gedrückt wird, also fügte ich auch dies hinzu. Schließlich trennte ich den Encoder-Algorithmus von der Tastenbehandlung und stellte separate Klassen bereit, so dass nun bei Bedarf jede beliebige Kombination aus Taste und Encoder verwendet werden kann, jeweils mit konfigurierbarem Verhalten.

Encoder Algorithmus erklärt

API

Die API von ClickEncoder ist einfach und leicht zu verstehen: service() führt die Geschäftslogik aus und die Zustandsinterpretation durch. Diese Methode muss regelmäßig ausgeführt werden, um zu überprüfen, ob der Encoder seit seinem letzten Aufruf bewegt wurde, in welche Richtung, wie viele Schritte, und diese Werte dann in einer Akkumulatorvariablen speichern. getIncrement() gibt die Schrittänderungen des Encoders seit dem letzten Aufruf zurück. getAccumulate() gibt die Summe der Inkremente seit dem Start zurück. getButton() gibt den aktuellen Button-Status zurück.

void service();
int16_t getIncrement();
int16_t getAccumulate();
Button::eButtonStates getButton();

Encoder-Status

Der Encoder verwendet einen Gray Code zur Kodierung der Schritte. getBitCode() wandelt diesen Code, der über die Hardware-Pins A und B des Encoders übertragen wird, in eine “0…3”-Rasten-Interpretation um, wobei die Zahlen bei einer Rechtsdrehung ansteigen und bei einer Linksdrehung abfallen. Dies geschieht effizient ohne Verwendung von if() oder anderer Verzweigungslogik.

uint8_t Encoder::getBitCode()
{
 // GrayCode convert
 // !A && !B --> 0
 // !A && B --> 1
 // A && B --> 2
 // A && !B --> 3
 uint8_t currentEncoderRead = digitalRead(pinA);
 currentEncoderRead |= (currentEncoderRead << 1);
 
 // bit0 of result to be inverted if set
 currentEncoderRead ^= digitalRead(pinB);
 return currentEncoderRead;
}

Ich habe hier mit einem Trick gearbeitet, sodass man sich den Code-Schnipsel oben möglicherweise mehrfach ansehen muss. Der Zustand von PinA wird auf Bit1 von currentEncoderRead geschrieben, indem ich es mit der <<-Operation nach links schiebe. Gleichzeitig bleibt der Status des 0. Bits durch |= aber erhalten. Würde ich jetzt PinB einfach logisch &= anbinden, dann würde ich den Gray-Code verletzen, nachdem A&&B=2 sein sollte und nicht 3.

Sind A und B also beide nicht gesetzt, bleibt das Ergebnis 0, denn 00^00=00=0. Ist nur A gesetzt, B aber nicht, so lautet das Ergebnis 11^00=11=3. Wenn B gesetzt ist, A aber nicht, ergibt sich 00^01=01=1. Sind beide gesetzt, schließlich 11^01=10=2.

Für weitere Informationen zum Thema logische Binäroperationen siehe mein Steckbrett-Lagerfeuer Projekt

Zustandsinterpretation

Nachdem der Bitcode gelesen wurde, wird die Variable rawMovement gesetzt, die uns sagt, wie weit der Encoder zwischen zwei Durchläufen der service() Routine gedreht wurde. Hier sieht man, dass dieser Schritt zeitkritisch ist: Es kommt zu Aliasing-Fehlern, wenn der Geber schneller einmal alle Positionen wechselt, als dass service() erneut aufgerufen wird. In diesem Falle würden Schritte verloren gehen.

void Encoder::handleEncoder()
{
 uint8_t encoderRead = getBitCode();
 // bit0 set = status changed, bit1 set = "overflow 3" where it goes 0->3 or 3->0
 uint8_t rawMovement = encoderRead - lastEncoderRead;
 lastEncoderRead = encoderRead;
 // This is the uint->int magic, converts raw to: -1 counterclockwise, 0 no turn, 1 clockwise
 int8_t signedMovement = ((rawMovement & 1) - (rawMovement & 2));

 encoderAccumulate += signedMovement;
 encoderAccumulate += handleAcceleration(signedMovement);
}

Hier ein weiterer Trick: signedMovement wird berechnet, indem die Bewegung in eine vorzeichenbehaftete Ganzzahl umgewandelt wird, die 0 als “nicht gedreht”, -1 als “links gedreht” und 1 als “rechts gedreht” darstellt. Dabei wird das Verhalten bei Integer-Überlauf ausgenutzt, in Kombination mit der Interpretation von “signedness”.

Abschließend wird die Akkumulation durchgeführt und die Beschleunigung, sofern konfiguriert, dem Akkumulator hinzugefügt, je nachdem, wie schnell der Geber gedreht wird.

Um diese beiden Methoden ohne Verzweigungen zu programmieren, habe ich mehrere Abende Grübelei und praktisch einen halben Block kariertes Papier benötigt. Offen gesagt haben mich diese paar Zeilen Code an den Rande der Leistungsfähigkeit meines Hirns gebracht. Ich habe das Programmieren eben nicht von der Pike auf gelernt 😅

Die Methode getAccumulate()

Sie ist wirklich einfach. Sie gibt nur den internen akkumulierten Wert zurück, der der Konfiguration des Encoders entspricht, wie viele Ticks einen Schritt ausmachen.

int16_t Encoder::getAccumulate()
{
 return (encoderAccumulate / stepsPerNotch);
}

Die Methode getIncrement()

Gibt zurück um wie viele Ticks sich der Encoder seit dem letzten Aufruf dieser Methode bewegt hat.

int16_t Encoder::getIncrement()
{
 int16_t accu = getAccumulate();
 int16_t encoderIncrements = accu - lastEncoderAccumulate;
 lastEncoderAccumulate = accu;
 return (encoderIncrements);
}

Ermittlung des Tasterzustands

Die Methode handleButton()

Alle Tasterzustände leiten sich von zwei Basiszuständen ab: gedrückt oder nicht gedrückt. Dies spiegelt sich in der Logik wider:

void Button::handleButton()
{
 if (lastGetButtonCount < ENC_BUTTONINTERVAL)
 {
 return;
 }
 lastGetButtonCount = 0;

 if (digitalRead(pinBTN) == pinActiveState)
 {
 handleButtonPressed();
 }
 else
 {
 handleButtonReleased();
 }

 if (doubleClickTicks > 0)
 {
 --doubleClickTicks;
 }
}

Der Taster kann so konfiguriert werden, dass er seltener ausgelesen wird als der Encoder. Wenn dies der Fall ist, bleibt diese Methode zwischenzeitlich ohne Aktion.

Taste gedrückt:

handleButtonPressed() kann entweder Closed, Held oder LongPressRepeat zurückgeben, je nachdem wie der Taster konfiguriert ist und wie lange er bereits gedrückt wurde.

Taste nicht gedrückt:

handleButtonReleased() kann entweder Clicked, Released oder Doubleclicked zurückgeben, abhängig von der Konfiguration des Tasters und der Anzahl der Klicks innerhalb einer bestimmten Zeit.

Konfiguration der Bibliothek

Das Verhalten der Encoder/Tastenerkennung kann in der Datei encoder.h mit Hilfe der unten aufgeführten Konstanten geändert werden. Die Werte wurden bereits optimiert und fühlen sich, zumindest für mich, natürlich an. Sie sollten geändert werden, wenn Sie ein anderes Serviceintervall als 1ms verwenden möchten, da diese Werte alle dieses Intervall als Referenz nehmen.

// ----------------------------------------------------------------------------
// Acceleration configuration (for 1ms calls to ::service())
//
constexpr uint8_t ENC_ACCEL_START = 150; // The smaller this value, the quicker you must turn to activate acceleration.
constexpr uint8_t ENC_ACCEL_SLOPE = 75; // the smaller this value, the stronger the acceleration will manipulate values.

// Button configuration (values for 1ms timer service calls)
//
constexpr uint8_t ENC_BUTTONINTERVAL = 20; // check button every x ms, also debouce time
constexpr uint16_t ENC_DOUBLECLICKTIME = 400; // second click within x ms
constexpr uint16_t ENC_LONGPRESSREPEATINTERVAL = 200; // reports repeating-held every x ms
constexpr uint16_t ENC_HOLDTIME = 1200; // report held button after x ms
// ----------------------------------------------------------------------------

Verwenden Sie sie in Ihrem Projekt!

Die Bibliothek ist eine Open-Source-Software, die unter der MIT-Lizenz steht.
PlatformIO-Benutzer? Ganz einfach, suchen Sie sie in der Ansicht ‘Bibliotheken’, die Tags sind Arduino, Encoder, Schallbert. Dann ist es nur noch ein Klick, um sie zu Ihrer Lösung hinzuzufügen.
Alternativ können Sie auch das repository klonen oder forken und die Header/Cpp-Datei nach eigenem Ermessen verwenden.
Sie möchten etwas beitragen? Vielleicht haben Sie eine effizientere Zustandsberechnung für die Taster? Ich würde mich freuen, Ihren Pull Request in meinem Posteingang zu finden.

CNC 'Opferplatte'

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Was ist eine ‘Opferplatte’?

Eine ‘Opferplatte’ ist ein Brett, was auf dem Maschinenbett befestigt und zumeist abgeplant wird. Auf ihm wiederum werden dann die Werkstücke befestigt. Es nennt sich Opferplatte, weil die Fräser beim Durchfräsen des Werkstückes meist einige Zehntel Millimeter tiefer in das Material tauchen als es stark ist, um jegliche Fasern sicher zu trennen und die Werkstückunterseite nicht auszufransen.

Zudem können Werkstücke ohne viel Aufhebens direkt auf der Platte festgeschraubt werden. Ist die Platte einige Zeit in betrieb und droht, uneben zu werden, lässt sie sich meist noch ein paar weitere male abplanen und somit weiternutzen, bevor sie dann nach langem produktiven Einsatz erneuert werden muss.

Ein weiterer Vorteil der Opferplatte ist, dass selbst bei fehlerhaften Fräsbefehlen nicht direkt der teure Maschinentisch in Mitleidenschaft gezogen wird und zumeist sogar der Fräser diese Fehler überlebt.

Projekt-Steckbrief

Schwierigkeitsgrad: mittel 3/5
Kosten: ~60€
Zeitaufwand: ~6h

Zur Anleitung

Das Design verwendet Schlitze für Hammermuttern in verschiedenen Winkeln, um eine sehr flexible Aufspannung zu ermöglichen. Es umfasst auch einen Anschlag, der die Vorbereitung bei Fertigung aus mehreren Plattenrohlingen erleichtert: Der Werkstücknullpunkt liegt immer an der gleichen Stelle, und das Einspannen gegen den Anschlag genügt meist bereits, so dass kein Niederhalten in Z-Richtung erforderlich ist. Der Anschlag hat zwei Aussparungen: Eine zur Aufnahme des Werkzeuglängensensors und eine weitere am XY-Nullpunkt, um Werkzeugkollisionen beim schnellen Positionieren zu vermeiden.

Einfache Einstellung für fast jede CNC

Die Maße, die ich genommen habe, passen für eine Basicline 0607 Portalfräsmaschine. Da ich aber ein parametrisches CAD-Tool verwende, müssen nur die Abmessungen an Ihre Maschine angepasst und einige Zeichnungsfehler behoben werden, sodass eigene Entwürfe schnell von der Hand gehen sollten.

Die Idee

Wie bereits erwähnt, muss meine Opferplatte die folgenden Kriterien erfüllen:

Sie muss auf dem Grundrahmen der CNC-Maschine befestigt werden können (Hammermuttern / M5-Schrauben)
Befestigungspunkt in der Nähe des XY-Nullpunkts
T-Nuten für flexible Montage bei 0°, 22,5°, 45°, 67,5°, 90°
Anschlag, Schnellmontage auf der Opferplatte zur Vereinfachung des Spannens und Verbesserung der Wiederholgenauigkeit
Anschlag zur Aufnahme des Werkzeuglängensensors
Anschlag zur Bereitstellung eines Ausschnitts am XY-Nullpunkt
Soll auf der CNC, für die sie entwickelt wurde, herstellbar sein (bei Bedarf mehrstufig)

Entwurfsphase: CAD

Ich begann mit einer Maßtabelle in Freecad und ein paar leeren Skizzen.

Montage am Grundrahmen

In die Tabellenkalkulation habe ich zunächst die Abmessungen des Grundrahmens und des CNC-Verfahrbereichs sowie die Parameter der Einschlagmutter, der Unterlegscheibe und des Befestigungselements eingegeben. Ich maß die genauen Positionen der T-Muttern des Grundrahmens, an denen ich das Opferplatte befestigen wollte, und gab sie in die Kalkulationstabelle ein.

Danach öffnete ich die erste Skizze und zeichnete das Opferplatten-Rechteck, wobei ich die Abmessungen mit den Daten aus der Tabelle so hinzufügte, dass die Skizze “fully constrained” - also vollständig bestimmt ist. Ich fügte Konstruktionslinien hinzu (d. h. Linien, die in der endgültigen Zeichnung nicht zu sehen sind, aber dazu dienen, Zwangsbedingungen zu verankern, Linien zu zeichnen oder die Symmetrie innerhalb einer Zeichnung zu markieren), wo die Zentren der T-Muttern des Grundrahmens positioniert sind.

Weiter fügte ich konzentrische Kreise für Unterlegscheibensenkungen und Durchgangslöcher in gleichmäßigen Abständen hinzu. Sie werden später die Befestigungselemente und ihre Unterlegscheiben aufnehmen. Über ihre endgültige Position auf der Y-Achse habe ich noch nicht entschieden, da die T-Muttern der Opferplatte einige dieser Befestigungspunkte beeinträchtigen würden.

Die CNC-Bearbeitung für diese Skizze muss auf der “Oberseite” der Opferplatte durchgeführt werden.

Schlitze für T-Muttern und Befestigungspunkte für den Anschlag

Nun war es wieder an der Zeit, der Tabelle einige Daten hinzuzufügen: T-Nut-Parameter, Winkel, Randbreite wie folgt:

Zunächst musste ich auf dem Opferplatte Konstruktionslinien hinzufügen, um den Verfahrbereich der CNC zu markieren. Danach musste ich etwas Platz für den Anschlag reservieren. Erst dann konnte ich mit dem Zeichnen und Positionieren der T-Nuten beginnen, die jeweils unterschiedliche Winkel und Längen hatten, je nachdem, welchen Rand ich aus Stabilitätsgründen beibehalten wollte.

Jede T-Nut erhielt eine Symmetrie-Konstruktionslinie, um die herum zwei Rechtecke zur Markierung der Schlitz- und Falzschultern liegen.

Dann fügte ich Senkungen für Schraubmuttern hinzu, die später den Anschlag am Rand der Opferplatte halten werden. In ihrer Mitte sind Durchgangsbohrungen für die Befestigungselemente vorgesehen.

In einem letzten Schritt passte ich die Positionen der Löcher in der Skizze für die Grundrahmenbefestigung an, wo sie mit den Schlitzen für die T-Muttern kollidierten.

Die CNC-Arbeit für diese Skizze wird auf der “Unterseite” der Opferplatte ausgeführt - die Hammermuttern funktionieren nur, wenn sie von unten greifen.

Anschlag

Hier müssen nur noch einige weitere Daten in das Tabellenblatt eingefügt werden: Ellipsoidabmessungen für den XY-Nullpunktausschnitt, den Werkzeuglängensensor und die Breite des Anschlags auf der Y-Achse. Seine Abmessungen auf der X-Achse waren bereits durch den Verfahrbereich der Maschine vorgegeben.

Das Zeichnen des Anschlags war einfach, da ich mit dem Werkzeug “Kante verbinden” Positionen von Linien aus anderen Skizzen importieren konnte. Der Anschlag ist ein eigener “Job” mit einem eigenen physischen Teil auf der CNC, und er wird nur auf der Oberseite gefräst.

Planungsphase: CAM

Jetzt kam der schwierige Teil: Statt drei Jobs wie oben angegeben, brauchte ich eigentlich sechs. Das liegt daran, dass der Verfahrbereich der CNC kleiner ist als die Abmessungen der Opferplatte. Außerdem plante ich mit Rohlingen, die bereits die richtigen Umrissmaße hatten, damit ich sie auf die Maschine einpassen konnte.

Der erste Teil dieser Arbeit bestand darin, Senkungen und Löcher für das untere Ende der Opferplatten-Halterungen zu schaffen. Ich setzte den Nullpunkt ganz unten links auf der Maschine (X0, Y-max), damit ich sicher sein konnte, dass die relativen Koordinaten passen würden.

Für den oberen Abschnitt wurde das oberste Loch auf der linken Seite als XY-Referenznullpunkt verwendet, der in der vorherigen Arbeit erstellt wurde. Auf diese Weise konnte ich das Material flexibler einspannen.

Ich wiederholte diese Vorgehensweise für die beiden anderen Jobs.

Für die T-Nut Schlitze musste ich die Skizze spiegeln und mein Material um die Y-Achse drehen, da die Unterseite der Opferplatte hier bearbeitet werden musste. Das könnte man auch in CAM machen, aber ich zog es vor, für diese Aufgabe schnell wieder ins CAD zu wechseln.

Für all diese Arbeiten habe ich einen 6-mm-Holzfräser mit 2 Schneiden und einer Fräserlänge von 21mm verwendet. Da dies meine allerersten Schritte mit einer CNC waren, habe ich mit sehr konservativen Parametern für dieses Werkzeug geplant: S24000U/min, F2800mm/min, Z+=6mm, XY+=85%.

Ich habe den ersten Job sogar “in der Luft” ausgeführt, um sicherzugehen, dass ich alles richtig eingestellt hatte.

Ausführung

Ich war ratlos, als ich das Material endlich auf dem Maschinenbett hatte: Wo sollte ich das bloß einspannen? Die Seiten waren durch das Portal belegt, was sich ja bewegen würde. An der Rückseite der Maschine ist bereits die Kellerwand… Würde es also ausreichen, das Werkstück nur an der Vorderseite einzuspannen? Und da ich ganz durchfräsen wollte, sollte ich eine weitere Opferplatte unter meiner Opferplatte anbringen, damit ich nicht versehentlich in das Maschinenbett schnitt?

Ich beschloss, dass diese Einwände berechtigt seien, und wartete, bis das Wochenende vorbei war, um etwas Altholz und mehr doppelseitiges Klebeband zu kaufen.

So habe ich niedergehalten: Standard-Zwingen unten, doppelseitiges Klebeband oben. Hat sehr gut funktioniert.

Bevor ich den Rahmen endgültig auf der Opferplatte befestigte, habe ich ihn mit einer “Spiral”-Strategie abgeplant. Es genügte bereits Z=0,3mm tief zu fräsen. Dabei kam ein 14-mm-Planfräser bei einer Geschwindigkeit von nur 5500U/min zum Einsatz. Fast 30 Minuten vergingen während der Ausführung. Das Ergebnis war eine Oberfläche, die so glatt war wie die des Originalmaterials.

Bewertung

Zum Glück hat am Ende alles geklappt. Wie sauber der die Schnitte sind! MDF und scharfe Schaftfräser scheinen gut miteinander zu harmonieren. Hinweis: Für Arbeiten in MDF braucht man eine wirklich gute Absaugung, da bei der Bearbeitung atemberaubende Mengen an Staub entstehen.

Mit der Gesamtqualität bin ich sehr zufrieden. Jeder einzelne Befestigungspunkt an Maschinenbett und Anschlag passt, und der Werkzeuglängensensor sitzt gut in seiner Aussparung.

Es gibt zwei Dinge zu bemängeln: Der von mir verwendete Schaftfräser ist sehr laut und gibt ein unangenehmes kreischendes Geräusch von sich, dem ich sogar einen Blogbeitrag gewidmet habe. Zweitens habe ich mich in meinem CAM-Tool nicht ausreichend um die Fräsrichtung gekümmert. Auf diese Weise entschied sich das CAM-Tool, einen Durchgang im Gegenlauf und einen weiteren im Gleichlauf durchzuführen (der Schlitz war so breit wie das Werkzeug, für das CAM-Tool ist es also beides Gleichlauffräsen, nur die “Seite” des Werkzeugeingriffs ändert sich). Der Unterschied ist ein sehr kleiner, aber spürbarer Grat an der Kante des Anschlags.

Mit dieser Opferplatte kann ich jetzt Platten bis zu einer Größe von 620 mm x 620 mm bearbeiten!

Nun, ein Manko ist noch der Werkzeuglängensensor. Er ragt in den Arbeitsbereich hinein, was ein Problem darstellt, wenn ich große Werkstücke bearbeiten will und Werkzeugwechsel geplant sind: In diesem Fall verwende ich Makros zur Messung der Werkzeuglänge, weshalb ich den Sensor nicht entfernen möchte. Als Iteration könnte ich den Anschlag so überarbeiten, dass er den Sensor vollständig umschließt.

Vielleicht.

Später.

Datenschutz

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Schallberts Blick auf den Datenschutz

Ich mag ungern getrackt werden. Also versuche ich ebenfalls, andere nicht zu tracken. Daher ist meine Website statisch, muss also keine Inhalte nachladen oder ständig Kontakt zu Drittanbietern halten um korrekt zu funktionieren. Ausnahme ist lediglich mein Kanal auf der Videoplattform MakerTube. Ich nutze gerade so viele Links und Inhalte dritter wie ich unbedingt benötige, um diese Website einigermaßen modern und ihre Navigation bequem gestalten zu können. Sie werden hier kein Cookie Banner oder Ähnliches finden, da diese Website keine Cookies benötigt.

Datenerhebung in Stichpunkten

Diese Website benutzt

Keine Cookies
Kein Tracking
Keine Analyse-Tools wie Google Analytics etc.
Keine eingebetteten Inhalte dritter wie Youtube, Social Media etc.; Ausnahme: mein Kanal auf MakerTube
Alle Links auf meiner Seite sind reine Verweise und verwenden keine Skripte. Solange sie nicht geklickt werden, bekommen Drittanbieter auch nichts von Ihnen mit.
Ich zeichne allerdings fehlgeschlagene Authentifikationsversuche an meinen Server auf, um ihn vor Angriffen zu schützen. Die aus diesem Anlass registrierten IP-Adressen und Zeitstempel der Loginversuche werden automatisiert in rollierenden Logdateien zwischengepuffert und in IPtables der Netzwerkschicht meines Servers für das “Banning” hinterlegt. Nach einer Woche werden die Daten ebenso automatisch gelöscht.
Der Hoster dieser Website ist Hetzner. Auf deren Hardware läuft die von mir gemietete virtuelle Maschine. Hetzner sammelt Logs und einige Daten zur Bereitstellung der Website, welche in Hetzners Datenschutzerklärung eingesehen werden können.

Fragen oder Bedenken?

Schreiben Sie mir gern formlos per Github Discussions: github.com/Schallbert. Ansonsten finden Sie meine Kontaktdaten unter About.

Datenschutzerklärung (das Kleingedruckte nach E-Recht24.de)

1. Datenschutz auf einen Blick

Allgemeine Hinweise

Die folgenden Hinweise geben einen einfachen Überblick darüber, was mit Ihren personenbezogenen Daten passiert, wenn Sie diese Website besuchen. Personenbezogene Daten sind alle Daten, mit denen Sie persönlich identifiziert werden können. Ausführliche Informationen zum Thema Datenschutz entnehmen Sie unserer unter diesem Text aufgeführten Datenschutzerklärung.

Datenerfassung auf dieser Website

Wer ist verantwortlich für die Datenerfassung auf dieser Website?

Die Datenverarbeitung auf dieser Website erfolgt durch den Websitebetreiber. Dessen Kontaktdaten können Sie dem Abschnitt „Hinweis zur Verantwortlichen Stelle“ in dieser Datenschutzerklärung entnehmen.

Wie erfassen wir Ihre Daten?

Ihre Daten werden zum einen dadurch erhoben, dass Sie uns diese mitteilen. Hierbei kann es sich z. B. um Daten handeln, die Sie in ein Kontaktformular eingeben. Andere Daten werden automatisch oder nach Ihrer Einwilligung beim Besuch der Website durch unsere IT-Systeme erfasst. Das sind vor allem technische Daten (z. B. Internetbrowser, Betriebssystem oder Uhrzeit des Seitenaufrufs). Die Erfassung dieser Daten erfolgt automatisch, sobald Sie diese Website betreten.

Wofür nutzen wir Ihre Daten?

Ein Teil der Daten wird erhoben, um eine fehlerfreie Bereitstellung der Website zu gewährleisten. Andere Daten können zur Analyse Ihres Nutzerverhaltens verwendet werden.

Welche Rechte haben Sie bezüglich Ihrer Daten?

Sie haben jederzeit das Recht, unentgeltlich Auskunft über Herkunft, Empfänger und Zweck Ihrer gespeicherten personenbezogenen Daten zu erhalten. Sie haben außerdem ein Recht, die Berichtigung oder Löschung dieser Daten zu verlangen. Wenn Sie eine Einwilligung zur Datenverarbeitung erteilt haben, können Sie diese Einwilligung jederzeit für die Zukunft widerrufen. Außerdem haben Sie das Recht, unter bestimmten Umständen die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen. Des Weiteren steht Ihnen ein Beschwerderecht bei der zuständigen Aufsichtsbehörde zu. Hierzu sowie zu weiteren Fragen zum Thema Datenschutz können Sie sich jederzeit an uns wenden.

2. Hosting

Externes Hosting

Diese Website wird bei einem externen Dienstleister gehostet (Hoster). Die personenbezogenen Daten, die auf dieser Website erfasst werden, werden auf den Servern des Hosters gespeichert. Hierbei kann es sich v. a. um IP-Adressen, Kontaktanfragen, Meta- und Kommunikationsdaten, Vertragsdaten, Kontaktdaten, Namen, Websitezugriffe und sonstige Daten, die über eine Website generiert werden, handeln. Der Einsatz des Hosters erfolgt zum Zwecke der Vertragserfüllung gegenüber unseren potenziellen und bestehenden Kunden (Art. 6 Abs. 1 lit. b DSGVO) und im Interesse einer sicheren, schnellen und effizienten Bereitstellung unseres Online-Angebots durch einen professionellen Anbieter (Art. 6 Abs. 1 lit. f DSGVO). Sofern eine entsprechende Einwilligung abgefragt wurde, erfolgt die Verarbeitung ausschließlich auf Grundlage von Art. 6 Abs. 1 lit. a DSGVO und § 25 Abs. 1 TTDSG, soweit die Einwilligung die Speicherung von Cookies oder den Zugriff auf Informationen im Endgerät des Nutzers (z. B. Device-Fingerprinting) im Sinne des TTDSG umfasst. Die Einwilligung ist jederzeit widerrufbar. Unser Hoster wird Ihre Daten nur insoweit verarbeiten, wie dies zur Erfüllung seiner Leistungspflichten erforderlich ist und unsere Weisungen in Bezug auf diese Daten befolgen.

Wir setzen folgenden Hoster ein:

Hetzner Online GmbH
Industriestr. 25
91710 Gunzenhausen
Germany

Tel.: +49 (0)9831 505-0
Fax: +49 (0)9831 505-3

Email: info@hetzner.com

3. Allgemeine Hinweise und Pflichtinformationen

Datenschutz

Die Betreiber dieser Seiten nehmen den Schutz Ihrer persönlichen Daten sehr ernst. Wir behandeln Ihre personenbezogenen Daten vertraulich und entsprechend den gesetzlichen Datenschutzvorschriften sowie dieser Datenschutzerklärung. Wenn Sie diese Website benutzen, werden verschiedene personenbezogene Daten erhoben. Personenbezogene Daten sind Daten, mit denen Sie persönlich identifiziert werden können. Die vorliegende Datenschutzerklärung erläutert, welche Daten wir erheben und wofür wir sie nutzen. Sie erläutert auch, wie und zu welchem Zweck das geschieht. Wir weisen darauf hin, dass die Datenübertragung im Internet (z. B. bei der Kommunikation per E-Mail) Sicherheitslücken aufweisen kann. Ein lückenloser Schutz der Daten vor dem Zugriff durch Dritte ist nicht möglich.

Hinweis zur verantwortlichen Stelle

Die verantwortliche Stelle für die Datenverarbeitung auf dieser Website ist:

Verantwortliche Stelle ist die natürliche oder juristische Person, die allein oder gemeinsam mit anderen über die Zwecke und Mittel der Verarbeitung von personenbezogenen Daten (z. B. Namen, E-Mail-Adressen o. Ä.) entscheidet.

Speicherdauer

Soweit innerhalb dieser Datenschutzerklärung keine speziellere Speicherdauer genannt wurde, verbleiben Ihre personenbezogenen Daten bei uns, bis der Zweck für die Datenverarbeitung entfällt. Wenn Sie ein berechtigtes Löschersuchen geltend machen oder eine Einwilligung zur Datenverarbeitung widerrufen, werden Ihre Daten gelöscht, sofern wir keine anderen rechtlich zulässigen Gründe für die Speicherung Ihrer personenbezogenen Daten haben (z. B. steuer- oder handelsrechtliche Aufbewahrungsfristen); im letztgenannten Fall erfolgt die Löschung nach Fortfall dieser Gründe.

Allgemeine Hinweise zu den Rechtsgrundlagen der Datenverarbeitung auf dieser Website

Sofern Sie in die Datenverarbeitung eingewilligt haben, verarbeiten wir Ihre personenbezogenen Daten auf Grundlage von Art. 6 Abs. 1 lit. a DSGVO bzw. Art. 9 Abs. 2 lit. a DSGVO, sofern besondere Datenkategorien nach Art. 9 Abs. 1 DSGVO verarbeitet werden. Sofern Sie in die Speicherung von Cookies oder in den Zugriff auf Informationen in Ihr Endgerät (z. B. via Device-Fingerprinting) eingewilligt haben, erfolgt die Datenverarbeitung zusätzlich auf Grundlage von § 25 Abs. 1 TTDSG. Die Einwilligung ist jederzeit widerrufbar. Sind Ihre Daten zur Vertragserfüllung oder zur Durchführung vorvertraglicher Maßnahmen erforderlich, verarbeiten wir Ihre Daten auf Grundlage des Art. 6 Abs. 1 lit. b DSGVO. Des Weiteren verarbeiten wir Ihre Daten, sofern diese zur Erfüllung einer rechtlichen Verpflichtung erforderlich sind auf Grundlage von Art. 6 Abs. 1 lit. c DSGVO. Die Datenverarbeitung kann ferner auf Grundlage unseres berechtigten Interesses nach Art. 6 Abs. 1 lit. f DSGVO erfolgen. Über die jeweils im Einzelfall einschlägigen Rechtsgrundlagen wird in den folgenden Absätzen dieser Datenschutzerklärung informiert.

Hinweis zur Datenweitergabe in die USA und sonstige Drittstaaten

Wir verwenden unter anderem Tools von Unternehmen mit Sitz in den USA oder sonstigen datenschutzrechtlich nicht sicheren Drittstaaten. Wenn diese Tools aktiv sind, können Ihre personenbezogene Daten in diese Drittstaaten übertragen und dort verarbeitet werden. Wir weisen darauf hin, dass in diesen Ländern kein mit der EU vergleichbares Datenschutzniveau garantiert werden kann. Beispielsweise sind US-Unternehmen dazu verpflichtet, personenbezogene Daten an Sicherheitsbehörden herauszugeben, ohne dass Sie als Betroffener hiergegen gerichtlich vorgehen könnten. Es kann daher nicht ausgeschlossen werden, dass US-Behörden (z. B. Geheimdienste) Ihre auf US-Servern befindlichen Daten zu Überwachungszwecken verarbeiten, auswerten und dauerhaft speichern. Wir haben auf diese Verarbeitungstätigkeiten keinen Einfluss.

Widerruf Ihrer Einwilligung zur Datenverarbeitung

Viele Datenverarbeitungsvorgänge sind nur mit Ihrer ausdrücklichen Einwilligung möglich. Sie können eine bereits erteilte Einwilligung jederzeit widerrufen. Die Rechtmäßigkeit der bis zum Widerruf erfolgten Datenverarbeitung bleibt vom Widerruf unberührt.

Widerspruchsrecht gegen die Datenerhebung in besonderen Fällen sowie gegen Direktwerbung (Art. 21 DSGVO)

WENN DIE DATENVERARBEITUNG AUF GRUNDLAGE VON ART. 6 ABS. 1 LIT. E ODER F DSGVO ERFOLGT, HABEN SIE JEDERZEIT DAS RECHT, AUS GRÜNDEN, DIE SICH AUS IHRER BESONDEREN SITUATION ERGEBEN, GEGEN DIE VERARBEITUNG IHRER PERSONENBEZOGENEN DATEN WIDERSPRUCH EINZULEGEN; DIES GILT AUCH FÜR EIN AUF DIESE BESTIMMUNGEN GESTÜTZTES PROFILING. DIE JEWEILIGE RECHTSGRUNDLAGE, AUF DENEN EINE VERARBEITUNG BERUHT, ENTNEHMEN SIE DIESER DATENSCHUTZERKLÄRUNG. WENN SIE WIDERSPRUCH EINLEGEN, WERDEN WIR IHRE BETROFFENEN PERSONENBEZOGENEN DATEN NICHT MEHR VERARBEITEN, ES SEI DENN, WIR KÖNNEN ZWINGENDE SCHUTZWÜRDIGE GRÜNDE FÜR DIE VERARBEITUNG NACHWEISEN, DIE IHRE INTERESSEN, RECHTE UND FREIHEITEN ÜBERWIEGEN ODER DIE VERARBEITUNG DIENT DER GELTENDMACHUNG, AUSÜBUNG ODER VERTEIDIGUNG VON RECHTSANSPRÜCHEN (WIDERSPRUCH NACH ART. 21 ABS. 1 DSGVO). WERDEN IHRE PERSONENBEZOGENEN DATEN VERARBEITET, UM DIREKTWERBUNG ZU BETREIBEN, SO HABEN SIE DAS RECHT, JEDERZEIT WIDERSPRUCH GEGEN DIE VERARBEITUNG SIE BETREFFENDER PERSONENBEZOGENER DATEN ZUM ZWECKE DERARTIGER WERBUNG EINZULEGEN; DIES GILT AUCH FÜR DAS PROFILING, SOWEIT ES MIT SOLCHER DIREKTWERBUNG IN VERBINDUNG STEHT. WENN SIE WIDERSPRECHEN, WERDEN IHRE PERSONENBEZOGENEN DATEN ANSCHLIESSEND NICHT MEHR ZUM ZWECKE DER DIREKTWERBUNG VERWENDET (WIDERSPRUCH NACH ART. 21 ABS. 2 DSGVO).

Beschwerderecht bei der zuständigen Aufsichtsbehörde

Sie haben das Recht, Daten, die wir auf Grundlage Ihrer Einwilligung oder in Erfüllung eines Vertrags automatisiert verarbeiten, an sich oder an einen Dritten in einem gängigen, maschinenlesbaren Format aushändigen zu lassen. Sofern Sie die direkte Übertragung der Daten an einen anderen Verantwortlichen verlangen, erfolgt dies nur, soweit es technisch machbar ist.

SSL- bzw. TLS-Verschlüsselung

Diese Seite nutzt aus Sicherheitsgründen und zum Schutz der Übertragung vertraulicher Inhalte, wie zum Beispiel Bestellungen oder Anfragen, die Sie an uns als Seitenbetreiber senden, eine SSL- bzw. TLS-Verschlüsselung. Eine verschlüsselte Verbindung erkennen Sie daran, dass die Adresszeile des Browsers von „http://“ auf „https://“ wechselt und an dem Schloss-Symbol in Ihrer Browserzeile. Wenn die SSL- bzw. TLS-Verschlüsselung aktiviert ist, können die Daten, die Sie an uns übermitteln, nicht von Dritten mitgelesen werden.

Auskunft, Löschung und Berichtigung

Sie haben im Rahmen der geltenden gesetzlichen Bestimmungen jederzeit das Recht auf unentgeltliche Auskunft über Ihre gespeicherten personenbezogenen Daten, deren Herkunft und Empfänger und den Zweck der Datenverarbeitung und ggf. ein Recht auf Berichtigung oder Löschung dieser Daten. Hierzu sowie zu weiteren Fragen zum Thema personenbezogene Daten können Sie sich jederzeit an uns wenden.

Recht auf Einschränkung der Verarbeitung

Sie haben das Recht, die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen. Hierzu können Sie sich jederzeit an uns wenden. Das Recht auf Einschränkung der Verarbeitung besteht in folgenden Fällen:

Wenn Sie die Richtigkeit Ihrer bei uns gespeicherten personenbezogenen Daten bestreiten, benötigen wir in der Regel Zeit, um dies zu überprüfen. Für die Dauer der Prüfung haben Sie das Recht, die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen.
Wenn die Verarbeitung Ihrer personenbezogenen Daten unrechtmäßig geschah/geschieht, können Sie statt der Löschung die Einschränkung der Datenverarbeitung verlangen.
Wenn wir Ihre personenbezogenen Daten nicht mehr benötigen, Sie sie jedoch zur Ausübung, Verteidigung oder Geltendmachung von Rechtsansprüchen benötigen, haben Sie das Recht, statt der Löschung die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen.
Wenn Sie einen Widerspruch nach Art. 21 Abs. 1 DSGVO eingelegt haben, muss eine Abwägung zwischen Ihren und unseren Interessen vorgenommen werden. Solange noch nicht feststeht, wessen Interessen überwiegen, haben Sie das Recht, die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen.

Wenn Sie die Verarbeitung Ihrer personenbezogenen Daten eingeschränkt haben, dürfen diese Daten – von ihrer Speicherung abgesehen – nur mit Ihrer Einwilligung oder zur Geltendmachung, Ausübung oder Verteidigung von Rechtsansprüchen oder zum Schutz der Rechte einer anderen natürlichen oder juristischen Person oder aus Gründen eines wichtigen öffentlichen Interesses der Europäischen Union oder eines Mitgliedstaats verarbeitet werden.

4. Datenerfassung auf dieser Website

Server-Log-Dateien

Der Provider der Seiten erhebt und speichert automatisch Informationen in so genannten Server-Log-Dateien, die Ihr Browser automatisch an uns übermittelt. Dies sind:

Browsertyp und Browserversion
verwendetes Betriebssystem
Referrer URL
Hostname des zugreifenden Rechners
Uhrzeit der Serveranfrage
IP-Adresse Eine Zusammenführung dieser Daten mit anderen Datenquellen wird nicht vorgenommen. Die Erfassung dieser Daten erfolgt auf Grundlage von Art. 6 Abs. 1 lit. f DSGVO. Der Websitebetreiber hat ein berechtigtes Interesse an der technisch fehlerfreien Darstellung und der Optimierung seiner Website – hierzu müssen die Server-Log-Files erfasst werden.

Anfrage per E-Mail oder Telefon

Wenn Sie uns per E-Mail oder Telefon kontaktieren, wird Ihre Anfrage inklusive aller daraus hervorgehenden personenbezogenen Daten (Name, Anfrage) zum Zwecke der Bearbeitung Ihres Anliegens bei uns gespeichert und verarbeitet. Diese Daten geben wir nicht ohne Ihre Einwilligung weiter. Die Verarbeitung dieser Daten erfolgt auf Grundlage von Art. 6 Abs. 1 lit. b DSGVO, sofern Ihre Anfrage mit der Erfüllung eines Vertrags zusammenhängt oder zur Durchführung vorvertraglicher Maßnahmen erforderlich ist. In allen übrigen Fällen beruht die Verarbeitung auf unserem berechtigten Interesse an der effektiven Bearbeitung der an uns gerichteten Anfragen (Art. 6 Abs. 1 lit. f DSGVO) oder auf Ihrer Einwilligung (Art. 6 Abs. 1 lit. a DSGVO) sofern diese abgefragt wurde. Die von Ihnen an uns per Kontaktanfragen übersandten Daten verbleiben bei uns, bis Sie uns zur Löschung auffordern, Ihre Einwilligung zur Speicherung widerrufen oder der Zweck für die Datenspeicherung entfällt (z. B. nach abgeschlossener Bearbeitung Ihres Anliegens). Zwingende gesetzliche Bestimmungen, insbesondere gesetzliche Aufbewahrungsfristen, bleiben unberührt.

Quelle:

e-recht24.de

Diese Website programmieren

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Mittel 3/5
Kosten: 0€
Zeitaufwand: ~15h

Die Idee

Die Idee entstand durch mein MobFobAmp-Projekt, für das ich kein Github-Repository hatte, da es keinen Code oder ähnliche Dokumentation gab. Also beschloss ich eine Website einzurichten, auf der ich Anleitungen für dieses Open-Hardware-Projekt bereitstellen kann, damit andere das Projekt nachbauen können. Ich wollte eine einfach zu hostende Lösung, die nicht zu viel Arbeit beim Einrichten erfordert. Da ich keinen eigenen Server habe, habe ich um Hilfe gebeten. moritzmar empfahl mir, für den Anfang “Github-Pages” als Site-Host zu verwenden, um eine einfache automatische Bereitstellung und globale Reichweite zu gewährleisten. Also habe ich das mal ausprobiert.

Erste Schritte

Eine statische Site kam mir genau Recht. Ohne die Notwendigkeit einer Datenbank oder eines großen Content-Management-Frameworks bleibt mein Site-Layout einfach und minimalistisch; ich wollte am Anfang nur dieses eine Projekt hosten. Github empfiehlt die Verwendung von Jekyll

Jekyll Logo ^[1]

als Website-Generator. Ich hatte einige Probleme mit dem Windows Subsystem für Linux (WSL), da es meine Terminaleingaben nicht akzeptierte, also folgte ich der Anleitung und verwendete den RubyInstaller, der bei mir sofort funktionierte.

Einrichtung der Site

Mir wurde klar, dass ich vielleicht mehrere meiner Projekte dokumentieren möchte. Deshalb kam ich auf die Idee, Projekte in Gruppen zusammenzufassen, jede mit einer Überschrift, einem kleinen Text und einem Miniaturbild. Wenn man darauf klickt, kommt man auf die jeweilige Projektseite. Das würde eine Menge Programmierarbeit für die Seiteneinrichtung und das Layout bedeuten, mit der ich nicht allzu viel Zeit verbringen wollte - meine anderen Projekte warten…

Erster Versuch mit Themes

Also folgte ich einer weiteren Anregung von Github-Pages: Die Verwendung von vordefinierten “Themes”. Zuerst habe ich das Agency Theme verwendet. Es hat eine tolle Landing Page mit einem großen Bild und unterstützt Sammlungen, die das von mir gewünschte Gruppieren von Projekten ermöglichen. Leider ist das Thema ein “Remote-Thema”, so dass die Anpassungsmöglichkeiten begrenzt waren, z. B. konnte ich eine Sammlung nicht auf eine andere Seite verweisen lassen, sondern es öffnete sich immer ein “Popup”, und das wollte ich einfach nicht. (Später habe ich herausgefunden, dass Remote-Layouts überschrieben werden können, aber da war es zu spät, denn ich hatte bereits zu einem anderen Theme-Anbieter gewechselt…) Das Theme, das ich derzeit verwende, ist das “Minimal Mistakes Theme” (siehe Fußzeile der Website), das sehr gut dokumentiert ist. Nach dem Herunterladen und ein paar ersten Schritten kämpfte ich mit benutzerdefinierten Farben (_sass) und den Kollektionen - wieder einmal - da ich zunächst nicht verstand, wie Jekyll die Bindungen hinter den Kulissen durchführt. Einige meiner Schwierigkeiten sind in den Blog-Beiträgen vom Juni 2021 zu finden.

Seitenlayouts: Hero Screens

Um die Navigation einfach und intuitiv zu gestalten, sollte man sich ein paar Gedanken darüber machen, wie das Layout der Seite aussehen soll. Die Herangehensweise wird sich bei jedem Seitentyp aufgrund der unterschiedlichen Komplexität und Dokumentstruktur unterscheiden.

Auf der Landing-/Homepage zum Beispiel soll die Navigation mitlaufen, so dass die Kategorien der Website immer sichtbar sind. Sie soll ein großes, breites Overlay-Bild mit der Seitenbeschreibung erhalten. Darunter sollen die neuesten Beiträge aufgelistet werden. Dies ist das Beispiel für die “Hero Pages” der Kollektion:

Die Projekte und ihre Inhalte enthalten eine Seitennavigation in der linken Seitenleiste, können ein scrollbares Panoramabild enthalten und haben eine breite Einstellung, um eine große Menge an Text im Inhaltsbereich anzuzeigen.

Die “hero screen”-Skizzen für die Layouts dieser Website finden Sie hier.

Sammlungen / Kollektionen

Sammlungen (englisch “Collections”) sind eine gute Möglichkeit, Inhalte zu gruppieren. Sehen Sie sich meine Open Hardware Projekte Seite an. Sie können alle Projekte in dieser Kategorie mit einem kleinen Teaser-Bild und einer Beschreibung finden, um einen Überblick zu bekommen.

So kann die Konfiguration der Sammlung aussehen:

Überlegen Sie sich einen passenden Namen für Ihre Sammlung, z.B. electronics.
Der Name der Sammlung wird in _config.yml als collections: electronics definiert.
Der Sammlungsname muss in #defaults als type: electronics gesetzt werden, damit Jekyll weiß, wie der tatsächliche Inhalt zu interpretieren ist.
Eine Sammlungsseite muss erstellt werden (z.B. im Ordner _pages) mit dem Attribut collection: electronics. Dies ist die Seite, die die Übersicht der Artikel in der Sammlung anzeigt.
Es muss ein Ordner mit demselben Namen wie der Name der Sammlung mit führendem Unterstrich erstellt werden: _electronics.
Alle Dokumente in diesem Ordner werden nach einem vollständigen Bauvorgang automatisch auf der Sammlungsseite angezeigt.
Diese Dokumente sollten ein “front matter” (Abschnitt vor dem eigentlichen Inhalt in der Datei, gekennzeichnet mit ---) erhalten, damit sie wie in der entsprechenden _layouts-Datei beschrieben angezeigt werden können, z.B. collection. Vergisst man dies, wirft einem Jekyll in der Konsole seitenlange, unverständliche Fehlermeldungen um die Ohren.

Mehr als das Standard-Theme

Ich habe zwar einige Theme-Standardeinstellungen überschrieben, verwende aber zumeist die bestehendenTheme-Infrastruktur. Dennoch hat meine Seite ein paar spezielle Anforderungen, so dass ich das Theme anpassen und neue Funktionen hinzufügen musste. Diese werden in den folgenden Abschnitten beschrieben.

Da der Navigationsbaum meiner Website ziemlich flach ist und ich nicht viele Seiten habe, zu denen ich navigieren muss, wollte ich, dass die linke Seitenleiste die Seitennavigation und nicht die Website-Navigation enthält. Daher bräuchte ich keine rechte Seitenleiste, so dass mehr Platz für den Seiteninhalt zur Verfügung stünde.

Inhaltsverzeichnis auf der linken Seite

Wie hier und dort geschrieben, war ich nie 100%ig zufrieden damit, wie meine Projektseiten aussahen:

Die ursprüngliche Idee des Themes ist, dass der Inhalt von zwei Seitenleisten eingerahmt wird. Die linke kann entweder Autoreninformationen, benutzerdefinierte Inhalte oder die Seitennavigation anzeigen. Der Inhaltsbereich ist zwischen breit und normal konfigurierbar, wobei in letzterem Fall Platz für eine zweite Seitenleiste auf der rechten Seite bleibt. Die rechte Seitenleiste ist so konfigurierbar, dass sie entweder gar nicht vorhanden ist oder das Inhaltsverzeichnis der Seite anzeigt.

Das Ziel war also die rechte Seitenleiste für mein Design zu eliminieren und statt der Seitennavigation in der linken Seitenleiste die Seitennavigation dorthin zu verschieben.

Es geht um den Ordner /_layouts, in dem Informationen darüber gespeichert werden, wie ein Seitenlayout aussehen soll. Das fragliche Seitendesign heißt single.html und ruft an einer bestimmten Stelle include sidebar.html auf, das sich in /_includes/sidebar.html befindet. Also habe ich mir einen neuen Parameter ausgedacht, mit dem ich die Anzeige des Inhaltsverzeichnisses in der linken Seitenleiste steuern kann, habe toc_left gewählt und eine Bedingung hinzugefügt:

<div class="sidebar sticky">
<!-- ...
{.% if page.toc_left %}
 {.% include toc_left nav=page.toc_left %}
{.% endif %}
... -->
</div>

(Trick: Ich musste jinja code auskommentieren und mit ... anführen, denn Liquid würde sie sonst selbst als Kommandos erkennen)

Implementierung des Inhaltsverzeichnisses

Es sollte in der linken Seitenleiste erscheinen. Also muste ich nur eine Datei namens toc_left erzeugen, die den Generator für das Inhaltsverzeichnis wie folgt aufruft:

<aside class="toc_left">
<nav class="toc" markdown="1">
<header><h4 class="nav__title"><i class="fas fa-{{ include.icon | default: 'file-alt' }}"></i>
<!-- ...
{.{ include.title | .default: site.data.ui-text[site.locale].toc_label }}</h4></header>
{.% include toc.html sanitize=true html=content h_min=1 h_max=6 class="toc__menu" skip_no_ids=true %} 
... -->
</nav>
</aside>

Audio-Einbettungen

Audio-Embeds sind diese kleinen Player-ähnlichen Dinger auf einer Website, die oft zu einer Streaming-Plattform oder ähnlichem weiterleiten. Ich brauche sie für einige meiner Audio-Projekte wie dieses mobfobamp: nur eine Überschrift und der Player darunter.

Dieser Beitrag hat mir sehr geholfen, so dass ich es einfach in das _include einfügen konnte, es ein wenig modifizieren konnte, und es funktionierte auf Anhieb.

Platzierung des Favicons

Ich folgte dieser Anleitung, um ein Favicon für die Website zu platzieren.

Der Pfad des Favicons muss unabhängig von dem Ordner, in dem sich die gerenderte Seite befindet, gültig sein. Ich musste ../ entsprechend der Tiefe der Seiten in der Ordnerstruktur der Website hinzufügen, um sicherzustellen, dass das Favicon nicht nur auf der Startseite, sondern auch auf Unterseiten angezeigt werden kann.

Optimierung für Suchmaschinen

Da meine Website einige Wochen lang nicht von Suchmaschinen gefunden wurde, beschloss ich, eine so genannte “SEO” (Suchmaschinenoptimierung) durchzuführen. Deshalb fügte ich jekyll-seo-tag hinzu und überarbeitete z.B. alle meine Links nach Juliette Sinibardy’s SEO 101. Danach habe ich meine Webseite dem Web-Analyse-Audit von Lighthouse unterzogen.

Für einen ersten Versuch sieht es meiner Meinung nach ziemlich gut aus. Das größte Problem auf der Leistungsseite scheint der CSS-Overhead zu sein.

Sicherheitsrichtlinie für Inhalte

Der Lighthouse-Audit hat gezeigt, dass es eine gute Idee wäre, externe Skripte - wie sie die Basisversion meines Themes enthält - einzuschränken. Also habe ich eine Content Security Policy (CSP) wie folgt eingeführt:

webrick:
 headers:
 Content-Security-Policy: 
 default-src 'self'; 
 script-src 'self'; 
 connect-src 'self'; 
 img-src 'self'; 
 style-src 'self' 
 font-src 'self;

Mit dieser strikten Auslegung werden Inhalte Dritter gar nicht mehr geladen (aber leider meine eigenen teils auch nicht).

Anfänglich wurde das Hintergrundbild meiner Homepage nicht angezeigt, meine eingebetteten Audiodateien konnten nicht abgespielt werden und alle Icons, die von extern geladen wurden, waren ebenfalls weg. Das Hinzufügen von media-src: 'self'; und etwas mehr Lektüre in Jakob Wilforss’ Blog und vor allem Lighthouses eigene Vorschläge halfen bei der Lösung dieses Problems. Mit Hilfe der Web developer Tools des Browsers habe ich die fehlenden Ressourcen ermittelt, die das Theme im Hintergrund zu laden versucht, so dass mein aktualisiertes CSP wie folgt aussieht:

webrick:
 headers:
 Content-Security-Policy:
 default-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net/; 
 script-src 'self';
 connect-src 'self';
 img-src 'self' 'unsafe-inline' https://upload.wikimedia.org/wikipedia/commons/ https://raw.githubusercontent.com;
 style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net/;
 font-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net/; 
 media-src 'self'; 
 object-src 'none';
 base-uri 'none';

Update

Ende 2021 bin ich vom Nachladen von Inhalten über Drittanbieter (oben namentlich Font Awesome und Wikimedia) auf die eigene, statische Bereitstellung übergegangen. Somit gibt es keine Dritten mehr, die beim Aufruf meiner Seite etwas von Ihnen mitbekommen - und die Seite lädt etwas schneller. Meine Content Security Policy habe ich wieder auf die Obere der beiden Darstellungen zurückgedreht, media-src 'self'; aber beibehalten.

Fehler

Hier sammele ich Fehler, deren Lösung trivial erscheint, die mich aber dennoch ganze Abende gekostet haben.

Jekyll serve: `UTF-8` incompatible character encoding

Man gibt bundle exec jekyll serve ein und erhält einen seltsamen UTF-8 “incompatible character encoding” Fehler? Die Ursache ist einfach: Eine der zu konvertierenden Dateien hat höchstwahrscheinlich keinen Header, der in das “Front matter” der Seite übersetzt werden kann, die aus dieser Datei generiert wird. Einfach die übliche Kopfzeile zur fraglichen Datei hinzufügen und schon funktioniert es wieder:

---
title: "Feeds and Speeds database"
description: "for (light) CNC milling machines"
header:
 image: "blah/testimage.jpg"
[...]
---

Webseite wird nicht dargestellt: `404`

Dieser Fehler war besonders fies versteckt, denn auf meinem Rechner als localhost wird die Seite einwandfrei dargestellt - nur “in Produktion” erscheint, wenn ich die Seite aufrufe, gar nichts.

Ursache: neuerdings verwende ich das permalink: Attribut in der Frontmatter von Seiten, die übersetzt werden sollen und auf einer tieferen Ebene liegen - für diese möchte ich die Links kurz halten, daher bekommen sie manuell erstellte Permalinks. Nur wenn ich ihnen ein “trailing slash” gebe, lassen sie sich auch online aufrufen. Beispiel:

# Falsch:
---
title: "This Page won't be displayed"
permalink: /projects/pageerror
# [...]
---

# Richtig:
---
title: "This Page will be displayed!"
permalink: /projects/nopageerror/
# [...]
# Wird auf dem deutschen Blog zu:
---

Website-Hosting

Diese Seite ist selbst ein normales Gitea-Repository. Es wird automatisch mit einer von Github Actions entlehnten Aktion gebaut, sobald Änderungen zum Main des Repositorys hinzugefügt werden.

Update Jan-2024

Inzwischen bin ich von Github-Pages nach Gitea umgezogen und hoste meine Webpräsenz nun selber. Dennoch sind alle Inhalte dieser Seite weiterhin als Repository verfügbar und können leicht von mir gewartet und auf Stand gebracht werden. Außerdem schütze ich die Site nun vor unautorisiertem Zugriff

Zusammenfassung

Sich damit vertraut zu machen wie Jekyll die Seite erstellt, wie das Theme mit meinen Befehlen interagiert und wie man das Verhalten des Themes überschreibt, hat einige Stunden gekostet. Aber ich denke, dass diese Seite eine klare Struktur und ein mehr oder weniger “professionelles” Aussehen besitzt - und ich musste nicht eine einzige Zeile JavaScript oder HTML schreiben, um das zu erreichen. Toll!

Inhalt in Markdown *.md geschrieben
Grundlegende Konfiguration der Seite in YAML _config.yml
Seitenlayouts in html und jinja *.html, abgelegt in _layouts und _includes
Seitenvariablen und Aussehen in SASS *.scss, automatische Generierung von css-Dateien

Lust mitzumachen oder Beiträge beizusteuern?

Sie haben Ideen, Kritik oder interessante Dinge, die Sie mir mitteilen möchten? Nehmen Sie gern über meine Diskussions-Seite Kontakt auf.

GoogleTest Demo

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Mittel 3/5
Kosten: 0€
Zeitaufwand: ~2h

Motivation

Es ist schön, bei der Entwicklung komplexerer Projekte ein leistungsfähiges Unit-Test-Framework zur Hand zu haben, das viel Zeit bei der Fehlersuche spart (vor allem das On-Target-Debugging in der Embedded-Welt kann sehr zeitaufwändig sein), die Codequalität verbessert und möglicherweise den Einblick in APIs und Architektur für andere verbessert.

Die Welt der “embedded controller”

Traditionell waren Mikrocontroller auf der Speicherseite begrenzt. In der Vergangenheit hatten sie weder viel RAM noch PROGMEM, also war mein meist in schlankem C geschrieben und die Konfiguration fand in Listen von #define statt, die nicht viel Rechenzeit kosten, weil der Präprozessor die Arbeit machen würde und nicht der µC zur Laufzeit. Meine Unit-Tests waren immer an die Hardware gebunden, auf der sie liefen - nehmen Sie Unity als bekanntes Beispiel - aber jetzt wollte ich etwas Neues ausprobieren: Code objektorientiert schreiben und die Geschäftslogik unabhängig von der Hardware testen lassen. Ich wählte das GoogleTest-Framework und wollte eine nahtlose Integration in meinen Workflow mit VScode und dessen Erweiterung PlatformIO erreichen.

Hierfür blieb bis vor kurzem nur der Weg, GoogleTest per GNU Compiler Collection parallel zu betreiben und durch PlatformIO ansteuern zu lassen. Neuerdings allerdings lässt sich GoogleTest als PlatformIO Library direkt nutzen. Daher gehe ich hier auf beide Wege ein.

GoogleTest direkt in PlatformIO verwenden

Hier gestaltet sich die Installation besonders einfach:

Mein Github-Repository PlatformIO-gTestgMock klonen.
Im Repository-Ordner ein Konsolenfenster öffnen und per git checkout googletest-native auf den entsprechenden Branch wechseln.
Den Anweisungen in der README-Datei des Repository folgen und das Setup ausprobieren.

So sieht es aus, wenn die Tests erfolgreich durchgeführt wurden:

GoogleTest per GCC einsetzen

Die benötigte Software kann man selbst (auch auf einem Windows¹ Rechner) installieren, um mit GoogleTest starten zu können.

MinGW herunterladen und installieren

Siehe diesen Thread im Forum von PlatformIO, wenn es Fragen zu den folgenden Schritten gibt.

Unix-Benutzer: bis hier die Schritte überspringen, denn wahrscheinlich werden nur die libpthreadgc-Bibliotheken zusätzlich benötigt. Prüfen Sie das Vorhandensein aller Bibliotheken (aber lassen Sie das Präfix mingw32- weg) und installieren ggf. fehlende nach. Stellen Sie sicher, dass die PATH-Variable korrekt gesetzt ist.
Windows-Benutzer:

Laden Sie MinGW herunter, z.B. von Sourceforge
Installieren Sie durch Ausführen von mingw-get-setup.exe. Wenn Sie grafische Benutzeroberflächen mögen, lassen Sie das entsprechende Kästchen angekreuzt. Ich empfehle nicht, das Installationsverzeichnis zu ändern. Wenn Sie das doch tun, müssen Sie sich sich den neuen Pfad merken.

MinGW konfigurieren

Damit GoogleTest läuft, müssen zusätzliche Pakete installiert werden:
- mingw32-gcc-g++
- mingw32-libmingwex
- mingw32-libmingwex-dll
- mingw32-libmingwex-dev
- mingw32-libpthreadgc-dll
- mingw32-libpthreadgc-dev
Um diese zu installieren,
- Wenn Sie die GUI verwenden: Suchen Sie die Bibliotheken unter “MinGW Standard Libraries” und fügen Sie sie nacheinander hinzu/aktivieren/installieren Sie sie.
- Benutzer des Kommandozeilen-Interpreters: Geben Sie mingw-get install ein und fügen Sie dann den Paketnamen hinzu. Wenn Sie eine Fehlermeldung erhalten, die besagt, dass einige der Pakete bereits existieren, umso besser.
Jetzt müssen Sie den Ordner “bin” von MinGW zu Ihren Systempfadvariablen hinzufügen, damit PlatformIO sie später finden kann. Wenn Sie ihn nicht von Hand modifiziert haben, sollte er C:\MinGW\bin lauten.
- GUI-Fans: folgen Sie dieser Anleitung
- CLI: Geben Sie set PATH=%PATH%;C:\MinGW\bin ein und überprüfen Sie, ob es mit echo %PATH:;=&echo.% funktioniert.

Glückwunsch! Sie haben MinGW installiert, die Umgebungsvariablen so gesetzt, dass es von Drittanwendungen leichter gefunden wird, und es für die Zusammenarbeit mit GoogleTest konfiguriert.

PlatformIO konfigurieren

Nachdem die Variable PATH gesetzt ist, muss VScode neu gestartet werden.
Damit PlatformIO korrekt mit dem gerade installierten Compiler verbunden wird, muss die native Umgebung verwendet werden. Dort befindet sich der Compiler mit allen benötigten Umgebungsvariablen. Öffnen Sie ein PlatformIO-Terminal in einem Ihrer Projekte und geben Sie pio platform install native ein.
Zwei Möglichkeiten:

A) Befolgen dieser Anleitung unter Verwendung meines Beispielprojektes wie unten beschrieben. Dann kann der nächste Abschnitt getrost übersprungen werden, da dieses Projekt vorkonfiguriert ist. Sie können nach Belieben damit herumspielen denn Sie verfügen von Anfang an über grundlegende Hardware-Abstraktionsschnittstellen.
B) Nehmen Sie Ihr eigenes Projekt und ändern Sie dessen Platformio.ini so, dass GoogleTest ausgeführt werden kann.

Dies sollten Sie zu Ihrer Platformio.ini hinzufügen:

[env:desktop]
platform = native
build_flags = 
	-std=gnu++11 # use installed GNU C++11 compiler.
	-pthread # found in gtest documentation
lib_deps = 
	googletest # Will automatically load latest googletest lib
lib_ignore = 
 src # most main.cpp's directly access the hardware. 
 # Can be removed if your project is different.
 #
 # PLUS: Any files that contain bare-metal hardware commands 
 # (e.g. digitalWrite), g++ won't have the headers or specialized compiler knowledge!
lib_compat_mode = off # Must-have for external stuff like gtest!

Erklärung: Für die Umgebung Desktop (= Computer ohne Microcontroller) wird der native Compiler verwendet, d.h. GCC/G++, der oben in der Anleitung installiert und für den die PATH-Variable festgelegt wurde. GoogleTest verwendet den C++11-Standard und Threading, der zu den Build-Flags hinzugefügt werden muss. Der Build von der googletest Bibliothek ab. Es werden alle Dateien/Ordner ignoriert, die Quell- oder Headerdateien mit hardwarebezogenen Befehlen oder Headern enthalten. Der Bibliothekskompatibilitätsmodus muss ausgeschaltet sein, damit der Library Dependency Finder googletest einbeziehen kann.

(Optional) Falls Sie lieber GUI-Schaltflächen verwenden als eine Zeile in die Konsole zu tippen um die Tests zu starten, erstellen Sie eine benutzerdefinierte Konfiguration.

Tests ausführen

Für einen schnelleren Einstieg kann mein Beispiel-Repository geklont werden (den main branch verwenden). Es enthält alle notwendigen Elemente, um zu prüfen, ob gTest und gMock korrekt funktionieren. So kann man direkt nachvollziehen, ob die Installation erfolgreich war.

Entpacken Sie die Zip-Datei bzw. verwenden Sie SSH, um das Repository zu klonen.
Öffnen Sie die Startseite der PlatformIO-Erweiterung, klicken Sie auf “Open Project”, und wählen Sie den Ordner aus.
Um die Unittests auszuführen, öffnen Sie ein PlatformIO-Terminal und geben Sie pio test -vvv -e desktop -f test_desktop ein. (-vvv = wortreich -e = Umgebung, -f = Filter). Die Parameter sind erforderlich, weil die Tests nur auf der “Desktop”-Umgebung lauffähig sind, nicht aber auf dem Microcontroller.
Nach einiger Zeit sollte die unten dargestellte Meldung angezeigt werden.

Super! Unit-Tests innerhalb von PlatformIO wurden gebaut und ausgeführt!

Tipps und Tricks

Zu beachten ist, dass der Ordner PlatformIO_gTestgMock/.pio/build/desktop nun eine ausführbare Datei namens program.exe enthält. Wird sie über die Kommandozeile ausgeführt, sollte das selbe Ergebnis wie in der obigen Abbildung herauskommen. Dies kann nützlich sein, wenn Tests nicht nur fehlschlagen, sondern das ganze Programm bei der Ausführung abstürzt. Zum Debuggen der Tests ist das auch hilfreich, da die CLI von PlatformIO dazu neigt, sich aufzuhängen. Man hat hier auch leichten Zugang zum Stracktrace - das sprengt den Rahmen dieser Übung aber bei Weitem.

Ab diesem Punkt

können Sie weiterlesen, um den Inhalt des Repositorys und die Funktionsweise von GoogleTest besser zu verstehen
Sie könnten das Schreiben von Tests üben, indem Sie weitere Fälle hinzufügen, z. B. um zu überprüfen, ob der Zustand “LOW” korrekt durchlaufen wird.
Sie könnten auch die Interfaces dieser Grundbausteine verbessern, z. B. durch Hinzufügen der Funktion analogRead() zur Hardware-Abstraktionsschicht
Sie könnten Ihr eigenes Projekt darauf aufbauen, die Hardware-Abhängigkeiten sauber ausschalten und es so einfach auf verschiedene Hardware-Geräte und Hersteller portieren
Oder Sie beschäftigen sich weiter mit diesen anderen genialen Dingen, die Sie in die Tat umsetzen wollten, bevor Sie von diesem Tutorial abgelenkt wurden.

Repository-Inhalte erklärt

Die folgenden Abschnitte behandeln die meisten Dateien im Repository und erklären, was sie im Detail tun. Die implementierte Geschäftslogik ist minimal und sollte als Beispielcode betrachtet werden. Ein reales Projekt, das alle auf dieser Seite dargestellten Muster verwendet, ist auf meiner Tonuino-Seite zu finden.

Schnittstelle der Hardware-Abstraktionsschicht

Schauen wir uns das Interface und seine Struktur genauer an.

// hal_if.h
namespace hardwareAbstraction {

// Hardware Abstraction Layer Interface class
class Hal_IF
{
public:
 virtual ~Hal_IF() = default;

 virtual bool digitalRead(uint8_t pinId) const = 0;
 virtual void digitalWrite(uint8_t pinId, bool value) const = 0;
};

} // hardwareAbstraction

Die Klasse Hal_IF hat zwei Methoden, die beide virtuell sind. Das bedeutet, dass eine Client-Klasse, die diese Schnittstelle verwendet, die Methode aufrufen kann und somit “automatisch” an die konkrete Implementierung der Methode weitergeleitet wird. Das = 0; macht diese Methoden rein virtuell, so dass das Überschreiben dieser Methoden durch eine abgeleitete Klasse nicht optional sondern vorgeschrieben ist. Das ist genau das, was wir hier wollen, denn wenn diese Methode nicht überschrieben würde, hätte sie kein Verhalten. Zu beachten ist, dass der Destruktor einer Schnittstellenklasse fast immer virtuell sein sollte.

LoopInOut

Die zu testende Logik. Sie greift nicht direkt auf die Ein-/Ausgabe-Hardware des µC zu, sondern auf die Variable m_hal, die eine Implementierung der Schnittstelle Hal_IF ist. Sie wird bei der Objekterzeugung per Referenz (gekennzeichnet durch das & bei der Typdeklaration) an die Klasse übergeben².

// loopInToOut.h

class LoopInToOut
{
public:
 LoopInToOut(hardwareAbstraction::Hal_IF& hal): m_hal(hal){};
 ~LoopInToOut() = default;

 bool loopThrough(uint8_t inPin, uint8_t outPin);

private:
 hardwareAbstraction::Hal_IF& m_hal;
};

Dies ermöglicht die eigentliche Magie von gMock: Da der Client-Code mit einer Schnittstelle arbeitet, kann ich die “echte” Implementierung (des Hardware-Zugriffs) zur µC-Laufzeit übergeben, aber für den Test kann ich eine “Modell”-Implementierung übergeben, über die ich zum Zeitpunkt der Ausführung des Tests die Kontrolle habe.

// loopInToOut.cpp

bool LoopInToOut::loopThrough(uint8_t inPin, uint8_t outPin)
{
 bool input = m_hal.digitalRead(inPin);

 m_hal.digitalWrite(outPin, input);
 return input;
}

loopThrough() ist wiederum sehr einfach. Sie liest den Zustand des Eingangspins und ordnet ihn dem Ausgangspin zu. Sie gibt den Zustand des Eingangspins an den Aufrufer zurück.

Modellierte Hardwareabstraktion (mock hal)

GoogleTest verwendet Makros, um Verhalten zu definieren. Die Mock-Klasse leitet sich ebenfalls von der Schnittstelle ab und stellt lediglich die Deklarationen der Schnittstellenmethoden bereit, die sie überschreibt. Es ist noch kein Verhalten festgelegt.

// hal_mock.h

class Hal_mock : public hardwareAbstraction::Hal_IF
{
public:
 MOCK_METHOD(bool, digitalRead, (uint8_t pinId), (const, override));
 MOCK_METHOD(void, digitalWrite, (uint8_t pinId, bool value), (const, override));
};

Die Testvorrichtung (test fixture)

Die Testvorrichtung enthält gemeinsame Daten und Verhaltensweisen für alle Testfälle innerhalb einer Testsuite. Name der Testsuite = Klassenname. Genau dieser Name muss in den Tests, die zu dieser Suite gehören sollen, wiederverwendet werden.

// unittest_loopInToOut.cpp
class loopInToOut_Test : public ::testing::Test
{
protected:
 virtual void SetUp()
 {
 m_loopInToOut = new LoopInToOut(hal_mock);
 }

 virtual void TearDown()
 {
 delete m_loopInToOut;
 }

 NiceMock<Hal_mock> hal_mock{};
 LoopInToOut* m_loopInToOut{nullptr};
};

Jeder Test verfügt also über einige vorbereitete Daten, die er verwenden kann: Die zu testende Klasse wird als Zeiger mit einer modellierten (Mock) Implementierung ihrer Abhängigkeit eingerichtet.

Der eigentliche Test

Der Test wird durch das Makro TEST_F definiert, was soviel bedeutet wie “Test mit Fixture”, das eine Testsuite und Testnamen erwartet. Das Makro ON_CALL ist ein Befehl an gMock, der der modellierten Klasse vorgibt, wie sie sich zu verhalten hat, wenn digitalRead(_) mit einer beliebigen Eingabe (Unterstrich = beliebig) aufgerufen wird: die Methode soll standardmäßig true zurückgeben.

// unittest_loopInToOut.cpp

TEST_F(loopInToOut_Test, loop_inputHigh_writesCorrectOutputHigh)
{
 ON_CALL(hal_mock, digitalRead(_)).WillByDefault(Return(true));

 EXPECT_CALL(hal_mock, digitalWrite(2, true));

 m_loopInToOut->loopThrough(1, 2);
}

Dann wird eine “Erwartung” an die nachgebildete Klasse formuliert, die besagt, dass digitalWrite mit Eingabewerten von (2, true) aufgerufen wird, die ebenfalls auf Korrektheit geprüft werden.

Die letzte Anweisung ruft die echte Implementierung auf, so dass die Erwartungen überprüft werden können.

Implementierung des Hardwareverhaltens

Da main.cpp auf die Hardware zugreift, muss es dafür eine Art Schnittstellenimplementierung geben.

// hal.h
class Hal : public Hal_IF
{
public:
 Hal() = default;
 ~Hal() = default;

 bool digitalRead(uint8_t pinId) const override;
 void digitalWrite(uint8_t pinId, bool value) const override;
};

Hier leitet Hal sich von Hal_IF ab und überschreibt alle seine Methoden.

// hal.cpp
#include "Arduino.h"

#include "hal.h"

namespace hardwareAbstraction{

bool Hal::digitalRead(uint8_t pinId) const
{
 return digitalRead(pinId);
}

void Hal::digitalWrite(uint8_t pinId, bool value) const
{
 digitalWrite(pinId, value);
}

Man erkennt, dass nur diese Quelldatei tatsächlich die Arduino.h für den Zugriff auf die Hardware einbindet. Die Abhängigkeit von den Hardware-Funktionen ist also sehr begrenzt und in Schnittstellen-Implementierungen gekapselt, die durch die Programmstruktur ausgewählt werden können. Während die main.cpp für das Zielgerät also ein Objekt der obigen Implementierung erzeugt, wird der Test stattdessen ein Mock übergeben.

Gtest Schlüsselkonzepte

Googles offizielle Webseite über Googletest kann sehr helfen, nicht nur für den Einstieg³. Das gmock Cookbook ist ein hervorragender Leitfaden, den ich im Laufe der Monate benutzt habe, als meine Tests immer komplexer und schwieriger zu schreiben wurden, und das gmock Cheat Sheet hilft, wenn man den Überblick verloren hat, wie ein Test für dieses oder jenes spezielle Problem zu schreiben ist.

Dependency Injection

Dependency Injection ist die grundlegende Mechanik, verstanden werden muss, damit man gMock erfolgreich anwenden kann. Ich versuche es mal mit einem Bild zu verdeutlichen.

Kurzgesagt ist die Schnittstelle lediglich ein Platzhalter für die Implementierung der Abhängigkeit der Client-Klassen.

Zur Laufzeit, z.B. wenn der Host das Client-Objekt erzeugt, wird er die Implementierung der Abhängigkeit an den Client übergeben (d.h. injizieren), der dann jede seiner Methoden aufrufen kann, da ihre Signaturen zur Kompilierzeit aufgrund der vom Client verwendeten Schnittstelle bekannt sind.

Das Mock ist nun lediglich eine Implementierung der Schnittstelle, die für die Tests spezialisiert ist.
Die eigentliche Implementierung wird in allen anderen Kontexten verwendet, sie zeigt das “echte” Verhalten dieser Klasse.

Hardware-Abstraktionsschicht

Dies ist vielleicht einer der kniffligen Punkte bei der Arbeit mit eingebetteter Software. Irgendwann geht es um die Interaktion mit der Außenwelt, sei es mit GPIO-Pins (General Purpose Input Output), den Zugriff auf eines der unzähligen Hardware-Bussysteme wie I2C, UART, SPI, CAN zur Steuerung externer Hardware oder einfach die Nutzung von Systeminterna wie dem EEPROM - da fangen die Probleme an.

Gtest läuft auf dem GCC/G++ Compiler, der einfach nichts von dem weiß, was der spezialisierte Compiler des jeweiligen Chips weiß. Er würde nicht einmal die Header-Dateien verstehen. Nun gibt es zwei Möglichkeiten, dieses Problem zu umgehen:

“Fake Header” für jede µC-spezifische Implementierung schreiben, die von GCC/G++ verwendet werden können
Eine Schnittstelle für jede µC-spezifische Implementierung unter Verwendung einer (Hardware-)Abstraktionsschicht programmieren, so dass Ihre Produktionsumgebung die Chip-Hardware wie gewohnt verwendet, die Testumgebung aber stattdessen Mocks benutzt.

Der zweite Ansatz hat eine Reihe von Vorteilen:

Er ist sauber. Er zwingt einen dazu, keine Abstraktionsschichten zu zusammenzufassen die getrennt gehören.
Er ist einfach. Man kann die Geschäftslogik testen, ohne den µC zu programmieren! Es müssen nur die Eingänge gemockt und die Ausgänge abgefangen werden.
Er ist portabel. Wenn man die Implementierung Abstraktionsschicht austauscht, kann man sie auf einer anderen Controller-Familie oder sogar auf Chips eines anderen Herstellers auszuführen.

Nachteile

Hmm, wo Licht ist, muss es doch irgendwo auch Schatten geben. Meiner Meinung nach sind die Nachteile, wenn man alles ohne angeschlossene Hardware testen will:

Speicher. Sowohl ROM als auch RAM werden schneller voll, wenn eine große Anzahl von Klassen und vtables existieren.
Besitz. Die Injektion von Abhängigkeiten trennt den Besitz von der Nutzung eines Objekts, und man muss sich entscheiden, wie beides organisiert werden soll.
Bibliotheken von Drittanbietern können nicht einfach verwendet werden sondern benötigen Anpassung. Ein Interface-Header, eine Adapter-Implementierung und ein Mock für jede Bibliothek, die “chip-internals” verwendet, sind zu erstellen.
Komplexität. Da Objekte über eine Schnittstelle injiziert werden, muss jetzt Call-by-Reference oder Übergabe per Zeiger durchgeführt werden 😨. Ersteres ist zusätzlich eingeschränkt, da es nur für Konstruktorinjektion funktioniert, nicht für andere Arten (Methodeninjektion, Setterinjektion usw.).

Einige weitere Tipps

Alles “hinter” der Abstraktionsschicht sollte so einfach wie möglich gehalten werden: Diese Dinge können nur auf dem Zielgerät getestet und ausgeführt werden. Beispiel: Jede Methode führt nur einen Befehl aus (wie in meinem Beispielcode).
Verwendung einer Loader-Klasse oder eines Dependency Injection Container (Nicolas Croad) erleichtert die Arbeit, denn er enthält alle zu injizierenden Objekte und kann sie auf Anfrage übergeben.
Die oben genannten Nachteile sollten im Blick behalten werden. Bei kleineren Projekten lohnt sich dieser Aufwand wahrscheinlich nicht.
Manchmal macht es sogar Sinn, mehrere Ebenen Schnittstellen zu haben. Dieses Muster kann nicht nur für die direkte Interaktion mit der Hardware zu verwendet werden, sondern auch zwischen Softwaremodulen, die dann in einer höheren Granularität getestet werden können. Dies kann sogar schneller sein als ein großen Haufen Klassen zu haben, die nur über Mocks in der Hardware-Abstraktionsschicht kontrolliert werden können.

Schwieriges Thema!

Sie haben sich jetzt eine Pause verdient. Das waren viele Informationen, die Sie verarbeiten mussten. Nehmen Sie sich Zeit. Kontaktieren Sie mich gern auf der discussions Seite zu diesem Thema, wenn Sie das Gefühl haben, dass etwas fehlt, nicht korrekt dargestellt ist, verbessert werden sollte oder einfach genau das ist, was Sie jetzt brauchten.

Die Installation unter Linux ist einfacher, da gcc und g++ bereits vorinstalliert sind. Selbst wenn sie noch nicht die richtigen Pakete zur Unterstützung von GoogleTest enthalten, sind ihr Fehlermeldungen viel aussagekräftiger als die unter Windows, z.B. wenn Bibliotheken fehlen. 🙃 ↩︎
Dies wird auch Constructor Injection genannt, eine Unterart der Dependency Injection, die ein Mittel zur Erreichung der Inversion Of Control ist. Ich habe einige Links zu weiteren Informationen vorbereitet. Dies ist ein umfangreiches Thema, über das ganze Bücher geschrieben worden sind. ↩︎
Übrigens: die googletest-Seite ist auch statisch wie meine und verwendet ebenfalls Jekyll 👋 …gefällt sie Ihnen? Ich würde gern Ihre Meinung dazu auf meiner Diskussionsseite erfahren. ↩︎

MobFobAmp

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Ein zweiter Prototyp meines mobilen Instrumentenverstärkers, dieses mal mit klappbarem Design. 28l Box mit 17cm Tiefmitteltöner. 15W Verstärkerleistung. 7.3kg inkl. Akku. Geeignet für E-Bass, Akustikgitarre, E-Piano.

Projekt-Steckbrief

Schwierigkeitsgrad: herausfordernd 4/5
Kosten: ~140€ ohne Akku
Zeitaufwand: ~15h

Vorstellung

Ein paar Bilder von meinem mobilen, klappbaren Bassverstärker 'MobFobAmp'.

Benötigt zusammengeklappt extrem wenig Platz

Flaches Design, leicht zu tragen

28l Gehäusevolumen wenn ausgeklappt, geschlossenes Design

Durch eine Höhe von 53cm auch als Hocker verwendbar

17cm Bass-Mittenlautsprecher, 4Ah-Akkupack für lange Laufzeit

Ein Blick nach Innen

Your browser does not support the audio element.

MobFobAmp Soundbeispiel

Your browser does not support the audio element.

A/B/A Vergleich geschlossenes vs. offenes Gehäuse

Your browser does not support the audio element.

MobFobAmp und Piano, externer Vorverstärker, maximale Lautstärke

Alle Aufnahmen habe ich mit meinem Smartphone gemacht. Dennoch bringen sie den Klang des Verstärkers realistisch rüber.¹

“MobFoBamp”: Motivation

Um die Nachteile meines vorherigen Prototypen zu beheben, wollte ich es mal mit einem größeren Lautsprecher und mehr Volumen probieren. Leider macht einem so eine große Box ja das Tragen schwer, also dachte ich mir, wenn man quasi die Luft raus ließe für den Transport, wäre das nicht eine Lösung…?

Die Idee: Klappbox

Eine Klappbox ^[1]

In Anlehnung an das Konzept einer Faltbox, wie es hier gezeigt wird, beschloss ich, dass mein Combo zum einfachen Transport zusammenklappbar sein sollte. Ich entschied mich zunächst für eine geschlossene Konstruktion, damit ich mich nicht um die Berechnung von Lüftungsöffnungen, Resonanzfrequenzen und Gruppenlaufzeiten kümmern musste.

Ich musste mir Gedanken darüber machen, wie ich Lautsprecher und Elektronik integrieren konnte, ohne die Möglichkeit zu verlieren, das Gehäuse vollständig zusammenzulegen.

Abmessungen

Ich habe die Breite des Gehäuses so gewählt, dass es bei Bedarf bequem in meine Bass-Gigbag passt. Alle anderen Abmessungen ergaben sich von selbst - die Höhe musste mindestens doppelt so groß sein wie die Breite, damit der obere und untere Deckel im zusammengeklappten Zustand untergebracht werden konnte (aber nicht zu hoch, um die Steifigkeit nicht zu reduzieren). Die “Tiefe” musste kleiner sein als “0,5*Breite” - (Materialstärke + Scharnierdicke), sonst würde das Falten nicht funktionieren, weil die Seiten im Weg wären.

Sound-Hardware

Für den Leistungsverstärker habe ich mich für das Modul entschieden, das ich schon früher gekauft habe. Ich wählte einen 6,5-Zoll-Hi-Fi-Tieftöner (50W, 4Ohm) mit niedriger Resonanzfrequenz, passend zu meinem versiegelten Gehäuse.

Simulation

Dann führte ich einige Simulationen durch, um herauszufinden, ob Gehäuse und Lautsprecher gut zusammenpassen würden.

Der geschätzte Qtc-Wert läge bei 0,63 anstelle des empfohlenen Wertes von 0,71 (optimale Sprungantwort), so dass das Gehäuse etwas überdämpft wäre und “straffer” klingen würde, aber im Vergleich zu einer optimalen Einstellung an Volumen am unteren Ende verlieren würde. Der Bau einer Box ist leider immer ein Kompromiss zwischen Klang, Leistung, Größe, Gewicht, Frequenzgang und Lautstärke, wobei ich Prioritäten setzen und bestimmte Attribute etwas vernachlässigen musste.

Ausprobieren

Als ich nach etwa 15 Stunden mit dem Bau des Gehäuses fertig war, war ich sehr erfreut zu sehen, dass es luftdicht schließt und solide und stabil steht. Für das Ausklappen brauchte ich weniger als 60 Sekunden, für das Zurückklappen in den ursprünglichen Zustand sogar weniger als 30 Sekunden. Da der Maximalpegel immer noch etwas niedrig war, fügte ich dem Setup ein Kompressorpedal hinzu, das einen Gain-Regler hatte, den ich als Vorverstärker verwenden konnte.

Der Klang dieses Geräts ist erstaunlich. Straffe Bässe, warme Mitten und subtile, aber brillante Höhen passen sehr gut zum charakteristischen Klang der Bassgitarre. Die maximale Lautstärke ist begrenzt, aber sie reicht immer aus, um mit einer Akustikgitarre mithalten zu können. Ich benutze ihn ständig als Übungsverstärker.

Klangqualität

Der wichtigste Aspekt eines Combos ist sicherlich, wie er klingt. Durch das faltbare Design kann er in zwei verschiedenen Setups betrieben werden.

Geschlossen: Straffer und ausgewogener Klang, guter Tiefbass-Punch. Ohne Vorverstärker ist der maximale Pegel OK, um mit einer Akustikgitarre zu spielen
Belüftet: Unterer Deckel um 3cm geöffnet, wobei der Riegel das Gehäuse gegen die Bodenplatte drückt. Viel lauterer Klang mit ausgeprägten tiefen Mitten, weniger ausgewogen und etwas dröhnend, Maximalpegel auf dem Niveau von Piano gespielt f.

Ich bin sehr zufrieden mit der Klangqualität, die MobFobAmp bietet. Die Option, “offen” zu spielen, erhöht die Flexibilität und lässt den Sound wirklich hervorstechen (mit den oben erwähnten Nachteilen).

Ich habe auch einige Messungen durchgeführt, um zu sehen, wie nahe das Design an einen idealen Frequenzgang herankommt, indem ich etwas Weißes Rauschen an MobFobAmp schickte und dann den Tonausgang mit einem Mikrofon aufnahm. Zum Vergleich habe ich eine Spektrumanalyse im Frequenzbereich angezeigt. Eine vollkommen neutrale Tonausgabe würde die orangefarbene Linie bei 0 dB für das gesamte Spektrum treffen. {: .align-center} Man kann sehen, dass die -3dB-Grenze oder der nutzbare Frequenzbereich von 30Hz bis ~1.5kHz reicht.

Add-Ons

9V Spannungsversorgung für Pedalboard

Ich benutze einige Effektpedale beim Üben, und ich wollte sie auch benutzen können, wenn ich MobFobAmp mitnehme. Deshalb habe ich beschlossen, eine “+9V”-Versorgungsschiene mit Hohlstecker (Außen = +) an Bord zu haben. Also kaufte ich einen seit Jahrzehnten auf dem Markt befindlichen linearen Spannungsregler aus der 78xx-Serie namens 7809 in einem TO-220-Design, der bis zu 1,5A Strom bei 9V liefern kann und einen Eingangsspannungsbereich von 11-35V akzeptiert. Das Bauteil kann mit wenigen zusätzlichen Teilen verwendet werden, wie in der Abbildung rechts gezeigt. Auf diese Weise kann ich jetzt ein Pedalboard mit der Batterie des MobFobAmp betreiben!

Piezo-Hochtöner

Als ich zum ersten Mal einen Drumcomputer mit mobfobamp benutzt habe, hatte ich das Gefühl, dass die Höhen einfach nicht ausreichen. Während sie für einen E-Bass perfekt waren, klangen die Hi-Hat, die Becken und sogar die Snare des Drumcomputers dumpf und muffig. Also bestellte ich einen einfachen Piezo-Treiber, den ich parallel zum Hauptlautsprecher anschließen konnte - das funktioniert perfekt. Ich fügte einen “2W/320Ohm”-Widerstand in Reihe mit dem Treiber hinzu, um die Pegel für meine Ohren genau richtig einzustellen. Das Ergebnis ist großartig.

MobFobAmp Vorteile:

Zusammenklappbar auf sehr kompakte Maße
Geringes Gewicht: 7.3kg inkl. Batterie, 6.9kg ohne
Läuft >20h mit einer Akkuladung als Übungsverstärker und moderater Lautstärke
Läuft >3h mit einer Batterieladung bei maximaler Lautstärke
Klingt sehr gut für Bass, E-Piano oder Akustikgitarre
Tiefe Töne bis hinunter zu “B0” funktionieren gut und klingen druckvoll
9V DC Ausgang für Vorverstärker oder Effektgeräte
Kann im “Bass Reflex Mode” für mehr Tiefmitten betrieben werden

Zu verbessern:

Ohne Piezo-Hochtöner wirken die Höhen matt und gedämpft
Geringer Headroom der Endstufe: Wenn der externe Vorverstärker zu stark aufgedreht wird, verzerrt die Endstufe vor allem tiefe Töne, erst mit Flattern, dann mit dem typischen Klang der Transistorsättigung
Die chaotische Verkabelung des Prototyps ist immer noch anfällig für mechanische Beschädigungen, daher wäre ein zusätzliches Gehäuse für die Elektronik schön
Natürlich reicht die Lautstärke und Leistung nicht aus, um ein Schlagzeug oder eine Band zu beschallen.
Ein Schutzgitter für den Lautsprecher wäre schön

MobFobAmp - DIY Replica

Natürlich ist der Nachbau erwünscht! Unten ein Link zur Anleitung. Mobfobamp DIY-Anleitung

Piano gespielt von Feliks Weber ↩︎

PC-Upgrade

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeit: Amateur 3/5
Kosten: ~500€
Zeitaufwand: ~20h

Ziel und Motivation

Im Jahr 2006 hatte ich mir einen Spiele-PC gegönnt. Als Gehäuse kaufte ich ein HTPC-Gehäuse. Es ist relativ flach und passt in das Rack einer Stereoanlage. 2015 tauschte ich ein erstes mal das Innenleben, als mir die Hardware zu langsam wurde. Ende 2025 war es wieder so weit: Das Netzteil zeigte sich mit der Leistungsaufnahme der neuen Grafikkarte überfordert, die Festplatten liefen voll und Spiele nicht mehr stabil.

Umbauten

Kurz: Es muss neue Hardware her. Doch diese erzeugt viel mehr Abwärme als die Vorherige. Zur Optimierung des Luftstroms sind daher einige Umbauten vorzunehmen. Klingt doch nach einem tollen Projekt mit vielen Facetten, die dieses Blog ausmachen: Mechanik, Elektronik, Software, CNC-fräsen.

Neue Komponenten

Einzubauen sind

650W Enermax Netzteil ersetzt 400W
Neues Motherboard MSI B550
AMD Ryzen5600x ersetzt Intel i5-6500
32GB DDR4 RAM statt 16GB
1TB PCIE SSD statt SATA SSDs
140mm Lüfter in 5.25" Schacht
2x60mm Lüfter in hintere Auslässe
96mm Lüfter für CPU, neuer Heatpipe-Kühler

Die meisten Komponenten besorge ich mir gebraucht. Nur Netzteil, Platte und Lüfter sind Neuware. Doch schnell zeigt sich, dass ich das Gehäuse modifizieren muss: Die Grafikkarte kollidiert mit dem 3.5"-Schacht, wo bis dato Festplatten und Kartenlesegerät untergebracht waren. Der große 140mm-Lüfter passt nur an die Stelle, wo sich der 5.25"-Schacht befindet.

Also müssen beide Schächte entfernt oder mit dem Trennschleifer bearbeitet werden, um Platz zu schaffen. Außerdem benötige ich eine Montagevorrichtung für den Lüfter vor der 5.25"-Öffnung. Hingucker für das Gehäuse wäre es jetzt noch, die Laufwerkklappe automatisch steuern zu können. Dann würde sie nur bei laufendem Lüfter unter hoher Rechenlast geöffnet und im Normalbetrieb geschlossen bleiben.

Anpassung des Gehäusedeckels

In meinem Artikel zum Thema Fräsen von SECC-Stahlblech zeige ich, wie man den Gehäusedeckel zwecks besserer Belüftung der Grafikkarte mit zusätzlichen Schlitzen ausstattet.

3.5"-Schacht

{< image src="/assets/images/htpc/floppy-bay-modified.avif" alt=“Image: Cutout in 3.5” bay" position=“right” >} Die Grafikkarte ist so lang, dass sie 1cm Überlappung mit dem 3.5"-Schacht besitzt. Zum Glück lässt sich der Schacht im Handumdrehen ausbauen. Also nehme ich den Trennschleifer zur Hand und bringe einen Ausschnitt in die Halterung ein. Anschließend bohre ich ein paar zusätzliche Löcher in die Seiten des Schachtes, sodass meine 2.5"-SSDs auf der von der Grafikkarte abgewandten Seite des Schachtes befestigt werden können. Auch der Schachtdeckel erhält ein weiteres Loch zur Befestigung am Gehäuse, da zwei Rastnasen durch den Ausschnitt für die Grafikkarte entfallen.

Der Kartenleser nutzt die volle Tiefe des Schachtes aus. Ich fürchte also schon, ihn gar nicht wieder montiert zu bekommen. Probehalber öffne ich sein Gehäuse und siehe da: Nur das vorderste Drittel wird tatsächlich von Leiterplatten belegt. Der hintere Teil ist anscheinend nur dafür da, Befestigungsmöglichkeiten zu bieten. Also trenne ich den hinteren Teil des Kartenlesergehäuses kurzerhand ab und baue alles wieder zusammen, sodass er sich nun passend im Schacht anbringen lässt.

5.25"-Schacht

Der Schacht ist hoch genug, um zwei Laufwerke aufzunehmen. Ich benutze aber kaum noch CDs bzw. DVDs - und wenn, dann tut es auch ein externes Laufwerk. Den leeren Laufwerkkäfig kann ich also ausbauen und stattdessen an seiner Stelle einen Lüfter montieren. Dafür entwerfe ich im CAD eine Adapterplatte, die Befestigungsmöglichkeiten und Ausschnitte für den Lüfter enthält.

Lüfterplatzierung

Ich setze Gehäuselüfter gezielt ein, um zwei voneinander getrennte Luftströmungen im PC-Gehäuse zu erzeugen: Die CPU-Netzeil-Strömung verläuft an der Gehäusefront über einen 140mm-Lüfter an den CPU-Kühler, von wo aus die Warme Luft durch Netzteil und zwei weitere 60mm-Gehäuselüfter hinaus geleitet werden.

Der Luftstrom zur Grafikkarte wird über einen außerhalb des Gehäuses verbauten 140mm-Lüfter gestützt. Die Grafikkarte selbst fördert die erwärmte Luft direkt über den Gehäusedeckel nach draußen. Um den externen Lüfter anzuschließen, schneide ich ein Loch in eine Slotblende für PCI-Einbauschächte. Dort hinein passt genau die Buchse eines Lüftersteckers. Mittels Heißkleber sichere ich die Buchse in der Blende und schließe sie sonst den Lüfter auch an einen AUX-FAN Anschluss an.

Klappensteuerung

Nun soll die Frontklappe noch automatisch öffnen, sobald der Lüfter dreht. Ist zwar komplizierter als wenn ich das von Hand mache, aber dieses Gimmick macht das Gehäuse doch erst richtig interessant. Ich entferne also das Klappenschloss und füge der Adapterplatte eine Halterung für ein Modellbauservo hinzu, welches die Klappe öffenn und schließen können soll.

Elektronik

Das Servo benötigt eine Ansteuerung. Außerdem möchte ich die Klappenzustand wie den Lüfter auch temperaturabhängig regeln, sodass ich die an dem Lüfter angelegte Spannung einlesen muss. Hierfür setze ich den Microcontroller ATTINY44 ein. Die Schaltung habe ich nur mit den allernötigsten Komponenten bestückt:

Der Microcontroller gibt ein pulsweitengesteuertes Signal an den Servo aus. Dessen Spannungsversorgung wird über einen Elko gepuffert. Die Energieversorgung für den Gehäuselüfter leite ich über zwei Steckerleisten weiter. Dort greife ich das Signal mittels Spannungsteiler ab und führe es einem Analogeingang zu. Ansonsten ist nur ein weiterer Widerstand verbaut, der den RESET-Eingang des Microcontrollers auf VCC zieht und ihn so in Betrieb hält.

Software-Anforderungen

Die Anforderungen an die Software sind einfach und klar:

Wenn der Lüfter steht, soll die Klappe schließen
Ist der Lüfter in Betrieb, soll die Klappe öffnen
Damit die Klappe nicht zu oft hin- und her fährt, soll der Klappenzustand mit etwas Verzögerung geändert werden und auch nur dann, wenn der Lüfter in der Zwischenzeit seinen Zustand beibehalten hat.

Die daraus entstandene Software ist auf meinem Github-Account frei verfügbar.

Software: Hauptschleife

Bei der Ansteuerung des Modellbauservos mache ich es mir einfach: Ich verwende die Servo-Bibliothek von Arduino.

Das Programm macht nicht viel. Ich initialisiere das Servo servoHatch, welches später im Programm angesteuert wird, definiere ein paar wenige Variablen und lege fest, auf welchem Pin der Spannungsteiler vom Lüfter liegt. Die Hauptschleife begnügt sich damit, die Spannung am Lüfter einzulesen und basierend darauf zu entscheiden, ob sich die Klappe bewegen sollte.

Die Auswertung übergebe ich dann der Klappensteuerung. Anschließend wartet das Programm 15ms und läuft dann erneut los.

Servo servoHatch; // create Servo object to control a servo
uint16_t fanVoltage{0}; // variable to read the value from the analog pin
bool open{false};

void setup() {
 pinMode(pinFanVoltage, INPUT);
}

void loop() {
 fanVoltage = analogRead(pinFanVoltage); // reads the value of the fan voltage (value between 0 and 1023)
 open = mapHatchState(fanVoltage);

 
 setHatch(open);
 delay(15); // waits for the servo to get there
}

Software: Hysterese

Mit der Funktion mapHatchState lege ich den Sollzustand der Klappe in Abhängigkeit der Spannung am Lüfter fest.

Liegt die Spannung lange genug unter etwa 4.8V, so schließt die Klappe oder behält ihren geschlossenen Zustand bei. Liegt sie darüber, soll die Klappe geöffnet werden. Der Dauer des Zustandswechsels hängt von der Spannung selbst ab; bei Werten weit ab vom Schwellwert läuft der Aggregator schneller voll und der Klappenzustand wird ebenfalls zügiger verändert.

bool mapHatchState(uint16_t voltage){
 #define maxint 32767 - 1024
 #define minint -32768 + 1024
 static int16_t vAggregate{0};
 static bool hatchOpen{false};

 // Divider VCC 33k T 22k GND, 12V fan will yield 4.8V at divider --> 983 digit
 // So a value of 410 is roughly 5V which allows Fan start + hatch open
 vAggregate = vAggregate + voltage - 410;
 if (vAggregate > maxint) {
 vAggregate = maxint;
 hatchOpen = true;
 }
 else if (vAggregate < minint) {
 vAggregate = minint;
 hatchOpen = false;
 }

 return hatchOpen;
}

Software : Klappe bewegen

Die Funktion setHatch() prüft den gewünschten Zustand der Klappe und bewegt sie, falls sie vom aktuellen Zustand abweicht, dort hin. Dabei wird dem Servo mittels write() ein Zielwinkel vorgegeben, der eingestellt und gehalten werden soll. Die Bewegung geschieht graduell und über die Iteration von hatchState, da die Klappe sich mir sonst viel zu ruckartig und schnell bewegt.

Your browser does not support the video tag.

Test der Klappensteuerung durch Verstellen der Lüfterspannung

void setHatch(bool open){
 static uint8_t hatchState{180}; // variable to capture current position, default closed
 static bool wasMoving{false};
 bool isMoving{false};

 if (open && (hatchState > 0)){
 hatchState--;
 isMoving = true;
 } else if (!open && (hatchState < 180)) {
 hatchState++;
 isMoving = true;
 }


 if (!wasMoving && isMoving) {
 servoHatch.attach(portServo); // connect servo on start
 }
 else if (wasMoving && !isMoving) {
 servoHatch.detach(); // disconnect servo on finish
 }

 servoHatch.write(hatchState);
 wasMoving = isMoving;
}

Die Funktionen attach() und detach() definieren den Signalausgang zum Servo, ordnen also den Pin des Microcontrollers intern dem Servo so zu, wie er tatsächlich verdrahtet ist. Bei meinen Experimenten fand ich heraus, dass das Servo im Stillstand bei detached nur wenig Energie benötigt - viel weniger, als wenn ich es attached lasse und nur kein weiteres Bewegungssignal sende. Daher melde ich es für jede Bewegung an und danach wieder ab.

Ergebnis

Ich erhalte einen schön aufgeräumten, modernen PC. Mittels diverser Bloatware-Lösungen (die ich nach getaner Arbeit direkt wieder deinstalliere) schaffe ich es nach einigem Fluchen, alle LED-Farben aufeinander abzustimmen. Besonderes Highlight ist die automatische Klappe, welche bei höherer CPU-Last samt Lüfter aktiviert wird.

QR-Codengrave

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Schwer 4/5
Kosten: 0€
Zeitaufwand: ~50h

Die Idee

Ein Freund bat mich, einen Bierdeckel für ihn anzufertigen. Ein eigenes Logo, ein paar Buchstaben. Nichts allzu Schweres. Auf der Rückseite wollte er einen QR-Code eingravieren lassen, der einen Link zu seiner Website enthält.

Ich habe also einen QR-Code mit einem Standard-Webtool erstellt und als .svg exportiert. Leider müsste ich in meinem CAM jedes einzelne Pixel anklicken und eine Carve-Action für dieses Pixel erstellen, was einige Minuten meiner Zeit für Auswahl-Klick-und-Parameter-Wähl-Prozeduren in Anspruch nehmen würde. Außerdem müsste ich einen Gravurstichel mit tiefenvariabler Gravur verwenden, um ein quadratisches Pixel zu erhalten, was viel mehr Bearbeitungszeit erfordert als eine runde Darstellung.

An diesem Punkt beschloss ich, viele, viele weitere Stunden meiner Zeit auf dieses Problem zu werfen und eine allgemeine Lösung für QR-Code-Gravuren zu entwickeln - eine Software namens QR-codengrave.

Erste Schritte

Spezifikation

Das, was ich mit dem Tool erreichen wollte:

Muss es können:

Texteingabe verarbeiten und in einen QR-Code konvertieren. Der Benutzer muss keine zusätzliche Konfiguration vornehmen.
Bietet die Option zur Verwaltung verschiedener CNC-Werkzeuge.
Ermöglicht Eingabe von Gravurparametern: Gravurtiefe, Eilgangbewegung im Job, Überflughöhe
Ermöglicht Eingaben für benutzerdefinierte XY0-Offsets für Werkstücke
Vektorisiert die Pixelausgabe des QR-Codes
Kann Pfade aus den Vektoren erstellen lassen, beginnt der Einfachheit halber mit einer Spirale nach innen
Übergabe der Pixellinien an ein Modul, das die Parameter des ausgewählten Werkzeugs verwendet, um Maschinenbahnen zu erstellen
Maschinenbahnen in G-Code konvertieren, der später von meiner Maschine interpretiert werden kann.
Gründliche Überprüfung der Algorithmen mit automatisierten Unit-Tests (bitte keine Abstürze in der realen Welt)
Bietet eine grafische Benutzeroberfläche, um die Parametereingabe so einfach wie möglich zu machen.

Optional

Eine Continuous-Integration-Pipeline sowohl für meine IDE als auch für Github-Aktionen erstellen
Eine Continuous-Deploy-Pipeline für meine IDE (PyInstaller) und Github-Aktionen (Artefakte, Releases) erstellen
Integrationstests für die GUI hinzufügen
Optimieren des Algorithmus zur Pfaderzeugung, da die “nach innen gerichtete Spirale” eine hohe Fertigungsqualität hat und schön anzusehen ist, aber nicht sehr effizient mit der Zeit umgeht.

Unbekannte

Zu Beginn dieses Projekts hatte ich einige offene Fragen und Risiken, die die Nutzbarkeit des Programms hätten einschränken oder sogar das gesamte Projekt undurchführbar machen können. Sie haben sich alle als falsch herausgestellt (zum Glück), aber dennoch sind hier die Risiken, die meine ganze Arbeit unbrauchbar hätten machen können:

Kameras lesen keine runden Punkt-als-Pixel-QR-Codes.
Der Kontrast, den meine Graviermaterialien bieten, ist zu gering, so dass das Lesen der Codes schlecht oder gar nicht funktioniert.
Die Bearbeitungszeit könnte sehr hoch sein, was das Projekt unwirtschaftlich machen würde.
Beschränkungen der Programmierwerkzeuge oder meiner Programmierfähigkeiten könnten die Entwicklungszeit so verlängern, dass es sich nicht lohnt, weitere Anstrengungen zu unternehmen.

Daher beschloss ich, Unit-Tests zusammen mit dem Code zu schreiben, um ein schnelles Feedback darüber zu erhalten, ob mein Code das leisten kann, was er soll. Außerdem habe ich die Funktionalität des Programms auf eine Gravurstrategie beschränkt und die GUI so gestaltet, dass sie nur eine Vorschau des QR-Codes anzeigt, nicht aber XY-Offsets oder anderen Schnickschnack.

Programmiersprache

Ich nahm einige Blätter Papier und notierte mir das Wesentliche.

Ein Modul soll sich um die Erstellung eines QR-Codes aus einer Texteingabe kümmern, ein anderes soll Vektoren und Pfade erzeugen, um diesen QR-Code zu gravieren, und eine GUI in der Mitte soll die Texteingabe, eine Bearbeitungsvorschau und Eingabemöglichkeiten für Fräswerkzeuge, Gravurparameter und Werkstückversätze enthalten.

Ich hatte ein paar Programmiersprachen zur Auswahl, die ich gut genug “spreche”:

C++ mit QT-Framework
Java
Python mit dem Tkinter-Framework

Ich entschied mich für die - meiner Meinung nach - einfachste Lösung, um so schnell wie möglich einen lauffähigen Prototyp zu haben: Python mit Tkinter. Ich kenne Tkinter von einem meiner früheren Projekte und obwohl es seine Einschränkungen hat, ist es immer noch leistungsstark genug und schnell zu verwenden.

Konzeptphase

Nach etwas Recherche fand ich eine ziemlich gute Open-Source-QR-Code-Bibliothek im Internet, die auch in Python verfügbar ist. Auf der Grundlage ihrer Ausgaben habe ich einen Vektorisierungsalgorithmus erstellt, der die QR-Code-Bibliothek abfragen kann, um die Werte der Pixel des QR-Codes in einer Scanzeile zurückzugeben:

 def _qr_bitstream_from_line(self, line):
 """Creates a bitstream from an input line of a QR-code data representation
 :param line: a QR-code data representation (line of bits within the QR-code)
 :returns bitstream: returns an array of bits reflecting the QR code's state at the respective
 point of the line."""
 bitstream = []
 if line.get_direction() == Direction.RIGHT:
 for x in range(line.get_p_start().x, line.get_p_end().x + 1):
 bitstream.append(self._qr.get_module(x, abs(line.get_p_start().y)))
 if line.get_direction() == Direction.LEFT:
 for x in range(line.get_p_start().x, line.get_p_end().x - 1, -1):
 bitstream.append(self._qr.get_module(x, abs(line.get_p_start().y)))
 if line.get_direction() == Direction.UP:
 for y in range(line.get_p_start().y, line.get_p_end().y + 1):
 bitstream.append(self._qr.get_module(line.get_p_start().x, abs(y)))
 if line.get_direction() == Direction.DOWN:
 for y in range(line.get_p_start().y, line.get_p_end().y - 1, -1):
 bitstream.append(self._qr.get_module(line.get_p_start().x, abs(y)))
 return bitstream

Dann musste ich aus diesen Linien Vektoren erstellen, so dass aufeinanderfolgende Pixel derselben Farbe zu einer Linie zusammengefügt werden konnten, die viel schneller herzustellen ist als einzelne Punkte:

 def _vectorize_bitstream(self, bitstream):
 """Creates a QrLineData object from an input bitstream
 :param bitstream: an array of bits = a line of the QR-code
 :returns line_vector: A list of QrLineData objects"""
 line_vector = []
 data = QrLineData(bitstream[0], True)
 for bit in range(1, len(bitstream)):
 if bitstream[bit] == data.get_state():
 data.add_length()
 else:
 line_vector.append(data)
 data = QrLineData(bitstream[bit])
 if not data.get_state():
 data.finalize()
 line_vector.append(data)

 return line_vector

Diese beiden Methoden würden nun von einer übergeordneten Methode aufgerufen werden, die einen spiralförmigen Pfad durch den QR-Code kennt. Meine erste GUI hatte nur drei Elemente: Ein Eingabefeld für den Text, der in einen QR-Code umgewandelt werden sollte, eine Schaltfläche, um den Algorithmus auszuführen, und eine Zeichenfläche, auf der der Gravurpfad des Algorithmus ausgegeben werden sollte.

Ich das Modul Turtle verwendet, um den vektorisierten QR-Code-Pfad zu zeichnen, ein Tool, das für Schülerinnen und Schüler geschrieben wurde, die sich in Programmiersprachen wie Python einarbeiten. Es ist zwar langsam, aber einfach einzurichten, so dass mir das für den Anfang genügte. Ich habe für’s Erste hart kodiert, um Zeit zu sparen, und meine Schleifen sind eher C-esk als pythonisch, aber egal.

 for vect in self._spiral_path[i].get_z_vector():
 if self._stop_draw:
 break
 length = vect.get_length()
 if vect.get_state():
 self.turtle.down()
 self.turtle.forward(self.pen_size * length)
 self.turtle.up()
 else:
 self.turtle.forward(self.pen_size * length)
 self.turtle.right(90)

Dieses sehr einfache Konzept sah für mich vielversprechend aus, aber ich musste ein paar Stunden daran feilen, weil meine anfängliche Ausgabe wie folgt aussah:

Your browser does not support the video tag.

QR-codengrave GUI test

Nach einer Weile konnte ich jedoch zuverlässig einen (21x21 Pixel) QR-Code auf den Bildschirm zeichnen und die Kamera meines Smartphones verwenden, um den Link zur Webseite zu erhalten. 🥳 Yeah!

Your browser does not support the video tag.

QR-codengrave Vektorerzeugung funktioniert

Unit-Tests

Die “Plattform”-Teile - Klassen vectorize_qr und machinify_vector - enthalten beide eine Menge überprüfbarer Berechnungen und Geschäftslogik. Deshalb sind meine Tests mit Pythons Standardmodul unittest schnell und einfach zu schreiben. In diesem Beispiel überprüfe ich, ob die von mir erstellte Linienklasse eine Länge (n+1 Stil) korrekt berechnet:

class TestLine(unittest.TestCase):

 def test_line_x_calculates_valid_length(self):
 line = Line(Point(0, 0), Point(5, 0))
 self.assertEqual(6, line.get_abs_length())

Aber es wurde schnell komplexer, als ich testen wollte, ob die Ausgabe der QR-Code-Generatorbibliothek in meinem Programm korrekt verarbeitet wird. Dazu musste ich die Bibliothek in meine zu testende Klasse einbinden, damit ich eine Mock-Implementierung einschleusen konnte, die dann im Test abgefragt wird.

Dieses Muster der Abhängigkeitsinjektion ist der Vorgehensweise in C++ sehr ähnlich, wo ich viel mehr Erfahrung habe (siehe ein Projekt hier oder ein anderes hier, zum Beispiel), nur dass in Python viel weniger Boilerplate-Code nötig ist, um dorthin zu gelangen. Ein paar Suchvorgänge im Internet und schon war der folgende Testfall geschrieben:

 def test_bitstream_qr_input_loop_xpos_correct(self):
 mock_qr = QrCode.encode_text("schallbert.de", QrCode.Ecc.MEDIUM)
 mock_qr.get_module = MagicMock()
 cam = VectorizeQr(mock_qr, 1)
 cam._qr_bitstream_from_line(self.test_line_x)
 mock_qr.get_module.assert_called_with(20, 0)

Ich injiziere die “echte” QrCode-Bibliothek, aber mit einer Mock-Methode, die für mich von Interesse ist, get_module(). In dem Test stelle ich sicher, dass die Methode mit den erwarteten Parametern aus meiner zu testenden Klasse aufgerufen wird.

Mit solchen Tests kann ich sichergehen, dass die Bausteine meines Algorithmus wie vorgesehen funktionieren und dass Regressionen schnell gefunden werden können.

Der lange Weg zum Produkt mit Minimalanforderungen

Beflügelt von diesem schnellen Erfolg, ging ich aufs Ganze. Vor der Implementierung des G-Code-Generators musste ich einen Werkzeugselektor entwerfen, da ich die Werkzeugeigenschaften zur Verfügung haben musste, bevor ich die Abmessungen und die Werkzeuggeschwindigkeit / den Vorschub für die QR-Code-Gravur einstellen konnte.

Nach einigen erfolglosen Versuchen im Hauptfenster entschied ich, dass das Werkzeugkonfigurationsfenster stattdessen ein Dialog sein sollte (den Tkinter Toplevel nennt), so dass die Werkzeugparameter eingegeben und nach Abschluss an die Haupt-GUI zurückgeschickt werden können. Ich habe den Dialog modal gemacht mit

 self._dialog.grab_set()

So hat er immer den Fokus, damit nicht mehrere Instanzen dieses Fensters gleichzeitig vorhanden sein können. Ich habe die konfigurierten Werkzeuge in einer nummerierten Liste gespeichert, so dass die Anwendung, sobald sie gefüttert wurde, die Liste zur Verfügung stellt, damit der Benutzer das gewünschte Werkzeug für den Job aus einem Dropdown-Menü auswählen kann.

In diesem Schritt musste ich zwei Dinge implementieren:

Überprüfungen für Wertetyp und -bereich
Ein Persistenzmodul, so dass die eingegebenen Tools einen Neustart der Anwendung überleben würden.

Überprüfungen von Wertetyp und -bereich

Dies könnte mit einem Ereignis-Auslöser innerhalb des Eingabefeld-Widgets wie folgt erreicht werden:

 reg = config_tool_frame.register(validate_number)
 tool_nr_entry.config(validate="key", validatecommand=(reg, '%P'))

Anschließend wird der eingegebene Wert an einen einfachen Validator übergeben, der lediglich versucht, den Eingabewert in einen Float-Wert umzuwandeln und False zurückgibt, wenn dies einen Fehler erzeugt,

def validate_number(entry):
 """Helper function that is used in validators to check
 that the entered keystroke is a number"""
 if entry == '':
 return True
 try:
 float(entry)
 return True
 except ValueError:
 return False

Eine Prüfung ob der Wert plausibel ist erfolgt erst, wenn die Schaltfläche “OK” gedrückt wird, um die eingegebenen Daten an die Anwendung weiterzuleiten. Bei Überschreitung des Bereichs würde ein Warn-Popup (Modul tkinter.messagebox) erscheinen, das auf das mögliche Problem hinweist.

Persistenz

Das Persistenzmodul war etwas schwieriger zu implementieren. Ich entschied mich dafür, ein Element zu erstellen, das C++-Kenner eine statische Klasse nennen würden, d.h. eine Klasse, die nicht instanziiert werden muss, um eine ihrer Methoden aufzurufen. Diese Klasse hat nur zwei Methoden namens load und save, die das tun, was ihr Name andeutet, indem sie Pythons pickle Modul zur Serialisierung von Objekten verwenden, die ich speichern wollte. In Python habe ich den Dekorator @classmethod verwendet, um die statische Natur dieser Klasse zu kennzeichnen.

So einfach kann die Serialisierung von Daten mit den richtigen Werkzeugen werden:

 with open(app_persistence_path, 'wb') as file:
 pickle.dump([cls._tool_list,
 cls._z_params,
 cls._xy0],
 file, protocol=2)

Als dies zuverlässig funktionierte, fügte ich ein Widget zur Konfiguration der Gravurparameter hinzu. Von Nachteil bei statischen Methoden ist, dass sie nur schlecht unit-testbar sind, weil Dependency Injection hier nicht funktioniert; sie sind ja instanzlos. Es bliebe mir nichts anderes üblich als “Fakes” zu schreiben, die im Testfalle die echte Speicher- bzw. Ladefunktion ersetzt.

Gravur-Parameter

Um den G-Code aus meinen QR-Code-Daten zu generieren, benötigte ich nicht nur Werkzeug- und Geschwindigkeits-/Vorschubdaten, sondern ich musste auch wissen, wie tief ich gravieren wollte, wie weit das Werkzeug bei Eilgängen über der Werkstückoberfläche schweben sollte und welche Sicherheitshöhe die CNC für die Rückkehr zum Ursprung oder zur Ausgangsposition verwenden sollte.

Es wird auf ähnliche Weise wie das Dialogfeld “Werkzeugkonfiguration” erstellt und verwendet dieselben Mechanismen zur Überprüfung von Typ und Bereich. Der einzige Unterschied besteht darin, dass er nicht über einen Klick auf eine Schaltfläche, sondern direkt über das zugehörige Textfeld gestartet wird, das den aktuellen Wert der Gravurparameter im Hauptfenster anzeigt.

Werkstück XY Nullpunktverschiebung

Der Konfigurationsdialog für den Werkstückversatz enthält einige Radiobuttons zur Auswahl der gängigsten Werkstückursprünge und eine benutzerdefinierte Option, mit der der Benutzer Werte für den X- und Y-Achsennullpunkt des Werkstücks eingeben kann. Eine Funktion im Hintergrund berechnet den erforderlichen Versatz relativ zum Startpunkt der Gravierspirale.

Normalerweise würde ich nicht wollen, dass die grafische Benutzeroberfläche Berechnungen durchführt oder viel Verzweigungslogik verwendet, da dies schwieriger zu verifizieren ist, weil die Test Fixtures damit größer und schwieriger zu warten werden. In diesem Fall habe ich mich jedoch entschieden, die Offset-Berechnung mit Hilfe einer Wertetabelle innerhalb des GUI-Moduls durchzuführen, um zu vermeiden, dass alle GUI-Module zur Plattform und zurück kommunizieren müssen (und das durch 4 Klassen hindurch).

 def _get_xy_offset(self, offset):
 """calculates an XY coordinate offset from a preset point, taking the selected tool diameter into account.
 :param offset the selected offset from the above enum class
 :returns a XY Point where XY0 is assumed for the engraving."""
 qr = self._qr_dimension
 d = self._tool_diameter
 offsets = {Offset.CENTER: Point((d - qr) / 2, (qr - d) / 2),
 Offset.TOPLEFT: Point(d / 2, -d / 2),
 Offset.TOPRIGHT: Point(d / 2 - qr, -d / 2),
 Offset.BOTTOMLEFT: Point(d / 2, qr - d / 2),
 Offset.BOTTOMRIGHT: Point(d / 2 - qr, qr - d / 2)
 }

 if offset in offsets:
 return offsets[offset]

Erstes Release V1.0

Die erste Version ist minimalistisch. Sie erfüllt ihren Zweck, hat aber noch einige Fehler (z.B. eine Fehlermeldung, wenn kein Werkzeug in der Auswahlliste ausgewählt ist) und Unzulänglichkeiten (z.B. ist das Zeichnen eines QR-Codes sehr langsam, beim erneuten Zeichnen kippt der QR-Code ein wenig usw.), aber sie sollte einfach funktionieren und dem Benutzer helfen, die schlimmsten Fehler auf seinem Weg zu vermeiden.

Ich habe die Ausführung auf meiner CNC-Maschine getestet und zumindest mein Handy ist in der Lage, zu einer Website zu navigieren, indem es einfach die Kamera auf das Werkstück hält 📱.

Automatisierte Integrationstests für die GUI: Frustrierende Arbeit

Als meine erste Version herauskam, wollte ich einige Tests für die grafische Benutzeroberfläche hinzufügen. Da ich es nicht geschafft habe, dort absolut keine Geschäftslogik zu haben, wollte ich zumindest Bereichsprüfungen sowie die Kommunikation mit der Plattform überprüfen, um sicherzustellen, dass alles wie vorgesehen funktioniert.

Aufgehängt in der Messagebox

Zu diesem Zweck schrieb ich einige Tests, die auf meinem lokalen Rechner liefen, mit dem Nachteil, dass, wenn der Test auf einen Warn- oder Fehlerdialog messagebox.showinfo / messagebox.showerror stieß, eine manuelle Benutzerinteraktion unbedingt erforderlich war, damit das Fenster geschlossen und der Test fortgesetzt werden konnte.

Ich habe keine einfache Möglichkeit gefunden, dieses Problem zu umgehen, da die Messagebox als unabhängiges Widget agiert, das nicht einfach manipuliert werden kann. Auch meine Versuche, einen Tastendruck als Seiteneffekt aus dem Test heraus auszulösen, waren nicht von Erfolg gekrönt (und wären am Ende wohl auch keine saubere Lösung gewesen).

Meine Lösung nach ein paar Stunden gemurmelten Fluchens ist, dass die Messagebox-Widgets in die GUI-Klassen injiziert werden, die sie verwenden:

@patch('src.gui.gui_tool_manage.GuiToolManager')
 def setUp(self, mock_guitoolmanager):
 tk.Tk() # required to have tk variables properly instantiated
 self.mock_guitoolmanager = mock_guitoolmanager
 self.mock_msg = MsgBox()
 self.mock_msg.showinfo = MagicMock()
 Persistence.set_mock_msgbox(self.mock_msg)
 self.config_tool = GuiConfigureTool(self.mock_guitoolmanager, self.mock_msg, {'padx': 5, 'pady': 5})

Auf diese Weise kann ich mock_msg in die Gui-Klasse werfen, so dass nicht die echte showinfo genommen wird, sondern das Mock weiß, ob er wie vorgesehen aufgerufen wurde. Ich könnte ihr zur Testvorrichtung hinzufügen, so dass mein Testcode selbst DRY bleiben könnte.

Es fügt dem Konstruktor mehr Argumente hinzu und delegiert die Instanziierung an eine Klasse höherer Ebene, aber die Verwendung innerhalb der zu testenden Klasse bleibt trivial. Im Einsatz unter Realbedingungen agiert die Schnittstelle wie ein Proxy, der dann die echte showinfo-Methode des Messagebox Objektes aufruft.

Probleme mit statischen Klassen

Da die Persistenzklasse, die ich oben erwähnt habe, statisch ist, d.h. keine Instanziierung erfordert, hatte ich das nächste Problem von Anfang an in meinen Code eingebaut: Ein Integrationstest würde nun versuchen, in eine tatsächliche “persistence.dat”-Datei zu schreiben, eine Abhängigkeit, die ich nicht haben wollte, insbesondere nicht in der kontinuierlichen Integration (CI) - denn dort würde das Programm die Rechte für das Schreiben auf Festplatte nicht besitzen.

Also habe ich Persistence in die Haupt-GUI-Datei verschoben, die nicht getestet werden würde, und folgte damit Steven Andersons großartigem Blogbeitrag. Die Haupt-GUI sollte ohnehin nur deklarativen Code enthalten, und die geladenen Daten werden dann in die Klassen kaskadiert, die sie verwenden, anstatt in die Persistenzklasse, die die eigentliche Lade-/Speicheroperation durchführt.

Zukünftige Versionen

Folgendes ist für spätere Releases geplant:

Die Zeichnungsgeschwindigkeit des QR-Codes muss erhöht werden
Grafikfehler (Skalierung, Kippen) und unscharfe Ränder des Zeichenbildschirms sollen behoben werden
CNC-Bahnen sollen optimiert werden, um die Fertigungszeit zu verringern
Fehlerbehebungen

Zumindest wenn es welche gibt; mal sehen, wie oft ich dieses Tool benutzen werde. Die Dinge, die mich am meisten stören, werden wahrscheinlich zuerst behoben werden.

Ach ja, noch etwas: Danke für’s Lesen des gesamten Artikels. Zur Belohnung gibt es eine Kopie QR-codengrave kostenlos zum Herunterladen. Es kann für den privaten Gebrauch gern verwendet werden. Falls Sie eine kommerzielle Nutzung planen, lassen Sie es mich bitte im Voraus wissen.

Rechtliches / Impressum

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Impressum

Angaben gemäß § 5 TMG / address

Kontakt

Redaktionell verantwortlich für den Inhalt nach § 55 Abs. 2 RStV:

Quelle

e-recht24.de

Streitschlichtung

Ich bin weder bereit noch verpflichtet, an Streitbeilegungsverfahren vor einer Verbraucherschlichtungsstelle teilzunehmen.

Haftung

Habe ich etwas falsch gemacht oder vergessen?

Ich bin auch nur ein Mensch und versuche, diese Website nach bestem Wissen und Gewissen der aktuellen Rechtslage entsprechend zu betreiben. Sollte dennoch etwas nicht den gesetzlichen Anforderungen entsprechen, so bitte ich höflich um eine formlose Mitteilung. Berechtigte Anmerkungen und Beschwerden werde ich umgehend bearbeiten und Mängel beseitigen.

Haftung für Inhalte

Als Diensteanbieter bin ich gemäß § 7 Abs.1 TMG für eigene Inhalte auf diesen Seiten nach den allgemeinen Gesetzen verantwortlich. Nach §§ 8 bis 10 TMG bin ich als Diensteanbieter jedoch nicht verpflichtet, übermittelte oder gespeicherte fremde Informationen zu überwachen oder nach Umständen zu forschen, die auf eine rechtswidrige Tätigkeit hinweisen.

Verpflichtungen zur Entfernung oder Sperrung der Nutzung von Informationen nach den allgemeinen Gesetzen bleiben hiervon unberührt. Eine diesbezügliche Haftung ist jedoch erst ab dem Zeitpunkt der Kenntnis einer konkreten Rechtsverletzung möglich. Bei Bekanntwerden von entsprechenden Rechtsverletzungen werde ich diese Inhalte selbstverständlich umgehend entfernen.

Haftungsausschluss

Meine Seite enthält Links und Referenzen zu externen Websites Dritter, auf deren Inhalte ich keinen Einfluss habe. Deshalb kann ich für diese fremden Inhalte auch keine Gewähr übernehmen. Für die Inhalte der verlinkten Seiten ist stets der jeweilige Anbieter oder Betreiber der Seiten verantwortlich. Die verlinkten Seiten wurden zum Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft. Rechtswidrige Inhalte waren zum Zeitpunkt der Verlinkung nicht erkennbar.

Eine permanente inhaltliche Kontrolle der verlinkten Seiten ist jedoch ohne konkrete Anhaltspunkte einer Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen werde ich derartige Links umgehend entfernen.

Urheberrecht

Die mir erstellten Inhalte und Werke auf diesen Seiten unterliegen dem deutschen Urheberrecht. Die Vervielfältigung, Bearbeitung und jede Art der Verwertung außerhalb der Grenzen des Urheberrechtes bedürfen meiner schriftlichen Zustimmung. Downloads und Kopien dieser Seite sind nur für den privaten, nicht kommerziellen Gebrauch gestattet.

Ich bemühe mich sehr, Inhalte Dritter als solche zu kennzeichnen und mir die Erlaubnis zur Verwendung dieser Inhalte vorab schriftlich einzuholen. Sollten Sie trotzdem auf eine Urheberrechtsverletzung aufmerksam werden, bitte ich um einen entsprechenden Hinweis. Bei Bekanntwerden von Rechtsverletzungen werde ich derartige Inhalte selbstverständlich umgehend entfernen.

Seifenbutler

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Mittel 3/5
Kosten: ~250€
Zeitaufwand: mehr als ein Jahr

Die Geschichte vom Seifenbutler

Begleiten Sie mich hier über eine Zeitraum von mehr als einem Jahr, in welchem ich beständig an ein- und demselben Projekt arbeite. Dabei geht es von einer Idee mit wenigen Anforderungen hin zur Vorserienreife. Ich erläutere meine Prototypenarbeit, gehe ein wenig auf die vielen Rückschläge ein und nähere mich am Ende einem - wie ich meine - guten Produkt an.

Idee

Mai 2022

Vor Kurzem bin ich beim Duschen von flüssigem Shampoo auf ein Shampoo bzw. Seife in fester Form umgestiegen. Da ich keine Ablage für die Seife hatte, wurde sie gleich mitgeduscht. So verbrauchte sie sich schneller, wurde tagelang nicht trocken und klebte auch noch am Rand der Dusche fest.

Ich wollte keinen normalen Seifenhalter kaufen, für den man Löcher in die gefliesten Wände bohren müsste. Also beschloss ich, einen Seifenhalter zum Anklemmen für die Duschstange zu entwerfen. Ich würde das Teil über dem Duschkopf anbringen, damit es nicht mehr Wasser als nötig ausgesetzt ist.

Außerdem soll der Seifenhalter im Handumdrehen und ohne Werkzeug zu montieren sein.

V1-V3: Erste Entwürfe in HPL

Juli 2022

Also entwarf ich meinen eigenen Halter. Ich wollte ein einfaches, rundes Design mit einem Klemmloch zur Befestigung an der Duschstange und einem abgesenkten Bereich, in dem die Seife bzw. das feste Shampoo untergebracht werden sollte. Durch einige Schlitze im Boden sollte das Wasser abtropfen und die Seife an der Luft trocknen können, wenn sie nicht benutzt wird. Ich wollte ein Befestigungselement im Inneren des Teils und eine Mutter auf der Innenseite anbringen, damit der Durchmesser des Lochs für die Duschstange verringert und der Seifenbutler - so der Name für das gute Stück - auf diese Weise festgeklemmt werden kann.

Um dies zu ermöglichen war es sinnvoll, zwei Bauteile zu fertigen - ein oberes, das die Seife an Ort und Stelle hält und Platz für die Aufnahme der Befestigungsmechanik bietet und ein unteres, das Ablaufschlitze für überschüssiges Wasser und die Aufnahme der anderen Hälfte der Befestigungsmechanik aufweist.

FreeCAD: Skizzen

FreeCAD-Artefakte werden auf eine bestimmte Art organisiert, um den Umgang mit verschiedenen Ansichten zu vereinfachen oder die spätere zweiseitige Bearbeitung mit Hilfe der Funktion Klonen vorzubereiten. Daher erstelle ich zunächst eine Reihe von Teilen im Modus Parts Design. Skizzen können in Körperelementen gruppiert werden, die wiederum in Teilelementen angeordnet sind.

Ich erstelle also ein Teil (gelbes Element), das “Skizzen” enthält - alle Originalzeichnungen (rote Elemente) aller Körper (blaue Elemente) des/der zu produzierenden Teils/Teile. Diese Zeichnungen sollten vollständig bestimmt “fully constrained” sein. Sie können keine Informationen zur Positionierung relativ zu anderen Komponenten enthalten. Das bedeutet, dass sich die Skizzen alle am gleichen Ort befinden. Somit sollten alle inaktiven Skizzen ausgeblendet werden um Verwechslungen zu vermeiden.

(Einen tieferen Einblick in meinen FreeCAD-Workflow bietet dieser Blog-Artikel.)

FreeCAD: Teile

Dann erstelle ich Teile, die später die zu schneidenden Komponenten enthalten, z.B. “clampingHoles”, “soapButler”, “wallHolder”. Sie enthalten jeweils eine Untermenge der Skizzen, aber keine Informationen zur endgültigen Positionierung. Zuletzt erstelle ich ein Teil für jeden Auftrag, den meine Produktion auszuführen hat, z. B. job00_clamping, job01_upperMill, job02_3dCut, job03_lowerFinish. Diese klonen Körperkomponenten, fügen aber Platzierungsinformationen hinzu, enthalten gespiegelte Teile für das 2-seitige Fräsen oder bieten einen Umriss, um die XY-0 richtig einzustellen.

Der Vorteil einer solchen Projektkonfiguration besteht darin, dass, wenn eine Original-Skizze aus irgendeinem Grund geändert werden muss, alle geklonten Teile automatisch ebenfalls geändert werden. Zudem kann man bei geschickter Organisation erreichen, dass Maße der Teile einfach in der Tabelle geändert werden können und sich dann die gesamte Teilegeometrie darauf anpasst, ohne dass manuell nachgearbeitet werden muss.

Bearbeitung

Für meinen ersten Prototyp habe ich Hochdrucklaminat als Material gewählt, da es sehr widerstandsfähig ist, ab und zu nass werden kann und ziemlich gut aussieht. Für die Bearbeitung habe ich Fräser mit niedriger Spiralsteigung verwendet, um die Vibrationen beim Schneiden des zähen HPL-Materials unter Kontrolle zu halten. Ich habe mich für beschichtete Einschneider-Hartmetallfräser entschieden, die ich vor einiger Zeit gekauft habe (für das Schneiden von Aluminium). Ich benutzte Exzenterspanner, um das Teil an seinem Platz zu halten, und nahm nur zwei zusätzliche Niederhalter zur Hand, damit das Teil auf dem Maschinenbett blieb.

Ich hatte einen Fehler im CAM-Programm, für dessen Behebung ich ein paar Minuten brauchte: Ich hatte die Werkzeugwege für die Spirale nach innen und nicht nach außen eingestellt. Das Problem dabei ist, dass die Spirale mit Fortschreiten des Schnittes immer schwammiger und instabiler wird. Ich konnte die Vibrationen nur dadurch in Schach halten, dass ich den Fräsvorgang häufig unterbrach und Klebeband an den Stellen anbrachte, an denen der Schnitt bereits eingebracht war.

Bewertung

Die Herstellung des ersten Prototyps lief ganz OK. Die Maschine brummte zuversichtlich, und abgesehen von einigen kleinen Fehlern (Befestigungslöcher im unteren Teil zu eng, Länge der Klammerbefestigung falsch angegeben) war ich mit dem Ergebnis einigermaßen zufrieden.

Ich brauchte etwa 20 Minuten, um das Teil auszulösen und die Anbindungen zu entfernen. Dies erschien mir als deutlich verbesserungswürdig.

V4: Fehlschlag mit billigem HPL

Oktober 2022

Ich habe die Fasenfunktion in meiner CAM noch nie verwendet und dachte, dies wäre eine gute Gelegenheit für einen Test, da die Teileecken bei meinem ersten Prototyp ziemlich scharf waren. Da ich nur einen 4mm Schaftfräser verwende, erschien mir der 90° 10mm Fasenfräser zu groß, zumal ich nach außen versetzen musste, um die Spitze des Fasenfräsers nicht zu verschleißen. Deshalb wählte ich einen 30°-Winkel, was sich schnell als Fehler herausstellte, da die Ecken damit kaum weicher wurden.

Ich vergaß auch, dass nur die Außenseite der Teile von einer abgeschrägten Kante profitieren würde. Ich hingegen wendete die Fase auf der Innenseite an, was der Verarbeitungsqualität abträglich war. Außerdem stellte ich fest, dass die neue HPL-Platte, aus der ich die Prototypen herstellte, nicht ganz plan auflag, so dass einige Teile des Umrisses nicht vollständig durchgefräst waren. Dies führte wiederum zu einer geringeren Qualität und zu erheblichen manuellen Nacharbeiten.

V5: Korrekturen im CAM und bessere Verarbeitungsqualität

November 2022

Ich finde die Freiarmklammer mit offenem Befestigungselement nicht so schön anzuschauen, weil sie Asymmetrisch ist. Außerdem würde sie wegen des engen Spalts schwer zu reinigen sein. Nach einigem Nachdenken kam ich auf die Lösung einer “Mittelklemme”: Das Befestigungselement würde gegen ein Stück Gummi drücken, das direkt an der Duschstange anliegt, um die Seifenablage in Position zu halten.

Fasen

Nachdem ich die Zeichnungen entsprechend aktualisiert hatte, erstellte ich ein weiteres, gespiegeltes Teil in FreeCAD im Modus “Draft”. Dieses Teil klont das Originalteil am Umriss und ist für das zweiseitige Fräsen bestimmt, wobei das Teil um seine linke obere Kante (XY-Null) gedreht wird. Auf diese Weise ist die Fase dann richtig umzusetzen, wenn ich sicherstellen kann, dass sich der XY-Nullpunkt nicht bewegt.

Das hat in der Praxis sehr gut funktioniert, und ich konnte auch das Anbringen von Senkbohrungen für die unteren Befestigungselemente automatisieren, was die Bauqualität erhöht. Das Ergebnis ist unten zu sehen.

Bewertung

Nachdem dieses fünfte Teil bearbeitet war musste ich leider feststellen, dass die Melaminbeschichtung an der Schnittkante leichte Ausrisse aufwies. Außerdem bemerkte ich während der Bearbeitung den Geruch nach verbranntem Material. Ein kurzer Blick auf den Fräser offenbarte die Ursache: Er war nach nur einer Stunde Betriebszeit trotz Beschichtung stumpf geworden. Das macht die Arbeit mit HPL ziemlich teuer und frustrierend. Außerdem war die Zykluszeit für diese Version recht lang: 15 Minuten für ein Teil. Das würde nie wirtschaftlich werden¹.

Deshalb habe ich versucht, alternative Materialien für den Seifenbutler zu finden. Inzwischen sollten die Prototypen ein paar Monate lang in der Dusche ausprobiert werden, um Langzeiterfahrungen zu sammeln. Ist HPL geeignet für den Einsatz im Feuchtraum? Kriecht das Wasser zwischen den beiden Schichten hindurch? Ist es leicht zu reinigen?

V6: Fehlschlag mit Birke-Multiplex

Mai 2023

Auf der Suche nach neuen Materialien besorgte ich wasserfeste Holzplatten, verleimt im Multiplexverfahren. Da sie mit 15mm deutlich stärker war als das vorher verwendete Material, vereinfachte ich das Design in eine Ausführung, die aus nur einem Teil besteht und hinten zentral über eine Madenschraube verfügt, die die Klemmung an der Duschstange übernehmen sollte.

Das Loch für die Madenschraube würde ich nach der Fertigung auf der CNC von Hand bohren.

Leider jedoch stellte sich das Material auf der CNC als ungeeignet für das Fräsen der Spirale heraus. Ich bekam zahlreiche Ausrisse und hatte Schwierigkeiten, das Werkstück niederzuhalten. Die Konturen meines Seifenbutlers waren für das kreuzverleimte Material schlicht zu fein bzw. die Faserlänge des Holzes zu groß.

Die fünf gefertigten Teile wanderten direkt in den Restmüll.

V7: Fehlschlag mit Aluminium-Verbundmaterial

Juli 2023

Ich kehrte nun zum Design als Zweiteiler zurück und überlegte, ob Aluminium-Verbundmateial durch seine Korrosionsbeständigkeit nicht ebenfalls für meine Seifenablage geeignet wäre.

Kurzerhand fertigte ich einen neuen Entwurf an², der die Eigenschaften des neuen Materials versucht, so gut wie möglich zu berücksichtigen. Nebenbei überlegte ich mir, dass durch das leichtere Material jetzt endlich eine Halterung über Magnete möglich sein müsste und sah entsprechende Senkungen im Rahmen dafür vor.

Ich hatte die Idee, dass ein Teil von je einer Seite der Duschstange aus angelegt und dann über die Magnete zusammengehalten würden - damit bin ich endlich die lästige Klemmschraube los und habe ein sehr einfaches Design.

Leider jedoch erwies sich das Konzept als völlig ungeeignet. Die Haltekraft der Magnete ist nicht hoch genug und die Klemmung funktioniert nur über das Abkippen des Seifenhalters nach vorne, welches einen seltsam schiefen Eindruck an der Duschstange ergibt.

Also: Weitertüfteln!

V8: Umstieg auf Acrylglas, Spannfutter

Juli 2023

Nach vielen Stunden am Rechner für den Entwurf kam ich auf ein neues Klemmprinzip, abgeschaut vom Bohrfutter eines Akkuschraubers: Drei im 120°-Winkel angebrachte, bewegliche Klemmvorrichtungen würden - mittels eines Kabelbinders zusammengeführt - Duschstangen beliebigen Durchmessers festhalten.

Fertigung

Ich stieß auf vielfältige Schwierigkeiten in der Fertigung, verursacht hauptsächlich durch die teils sehr kleinen Komponenten, welche zudem auch noch Kerben für die Führung der Kabelbinder aufweisen mussten. Hinzu kam bei mir die Einsicht, dass Entwurf und Anfertigung leichtgängiger Passungen ohne merkliches Spiel für mich eine große Herausforderung sind und eine Menge erfolgloser Versuche benötigt, bis ich am Ziel bin.

Durch die Verwendung verschieden großer (2mm, 4mm) Fräser und Optimierung der Fräsreihenfolge konnte ich die Teile jedoch schließlich erfolgreich und in guter Qualität herstellen. Siehe dazu mein Artikel zum Thema Kleinteile Fräsen. Einzig die Spirale bereitet mir noch Kopfzerbrechen, denn auch in Acrylglas möchte sie dem Fräser am liebsten ausweichen. Dadurch sind ihre Kanten recht scharf.

Der Zusammenbau gestaltete sich zum Glück einfach - man benötigt nur eine Schraube und etwas Plastikklebstoff. Nur das Einfädeln des Kabelbinders will geübt sein.

Praxistest

Ich hatte diese Variante testweise für ein paar Monate in meiner Dusche. Da die Schraube nur verzinkt war, begann sie leider recht schnell, zu korrodieren. Merke: Edelstahl verwenden.

Die Stabilität des Seifenbutlers ist weiter verbesserungswürdig. Der Kabelbinder lässt etwas Spiel, sodass mit wenig Kraftaufwand Neigungen von rund 10° gegenüber der Senkrechten der Duschstange möglich sind. Dabei knarzt es ganz schön zwischen Ober- und Unterteil. Da muss noch nachgebessert werden.

Außerdem würde ich den Klemmmechanismus gern wieder etwas vereinfachen.

V9: Gegossenes Acrylglas, Seifenbutler abnehmbar

Juli 2023

Diese Weiterentwicklung hält Ober- und Unterschale vorn mit Magneten zusammen, welche sich unsichtbar im Material versenken lassen. Im Klemmbereich hinten befinden sich zwei Einsätze, die wie bei einer Schublade in eine passende Aussparung des Seifenbutler passen und ihn so zusammenhalten.

Ich habe mehrere Prototypen benötigt, bis ich die Binderführung soweit hatte, dass der Kabelbinder einfach hinten in den Seifenbutler gesteckt wird, er sich von selbst um die Duschstange legt und schließlich wieder zum Vorschein kommt, wo er dann zum Festzurren bereit liegt.

Dies ist das erste Design, was meine Anforderungen hinsichtlich Haltekraft und Einfachheit der Montage erfüllt. Leider ist die Fertigung komplex und die Toleranzen müssen eng gehalten werden, da der Seifenhalter entweder zu leicht aus der Klemmung herausrutscht oder aber durch zu enge Passungen kaum angebracht werden kann.

Your browser does not support the video tag.

Seifenbutler zip tie demonstration

V10: Verbessertes Fertigungsverfahren

August 2023

Mit ein paar Optimierungen entspricht diese Version der V9. Ich erreichte eine bessere Wiederholbarkeit in der Fertigung und kann Toleranzen für Passungen etwas großzügiger auslegen.

Mit diesem Design hole ich mir erste Rückmeldungen aus dem Bekanntenkreis. Einhellige Meinung: Kabelbinder wirken wie ein Provisorium und können den Kunden nicht zugemutet werden.

Also zurück ans Reißbrett.

V11: Stecksystem ‘L-Nase’ in HPL

August 2023

Ein weiterer Versuch in HPL, dieses Mal mit Vielzahnfräsern. Sie raspeln das Material eher als dass sie es schneiden und sind für die Bearbeitung abrasiver, faserreicher Materialien wie CFK/GFK ausgelegt. Die hohe Zähigkeit von HPL gepaart mit der schlechten Wärmeableitung jedoch lassen die Fräser nach nur zwei gefertigten Prototypen komplett stumpf werden. Also sind sie auch keine Lösung für effiziente Arbeit in HPL für mich.

Das Design ist wieder mehrteilig und erreicht die Klemmung im letzten Update über eine hinten montierte Schraube, die nach Zusammensetzen von Vorder- und Rückteil angezogen wird. Dadurch wird der Seifenhalter insgesamt länger, was ich vom Design her nicht optimal finde.

Die Fertigungsqualität hingegen habe ich inzwischen gut im Griff, finde ich. Die Schnitte sind sauber und auch die Qualität der Kanten ist sehr ansprechend.

Durch die schnelle Abnutzung der Fräser ist es für mich sehr schwer, in eine leichte Übermaßpassung für die Steckverbindung herzustellen. Allzu leicht geschieht es bei meinen Versuchen, dass der Fräser zu schnell an Durchmesser verliert und die Teile gar nicht oder nur mit roher Gewalt ineinander gesteckt werden können.

Vielleicht kann ich dieses Problem durch eine andere Passungsgeometrie lösen?

V12: Stecksystem ‘Brio’

September 2023

Hier verwende ich wieder Acrylglas, diesmal die extrudierte Variante. So sind die Dicketoleranzen gegenüber der gegossenen Variante sehr gering und meine Z-Nullpunkte sind stets passend. Dies ist prima für anzubringende Fasen, die endlich bei jedem Teil gleich breit ausfallen und dem Material eine hohe Wertigkeit verleihen.

Nun habe ich auch eine Lösung für die Spirale: Doppelseitige Bearbeitung. Dadurch steigt zwar der Aufwand für mich, allerdings verbringe ich lieber mehr Zeit an der Maschine, als mich später über mangelnde Qualität zu ärgern.

Mein Vorgehen: Ich fräse die Spirale fast ganz durch und lasse nur zarte 0.3mm stehen. Auf der Rückseite dann verwende ich den Fasenfräser und fahre die Spirale von innen nach außen ab. Zusätzlich sichere ich die Unterseite mit Klebeband, sodass mein Vakuumtisch die Spirale sicher halten kann und Schwingungen vermieden werden.

Das Design sieht ein Rändelrad vor, sodass die Klemmung ohne Werkzeug erfolgen kann. Da die Klemmung starke Zugkräfte auf die Verbinder ausüben und sie daher aus Stabilitätsgründen genau in der Achse der Duschstange positioniert sein müssen, habe ich auch hier ein leichtes Abkipp-Problem. Dieses verstärkt sich, je kleiner der Durchmesser der Duschstange ist.

Mit einer weiteren Variante konnte ich das Abkippen vermeiden, allerdings sind die Zapfen dann nicht mehr verdeckt. Dies wiederum hat zur Folge, dass dort jetzt Duschwasser eindringt und Rückstände hinterlassen kann.

Ich bin fast da. Trotzdem kann ich vielleicht noch etwas verbessern.

V13: Klemmautomatik und Nullserienfertigung

Oktober 2023

In Version 13 versuche ich, die Vorteile der vorgehenden Varianten V9-V12 zu bündeln und dabei die Nachteile (Abkippen, Kabelbinder, Montage mit Werkzeug, instabil) so gut wie möglich zu umgehen.

Neues Klemmkonzept

Ich verfolge daher noch ein neues Klemmkonzept. Ich möchte alle handelsüblichen Duschstangen bei der Montage berücksichtigen und muss daher zwischen 18mm und 25mm sicher klemmen. Aus den vorherigen Versionen ist mir ebenfalls klar geworden, dass zusätzlicher Druck von zentral hinter der Duschstange ausgeübt werden muss, um ein Abkippen des Seifenbutlers nach vorn zu verhindern.

Zusätzlich versuche ich, die Verriegelung um die Duschstange über eine Drehbewegung zu realisieren. Der Drehpunkt ist dabei die Mitte der Spirale, was drei weitere Schraubverbindungen am Umfang des Seifenbutlers erforderlich macht. Mit V13.9 schaffe ich endlich den Durchbruch.

Eine Klemmautomatik wird durch das Zusammenschieben von Ober- und Unterschale betätigt, sodass der Seifenbutler sich dem Durchmesser der Duschstange stufenlos anpasst. Die Arretierung findet über ein Rändelrad an der Unterseite statt, wo eine schiefe Ebene am Fanghaken unbeabsichtigtes Öffnen verhindert.

Fertigung

Dieses Design ist unglücklicherweise sehr komplex. Es besteht aus fünf Komponenten aus Acrylglas, fünf Schrauben und einer Rändelschraube mit Federring, deren Zusammenbau etwas Zeit in Anspruch nimmt.

Die Arbeit an der CNC beträgt über 10 Minuten pro Teil, was doch recht üppig ausfällt. Zudem habe ich einiges an Verbrauchsmaterial durch die erforderliche Werkstückniederhaltung.

Dennoch: Die Fertigungsqualität ist so hoch wie nie zuvor und der Seifenbutler ist jetzt kinderleicht und ohne Werkzeug binnen kurzer Zeit anzubringen.

Fazit

Januar 2024

Wenn ich meine CAD-Dateien so durchsehe, dann habe ich in der Summe bis jetzt 42 Versionen meines Seifenhalters geplant, aufgeteilt in 13 teils sehr unterschiedliche Designs. 21 dieser Versionen haben es am Ende auch wirklich auf die CNC geschafft und 5 von ihnen sind wiederum in einer größeren Stückzahl als 3 hergestellt worden.

Ich habe vier Seifenbutler zwecks Dauertest in meiner Dusche und inzwischen werden sie von der ganzen Familie benutzt.

Die Anzahl Stunden, die ich mit dem Thema bis jetzt verbracht habe, kann ich gar nicht seriös zählen - es waren aber echt viele. Ich habe eine Menge über Materialien und ihre Eignung für verschiedene Teilegeometrien, Aufnahme von Kräften, ihre Bearbeitbarkeit und dafür notwendige Schnittwerte an meiner Maschine gelernt. Und auch, dass es sich lohnt, Dinge mit Biss auch über lange Zeit weiterzuverfolgen. Vielleicht nicht monetär, doch auf jeden Fall für mich als Mensch.

Ich möchte auch gar nicht ausschließen, weitere Optimierungen am Seifenbutler vorzunehmen - erst einmal will ich in naher Zukunft aber schauen, ob er als Nischenprodukt markttauglich ist.

Einen tieferen Einstieg zu den Herausforderungen bei Bearbeitung von HPL gebe ich in diesem Blogbeitrag. ↩︎
Wie man an den CAD-Bildern ab hier erkennen kann, bin ich mit meiner Zeichensoftware umgestiegen (von FreeCAD nach CADasCAM). Für 2D-Zeichnungen ist es trotz einiger Nachteile leichter zu bedienen und ich komme schneller zu Ergebnissen. Ein großer Wermutstropfen: CADasCAM ist nicht quelloffen 😥. ↩︎

Spindel-Upgrade

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeit: Experte 5/5
Kosten: ~2700€
Zeitaufwand: ~20h

CNC Spindel-Upgrade

Entgegen meiner Aussage hier habe ich mich entschieden, eine Hochfrequenz-Spindel zu kaufen. Ich musste eine Menge lesen, planen, bauen und testen bevor ich mit der neuen Spindel endlich “Späne machen” konnte.

Gründe für die Investition

Es gibt starke und schwache Argumente für solch ein Upgrade. Kurz gesagt waren meine Argumente eher schwach, also hätte ich bei meinem bewährten Oberfräsmotor (Universalmaschine) bleiben können, deren Möglichkeiten und Grenzen nach einem Jahr im Einsatz klar auf der Hand lagen. Letztendlich war es mehr eine emotionale als eine faktenbasierte Entscheidung.

Starke Argumente 🥰

Mehr Leistung: Dieses Problem sollte nun nicht erneut auftreten, denn die Spindel kann jetzt deutlich höhere Zustellungen und Geschwindigkeiten fahren. Daher reduziert sich die Herstellungszeit, vor allem bei Aufträgen, bei denen viel Material abgetragen werden muss.
Mehr Drehmoment bei niedrigen Drehzahlen: Mein Fräsmotor konnte bei Einsatz eines Planfräsers die Drehzahl kaum halten, zudem überhitzte er sehr schnell weil sein Lüfterrad nicht genügend Luftdurchfluss ermöglichte. Durch die Fremdkühlung ist das Problem jetzt behoben.
Vibrationen: Ich hoffe, dass mein Vibrationsproblem durch die gesteigerte Steifigkeit der Spindelmontage nun gelöst ist; das wird sich aber erst noch zeigen müssen.
Höhere Präzision durch bessere Maschinenlager und höhere Stabilität der Halterung

Schwache Argumente 🤔

Die Spindel ist deutlich leiser als mein vorheriger Fräsmotor.
Ich finde Drehstrom-Asynchronmotoren und ihr Betrieb über Frequenzumrichter (FU) super spannend.
Ich mag das schicke Aussehen der Spindel.
Ich habe mich über ein halbes Jahr lang mit den Leuten bei Spinogy unterhalten und verschiedene Lösungen diskutiert. Ich wollte sie am Ende nicht ohne Kauf zurücklassen.
Der Frequenzumrichter hat zusätzliche interne Sicherheitsmechanismen, die bei Auftreten eines Fehlers Beschädigung von Maschine bzw. Werkstück verhindern können

Gegenargumente 🤨

Schlechte Kosten-Nutzen-Bilanz: Die Maschine ist etwas vielseitiger und schneller geworden, die Kosten aber sind deutlich gestiegen
Aufwärmzeit der Spindel sind nun 30 Minuten, eine echt lange Zeit wenn man die Maschine nicht im täglichen Einsatz hat
Langwierige Einarbeitung in das Fachgebiet wird benötigt. Über 400 Seiten Frequenzumrichter- und Spindel-Handbücher waren zu lesen, Schaltpläne zu zeichnen und ein Schaltschrank aufzubauen.
Die Portalkonstruktion meiner CNC ist für leichte bis mittelschwere Zerspanungstätigkeiten gedacht. Wenn ich die Leistung der Spindel vollständig ausnutzen möchte, würde es die Maschine überlasten, insbesondere ihren Schwachpunkt, die Z-Achse.
Die Spindel wiegt das Dreifache verglichen mit dem Fräsmotor, den ich vorher im Einsatz hatte.
Die komplexere Ansteuerung per Frequenzumrichter fügt eine Menge potentieller Fehlerquellen hinzu.

Zusammenfassend kann ich sagen, dass die Spindel durch ihre hohe Leistungsfähigkeit nicht so richtig zum Rest des Systems passt und ihre Vorteile dadurch nicht zur Gänze ausspielen kann. Ich hoffe, dass ich die Kaufentscheidung nicht bald bereuen werde.

Automatischer Werkzeugwechsel?

Hätte ich einen gut laufenden Fachbetrieb, z.B. zur Herstellung von Produkten aus Holz, dann wäre ein Werkzeugwechsler sicher eine gute Investition.

Für die Prototypenherstellung hingegen trifft meine Hypothese hier noch immer zu. Ich benötige eine Menge verschiedener Fräser, da ich mit verschiedenen Materialien, Durchmessern und Typen experimentiere. Allein die Kosten für genügend Steilkegel-Werkzeughalter allein würden die der Spindel bereits übersteigen.

Stattdessen habe ich mir eine weitere Spindelmutter besorgt. Somit kann ich die Spannzangen meist in den Muttern belassen, was ein paar weitere Sekunden pro Wechselvorgang einspart.

Kosten 💶

Ich habe noch einige andere Entscheidungen getroffen um meinen nur gelegentlichen Betrieb der Maschine als Nebenerwerb zu berücksichtigen sowie die Kosten gering zu halten. Bei meiner Spindelkonfiguration habe ich die Option mit reduzierter Leistung gewählt und die Spezifikationen der Lager nicht erhöht (obwohl ich für kleine Fräser schon die 50.000U/min gebrauchen könnte), so dass die Maschine auf 30kU/min begrenzt ist. Ich habe Luftkühlung der wassergekühlten Variante vorgezogen und nicht in ein System zur kontinuierlichen Temperaturüberwachung investiert.

Dennoch betragen die Gesamtkosten des Systems mehr als das Doppelte der Spindelkosten. Obwohl der FU nicht allzu teuer ist, summieren sich abgeschirmte Motorkabel, Steckverbinder, Drehmomentschlüssel, Netzfilter, Spannzangen/Muttern, der Schaltkasten und viele zusätzliche Kleinteile ganz schön auf.

Informationsphase

Um die neue Spindel zum Laufen zu bringen, musste ich ein komplettes Subsystem planen, bauen und konfigurieren das Spindelantrieb, Kühlung und Hilfsstromversorgung umfasst. Aufgrund der Komplexität des Projekts habe ich meine Arbeit in verschiedenen, aufeinander aufbauenden Phasen durchgeführt. Ich begann mit der Informationsphase, in der ich mir einige Fragen beantworten musste, die ich im Folgenden erläutere.

Antrieb mit variabler Frequenz

Wie ich in diesem Artikel bereits schrieb, wird ein Frequenzumrichter zur Steuerung der Drehzahl einer HF-Spindel verwendet. Der Motor heißt so, weil er weit oberhalb der Netzfrequenz (in meinem Kontinent 50 Hz) arbeitet, um höhere Drehzahlen zu erreichen wie sie für meine Anwendungen oft erforderlich sind.

Um einige Fragen in der Tiefe beantworten zu können, telefonierte ich mit einem Experten von Omron (Hersteller von Frequenzumrichtern), Herrn Wagner.

U/f-Kennlinie" oder “sensorlose Vektorregelung”?

Wird die U/f-Kennlinie gewählt, reduziert der Frequenzumrichter die Spannung zusammen mit der Frequenz, solange der Motor unterhalb seiner Eckfrequenz arbeitet (die bei meiner Maschine 400 Hz beträgt). Das liegt daran, dass die Induktivität der Ständerwicklung mit niedrigerer Frequenz abnimmt. Das wiederum erhöht den Stromfluss durch den Stator, und damit steigen auch Drehmoment und Verlustleistung. Durch die Anwendung der U/f-Kennlinie wird der Strom und damit das Drehmoment letztlich konstant gehalten. Bei sehr langsamen Drehzahlen nimmt die Induktivität im Vergleich zum Statorwiderstand jedoch so sehr ab, dass das Drehmoment überproportional abfällt. Daher ist diese Option für den Betrieb im unteren Drehzahlbereich eine schlechte Wahl. An oder oberhalb der Eckfrequenz des Motors hingegen bleibt die Spannung stabil und nur die Frequenz wird erhöht, was das Drehmoment verringert.
Bei der “sensorlosen Vektorregelung” verwendet der FU ein mathematisches Modell des Motors den er antreibt. So können optimale Schaltzeiten für die Treiber erreicht werden und damit kann unabhängig von der Motordrehzahl immer das Nenndrehmoment (oder sogar mehr) zur Verfügung gestellt werden. Dies ist besonders nützlich für Anwendungen, die einen Schweranlauf erfordern wie z. B. Aufzüge usw. Das Modell des Motors wird zumeist über eine automatische Kalibrierroutine ermittelt, wobei die Antriebsmaschine mit dem FU verbunden sein muss.

Hier ist ein Link zu einem youtube-Video, in dem die beiden Optionen bei niedrigen Drehzahlen verglichen werden. Ein weiteres Video zeigt, wie der FU bei großer Last sogar mehr als das Nenndrehmoment des Motors zur Verfügung stellen kann.

Da die meisten der von mir verwendeten Schaftfräser eine Drehzahl von 15000 U/min oder mehr erfordern, werde ich die Nachteile der U/f-Kennlinie wahrscheinlich nicht spüren. Außerdem ist bei meinem FU die Option “sensorlose Vektorregelung” nur bis 400 Hz verfügbar, so dass ich nur 80 % des Drehzahlbereichs der Spindel nutzen könnte. Daher entscheide ich mich für die U/f-Kennlinie.

Auslauf, Bremswiderstand oder Energierückgewinnungssystem?

Zum Abbremsen des Motors kann der Frequenzumrichter mit verschiedenen Optionen konfiguriert werden. Wenn der Motor per Standardeinstellung im Freilauf ausläuft, kann es lange dauern, bis die Spindel bei voller Drehzahl zum Stillstand kommt.

Wenn ein Bremswiderstand konfiguriert wird wie ich es bei meiner Anwendung mache, benötigt das Abbremsen nur zwei Sekunden. Ich habe außerdem eine Gleichstrombremse konfiguriert, sodass die Welle vollständig zum Stillstand gebracht wird.

Für leistungsstärkere Maschinen oder Anwendungen, bei denen große Massen bewegt werden, kann ein Energierückgewinnungssystem sinnvoll sein. Es wird an den Zwischenkreis des FU angeschlossen und ist in der Lage, die durch die überschüssige Bewegungsenergie des Motors erzeugte Leistung ins Netz zurückzuspeisen. Um diese Funktion zu nutzen, ist ein zusätzliches Gerät erforderlich und die Kompatibilität des FU-Zwischenkreises mit diesem Einspeisewandler muss sichergestellt werden. Die hohen Systemkosten zahlen sich nur aus, wenn große Energiemengen zurückgewonnen werden können.

Welche Modulationsfrequenz bzw. Taktfrequenz sollte ich verwenden?

Die Takt-/Modulations-/Trägerfrequenz ist die Häufigkeit, mit der die Leistungstransistoren im FU schalten, um eine sinusähnliche Ausgangsspannung für den Motor zu liefern. Bei meinem FU kann sie in einem Bereich von 2-15kHz konfiguriert werden.

Um eine optimale Frequenz zu wählen, muss ein Gleichgewicht zwischen mehreren Faktoren gefunden werden:

Die Schaltverluste der Transistoren steigen bei höheren Frequenzen.
Die Durchlassverluste von Transistoren nehmen bei niedrigeren Frequenzen zu.
Das menschliche Ohr ist besonders empfindlich im Bereich von 2-5kHz.
Resonanzfrequenzen des Motorsystems sollten vermieden werden.
Elektromagnetische Störaussendungen nehmen bei höheren Frequenzen zu.

Wenn der Motorhersteller eine Empfehlung für die Modulationsfrequenz abgibt, sollten diese natürlich befolgt werden. Ich habe mit verschiedenen Werten herumgespielt und mich für 5kHz als guten Kompromiss zwischen den oben genannten Faktoren entschieden. Ich hatte auch den Eindruck, dass dieser Wert bei meiner Maschine besser klang als 6 oder 4 kHz.

Kann ich die Luftkühlung in Abhängigkeit von der Spindeltemperatur steuern?

Ja, das ist möglich. Alles, was dafür benötigt wird ist ein kontinuierlicher (nicht schaltender) Temperatursensor, z. B. ein PT100 oder ein anderes Thermoelement, ein Messwertgeber und ein freier Analogeingang am Frequenzumrichter. Dieser wird so konfiguriert, dass er über eine Fensterfunktion einen der freien digitalen Ausgänge ansteuert, der wiederum ein Relais schaltet, an das der Lüfter angeschlossen werden muss.

Meine Spindel ist leider mit einem schaltenden Thermistor ausgestattet, der über einen Temperaturalarm-Eingang mit dem FU verbunden ist. So kann er das System bei Überhitzung abschalten. Er ist aber nicht für eine kontinuierliche Temperaturüberwachung/-steuerung des Lüfters geeignet.

Reicht eine Spannung von 18 V aus, um an einem 24 V-Digitaleingang “High”-Signalpegel zu erkennen?

Ja, bei meinem FU konnte ich eine niedrigere Spannung als die angestrebten 24 V an einen Logikeingang anlegen und trotzdem wurde der Pegel HIGH erkannt.

Kann ich den logischen Masseanschluss des FU ohne Probleme an die Masse meiner Gleichstromversorgung anschließen?

Ja. Muss man sogar. Der ‘Run’-Ausgang meiner CNC ist potenzialfrei. So musste ich die positive Steuerspannung des FU auf den Kontakt legen und dessen Ausgang mit dem ‘Run’-Eingang des FU verbinden. Der Stromkreis ist aber nur dann geschlossen, wenn im FU-Schaltschrank Logik-Masse und DC-Masse verbunden werden. Auch die analoge Ausgangsspannung meiner CNC zur Steuerung der Spindeldrehzahl muss dieselbe Erdungsreferenz wie der FU verwenden, also ist sie ebenfalls mit der logischen Masse des FU verbunden. Der Schaltplan zeigt diesen Sachverhalt an der Masseverbindung von T1

Was muss ich hinsichtlich der elektromagnetischen Verträglichkeit beachten?

Netzfilter zwischen Netzschalter und FU verwenden (Das ist in Deutschland sogar Vorschrift).
Abgeschirmte Kabel für den angeschlossenen Motor verwenden.
Die Motoranschlussleitung so kurz wie möglich halten.
Müssen doch lange Leitungen verwenden (>10m), HF-Rauschfilter bzw. Drossel einbauen.
Abschirmung zusammen mit den Schutzerdungsleitungen des Motors an die Schutzerdungsplatte des FU anschließen.
Sicherstellen, dass die Abschirmung einen leitenden Kontakt zu den Kabelsteckern herstellt.
Durchgangsprüfung nach DIN VDE 0701-0702 durchführen.
Vergewissern, dass der Schaltkasten über eine zentrale Schutzerdungsklemme verfügt, an die jedes Gerät innerhalb des Schaltkastens angeschlossen wird.
Vergewissern, dass die Schutzerde der Netzversorgung ebenfalls an diese Klemme angeschlossen ist.
Bei der Verkabelung des Schaltkastens die Motorzuleitung so weit wie möglich von den Signalleitungen entfernt verlegen.
Zur Reduktion elektromagnetischer Störabstrahlung sind Schaltkastengehäuse aus Metall solchen aus Kunststoff vorzuziehen. Zumindest ist eine metallische Trägerplatte zu verwenden, auf der alle Komponenten montiert werden.

Spindel

Um die passende Spindel für Ihre Maschine und Anwendung auszuwählen, gibt es - unabhängig vom Motortyp - einige Punkte zu beachten.

Leistung

Die Spindelleistung ist vielleicht weniger wichtig als gedacht. Hier mache ich ein paar Beispiele zur Orientierung.

<=400W HF-Spindel oder <=800W Oberfräsenmotor: Für eine Hobby-Maschine, die nicht unbedingt mit hohen Vorschüben betrieben werden kann. Bei schwerer zu schneidenden Materialien wie Aluminium oder HPL reicht eine geringe oder mittlere Schnitttiefe pro Durchgang aus. Der Maschinenrahmen wiegt weniger als 60 kg und ist für sein Gewicht relativ groß, z.B. bei einer Arbeitsfläche von >0,5 m².
<=700W HF-Spindel oder <=1200W Oberfräsenmotor: Die Maschine wiegt mehr oder ist steifer als die oben genannte Option. Häufig werden Fräser mit einem Durchmesser um die 6mm verwendet oder es muss viel mit Planfräsern gearbeitet werden. Die Z-Achse der Maschine ist kräftig ausgelegt und man hat das Gefühl, dass die Maschine bei 3000mm/min, Z+6mm und einem 6mm Fräser locker mit Hartholz zurechtkommt.
1,1kW/1,5kW HF-Spindel: Eine kompakte, schwerere Maschine (ca. 500x500mm Verfahrweg bei 100kg Gewicht), die Aluminium oder Holz mit höheren Vorschubgeschwindigkeiten schneiden soll. Bei der Bearbeitung von Holz verwenden Sie häufig Schruppfräser, um Zeit zu sparen. Die Maschine kann höhere Beschleunigungen und schnelle Bewegungen bewältigen (z.B. 1000mm/s² und 300mm/s).
>=2,2kW: Sie haben den Hobbybereich verlassen - wahrscheinlich für immer - sowohl mit Ihrer Maschine als auch mit dem Auftragsbestand, der sich auf Ihrem Schreibtisch angesammelt hat. Sie haben eine Werkstatt, eine professionelle Staubabsaugung und eine schwerere Maschine, der Sie zutrauen, den ganzen Tag lang ohne intensive Überwachung zu laufen. Vielleicht betrachten Sie diesen Blog als “nicht anspruchsvoll genug” und machen sich auf zu neuen Ufern, wo man Ihnen als Profi wirklich helfen kann.

Gewicht

Das Gewicht hängt von der Leistung ab. Ein 800-Watt-Motor für eine Oberfräse kann einschließlich Halterung unter 2 kg wiegen, während eine 2,2-kW-HF-Spindel mit automatischem Werkzeugwechsel ohne Werkzeughalter 6,5 kg oder mehr auf die Waage bringt. Auch Halterung und Leitungen werden tendenziell größer. Ein hohes Spindelgewicht kann sich vor allem bei leichten Maschinen negativ auswirken. Im Extremfall kann sich die Z-Achse nach unten bewegen, wenn die Schrittmotortreiber inaktiv sind. Die Maschinenbeschleunigung, insbesondere an der Portalbewegungsachse, muss möglicherweise reduziert werden, damit keine Schritte verloren gehen. Es ist zu bedenken, dass schwerere Spindeln in der Regel voluminöser sind, so dass sich die Schnittkräfte aufgrund einer größeren Hebelwirkung ungünstig auf die Z-Achse auswirken können.

2-polige oder 4-polige Ausführung?

Wird insbesondere bei niedrigen Drehzahlen ein hohes Drehmoment benötigt, sollten Sie sich für eine 4-polige Ausführung entscheiden. Dann wird allerdings die doppelte Frequenz benötigt, um die gleiche Drehzahl wie bei einem 2-poligen Motor zu erreichen. Wird die Maschine häufig mit hohen Drehzahlen betrieben, sollte stattdessen eine 2-polige Spindel Anwendung finden.

Wasser- oder luftgekühlt?

Auch dies ist eher eine Frage der Kosten und der Professionalität als alles andere. Natürlich funktioniert die Selbstkühlung durch einen auf der Welle fest montierten Lüfter gut. Eine Fremdkühlung per Lüfter ist etwas teurer, aber auch leiser. Ihr Hauptvorteil besteht darin, dass die Spindel unabhängig von ihrer Drehzahl nicht zu warm wird.

Eine Wasserkühlung führt die Wärme nochmal deutlich effizienter aus dem Motor ab, und die hohe Wärmekapazität des Wassers führt zu homogenen Temperaturen in der gesamten Spindel. Sie dämpft die Vibrationen und ist die leiseste Kühlungslösung von allen. Andererseits ist das System viel teurer, komplexer, benötigt mehr Platz für Pumpe, Kühler und Ausgleichsbehälter usw. und muss öfter gewartet werden.

Die Planungsphase

Nachdem die Handbücher aller bestellten Teile überflogen waren, konnte ich einen schematischen Schaltplan für das Spindel-Subsystem zeichnen.

Oben ist der Frequenzumrichter mit seinen Klemmen zu sehen. X1 ist der Netzstromeingang mit dem Trennschalter S2. X2 verbindet die Spindel mit dem FU und X3 ist der Signalanschluss für die CNC. Rechts unten befindet sich die Gleichstromversorgung T1, die die Luftkühlung versorgt und die logische Spannungsschiene bereitstellt. Die Temperatur des Spindelmotors M1 wird durch den Thermistor R3 überwacht (hier habe ich vergessen, die Beschriftung hinzuzufügen). Der Spindelkühlmotor M2 wird durch ein Zeitrelais gesteuert, das wiederum durch das “RUN”-Signal gesteuert wird. Ein digitaler Mehrzweckausgang ist mit einer roten LED D1 verbunden, die so konfiguriert ist, dass sie aufleuchtet, wenn eine Überlastwarnung vorliegt.

Der Schaltplan ist ziemlich einfach gehalten. Deshalb habe ich keine Zeit in saubere Zeichnungen investiert. Um es noch authentischer aussehen zu lassen, habe ich etwas ☕ auf das Papier verschüttet.

Dies ist die Pinbelegung des Spindelsteckers X2 und des entsprechenden Anschlusses am FU. Sie war mehrmals nützlich, als ich dem abgeschirmten Motorkabel (orangefarben, siehe Bannerbild oben) Steckverbinder hinzufügte sowie während der Geräteprüfung.

Ich notiere mir stets das erforderliche Anzugsdrehmoment für jede Schraube, einschließlich der für die Klemmen, und lege die benötigten Werkzeuge vor Baubeginn bereit.

Die Bauphase

Schaltschrankbau für den Umrichter der Spindel

Inbetriebnahme

Vor Inbetriebnahme war der Testplan abzuarbeiten. Danach war der Spindel-Fettverteilungslauf gemäß Anweisungen des Herstellers zu starten. Schließlich kalibrierte ich den Analogausgang “0-10V” in der CNC-Software, um die Frequenz des Frequenzumrichters mit der Drehzahl der Spindel abzugleichen. Beispiel: S10000 sollte 3,33V am Ausgang erzeugen und den FU mit einer Frequenz von etwa 175Hz laufen lassen, um den Schlupf zu berücksichtigen.

Um zu sehen, dass das System wie vorgesehen funktioniert, habe ich ein paar Testläufe gemacht: 8mm PMMA, Vollnut, einmaliger Durchlauf in Z+=8mm, 4mm Einschneider (poliert) Hartmetallfräser bei S=26kUPM und F=3000mm/min.

Die Analysephase

Diese Phase wird später folgen, vielleicht ein Jahr nach der Arbeit mit der neuen Spindel. Ich werde mir Folgendes ansehen:

Hat sich die Investition gelohnt (etwa 8x teurer als ein Oberfräsenmotor)?
Habe ich die zusätzlichen Möglichkeiten (höhere Leistung und mehr Drehzahl) genutzt?
Erzielt sie spürbar bessere Ergebnisse?
Ist sie zuverlässiger und wartungsärmer als mein bisheriger Motor?

Aber was ich schon jetzt sagen kann: Ich habe viel gelernt. Es hat Spaß gemacht, das System zu entwerfen, zu verkabeln und einzurichten. Und es war aufregend zu sehen, dass es tatsächlich so funktioniert, wie ich es mir vorgestellt habe 🙂.

Spirograph

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Der Spirograph

Spirographen sind mathematische Spielzeuge. Mit ihrer Hilfe kann man ganz leicht sich wiederholende Kurven zeichnen. Die einfachste Version besteht aus einem Zahnrad, das auf der Innenseite eines feststehenden Zahnkranzes läuft. Das Zahnrad hat ein paar Löcher, in die die Spitze eines Stiftes passt. Die Löcher befinden sich außerhalb der Mitte des Zahnrads, so dass beim Drehen des Rads im Inneren des Hohlrads parabolische Formen entstehen.

Die Anzahl der Umdrehungen, die nötig sind um eine geschlossene Form zu zeichnen, hängt vom Verhältnis der Zahnanzahl zwischen den beiden Zahnrädern ab.

Version 0

Der erste Entwurf haben wir gemeinsam mit den Jungs von CADasCAM in der Werkhalle erstellt. Es handelt sich um eine 14:9-Zahnkombination. Das kleinste gemeinsame Vielfache (auch KGV genannt) der beiden Zahnräder beträgt 126, was zu Zeichnungen mit vielen (126 / 9 = 14) Kanten führt. Wir entschieden uns für Aluminium als Material.

Your browser does not support the video tag.

Fräsen von Spirograph_V0 auf einer übertakteten CompactLine CNC

Die Fertigung war erfolgreich und die Räder ließen sich von Zahn zu Zahn platzieren aber leider nicht drehen, weil der nächste Zahn des inneren Zahnrads nicht auf die Flanke, sondern auf den Kopf des Hohlradzahns traf. Die Krümmung des Hohlrads hatten wir nämlich nicht berücksichtigt, sodass die langen Zahnköpfe zu eng zusammen standen.

Version 1

Als der Workshop vorbei war, nahm ich den Entwurf mit nach Hause und versuchte ihn zu verbessern. Ich kürzte die Zahnköpfe des Hohlrads, um das vorherige Problem zu beheben und fügte Verrundungen hinzu, damit die Zahnräder nicht so schwergängig ineinander griffen.

Ich habe den Entwurf in 18mm Buche Leimholz gefräst. Ich verwende eine zweiseitige Bearbeitung, weil sich das Anfasen von Hand auf der Rückseite bei diesen komplexen Formen als etwas mühsam erwies. Dazu schneide ich nicht komplett durch das Material, sondern lasse unten eine 1mm dicke “Zwiebelhaut” stehen, die alles an ihrem Platz hält für den zweiten, rückseitigen Bearbeitungsvorgang.

Danach wird das Werkstück gedreht, sodass die Unterseite oben ist. So können die Kanten der Unterseite abgeschrägt werden. Dabei durchbohrt der Fräser die “Zwiebelhaut” und schneidet die Werkstücke praktisch aus dem Rohmaterial heraus, sodass ich sie nur noch vom Maschinenbett nehmen muss. So waren nur die Grate abzuschleifen, was weniger als fünf Minuten manuelle Nacharbeit erforderte.

Aber es passte immer noch nicht. Diesmal, weil die Flanken des inneren Rades zu breit waren. Das hatte zur Folge, dass sie nicht die volle Eingriffstiefe zuließen was wiederum dazu führte, dass der nächste Zahn des Innenrads erneut auf den Zahnkopf des Zahnkranzes traf.

Version 2

Ich habe herausgefunden, dass in Version_1 das kleine Zahnrad eine positiven “Zahnprofilverschiebung” hatte, während der Innenkranz auf Null belassen wurde. Das konnte überhaupt nicht funktionieren, also habe ich es korrigiert. Ich habe auch die konkaven Radien beider Räder größer geplant, sodass ein 6mm-Schaftfräser in der Lage sein würde, alle Details richtig herauszuarbeiten. Schließlich fügte ich etwas Spiel für die Zahnflanken hinzu und sorgte für mehr Platz am Zahnfuß, damit die Zähne besser ineinander greifen.

Um dem inneren Rad mehr Platz zu geben, habe ich die Zahnradkombination auf 16/7 verändert, was dann 112 / 7 = 16 Schleifen zeichnen wird (noch engere Darstellung), bevor sich das Muster wiederholt.

Diesmal habe ich es aus 5mm extrudiertem Acryl (PMMA), opak weiß, gefertigt. Ich wählte eine ähnliche zweiseitige Frässtrategie wie oben beschrieben, fügte aber einen Schlichtlauf hinzu, um die Kantenqualität zu verbessern. Folgende Parameter kamen zur Verwendung:

Fräser, Material: PMMA (Acryl)	Werkzeugtyp	Zahn	Durchmesser [mm]	Drehzahl [U/min]	Vorschub [mm/min]	Z+ [mm]	XY+ [mm]
VHM-Habichtschnabel FSECO1	Schruppen	1	4	24000	3000	8	3,6
FSAC Acrylschneider poliert	Schlichten	1	4	26000	3000	8	0,2
Hartmetall Kegel 90° FEF	Fasen	3	10	15000	5000	3	3

Und es funktionierte einwandfrei 😄. Die Schnittqualität war sehr gut. An manueller Nacharbeit blieb mir weniger als eine Minute Arbeit zum Entgraten.

Your browser does not support the video tag.

Aktualisierte Zahnparameter ermöglichen reibungslosen Eingriff

Aber es gab noch Raum für Verbesserungen:

Löcher direkt in den Zähnen machen keinen Sinn, weil sich das innere Rad bei Eingriff dieses Zahns nicht mehr durch den Stift weiterdrehen lässt
5mm Löcher sind etwas zu klein, um alle Arten von Buntstiften unterzubringen
16 Zähne modul10 sind nicht genug, um ein DIN A4-Papier zu füllen
Die elliptische Form sieht schön aus, ist aber etwas schwer festzuhalten

Deshalb habe ich einen weiteren Schritt in der Entwicklung gemacht:

Version 3

Eine kleine Aktualisierung gegenüber Version_2, dieses Mal mit einer 18/10-Paarung (KGV von 90, also 9 Schleifen pro Durchlauf). Ich habe die Lochabstände in Form einer Fibonacci-Spirale überarbeitet, um ausdrucksstärkere Designs zu erzeugen. Schließlich habe ich den Umriss an die Größe von DIN A4-Papier angepasst, so dass die Entwürfe nun zentriert sind.

Für die Herstellung habe ich dieselben Parameter wie bei der vorherigen Version verwendet. Wie gut das Ergebnis geworden ist! Ich frage mich, ob ich die letzten 5% an Qualität herausholen kann, indem ich die Grate ganz vermeide. Der Grat entsteht, wenn der konische Fräser die Unterseite des Materials durchsticht, um den endgültigen Ausschnitt auf meinem Vakuumtisch herzustellen. Ich muss also in Zukunft etwas “tiefer” fräsen als das verbliebene Material stark ist. Der Hersteller der Fräser empfahl mir im Nachgang, Vorschub und Drehzahl bei Arbeit in Acrylglas für die Fasenfräser zu senken, wenn der Zielvorschub wegen ständiger Beschleunigungs- und Abbremsvorgänge nicht erreicht werden kann.

Außerdem ist mir aufgefallen, dass die Maschine Rattermarken erzeugt, wenn sie bei “G01”-Bearbeitungen auf die Zielgeschwindigkeit beschleunigt. Ich vermute, dass dies auf die begrenzte Steifigkeit des Rahmens zurückzuführen ist. Es ist nur unter einem bestimmten Winkel sichtbar, aber nicht spürbar.

Das fertige Produkt sieht dann so aus. Durch die Fasen und abgerundeten Kanten liegt es sehr angenehm in der Hand. Die Zahnräder laufen mühelos und die 18/10-Zahnradkombination hat so viele Zähne, dass auch Kinder kein Problem damit haben, die Formen herzustellen (ausprobiert).

Und schließlich bin ich auch damit zufrieden, wie die Zeichnungen aussehen. Mit kräftigen Strichen und groß genug (15x15cm). Die Linien stehen nicht zu eng zusammen. Die höhere Anzahl von Löchern, die das größere innere Rad erlaubt, hilft auch dabei, eine größere Vielfalt an Figuren zu erzeugen.

Ich habe die Versionen 2 sowie 3 einer nahegelegenen Schule sowie einem Kindergarten gespendet. Bin gespannt, wie sie im Alltag damit zurechtkommen.

Lust auf einen Nachbau bekommen?

Das ist kein Problem. Hier steht ein ZIP-Ordner zum Download bereit.

Was ist im Ordner enthalten?

CADasCAM Projekt, das alle Arten von Zahnradpaarungskonfigurationen ermöglicht
Zeichnungsdateien (DXF) für das Fräsen von Vorder- und Rückseite
EstlCAM Projektdateien zusammen mit meiner Werkzeugdatenbank
CNC-Betriebsdateien (tap), die zu meiner Maschine passen
Ein Readme (txt), das den XY-Nullpunkt und die erforderlichen Offsets definiert

Kostet es etwas?

Nein. Beachten Sie, dass die von mir verwendete Lizenz das Paket zu “freier Software” macht. Bitte kontaktieren Sie mich jedoch, falls Sie die Entwürfe gewerblich verwenden möchten.

Haftungsausschluss

Wie üblich stehen die Dateien kostenlos zum Download zur Verfügung. Im Gegenzug übernehme ich keine Verantwortung oder Haftung für deren Inhalt.

WARNUNG ⚠️

Diese Dateien bieten oder ermöglichen die Ausgabe von G-Code-Anweisungen für echte Maschinen, die in der physischen Welt tatsächlich Dinge tun. Es könnten Code-Fehler oder Bugs enthalten sein, die möglicherweise zu Maschinenabstürzen oder Schlimmerem führen können. Ich übernehme keine Haftung für Arbeitsunfälle, Systemausfälle, Geräteausfälle, Produktionsausfälle, Ablaufstörungen oder andere negative Auswirkungen, die durch die von mir zur Verfügung gestellten Dateien verursacht werden könnten.

HINWEIS ℹ️

Es liegt in der Verantwortung des Maschinenbetreibers, den G-Code sorgfältig zu prüfen und sicherzustellen, dass er auf der jeweiligen Maschine wie vorgesehen funktioniert und keinen Schaden verursacht.

Update

Ein paar weitere sehr schöne Spirographen habe ich Anfang 2024 für die Maker Faire angefertigt. Das Grundmaterial ist mitteldichte Faserplatte (MDF), auf welche ich eine Lage Olivenholzfurnier aufgebracht habe.

Tonuino - alternative Firmware

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Difficulty: Experte 5/5
Kosten: 0€
Zeitaufwand: ~400h

Galerie

Die alternative Tonuino-Firmware im Einsatz.

NFC-Tags sind Vögel, die zum Abspielen ins Häuschen gesetzt werden

Anwendungsbeispiel mit Microcontroller unter Verwendung meiner ClickEncoder-Bibliothek

Anwendungsbeispiel mit Arduino in einem Gitarrenverstärker

Gesteuert wird der Player in diesem Fall mit drei Tasten.

In disem Projekt entstand eine Software für eine NFC-Tag gesteuerte Jukebox. Sie ist für das Arduino-Framework optimiert und verbindet die Hardware eines Mp3-Players (mit SD-Karte), ein NFC-Tag-Lesegerät und ein paar Bedienelemente.

Ein NFC-Tag wird mit einem Ordner auf der SD-Karte verknüpft, welcher Audiodateien enthält. Das Tag speichert auch Informationen über den gewünschten Wiedergabemodus für dieses Album, z. B. “Zufällig”. Sobald ein verknüpfter Tag in die Nähe der Jukebox gebracht wird, wird der konfigurierte Ordner im entsprechenden Wiedergabemodus abgespielt. Mit den Bedienelementen kann der Titel ausgewählt, die Lautstärke geändert und sogar durch ein Sprachmenü navigiert werden, was das Löschen, Verknüpfen und Konfigurieren eines Tags sowie Sperren/Entsperren der Eingabetasten ermöglicht.

Motivation

Idee und fantastische Umsetzung hatte ich auf Thorsten Voß’ blog gesehen. Es begann mit der Funktionalität (encoder support), die ich hinzufügen wollte. Leider war der ursprüngliche Code ein zusammenhängender Block mit mehreren tausend Zeilen Code und für mich schlechter Lesbarkeit, so dass es mir schwer fiel, meine Änderungen einzubringen.

Also habe ich den Code von Grund auf neu geschrieben, um eine bessere Struktur, Lesbarkeit, Wartbarkeit und Erweiterbarkeit zu erreichen. Parallel dazu las ich einige Bücher über objektorientiertes Design in C++, Clean Code und Software Design Patterns und wandte einige davon dort an, wo ich sie für geeignet hielt. Auf diese Weise konnte ich sowohl die Modularität als auch die Lesbarkeit des Codes verbessern und habe außerdem gelernt, wie man Code in einem “größeren” Projekt schreibt.

Schwierigkeiten

Dies war mein erstes eigenes C++-Projekt, und vielleicht war es für den Anfang ein wenig zu groß. All die für mich neuen Konzepte, das Schreiben an eine Schnittstelle, die erstmalige Verwendung von Platformio als IDE, die Verwendung des googletest unit test framework, die Einsatz von Coding Patterns wie [factory](https://www. oodesign.com/factory-pattern.html) oder Dependency Injection kostete mich Abend um Abend über fast ein Jahr, bis ich dieses Projekt schließlich fertigstellen konnte. Und es gibt immer noch etwas zu überarbeiten und zu verbessern.

Übersicht

Unit-Test-Suite mit über 250 Testfällen
Serielle Debug-Ausgabe konfigurierbar
Lose gekoppelte, objektorientierte Architektur in C++
Einzelne Module mit klaren Aufgaben, skalierbar und leicht zugänglich für zukünftige Funktionen
benutzerdefinierte Hardware-Abstraktionsschicht; der größte Teil des Codes sollte ohne Änderungen auf andere MCUs portierbar sein
eigenes Dependency Injection Framework (Loader Klasse)

Funktionen

Konfigurierbare Benutzereingabe (Tasten oder Encoder)
Auto-Poweroff, wenn für eine konfigurierbare Zeit keine Taste gedrückt wird
Einschalten durch Drücken der “Play”-Taste
Autoplay-Funktion
Status-Led-Funktion
Sperren/Entsperren der Benutzereingabe
Mehrere Wiedergabemodi [Album, Zufall, Speichern des Titelfortschritts, Nur ein Titel] pro Nfc-Tag verfügbar
Sprachmenüs zum Verknüpfen oder Löschen von Nfc-Tags
Optimiert für Batterieanwendungen (z.B. Powerbank) unter Verwendung von Ruhezuständen
Niedriger Stromverbrauch @5V: ~40mA im Leerlauf, ~75mA bei mittlerer Lautstärke
Konfigurationsdatei für Startlautstärke, Einschlaf-Timer etc.
Automatische Wiederherstellung bei Eingabeaufforderung, die niemand bedient
Sprachansagen für die häufigsten Fehlermeldungen

Nicht enthaltene Funktionen

Keine Erkennung des Ladezustands der Powerbank
Kein Konfigurationsmenü (Startlautstärke, Dauer des Einschlaf-Timers, Standby-Dauer usw.)
…

Dokumentation

Das Projekt ist für das Arduino Framework erstellt - getestet auf einem Arduino nano Board - unter Verwendung der PlatformIO IDE. Die folgenden Abschnitte zeigen das Design.

Projekt Modulübersicht

Ordnername in `/lib`	Zweck
Arduino	minimalistische hardwarenahe Implementierungen, nicht Unit-testbar
Arduino_HardwareAbstraction	Hardware-Abstraktion, um Portabilität und Testen zu ermöglichen
Config	Systemkonfigurationsparameter
Folder	Geschäftslogik für Wiedergabeliste und Wiedergabemodus
Loader	Dependency Injection Framework
MessageHandler	Systemnachrichten und Debug-Framework
Mp3	Mp3-Steuerung (Status, Ordner, Sprachausgabe, Anzeigen)
Nfc	Tag-Steuerung (Status, Lesen, Schreiben, Löschen)
PowerManager	Steuerung von Status-LED und Ruhezustand abhängig vom Systemstatus
Tonuino	Haupt-Task-Scheduler
UserInput	Verarbeitung von Tasten- oder Encoder-Eingaben
Utilities	Timer, Led-Steuerung, Pin-Steuerung
VoiceMenu	Geschäftslogik für das Menü Link / Löschen / Konfiguration

Verwendete externe Bibliotheken

Automatische Installation durch Platformios “Library Dependency Finder” beim erstem Kompiliervorgang

Klassendiagramme

Klassendiagramme wären zu viel nicht-automatisierte Arbeit gewesen. Stattdessen habe ich das hier vorbereitet:

Software-Modulübersicht

Sie sollte ein genaues Verständnis dafür vermitteln, wie die Softwaremodule zusammenwirken und welche APIs die Module anbieten.

Los geht’s!

Zuerst muss mein repository, geklont werden - entweder per git clone, Download als zip-Datei oder per https. Das README.md Dokument bietet einen leichten Einstieg. Ich empfehle die Verwendung von PlatformIO für dieses Projekt. In den folgenden Abschnitten sind die Teilfunktionen des Programms erläutert, und wie deren korrekte Funktion sichergestellt wird.

Testen

Unit-Tests

Unit-Tests wurden mit dem gtest C++ Unit-Test-Framework geschrieben. Sie befinden sich im Ordner test/desktop. Zu beachten ist, dass googletest die Installation von gcc mit einigen Bibliotheken voraussetzt. Die Anleitung dazu findet man in einem meiner anderen Projekte. Sobald diese Voraussetzungen erfüllt sind und ein einfacher ASSERT_TRUE(false);-Test mit der gtest-Umgebung erwartungsgemäß fehlschlägt, können die Unit-Tests des Projekts erstellt und mit pio test -e desktop -f desktop, in der PlatformIO CLI (Terminal) ausgeführt werden.

Akzeptanztests

Obwohl diese Tests automatisiert werden könnten, ist es viel einfacher, diese Tests von Hand durchzuführen, nachdem der Mikrocontroller programmiert und alle elektronischen Komponenten zusammengesteckt wurden. Jede Zeile in den folgenden Tabellen ist ein eigenständiger Testfall. Die Testsuiten (“Überschrift Name”) haben eine System Pre: Eigenschaft, die vor der Ausführung der einzelnen Testfälle wiederhergestellt werden muss. Wenn die Erwartungsklausel erfüllt ist, ist der Test BESTANDEN. Ich habe die Tests auf Englisch belassen, weil sie recht eng mit dem Code korrespondieren.

Switching ON

System Pre: System is OFF

Action	Expectation
press Play/Pause button	LED flashes slowly?
press Play/pause button	Welcome prompt plays?

Switching OFF

System Pre: System is ON

Action	Expectation
Playback on pause, no button input	System switches off after a time?
System shutdown	Farewell prompt plays?
System shutdown	LED switched off?

Play Help Prompt

System Pre: System is ON

Action	Expectation
Long press Play/Pause button	Help prompt plays?
Help prompt playing	Can be interrupted with any button press?

Behavior without Tag

System Pre: System is ON, no Tag present

Action	Expectation
press Play/Pause button	prompts “couldn’t find track” error?
press Next button	prompts “couldn’t find track” error?
press Prev button	prompts “couldn’t find track” error?
doubleclick Play/Pause button	Delete Menu prompt played?

Behavior with Tag

System Pre: System is ON, linked Tag available

Precondition	Action	Expectation
no Tag placed	place known Tag	starts Playback of correct Folder?
active playback	press Next button	plays next track?
active playback	press Next button	next track in accordance with selected playMode of Folder?
active playback	long press Next button	increases volume?
active playback	press Prev button	plays previous track?
active playback	press Prev button	previous track in accordance with selected playMode of Folder?
active playback	long press Prev button	decreases volume?
active playback	press Play/Pause button	pauses track?
paused playback	press Play/Pause button	resumes track?
active playback	doubleclick Play/Pause button	Lock prompt played?
active playback	doubleclick Play/Pause button	Playback resumes after Lock prompt played?
active playback	doubleclick Play/Pause button	locks button input?
locked button input	doubleclick Play/Pause button	Unlock prompt played?
locked button input	doubleclick Play/Pause button	Playback resumes after Unlock prompt played?
locked button input	doubleclick Play/Pause button	unlocks button input?
paused playback	doubleclick Play/Pause button	Playback resumes after Lock prompt played?

Behavior with unlinked Tag

System Pre: System is ON

Action	Expectation
place unlinked Tag	plays LinkMenu Prompt?
navigate through LinkMenu	plays Configuration Success Prompt?
place Tag again	plays linked folder?

Hardware

Materialliste

Ich habe versucht mit möglichst wenigen Einzelteilen auszukommen. Für ein Projekt dieser Größe ist die Liste denke ich recht kurz geblieben.

Menge	Artikel	Zweck
1	Arduino (z.B. Nano)	Gehirn
1	Dfplayer Mini Mp3 Player	Mund
1	Micro SD Karte	Speicher
1	MFRC522 Nfc-Leser	Psi-Sense
1	Bistabiles Relais 5V, z.B. HFE20	Kaffee - kein Schlaf
2	Dioden z.B. 1n4007	Venenklappe
1	PNP-Transistor z. B. BC327	Kaffeemaschinenschalter
2	Widerstände 1k	Blutstromaufbereiter
1	Widerstand 220	Blinkstärke dimmen
1	LED, Farbe nach Wahl	blinken
1	Powerbank/ 5V Versorgung	Lebensmittel
3	Drucktasten, z.B. Cherry MX Tasten	Drucksensoren
1	Lautsprecher, z.B. 5W@4Ohms	Stimmbänder
1	USB-A-Stecker	Strohhalm
1	Gehäuse	Körper

Zusätzliche Bauteile und Tipps

Überbrückungsdrähte, Platine, Buchsen und Verbrauchsmaterial nach eigenem Ermessen Wie beim “Original”-Projekt; alternativ einen Drehgeber anstelle der Drucktasten kaufen und das Projekt so konfigurieren, dass er statt der Taster ausgelesen wird. Da das System für den Batteriebetrieb optimiert ist, nehmen Sie ein bi-stabiles Relais oder einen JFET-Transistor (mit niedriger Gate-Spannung und niedrigem Source-Drain-Spannungsabfall) für die KeepAlive-Funktionalität, die den zusätzlichen Strom durch die ständig eingeschalteten Relaisspulen vermeidet. Eine billige Powerbank reicht für viele Stunden Betrieb. Alternativ können z.B. 3xAA-Batterien verwendet werden - allerdings macht der Dfmini-Player ordentlich Lärm, wenn die Spannung zu sehr einbricht. Er kann sogar bei wiederholten Neustarts durch Stromstöße zerstört werden, also Vorsicht bei nachlassender Akkuladung.

Schaltplan

Über mich

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Sinn und Zweck dieser Website

Ich betreibe meinen Weblog als Hobby auf freiwilliger Basis. Mit dieser kostenlosen Webpräsenz möchte ich Interesse an Technik wecken. Ich behandele hier Themen der Mechanik, Elektronik und Informationstechnik. Besondere Schwerpunkte lege ich auf die Fertigung von Dingen mittels CNC-Frästechnologien sowie auf Einrichtung, Betrieb, Deployment und Wartung meines Servers und seiner Inhalte. Gelegentliche Artikel über Elektronikentwicklung und IT-Security runden den Blog ab.

Wahrscheinlich bin ich selbst mein bester Kunde: Wie oft ich den Blog als Dokumentation für eigene Belange lese! Eigennützig sind zudem die Lernerfolge für mich selbst 😄

Über “KI”

Diese Website ist und bleibt frei vom Output von “KI”-Werkzeugen. Die Artikel sind handverfasst (Das merkt man denke ich auch) und ich habe nicht vor, dies zu ändern. Für Übersetzungen hingegen nehme ich “KI”-basierte Translators zur Hand. In den Anfangszeiten bis Q1-2023 betraf dies ausschließlich deutsche Artikel, da ich den Blog auf Englisch geführt hatte.

Danach jedoch schreibe ich auf Deutsch und lasse die Artikel auf Englisch übersetzen, weil sich die “KI” in diese Richtung viel leichter tut und meiner Meinung nach bessere Ergebnisse erzeugt. Dennoch halte ich bei jedem übersetzten Post Lektorat und gebe mir viel Mühe, qualitativ hochwertige und interessante Artikel zu veröffentlichen.

Auch die Recherche und alles drum herum passieren auf diesem Blog stets manuell.

Daher muss ich für jede Minute Lesezeit grob eine Stunde Arbeit investieren.

Wo ich “KI” allerdings nutze: Als “Rubber Ducky” für Ideen und Lösungsansätze, auf die ich bei fehlendem eigenen Horizont nicht kommen würde. Praktisch als erweiterte Suchmaschine. Aber auch von diesem Output kommt nichts in den Artikeln an.

Wer ist Schallbert?

Ich bin Schallbert¹. Amateurbastler und Entwickler, Elektroniker für Betriebstechnik, Elektroingenieur. Ich arbeite seit über zehn Jahren in der Industrie sowohl als System- und Entwicklungsingenieur für Elektronik und Hardware wie auch als Softwareprojektleiter, -Entwickler und Scrum Master. Ich bin passionierter Hobby-Bassist.

Woher kommt der Name?

Schallbert ist eine Zusammensetzung aus den Worten Schall (ein sich im Raum ausbreitender Klang) und Bert (ein Vorname). Phonetisch wie Albert, hatte ich ihn ursprünglich mal als Spielernamen gewählt: Er ist kurz und eingängig, als Nickname hinreichend selten und wenn man mag, kann eine Freude an Musik und Bewunderung für Albert Einstein hineingelesen werden.

Kontakt

via Github Discussions: schallbert.github.io
auf meinem Kanal bei PeerTube: CNC corner bei MakerTube
via PlatformIO (Bei µC-Themen): Ihr Konto –> Nachrichten –> Neue Nachricht PIO Community
via Sorotec Forum (Bei CNC-Themen): hobbyline.info
via CNCzone Forum (CNC-Themen): cnczone.nl -> Private Message
Direkter Kontakt (nicht bevorzugt): Siehe Rechtliches

Bild freundlicherweise gezeichnet und zur Verfügung gestellt von Likosdev ↩︎

Umzug von Github Pages

Schallbert — Mon, 01 Jan 0001 00:00:00 +0000

Projekt-Steckbrief

Schwierigkeitsgrad: Mittel 3/5
Kosten: 5-50€/Monat
Zeitaufwand: ~10h

Motivation

Ich habe mich entschieden, meine Website von Github-Pages auf meinen eigenen Server umzuziehen. Dies geschieht aus zwei Gründen: Zum einen möchte ich den Server in Deutschland stehen haben (Datenschutz) und zum anderen bietet mir Github Pages keine einfach zu handhabende Möglichkeit, meine Site zweisprachig anzubieten.

Zusätzlich kann ich ebenfalls ein paar lang gehegte Wünsche realisieren: Ein eigener mini-Dateiserver und eine Webseite für meinen kleinen Nebenerwerb werden jetzt möglich. Aufsetzen werde ich sie allerdings in einem späteren Schritt.

Überblick

In diesem Projekt werde ich einen virtuellen Server anmieten und dort per SSH das Container-Managementsystem Docker installieren.

In einem Container soll eine Instanz von gitea laufen, welche das Versionsmanagement für mich übernehmen und über sogenannte Actions eine CI/CD-Pipeline¹ bereitstellen wird.

Durch die Automation mit Gitea Actions möchte ich dann in der Lage sein, die von Jekyll per Workflow-Datei gebaute Site auf einem caddy-Server zu veröffentlichen, also in “Produktion” zu geben.

caddy stellt hier nicht nur den Server, sondern auch einen Reverse Proxy zur Verfügung, welcher mir Portmapping und die Adresszuordnung abnehmen kann. Ganz nebenbei kümmert sich caddy noch vollautomatisiert um die Zertifikatsverwaltung für https über Let’s Encrypt.

Da auch caddy in Docker laufen wird, müssen virtuelle Netzwerke angelegt und korrekt konfiguriert werden, sodass die Container miteinander “reden” können.

Schreiten wir zur Tat - aber immer Schritt für Schritt.

Konfiguration meines Servers

Die folgenden Abschnitte beschreiben Schritt für Schritt, wie ich vorgegangen bin, meinen Cloud-Server einzurichten und für das Veröffentlichen dieses Blogs vorzubereiten.

SSH auf dem Server einrichten

Direkt nachdem ich den sogenannten “Cloud-Server” angemietet hatte, habe ich den Zugriff per SSH konfiguriert und damit den Passwort-Login deaktiviert. Dafür prüfe ich zuerst, ob mein ssh-agent bereits läuft bzw. starte ihn direkt mit dem Befehl eval ssh-agent.

Sodann erstelle ich mir ein neues Schlüsselpaar per Befehl

ssh-keygen -t ed25519 -C "your_email@example.com" -f "~/.ssh/mein-cloud-server"

Dieses Beispiel erzeugt Schlüsseldateien mit dem Verfahren (-t) ed25519, welche per Kommentar (-C) eine Mailadresse enthalten und unter dem Dateinamen (-f) mein-cloud-server gespeichert werden.

Den öffentlichen Schlüssel mein-cloud-server.pub habe ich dann im Webportal meines Servers unter “Security” eingegeben und den dann erhaltenen Fingerprint verifiziert mittels

ssh-keygen -lf <fingerprint_from_server> "~/.ssh/mein-cloud-server"

Anschließend habe ich die config-Datei im .ssh-Verzeichnis so angepasst, dass ich nur noch ssh server statt der IP-Adresse eingeben muss, um mich drauf zu verbinden - Faulheit siegt 😀

#.ssh/config
Host server
 User root
 Hostname ip_address_of_server
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/mein-cloud-server

Gebe ich nun ssh server in die Konsole ein, so erscheint beim ersten Mal die Meldung, dass der Verbindungsaufbau zu einem unbekannten Partner mit Fingerprint soundso stattfinden wird und bittet um explizite Zustimmung. Nun kann der Fingerprint mit dem des Servers (auf der Webseite des Anbieters) abgeglichen und somit sichergestellt werden, dass man auch wirklich zu dem angestrebten, eigenen Server verbindet und nicht zu einem Dritten, der die Anfragen lediglich transparent weiterleitet. Stimmt man mit yes zu, so wird der Fingerprint der known_hosts-Datei hinzugefügt und das Zielsystem in Zukunft als bekannt angesehen.

Docker installieren 🐳

Auf meinem Server läuft ein Standard-Ubuntu, für die die von Docker bereitgestellte Anleitung zur Installation des Docker-Repository per apt reibungslos funktioniert. Einfach per SSH drauf einwählen und die entsprechenden Befehle ausführen - fertig. Dabei wird der von mir benutzte Dienst docker-compose gleich mit installiert, welcher Konfigurationsdateien für die Zielcontainer interpretieren und die Container mit den entsprechenden Parametern gleich richtig hoch- und herunterfahren kann.

caddy installieren 🛒

Zuerst lege ich den Ordner per mkdir caddy2 im Stammverzeichnis meines Servers an - soviel Zeit muss sein. Um caddy im Docker laufen lassen zu können, habe ich in diesem Ordner die folgende docker-compose.yml erstellt:

#caddy2/docker-compose.yml

version: '3'
services:
 caddy:
 image: caddy:latest
 container_name: caddy
 ports:
 - "80:80"
 - "443:443"
 environment:
 - ACME_AGREE=true
 restart: unless-stopped
 volumes:
 - ./Caddyfile:/etc/caddy/Caddyfile
 - ./caddy_data:/data
 - ./caddy_config:/config
 - ./www:/www
 networks:
 - caddy-proxy

networks:
 caddy-proxy:
 external: true

Diese Datei sagt Docker, dass es für den Service das aktuellste Image von caddy verwenden und dem Container den Namen caddy geben soll. Des Weiteren sollen die Ports 80 (http) sowie 443 (https) verfügbar gemacht und die Zertifikatsverwaltung per ACME_AGREE zugelassen werden. Der Container bindet die von Caddy benötigten Dateien (Caddyfile, data, config) ein und kann ebenso auf die von mir unter /www abgelegten Dateien zum späteren Veröffentlichen meiner Website zugreifen. Der Container befindet sich im Netzwerk caddy-proxy und durch external: true weiß der Container, dass dieses Netzwerk unabhängig von diesem Container bereits besteht.

Damit wir den caddy-Container korrekt aufsetzen können, müssen wir also das Docker-Netzwerk vorher per docker network create caddy-proxy erstellen. Mit docker network ls kann man nun prüfen, ob das Netzwerk korrekt angelegt wurde.

NETWORK ID NAME DRIVER SCOPE
<redacted> bridge bridge local
<redacted> caddy2_default bridge local
<redacted> caddy-proxy bridge local

Sieht gut aus!

Anschließend erstelle ich eine Caddyfile zur Konfiguration von Caddy:

# caddy2/Caddyfile
blog.schallbert.de {
 root * /www/blog
 encode gzip
 file_server
}

Dieser Eintrag sagt caddy, dass der Inhalt des Ordners /www/blog als Dateiserver, der die gzip-Komprimierung unterstützt, unter blog.schallbert.de verfügbar machen soll.

Test-Website erstellen 🧪

Ach ja, was auch noch wichtig ist, bevor wir den Container starten: Der DNS² sollte die Adresse auch auflösen können. Dafür logge ich mich in meinem DNS-Manager ein und ordne der Subdomain die feste IP-Adresse meines Servers zu:

TYPE NAME VALUE TTL
A blog.schallbert.de <redacted> 86400

Schlussendlich soll der Server ja auch etwas anzeigen können. Eine Testseite genügt ja schon. Also ganz fix:

mkdir ~/caddy2/www/blog
cd ~/caddy2/www/blog
nano index.html

Und dort dann ein unverkennbares Hello World eintragen:

<!-- blog/index.html -->
<h1>ALL YOUR BASE ARE BELONG TO US</h1>

Speichern, fertig.

Das Stammverzeichnis von caddy sieht nun so aus:

*caddy_config* *caddy_data* Caddyfile docker-compose.yml *www*

Jetzt endlich kann der Container erstellt und caddy darin hochgefahren werden:

docker compose up -d

Die Option -d bedeutet “detach”, also wird der Container hochgefahren und von der Konsole abgekoppelt, sodass sie nicht blockiert wird.

[+] Running 1/1
 ✔ Container caddy Started

Super, das sieht auch gut aus. Jetzt schnell mal auf die Seite navigieren:

Gitea installieren 🍵

Wie oben kurz angerissen, benötige ich Gitea für zwei Zwecke: Erstens möchte ich für meine Dateien wie von Github gewohnt ein Versionsmanagement haben und zweitens möchte ich meine Seite mit Hilfe von Gitea über Jekyll bauen und dann auf den Server schieben.

Wie schon bei caddy, beginnt alles in einem entsprechenden Ordner:

cd ~
mkdir gitea
cd gitea
nano docker-compose.yml

Die docker-compose.yml für Gitea habe ich mir aus verschiedenen Beispielen zusammengebastelt. Hier ist sie:

# gitea/docker-compose.yml
version: "3"

networks:
 gitea:
 external: false
 caddy-proxy:
 external: true
 name: caddy-proxy

services:
 gitea:
 image: gitea/gitea:latest
 container_name: gitea
 restart: always
 environment:
 - USER_UID=1000
 - USER_GID=1000
 - SSH_DOMAIN=git.schallbert.de
 - GITEA_HOSTNAME=git.schallbert.de
 networks:
 - gitea
 - caddy-proxy
 volumes:
 - ./gitea:/data
 - ./log:/app/gitea/log
 - /etc/timezone:/etc/timezone:ro
 - /etc/localtime:/etc/localtime:ro
 ports:
 - "127.0.0.1:3000:3000"
 - "222:22"
 runner:
 image: gitea/act_runner:nightly
 environment:
 - CONFIG_FILE=/config.yml
 - GITEA_INSTANCE_URL=https://git.schallbert.de
 - GITEA_RUNNER_NAME=ichlaufe
 - GITEA_RUNNER_REGISTRATION_TOKEN=
 volumes:
 - ./runner/config.yml:/config.yml
 - ./runner/data:/data
 - /var/run/docker.sock:/var/run/docker.sock

Die Bedeutung ist in etwa wie folgt: gitea ist Teil der Docker-Netzwerke gitea sowie caddy-proxy. Der Container, in dem der Service läuft, heißt gitea und wird bei Absturz stets automatisch neu gestartet. Die User-ID wird mit 1000 in einem Wertebereich gesetzt, welcher weder für Administratoren noch andere besondere Benutzer reserviert ist. Per SSH und http ist gitea unter git.schallbert.de erreichbar, und zwar auf Ports 22 bzw. 3000 - dort aber nur per localhost, also nicht “von außen”.

Gitea hat Zugriff auf Zeitzone und Lokalzeit des Servers, außerdem legt es Logs unter /log und Dateien unter /data ab. Gitea verfügt über einen action runner, der auf der gitea-Instanz läuft, ichlaufe heißt und dessen Konfiguration in der config.yml zu finden ist. Der Runner kann im Docker über dessen Standard-Socket Aktionen ausführen, z.B. ubuntu-latest installieren und darauf Jekyll zum Laufen bringen. Die Basiskonfiguration des Runners habe ich dem offiziellen Repository entnommen.

Gitea akzeptiert nur Runner, deren Token unter GITEA_RUNNER_REGISTRATION_TOKEN registriert sind - Dies holen wir zu einem späteren Zeitpunkt nach.

Nun starten wir Gitea mal, sodass wir die erforderlichen Ordner zur Konfiguration erstellt bekommen.

docker compose up

So sieht die Konsolenausgabe bei mir aus:

[+] Running 4/2
 ✔ Network gitea_default Created 0.0s 
 ✔ Network gitea_gitea Created 0.1s 
 ✔ Container gitea Created 0.1s 
 ✔ Container gitea-runner-1 Created 0.0s 
Attaching to gitea, gitea-runner-1
gitea | Server listening on :: port 22.
gitea | Server listening on 0.0.0.0 port 22.
gitea | 2023/11/18 17:19:52 cmd/web.go:242:runWeb() [I] Starting Gitea on PID: 15
gitea | 2023/11/18 17:19:52 cmd/web.go:111:showWebStartupMessage() [I] Gitea version: 1.21.0 built with GNU Make 4.4.1, go1.21.4 : bindata, timetzdata, sqlite, sqlite_unlock_notify
gitea | 2023/11/18 17:19:52 cmd/web.go:112:showWebStartupMessage() [I] * RunMode: prod
gitea | 2023/11/18 17:19:52 cmd/web.go:113:showWebStartupMessage() [I] * AppPath: /usr/local/bin/gitea
gitea | 2023/11/18 17:19:52 cmd/web.go:114:showWebStartupMessage() [I] * WorkPath: /data/gitea
gitea | 2023/11/18 17:19:52 cmd/web.go:115:showWebStartupMessage() [I] * CustomPath: /data/gitea
gitea | 2023/11/18 17:19:52 cmd/web.go:116:showWebStartupMessage() [I] * ConfigFile: /data/gitea/conf/app.ini
gitea | 2023/11/18 17:19:52 cmd/web.go:117:showWebStartupMessage() [I] Prepare to run web server

Webzugriff einrichten

Nun gehe ich erneut in meinen DNS-Manager und setze die Adresse für den Webzugriff:

TYPE NAME VALUE TTL
A git.schallbert.de <redacted> 86400

Außerdem muss die Caddyfile angepasst werden, damit Anfragen aus dem Web auch richtig weitergeleitet werden können. Also zurück in den caddy2 Ordner und mit nano Caddyfile folgenden Abschnitt hinzufügen:

# caddy2/Caddyfile
git.schallbert.de {
 reverse_proxy * http://gitea:3000
}

Nun werden Anfragen nach git.schallbert.de auf den im Docker geöffneten Port 3000 des Gitea-Containers weitergeleitet.

Gitea per Web-Oberfläche konfigurieren

Navigiere ich im Browser jetzt auf die entsprechende Adresse, so bekomme ich ein Login-Fenster angezeigt - genau wie in dieser Demo.

Nun denke ich mir ein schönes Passwort aus, klicke auf Register und bekomme hernach die Möglichkeit, Gitea per Weboberfläche zu konfigurieren. Dies tue ich aber nur rudimentär, denn ich möchte am Ende ja meine eigene Konfiguration verwenden.

Anschließend erstelle ich wie im Kapitel SSH einrichten oben beschrieben ein weiteres SSH-Schlüsselpaar per ssh-keygen und passendem Dateinamen -f ~/.ssh/gitea. Diesen lade ich dann auf Gitea unter Settings->SSH/GPG Keys hoch und verifiziere ihn.

Nun kann ich auf meinem Rechner erneut in der config-Datei des .ssh-Verzeichnisses den Abschnitt zum Login auf Gitea erstellen:

# .ssh/config
Host gitea
 User schallbert
 Hostname git.schallbert.de
 PreferredAuthentications publickey
 Identityfile ~/.ssh/schallbert_gitea

Jetzt schnell prüfen, ob auch alles funktioniert:

ssh gitea
Host 'git.schallbert.de' is known and matches the ED25519 host key.
debug1: Found key in /home/schallbert/.ssh/known_hosts

Perfekt.

Gitea-Konfiguration per `app.ini` fertigstellen

Da die Konfiguration aber noch nicht abgeschlossen ist, fahre ich den Container nun wieder herunter:

docker compose down

und navigiere nach /gitea/gitea/conf. Dort öffne ich die app.ini und modifiziere sie wie folgt:

# conf/app.ini
APP_NAME = Gitea: Git with a cup of tea
RUN_MODE = prod
RUN_USER = git
WORK_PATH = /data/gitea

[repository]
ROOT = /data/git/repositories
DEFAULT_BRANCH = main

[repository.local]
LOCAL_COPY_PATH = /data/gitea/tmp/local-repo

[repository.upload]
TEMP_PATH = /data/gitea/uploads

[server]
APP_DATA_PATH = /data/gitea
DOMAIN = git.schallbert.de
SSH_DOMAIN = git.schallbert.de
HTTP_PORT = 3000
ROOT_URL = https://git.schallbert.de/
DISABLE_SSH = false
SSH_PORT = 222
SSH_LISTEN_PORT = 22
LFS_START_SERVER = true
LFS_JWT_SECRET = <redacted>
OFFLINE_MODE = false

[database]
PATH = /data/gitea/gitea.db
DB_TYPE = sqlite3
HOST = localhost:3306
NAME = gitea
USER = root
PASSWD =
LOG_SQL = false
SCHEMA =
SSL_MODE = disable

[indexer]
ISSUE_INDEXER_PATH = /data/gitea/indexers/issues.bleve

[session]
PROVIDER_CONFIG = /data/gitea/sessions
PROVIDER = file

[picture]
AVATAR_UPLOAD_PATH = /data/gitea/avatars
REPOSITORY_AVATAR_UPLOAD_PATH = /data/gitea/repo-avatars

[attachment]
PATH = /data/gitea/attachments

[log]
MODE = file
LEVEL = info
ROOT_PATH = /data/gitea/log

[security]
INSTALL_LOCK = true
SECRET_KEY =
REVERSE_PROXY_LIMIT = 1
REVERSE_PROXY_TRUSTED_PROXIES = *
INTERNAL_TOKEN = <redacted>
PASSWORD_HASH_ALGO = pbkdf2

[service]
DISABLE_REGISTRATION = true
REQUIRE_SIGNIN_VIEW = false
REGISTER_EMAIL_CONFIRM = false
ENABLE_NOTIFY_MAIL = false
ALLOW_ONLY_EXTERNAL_REGISTRATION = false
ENABLE_CAPTCHA = false
DEFAULT_KEEP_EMAIL_PRIVATE = false
DEFAULT_ALLOW_CREATE_ORGANIZATION = false
DEFAULT_ENABLE_TIMETRACKING = true
NO_REPLY_ADDRESS = noreply.localhost

[lfs]
PATH = /data/git/lfs

[mailer]
ENABLED = false

[openid]
ENABLE_OPENID_SIGNIN = true
ENABLE_OPENID_SIGNUP = true

[cron.update_checker]
ENABLED = false

[repository.pull-request]
DEFAULT_MERGE_STYLE = merge

[repository.signing]
DEFAULT_TRUST_MODEL = committer

[oauth2]
JWT_SECRET = <redacted>

[actions]
ENABLED = true

Hier ist wichtig zu sicherzustellen, dass ROOT_URL und die Portkonfiguration mit jener der docker-compose.yml übereinstimmt. Die Datenbank (sqlite3) wird konfiguriert und gitea zugänglich gemacht. Außerdem deaktiviere ich aus Sicherheitsgründen die Registrierungsmöglichkeit neuer Benutzer DISABLE_REGISTRATION = true sowie jene per Openid ENABLE_OPENID_SIGNIN = false ENABLE_OPENID_SIGNUP = false und schalte Gitea Actions per ENABLED = true ein.

Nun kann der Container neu gestartet werden:

[+] Running 4/4
 ✔ Network gitea_default Created 0.1s 
 ✔ Network gitea_gitea Created 0.0s 
 ✔ Container gitea Started 0.0s 
 x Container gitea-runner-1 Error 0.1s

Gut, Gitea läuft schonmal. In einem letzten Schritt kümmere ich mich nun um den Action Runner.

Action Runner einrichten 🏃

Für die ersten Schritte hilft die offizielle Anleitung weiter.

Ich logge mich erneut auf der Weboberfläche über git.schallbert.de ein. Die Aktivierung von Actions in der app.ini im vorigen Abschnitt lässt jetzt bei Settings->Actions ein neues Menü erscheinen. Hier klicke ich nun auf Create new Runner und kopiere mir das REGISTRATION TOKEN.

Anschließend öffne ich die docker-compose.yml im Gitea-Stammverzeichnis erneut und füge wie hier vorgeschlagen Folgendes ein:

# gitea/docker-compose.yml
# [...]
runner:
 image: gitea/act_runner:nightly
 environment:
 - CONFIG_FILE=/config.yml
 - GITEA_INSTANCE_URL=https://git.schallbert.de
 - GITEA_RUNNER_NAME=ichlaufe
 - GITEA_RUNNER_REGISTRATION_TOKEN= <redacted>

Nach einem Neustart des Containers mit docker compose down && docker compose up -d erscheint nun der Runner als “gestartet” im Log:

✔ Network gitea_default Created 0.1s 
✔ Network gitea_gitea Created 0.0s 
✔ Container gitea Started 0.0s 
✔ Container gitea-runner-1 Started 0.1s

Hervorragend, jetzt schauen wir auf der Weboberfläche nach und siehe da:

Fehlt noch der Beweis, dass der Runner auch wirklich arbeitet.

Funktionsprüfung Runner

Für die Prüfung des Action Runner nehme ich erneut die Dokumentation von Gitea zur Hilfe. Ich erstelle ein neues Repository auf der Gitea-Weboberfläche mit Namen runner-test und füge den Inhalt der oben verlinkten Datei im Verzeichnis /.gitea/workflows/01-test.yml hinzu.

Commit, push, und - nichts.

Ah, der Workflow startet nur on: [push]. Er kann also gar nicht starten, wenn er gerade selbst erst auf den Server geladen wurde.

Gut, erstelle ich halt noch eine Datei, commit, push. Ergebnis:

Wahnsinn! 🥳

Zwischenfazit

Ich habe hier so getan, als wäre der Weg in einer geraden Linie verlaufen und als hätte alles reibungslos geklappt. Leider traf das so nicht zu. Es war zwar überraschend einfach, die Programme in Docker zum Laufen zu bringen, doch miteinander reden wollten sie lange nicht. Ich hatte zudem ziemliche Probleme mit der Caddyfile So einfach sie auch erscheinen mag, lange wollte so gar nichts in meinem Browser erscheinen - weder Gitea noch die blog-Testseite. Ein Ping an die Seite vom Terminal des Servers aus funktionierte aber, also konnte ich den Fehler schnell auf die Konfiguration von caddy zurückführen.

Die Ursache: Da caddy im Docker läuft, muss die Caddyfile als Volume eingebunden werden. Im Caddyfile selber muss der Ordner vom Root des Volumes aus, also mit führendem /, angegeben werden.

Auf der anderen Seite hat die Konfiguration von Gitea viel reibungsloser geklappt, als ich dachte. Sogar das aufwändige Freischalten des Runners, welcher auch im Docker nochmal extra geroutet werden muss, war weniger schlimm als ich dachte.

Mit diesem Grundgerüst habe ich jetzt einen flinken Server, welcher meinen Blog später bestimmt reibungslos hosten kann.

Die nächsten Schritte - das Aufsetzen des Bauprozesses für meine Website - werden in diesem Artikel hier und dann auch in Jekyll nativ hier abgehandelt.

Update: Server-Architektur im Januar 2024

Ich habe den Server inzwischen mehrfach um Peripheriefunktionen erweitert. So habe ich mich um Sicherheit und Backups ebenso gekümmert wie um automatische Updates, wobei mir die Kapselung durch Docker nicht nur einmal auf die Füße gefallen ist und einiges an Zeit gekostet hat. Auch wenn noch immer nicht alle Aspekte vollständig abgedeckt sind (Benachrichtigungen sind z.B noch ein offenes Thema), komme ich meinem Ziel, einen weitgehend selbstständig laufendes System zu schaffen, spürbar näher.

Am Ende möchte ich schließlich wieder dahin zurückkehren, Inhalte zu erzeugen. Und mich nicht mehr als nötig mit dem Drumherum beschäftigen.

CI/CD steht für “Continuous Integration / Continuous deployment” und bedeutet, dass das System bei Update der verwalteten Dateien automatisch die Website neu baut, testet und veröffentlicht. ↩︎
DNS steht für Domain Name System, ein verteiltes hierarchisches System zur Namensauflösung von Websites. Hintergrund ist, dass es viel schwieriger ist, sich eine IPV6-Adresse wie 2a02:ec80:300:ed1a:0:0:0:1 zu merken statt en.wikipedia.org in die Adresszeile eines Browsers einzugeben. ↩︎

Parameter	Wert
Auszugsparameter \( f_{ax,k} \)	14 N/mm²
Torsionsfestigkeit \( f_{tor,k} \)	3 Nm
Einschraubdrehmoment \( R_{tor,mean} \)	\( \frac{f_{tor,k}}{R_{tor,mean}} \) ≥ 1,5
Vorbohren in Nadelholz	2.5 mm
Vorbohren in Laubholz	3 mm

Schallberts Blog

Schallberts Blog mit Hugo

Was ist geschehen?

Warum habe ich das gemacht?

Was haben die LeserInnen davon?

Artikel zum Thema

Was fehlt noch?

Umzug von Jekyll zu Hugo

Projekt-Steckbrief

Warum überhaupt wechseln?

Weitere Schwierigkeiten mit Jekyll

Die Chancen

Das Migrationswerkzeug

Anpassen der Front Matter

Konfiguration des Theme

Organisation der Ordnerstruktur

Vorher

Nachher

Manuelle Anpassungen: Shortcodes

Hugo

Jekyll

image

audio

video

links

Manuelle Anpassungen: Partials

index

math

cover image

Manuelle Anpassungen: Layouts

baseof.html

list.html

single.html

Direkter Vergleich

Größe

Komplexität

Auslieferung/Continuous Deployment

htmltest-Konfiguration für Hugo

htmltest

Ausgabe in Datei umleiten

Fehlerkategorien

Das Log bereinigen

“Missing trailing slash”: Fehlerbehebung per Markup

Manuelles Suchen und Beheben

Das Ergebnis

Hugo Multi-Lang: Interne Permalinks

Konfiguration

Das Problem mit der Standardsprache

Lösung: Sprachabhängige Link-Prefixes

Standardsprache auslesen

Code für render-link.html

Zusatzfunktionen

Richtig auflösende Permalinks auf Überschriften

Funktioniert so noch nicht.

Code für render-link.html mit Unterstützung für Überschriften

Scheitern von SSH-Verbindungen

Problem: “No Route To Host”

Problem: Connection Refused

Problem: Too Many Authentication Failures

Server-Anmeldelimit prüfen

Git-Config überprüfen

Problem: Permission Denied (publickey,password)

Problem: Agent Refused Operation

Hardware Security Key: SSH einrichten

Motivation

SSH-Zugriff für Hardware Security Keys einrichten

Was so nicht funktioniert

Bedeutung des Kommandos und der wichtigsten Optionen

Woran hat es gelegen?

Was hingegen funktioniert

Was verify-required benötigt

Installation von ssh-askpass

Nervig: Gnome-Popup “Allow inhibiting shortcuts”

Übertragung auf Windows-Systeme

VPS: Vorsicht bei Schlüssel-Ersatz

Neue Schlüssel manuell auf VPS ablegen

Schlüssel erfolgreich übertragen?

Auf direktem Wege ohne ssh-copy-id

Überlegungen zu Komfort und Bedienbarkeit

Hardware Security Keys

Was `verify-required` benötigt

Einfache Lösung: DinD-Container `privileged` starten