Diverse Beiträge

Arduino als ISP-Programmer
ATtiny Mikrocontroller mit Arduino IDE programmieren
Installation von Node.js
Node.js Modul pcf8574
OpenVPN Server einrichten
OpenVPN - Zugriff auf Netzwerk hinter einem Client

.markdownlint.json

@@ -7,6 +7,10 @@
     "siblings_only": true
   },
 
+  "MD026": {
+    "punctuation": ".,;:。，；："
+  },
+
   "MD028": false,
 
   "MD033": {

.vscode/md-snippets.code-snippets

@@ -26,7 +26,7 @@
 	"IMG Tag": {
 		"scope": "markdown",
 		"prefix": "img",
-		"body": "{% img $TM_SELECTED_TEXT thumb: $1 %}",
+		"body": "{% img $TM_SELECTED_TEXT$1 thumb: $2 %}",
 		"description": "Add img Nunjunks Tag"
 	},
 
@@ -39,5 +39,14 @@
 			"{% endgrid %}"
 		],
 		"description": "Add grid Nunjunks Tags"
+	},
+
+	"Codefile Tag": {
+		"scope": "markdown",
+		"prefix": "codefile",
+		"body": [
+			"{% codefile $1 $2 $3 %}"
+		],
+		"description": "Add codefile Nunjunks Tags"
 	}
 }

.vscode/settings.json

@@ -23,6 +23,7 @@
     "Adminoberfläche",
     "Antippen",
     "Arduinos",
+    "avrdude",
     "Blockly",
     "Durchkontaktierungen",
     "EEPROM",

posts/arduino-als-isp-programmer.md

@@ -0,0 +1,81 @@
+---
+title: Arduino als ISP-Programmer
+author:
+  name: Peter Müller
+  link: https://crycode.de
+banner: banner.webp
+date: 2017-07-27 12:00:00
+categories:
+  - Elektronik
+tags:
+  - Arduino
+  - ATMega
+  - ATtiny
+  - Elektronik
+  - ISP-Programmer
+  - Mikrocontroller
+abbr:
+  ISP: In-System-Programmierung
+  SPI: Serial Peripheral Interface
+---
+
+Ein Arduino kann recht einfach auch als {% abbr ISP %}-Programmer für andere Mikrocontroller verwendet werden. Dabei kommt die serielle {% abbr SPI %}-Schnittstelle zum Einsatz.
+
+Mit Hilfe eines {% abbr ISP %}-Programmers ist es möglich, diverse Mikrocontroller-Typen zu programmieren. ISP steht dabei für In-System-Programming, was so viel bedeutet, wie dass der Controller direkt im Einsatzsystem programmiert werden kann.
+
+<!-- more -->
+
+Im folgenden Beispiel verwende ich einen *Arduino Nano* zum Programmieren eines *ATtiny85* Controllers. Es können natürlich auch andere Arduinos und andere Mikrocontroller (z.B. ATMega8, ATMega328, ATMega64, etc.) verwendet werden.
+
+## Arduino vorbereiten
+
+Damit der Arduino als {% abbr ISP %}-Programmer eingesetzt werden kann, muss dieser erst selbst entsprechend programmiert werden.
+
+Hierfür ist in der *Arduino IDE* bereits das Beispiel *ArduinoISP* enthalten, welches lediglich geöffnet und über USB auf den Arduino geladen werden muss.
+
+{% img arduinoisp.webp thumb: ArduinoISP Sketch laden %}
+
+## Verkabelung zum Ziel-Mikrocontroller
+
+Die Verkabelung zum Ziel-Mikrocontroller erfolgt nach dem folgenden Muster.
+
+{% grid 2 %}
+{% img steckplatine.webp thumb: Steckplatine %}
+{% img schaltplan.webp thumb: Schaltplan %}
+{% endgrid %}
+
+| Arduino Pin | ISP-Funktion | Farbe im Beispiel |
+|---|---|---|
+| D13 | SCK | gelb |
+| D12 | MISO | grün |
+| D11 | MOSI | orange |
+| D10 | RESET | weiß |
+
+Der Kondensator dient als Puffer für den Reset des Arduinos selbst, da der Arduino sonst beim Programmieren des Ziel-Mikrocontrollers oftmals resettet wird und damit das Programmieren fehlschlägt. Ich habe hier einen 22&nbsp;µF Elko verwendet, da dieser mir als erstes in die Hände fiel. Andere Kondensatoren in dieser Größenordnung sollen den gleichen Effekt haben.
+
+Der 10&nbsp;kΩ Widerstand dient als Pull-Up für den Reset des Ziel-Mikrocontrollers.
+
+{% img steckplatine-foto.webp thumb: Foto vom Aufbau auf einer Steckplatine %}
+
+## Programmieren des Ziel-Mikrocontrollers
+
+### Arduino IDE
+
+In der Arduino IDE muss über das Menü *Werkzeuge* -> *Programmer* -> *Arduino as ISP* ausgewählt werden.
+
+Dann kann der Sketch entweder durch klicken des *Hochladen*-Buttons bei gedrückter Umschalttaste, oder über das Menü *Sketch* -> *Hochladen mit Programmer* auf den Ziel-Mikrocontroller geladen werden.
+
+### avrdude
+
+Bei Verwendung von *avrdude* über die Kommandozeile sind die folgenden Parameter anzugeben:
+
+* Programmer: `-c arduino` oder `-c stk500v1`
+* Port: `-P /dev/ttyUSB0`
+* Baud: `-b 19200`
+
+Zum Lesen der Fuse-Bits des ATtiny85 würde der komplette avrdude-Befehl dann so aussehen:
+
+```sh Fuse-Bits des ATtiny85 mit avrdude auslesen
+avrdude -p t85 -c arduino -P /dev/ttyUSB0 -b 19200 -v -E noreset -F \
+  -U lfuse:r:-:i -U hfuse:r:-:i
+```

