Projects on Schallberts Blog

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…

🎄 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.

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.

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

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. ↩︎