posts/attiny-mikrocontroller-mit-arduino-ide-programmieren.md

@@ -0,0 +1,89 @@
+---
+title: ATtiny Mikrocontroller mit Arduino IDE programmieren
+author:
+  name: Peter Müller
+  link: https://crycode.de
+#banner: banner.webp
+date: 2017-07-08 12:00:00
+categories:
+  - Elektronik
+tags:
+  - Arduino
+  - ATtiny
+  - AVR
+  - Elektronik
+  - Mikrocontroller
+abbr:
+  ISP: In-System-Programmierung
+---
+
+Die [Arduino IDE](https://www.arduino.cc/en/software) bringt von Hause aus keine Unterstützung für *ATtiny* Mikrocontroller mit. Über den *Boardverwalter* ist es jedoch sehr einfach möglich, zusätzliche Pakete mit diversen Boards zu installieren.
+
+Damit wird es ermöglicht, Mikrocontroller der Typen **ATtiny25/45/85** und **ATtiny24/44/84** zu programmieren.
+
+<!-- more -->
+
+## Boardverwalter-URL hinzufügen
+
+Als Erstes fügen wir eine zusätzliche Boardverwalter-URL hinzu.
+
+Hierfür öffnen wir über das Menü Datei die *Voreinstellungen* und klicken anschließend auf den Fenster-Button neben *Zusätzliche Boardverwalter-URLs*.
+
+{% grid 2 %}
+{% img voreinstellungen.webp Voreinstellungen %}
+{% img boardverwalter.webp thumb: Boardverwalter-URLs öffnen %}
+{% endgrid %}
+
+In dem sich öffnenden Fenster fügen wir die folgende URL in einer neuen Zeile hinzu und bestätigen beide Fenster mit OK.
+
+`https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json`
+
+{% img boardverwalter-2.webp thumb: Boardverwalter-URLs %}
+
+> [!TIP]
+> Nicht von der 1.6.x in der URL irritieren lassen, es funktioniert auch mit der aktuellen Version einwandfrei. 😉
+
+## Paket "attiny" installieren
+
+Nun können wir das Paket "attiny" über den Boardverwalter installieren.
+
+Dazu öffnen wir über das Menü *Werkzeuge*, *Board* den *Boardverwalter*.
+
+{% img werkzeuge-boardverwalter.webp thumb: Menü Werkzeuge, Boardverwalter %}
+
+Hier suchen wir nach "attiny" und installieren das Paket.
+
+{% img boardverwalter-attiny.webp thumb: Suche nach attiny im Boardverwalter %}
+
+## Board auswählen
+
+Ist das Paket installiert, so kann über das Menü *Werkzeuge*, *Board* der *ATtiny25/45/85* oder *ATtiny24/44/84* ausgewählt werden.
+
+{% img board-attiny.webp thumb: Board-Auswahl %}
+
+Anschließend ist es noch wichtig, den entsprechenden Prozessor und die Clock auszuwählen.
+
+{% img prozessor-attiny.webp thumb: Prozessorauswahl %}
+
+## Pin-Belegung
+
+Die Pin-Belegung der ATtiny Controllers in Arduino ist wie folgt:
+
+| Hardware-Pin | Funktion | Arduino Pin | Alternative Funktion |
+|---|---|---|---|
+| 1 | PB 5 | D5 | Ain0 |
+| 2 | PB 3 | D3 | Ain3 |
+| 3 | PB 4 | D4 | Ain2 |
+| 4 | GND | | |
+| 5 | PB 0 | D0 | pwm0 |
+| 6 | PB 1 | D1 | pwm1 |
+| 7 | PB 2 | D2 | Ain1 |
+| 8 | Vcc | | |
+
+## Programmierung/Flashen
+
+Zum Übertragen des Programms auf den ATtiny Mikrocontroller wird ein {% abbr ISP %}-Programmer benötigt. Für den normalen Arduino Bootloader besitzt der ATtiny einfach zu wenig Platz.
+
+Als {% abbr ISP %}-Programmer kann ganz einfach ein Arduino verwendet werden, wie bereits im Beitrag [Arduino als ISP-Programmer](/arduino-als-isp-programmer/) beschrieben.
+
+Das Hochladen des Sketches erfolgt dann durch einfaches klicken des *Hochladen*-Buttons, wobei automatisch erkannt wird, dass hierfür ein Programmer benötigt wird. Alternativ kann die Verwendung des Programmers durch klicken des Hochladen-Buttons bei gedrückter Umschalttaste, oder über das Menü *Sketch* -> *Hochladen mit Programmer* erzwungen werden.

posts/installation-von-node-js.md

@@ -0,0 +1,164 @@
+---
+title: Installation von Node.js
+author:
+  name: Peter Müller
+  link: https://crycode.de
+#banner: banner.webp
+date: 2017-04-17 12:00:00
+updated: 2024-04-29 12:47:47
+categories:
+  - [Node.js]
+  - [Software]
+tags:
+  - Node.js
+  - Linux
+---
+
+{% img nodejs-logo.webp type:none right:true %}
+
+In den Repositories von Ubuntu, Debian und anderen Linux Systemen ist [Node.js](https://nodejs.org/) zwar vorhanden, jedoch sind dies meistens keine aktuellen Versionen.
+
+Zur Installation einer aktuellen Version gibt es drei Möglichkeiten, welche im Folgenden beschrieben werden.
+
+<!-- more -->
+
+> [!TIP]
+> Es sollte möglichst immer die jeweils aktuelle LTS-Version von Node.js genutzt werden.  
+> LTS-Versionen sind hier alle Versionen mit einer geraden Major-Versionsnummer (z.B. 20.x).
+
+Unabhängig von der verwendeten Installationsmethode müssen wir zunächst die gegebenenfalls installierte veraltete Version von Node.js vom System entfernen:
+
+```sh Entfernen der alten Node.js Version
+sudo apt remove nodejs
+sudo apt autoremove
+```
+
+<!-- toc -->
+
+## Installation mittels Node Version Manager (nvm)
+
+{% img nvm-logo.webp type:none right:true %}
+
+Der [Node Version Manager](https://github.com/nvm-sh/nvm) (nvm) ist ein Script, welches es sher komfortabel ermöglicht schnell und einfach eine oder auch mehrere Versionen von Node.js zu installieren und zu verwalten.
+
+Die Installation von *nvm* erfolgt einfach über den folgenden Befehl:
+
+```sh Installation von nvm
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
+```
+
+Dieses Installationsscript läd die benötigten Dateien von GitHub herunter und fügt die benötigten Einträge in beispielsweise der Datei `~/.bashrc` hinzu.
+
+Zum Installieren von Node.js wird anschließend `nvm install` mit der gewünschten Node.js Version aufgerufen.
+
+```sh Installation einer Node.js Version mittels nvm
+nvm install 20
+```
+
+Mit *nvm* ist es auch möglich mehrere Node.js Versionen parallel zu installieren. Hierzu wird einfach `nvm install` mehrfach mit der jeweiligen Version aufgerufen. Die entsprechend aktuell zu verwende Version kann dann jederzeit mittels `nvm use` ausgewählt werden.
+
+```sh nvm install und use Beispiele
+nvm install 16
+nvm use 16
+# Now using node v16.20.2 (npm v8.19.4)
+node -v
+# v16.20.2
+nvm use 20
+# Now using node v20.12.2 (npm v10.5.0)
+node -v
+# v20.12.2
+```
+
+> [!NOTE]
+> Nachteil dieser Installationsmethode ist, dass *Node.js* damit nur dem aktuellen Benutzer zur Verfügung steht und es bei der Verwendung von unterschiedlichen Nutzern für verschiedene Programme zu etwas umständlichen Konstellationen kommen kann.
+
+## Installation über das NodeSource-Repository
+
+Dies ist eine einfache und zugleich sichere Methode zur Installation. Hierbei wird das Repository von [NodeSource](https://github.com/nodesource/distributions/) verwendet und alle Updates werden wie gewohnt über den Paketmanager installiert.
+
+Abhängig von der gewünschten Version rufen wir einen der folgenden Befehle auf. Das Setup-Script erkennt dabei automatisch das verwendete Betriebssystem und richtet die Paketquellen dementsprechend ein.
+
+```sh Einrichtung des NodeSource Repositories
+VERSION=20.x
+curl -fsSL https://deb.nodesource.com/setup_$VERSION | sudo -E bash -
+```
+
+Die Variable `VERSION=20.x` muss jeweils auf gewünschte Version angepasst werden. Für *Node.js* 18 wäre dies dann beispielsweise `VERSION=18.x`.
+
+Anschließend installieren wir *Node.js* und die Build-Tools, welche zur Installation von *Node.js* Modulen mit nativen Addons benötigt werden.
+
+```sh Installation von Node.js über das NodeSource Repository
+sudo apt install nodejs build-essential
+```
+
+### Probleme beim Installieren von globalen Modulen
+
+Bei der Installation von globalen Modulen (`-g` bzw. `--global`) kann es zu *EACCESS*-Fehlern, also Berechtigungsfehlern kommen. Selbst `sudo` hilft hier wenig und sollte in diesem Fall eh nicht verwendet werden.
+
+Als Lösung wird in der [offiziellen Dokumentation](https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally) empfohlen das Standardverzeichnis für *npm* zu ändern.
+
+Hierfür legen wir zuerst im eigenen Home-Verzeichnis ein neues Verzeichnis an, sofern dies nicht bereits existiert:
+
+```sh Verzeichnis .npm-global anlegen
+mkdir -p ~/.npm-global
+```
+
+Anschließend wird *npm* so konfiguriert, dass es dieses Verzeichnis für gobale Module verwendet:
+
+```sh npm für das Verzeichnis konfigurieren
+npm config set prefix '~/.npm-global'
+```
+
+Damit die Module in einer Shell auch gefunden werden, wird ein entsprechender Eintrag am Ende der Datei `~/.profile` hinzugefügt und die Änderungen anschließend in die aktuelle Shell übernommen:
+
+```sh Pfad für global installierte Module dem Profil hinzufügen
+echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.profile
+source ~/.profile
+```
+
+Das war’s dann auch schon. 🙂
+
+## Manuelle Installation
+
+Zur manuellen Installation ist es zunächst entscheidend, sich über die [offizielle Downloadseite](https://nodejs.org/en/download/) von *Node.js* die zur Plattform passende Variante herunterzuladen.
+
+* Auf einem normalen 64-bit Ubuntu oder Debian System ist dies von den *Prebuild Binaries* für *Linux* die *x64* Variante.
+* Auf neueren Raspberry Pis mit 64-bit Betriebssystem ist dies von den *Prebuild Binaries* für *Linux* die *ARM64* Variante.
+* Auf einem Raspberry Pi ab Modell 2B ist dies von den *Prebuild Binaries* für *Linux* die *ARMv7* Variante.
+* Für die älteren oder kleineren Raspberry Pis mit ARMv6 Prozessor (Raspberry Pi A/A+/B/B+/Zero/ZeroW) oder auch 32-bit Linux Systeme gibt es keine offiziellen Downloads mehr. Wie wir dennoch eine aktuelle Version von *Node.js* auf diese Systeme installiert bekommen, beschreibe ich weiter unten im Abschnitt Aktuelles *Node.js* auf ARMv6 oder 32-bit Linux.
+
+Im folgenden Beispiel verwenden wir ARMv7 von *Node.js* v20.12.2.
+
+```Manuelle Installation von Node.js auf einem Raspberry Pi
+cd /tmp
+wget https://nodejs.org/dist/v20.12.2/node-v20.12.2-linux-armv7l.tar.xz
+tar -xvf node-v20.12.2-linux-armv7l.tar.xz
+sudo mv node-v20.12.2-linux-armv7l /opt/
+sudo ln -s /opt/node-v20.12.2-linux-armv7l /opt/node
+sudo chown -R root:root /opt/node*
+sudo ln -s /opt/node/bin/node /usr/bin/node
+sudo ln -s /opt/node/bin/npm /usr/bin/npm
+```
+
+Damit ist *Node.js* dann installiert und Befehle `node` sowie `npm` sind global verfügbar.
+
+Es empfiehlt sich auch noch das Verzeichnis `/opt/node/bin` der *PATH*-Variable hinzuzufügen, damit global installierte *Node.js* Module (wie beispielsweise TypeScript) automatisch global in jeder Shell verfügbar werden. Hierfür rufen wir einfach den folgenden Befehl auf, welcher die Datei `/etc/profile.d/nodejs.sh` anlegt und damit bei jedem Login eines Benutzer den Pfad automatisch erweitert.
+
+```sh Pfad global hinzufügen
+echo PATH=\$PATH:/opt/node/bin | sudo tee /etc/profile.d/nodejs.sh > /dev/null
+```
+
+Damit ist dann auch die manuelle Installation abgeschlossen. Zu beachten bleibt noch, dass keine automatischen Updates erfolgen.
+
+### Aktuelles Node.js auf ARMv6 oder 32-bit Linux - Unofficial Builds
+
+Seit *Node.js* Version 10 gibt es keine offiziellen Downloads mehr für Linux-Systeme mit 32-bit Prozessor. Ab Version 12 dann auch nicht mehr für Systeme mit ARMv6.
+
+Glücklicherweise gibt es aber das [Node.js Unofficial Builds Project](https://github.com/nodejs/unofficial-builds), welches genau diese Varianten automatisch zu jedem neuen Release bereitstellt.
+
+> [!IMPORTANT]
+> Dieses Projekt ist experimentell! Es wird nicht garantiert, dass sein Ergebnis konsistent bleibt, und seine Existenz wird nicht für die Zukunft garantiert.
+
+Auf der [Downloadseite](https://unofficial-builds.nodejs.org/download/release/) sind für alle aktuellen Versionen von *Node.js* die fertig kompilierten Archive, für unter anderem *armv6l* und *x86*, verfügbar.
+
+Die Installation auf dem System erfolgt wie weiter oben im Abschnitt [Manuelle Installation](#manuelle-installation) beschrieben, nur eben mit dem passenden Link aus den inoffiziellen Builds.