ESP32-basierter ArtNet-zu-DMX-Konverter: Aktualisieren Sie Ihr älteres DMX-Gerät
über
Das ArtNet-Protokoll hat den DMX-Standard ins Netz gebracht. Die neuen ArtNet-Geräte sind natürlich abwärtskompatibel mit dem DMX-Standard, aber nicht umgekehrt. Was also tun mit einem älteren DMX-Gerät? Die in diesem Artikel vorgestellte Schnittstelle ermöglicht es Ihnen, es zu aktualisieren und die Kompatibilität mit diesem neuen Standard zu gewähren.
Die Idee für dieses Projekt kam fast spontan auf, als ich über die Abwärtskompatibilität des ArtNet-Standards nachdachte. Ein Universum sowohl im ArtNet als auch im DMX besteht aus 512 Kanälen, und die Werte jedes Kanals variieren von 0 bis 255. Die meisten Geräte der neuesten Generation von ferngesteuerten Geräten (RDMs), die in der Unterhaltungsindustrie verwendet werden, sind mit beiden Protokollen kompatibel. Aber wie geht man mit denen um, die ihren Job immer noch hervorragend erledigen, aber nur das DMX sSignal empfangen? Die einfachste Idee ist es, das Signal extern von ArtNet zu DMX über ein drahtloses, kompaktes, rekonfigurierbares Gerät zu konvertieren.
ArtNet zu DMX Konverter: Hardware
Das gesamte Projekt basiert auf einer 38-poligen Version des ESP32 Moduls, wie in Abbildung 1 dargestellt, während das einfache Schaltbild in Abbildung 2 veranschaulicht ist. Dieses Board wurde aufgrund seiner hohen Rechenleistung und internen Speicherkapazität, seines geringen Preises, seiner kompakten Bauweise und seiner großen Community ausgewählt. Für die Stromversorgung wurde ein 5V-Abwärtswandler-DC-DC-Konverter verwendet.
Für den DMX-Bereich können im Internet zwei TTL-DMX-Wandler mit Anschlüssen gefunden werden (Abbildung 3), jedoch zu einem sehr hohen Preis im Vergleich zu den anderen Komponenten. Daher haben wir uns entschieden, zwei TTL-zu-RS-485-Wandler (Abbildung 4) und zwei weibliche 3-polige XLR-Panelanschlüsse zu verwenden. Schließlich benötigen wir einen DC-Buchsenpanelanschluss und ein Kunststoffgehäuse, um alles zu verschließen.
Verbindungsherstellung: Vereinfachtes Schaltungsdesign
Ursprünglich habe ich eine Leiterplatte (PCB) für das Projekt erstellt, mit der eingebetteten 30-poligen Version des ESP32 (siehe Abbildung 5), aber die extreme Einfachheit der Verbindungen ermöglicht auch eine Implementierung ohne gedruckte Schaltung, unter Verwendung des erweiterten 38-poligen Moduls. Tatsächlich ist das Anschlussdiagramm leicht zu interpretieren und in Abbildung 6 verfügbar. Fangen wir mit dem Stromabschnitt an: Der panelmontierte DC-Stecker ist mit dem Eingang des DC-DC-Wandlers verbunden. Die 5V-Ausgangsspannung des letzteren ist mit VIN am ESP32 (Pin 19) sowie den VCC-Pins beider RS-485-Module verbunden. Die gleiche Verbindung sollte für die GND-Pins der drei Platinen hergestellt werden, die mit der Ausgangsmasse des DC-DC-Wandlers verbunden werden.
Was die Signale betrifft, so verfügt jedes Modul über drei Eingangspins: Die RE- und DE-Pins des Moduls A sollten mit IO4 (Pin 26) des ESP32-Moduls verbunden werden, während der DI-Pin des A-Transceivers mit IO17 (Pin 28) des ESP32 verbunden sein sollte. Der Ausgang jedes Transceivers sollte gemäß dem folgenden Diagramm mit einem XLR-Anschluss verbunden werden: Die Pins A und B des MAX485 sollten jeweils mit den Pins 3 und 2 des Anschlusses verbunden werden. Pin 1 des Anschlusses kann mit Masse verbunden werden.
Skizze
Die Skizze für dieses Projekt basiert auf der GitHub-Skizze ArtNetWiFiNeopixel von rstephan und DMX_Write von Mitch Weisbord. Sie können die Skizze dieses Projekts direkt aus dem GitHub- Repository dieses Projekts herunterladen.
Wie immer werden wir fortfahren, sie als Ganzes zu analysieren, in mehrere Auflistungen unterteilt, und einige Höhepunkte des Codes genauer betrachten. In Listing 1 erfolgt die Einbindung von Bibliotheken und die DHCP-Konfiguration. Sehen wir uns das genauer an. Mehrere Variablen, die für das Kompilieren der Skizze nützlich sind, sind in der Arduino.h-Bibliothek enthalten, zusammen mit der Einbindung mehrerer anderer Bibliotheken, die grundlegende Funktionsklassen enthalten, wie z. B. stdlib, stdio, string, usw.
#include <Arduino.h>
#include <esp_dmx.h>
#include "ArtnetWifi.h"
#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
//#define DHCP_DISABLED
#ifdef DHCP_DISABLED
IPAddress local_IP(192, 168, 1, 154);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress primaryDNS(192, 168, 1, 1); //optional
IPAddress secondaryDNS(1, 1, 1, 1); //optional
#endi
Die Bibliothek esp_dmx.h enthält den gesamten Satz von Anweisungen zum Senden von Signalen an das TTL-zu-RS-485-Modul.
Dann haben wir die Bibliotheken ArtnetWifi.h und WiFi.h zum Empfangen von ArtNet-Paketen und zum Verwalten der Verbindung zum Access Point. Die Bibliotheken ESPmDNS.h, WiFiUdp.h und ArduinoOTA.h sind andererseits funktional für die OTA-Firmwareladung und das Festlegen des Gerätenamens im Netzwerk unter Verwendung des mDNS-Protokolls.
Dann folgt eine #define DHCP_DISABLED: Durch diese Direktive können wir wählen, ob eine statische IP-Adresse festgelegt oder alles an den DHCP-Server delegiert werden soll (durch Auskommentieren der Zeile). Wenn wir uns entscheiden, eine statische IP zu verwenden, ist es notwendig, alle damit verbundenen Konstanten auf die gewünschte IP, das Gateway und das Subnetz festzulegen. Sie können außerdem die DNS-Server wählen. Wenn wir uns dafür entscheiden, eine dynamische IP zu verwenden, ist es immer noch nützlich (aber nicht unbedingt erforderlich), die IP-Adresse des ESP32 zu kennen.
| ESP32 Pin | MAX485 Pin |
|---|---|
| 4 | DE |
| 17 | DI |
| 4 | RE |
Tabelle 2: ESP32 zu RS485-B-Modul-Verbindungen
| ESP32 Pin | MAX485 Pin |
|---|---|
| 21 | DE |
| 19 | DI |
| 21 | RE |
Wir werden später mehr darüber erklären. Listing 2 umfasst den verbleibenden Teil des Präprozessors. Zunächst werden die Objekte, die mit den Bibliotheken WiFiUDP und ArtnetWifi zusammenhängen, erstellt. Anschließend werden in den Zeichenkettenkonstanten SSID und Passwort der Name des Wi-Fi-Netzwerks, mit dem sich der ESP verbindet, sowie sein Passwort definiert. Die ESP-Pins, an die beide RS-485-Transceiver angeschlossen werden sollen, sind in Tabelle 1 und Tabelle 2 aufgeführt.
WiFiUDP UdpSend;
ArtnetWifi artnet;
const char* ssid = "MyArtNetNetwork";
const char* password = "MyArtNetNetwork";
/* Zuerst definieren wir die Hardware-Pins, die wir mit unserem ESP32 verwenden. Wir müssen festlegen, welcher Pin Daten sendet und welcher Pin Daten empfängt. DMX-Schaltungen müssen oft auch darüber informiert werden, wann wir Daten senden und wann wir Daten empfangen. Dies können wir durch Festlegen eines Enable-Pins tun. */
int transmitPinA = 17;
int receivePinA = 16; //Nicht verbunden
int enablePinA = 4;
int transmitPinB = 21;
int receivePinB = 16; //Nicht verbunden
int enablePinB = 19;
/* Stellen Sie sicher, dass diese Pins mit Ihrem ESP32 kompatibel sind! Einige ESP32s, wie z. B. die ESP32-WROVER-Serie, ermöglichen es Ihnen nicht, Daten auf den Pins 16 oder 17 zu lesen oder zu schreiben, daher ist es immer ratsam, die Handbücher zu lesen. */ /* Als nächstes entscheiden wir, welchen DMX-Port wir verwenden möchten. Der ESP32 hat entweder 2 oder 3 Ports. Port 0 wird typischerweise verwendet, um serielle Daten an Ihren Seriellen Monitor zurückzusenden, daher sollten wir diesen Port nicht verwenden. Lassen Sie uns Port 1 verwenden! */
dmx_port_t dmxPortA = 1;
dmx_port_t dmxPortB = 2;
/* Jetzt möchten wir irgendwo unsere DMX-Daten speichern. Da ein einzelnes Paket DMX-Daten bis zu 513 Bytes lang sein kann, möchten wir, dass unser Array mindestens so lang ist. Diese Bibliothek weiß, dass die maximale DMX-Paketgröße 513 beträgt, sodass wir die Array-Größe mit DMX_PACKET_SIZE ausfüllen können. */
byte dataA[DMX_PACKET_SIZE];
byte dataB[DMX_PACKET_SIZE];
// ArtNet-Einstellungen const int startUniverse = 0;
// ÄNDERN SIE FÜR IHRE EINRICHTUNG die meisten Software verwendet 1,
// einige Software senden das erste ArtNet-Universum als 0. const int maxUniverses = 2;
const int maxUniverses = 2;
const int numberOfChannels = 1024;
bool universesReceived[maxUniverses];
bool sendFrame = 1;
int previousDataLength = 0;
Für jedes der Module haben wir den Empfangspin auf 16 gesetzt, obwohl diese tatsächlich nicht verbunden sind und in unserem Design nicht verwendet werden. Weiter geht es mit der Hardware-Einstellung durch die Definition der ESP-TTL-Ports: Wir verwenden Ports 1 und 2 für die Universen A und B. Die Daten für die 2 DMX-Universen werden in zwei Byte-Arrays, dataA und dataB, encapsuliert, deren Größen in DMX_PACKET_SIZE definiert sind. DMX_PACKET_SIZE ist in der esp_dmx.h-Bibliothek definiert und hat einen Wert von 513. Schließlich werden alle Variablen definiert, die für die Verarbeitung von ArtNet-Paketen verwendet werden. Besondere Aufmerksamkeit gilt der Konstanten startUniverse: Diese gibt tatsächlich an, ab welchem Universum wir Daten berücksichtigen möchten.
Sie sollte geändert werden, falls wir beabsichtigen, eine Installation mit mehreren Empfängern aus verschiedenen Universen zu erstellen. Sie muss auch in Fällen geändert werden, in denen das Programm, das Pakete sendet, mit einer Nummerierung beginnt (anstatt 0) mit 1. Es werden dann Konstanten definiert, die die maximale Anzahl von Universen, Kanälen und andere Variablen betreffen, die verwendet werden, um Zustände zu überwachen und Schleifen zu verarbeiten.
Listing 3 enthält alle Anweisungen innerhalb von setup(). Die serielle Verbindung wird zunächst mit 115.200 Bits pro Sekunde initialisiert, um das Debuggen des Boards zu ermöglichen, z.B. um die erhaltenen IP zu überprüfen. Wenn vorhanden, werden alle Parameter konfiguriert, um eine statische IP zu erhalten, und im Falle eines Fehlers wird eine Nachricht über die serielle Schnittstelle gesendet. Anschließend wird eine Verbindung zum Netzwerk hergestellt und, falls erfolgreich, die IP des Boards über die serielle Schnittstelle ausgegeben. Der Hostname ESP32-ArtNet-to-DMX-Converter wird dann festgelegt, der im Abschnitt Board-Manager der verschiedenen IDEs angezeigt wird. Diese Funktion ist sehr nützlich, um ein Gerät unter vielen in einer "Flotte" erkennen zu können. Die Verwaltung des OTA-Firmwareladens wird dann initialisiert, und als nächstes kommt die ArtNet-Bibliothek.
void setup() {
/* Starten Sie die serielle Verbindung zum Computer, damit wir Nachrichten an den seriellen Monitor protokollieren können. Setzen wir die Baudrate auf 115200. */
Serial.begin(115200);
// Setup wifi
WiFi.mode(WIFI_STA);
#ifdef DHCP_DISABLED
// Kommentieren Sie dies aus, um DHCP anstelle einer statischen IP zu verwenden if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) { Serial.println("STA-Konfiguration fehlgeschlagen");
}
#endif
WiFi.begin(ssid, password);
delay(1000);
Serial.println("\nConnecting");
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(100);
}
Serial.println("\nMit dem WiFi-Netzwerk verbunden"); Serial.print("Lokale ESP32-IP: "); Serial.println(WiFi.localIP());
// Port standardmäßig auf 3232
// ArduinoOTA.setPort(3232);
// Hostname standardmäßig auf esp3232-[MAC] ArduinoOTA.setHostname("ESP32-ArtNet-zu-DMX-Konverter");
// Standardmäßig keine Authentifizierung
// ArduinoOTA.setPassword("admin");
// Das Passwort kann auch mit seinem md5-Wert festgelegt werden
// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
typ = "Dateisystem";
// ANMERKUNG: Hier könnte das Aushängen von SPIFFS erfolgen
// um SPIFFS zu aktualisieren Serial.println("Beginne " + typ + " zu aktualisieren");
})
.onEnd([]() {
Serial.println("\nEnde"); })
.onProgress([](unsigned int fortschritt, unsigned int insgesamt) { Serial.printf("Fortschritt: %u%%\r", (fortschritt / (insgesamt / 100)));
})
.onError([](ota_error_t fehler) {
Serial.printf("Fehler[%u]: ", fehler);
if (fehler == OTA_AUTH_ERROR)
Serial.println("Authentifizierung fehlgeschlagen");
else if (fehler == OTA_BEGIN_ERROR)
Serial.println("Start fehlgeschlagen");
else if (fehler == OTA_CONNECT_ERROR)
Serial.println("Verbindung fehlgeschlagen");
else if (fehler == OTA_RECEIVE_ERROR)
Serial.println("Empfang fehlgeschlagen");
else if (fehler == OTA_END_ERROR)
Serial.println("Ende fehlgeschlagen");
});
ArduinoOTA.begin();
artnet.setArtDmxCallback(onArtNetFrame);
artnet.begin("ESP32-ArtNet-to-DMX-Converter");
/* Setzen Sie die DMX-Hardwarepins auf die Pins, die wir verwenden möchten. */ dmx_set_pin(dmxPortA, transmitPinA, receivePinA, enablePinA); dmx_set_pin(dmxPortB, transmitPinB, receivePinB, enablePinB);
/* Jetzt können wir den DMX-Treiber installieren! Wir sagen ihm, welchen DMX-Port wir verwenden möchten und welche Interrupt-Priorität er haben soll. Wenn Sie sich nicht sicher sind, welche Interrupt-Priorität Sie verwenden sollen, können Sie das Makro DMX_DEFAULT_INTR_FLAG verwenden, um den Interrupt auf seine Standardwerte zu setzen. */
dmx_driver_install(dmxPortA, DMX_DEFAULT_INTR_FLAGS);
dmx_driver_install(dmxPortB, DMX_DEFAULT_INTR_FLAGS);
Zuletzt werden die ESP-Ausgangspins und der serielle Port festgelegt, die jedem Transceiver zugeordnet werden, und die Priorität der Interrupts, die verwendet werden sollen, wird definiert. Listing 4 enthält den gesamten Teil, der sich auf die Funktion onArtNetFrame() bezieht. Zunächst wird überprüft, ob der Wert jeder empfangenen Universe zu den Universen unseres Interesses gehört. Falls dies der Fall ist, wird die Flagge der entsprechenden Zelle des Arrays auf 1 gesetzt. Es wird dann überprüft, ob alle erforderlichen Universen empfangen wurden; andernfalls wird die Funktion beendet. Als nächstes wird überprüft, ob jeder der empfangenen Kanäle zu Universe A oder Universe B gehört und in das entsprechende Array aufgenommen wird.
void onArtNetFrame(uint16_t universe, uint16_t numberOfChannels,
uint8_t sequence, uint8_t* dmxData) {
sendFrame = 1;
// Store which universe has got in
if ((universe - startUniverse) < maxUniverses)
universesReceived[universe - startUniverse] = 1;
for (int i = 0; i < maxUniverses; i++) {
if (universesReceived[i] == 0) {
//Serial.println("Broke");
sendFrame = 0;
break;
}
}
// read universe and put into the right array of data
for (int i = 0; i < numberOfChannels; i++) {
if (universe == startUniverse)
dataA[i + 1] = dmxData[i];
else if (universe == startUniverse + 1)
dataB[i + 1] = dmxData[i];
}
previousDataLength = numberOfChannels;
dmx_write(dmxPortA, dataA, DMX_MAX_PACKET_SIZE);
dmx_write(dmxPortB, dataB, DMX_MAX_PACKET_SIZE);
dmx_send(dmxPortA, DMX_PACKET_SIZE);
dmx_send(dmxPortB, DMX_PACKET_SIZE);
dmx_wait_sent(dmxPortA, DMX_TIMEOUT_TICK);
dmx_wait_sent(dmxPortB, DMX_TIMEOUT_TICK);
// Reset universeReceived to 0
memset(universesReceived, 0, maxUniverses);
}
Als nächstes werden die Daten aus jedem Universum in die entsprechenden Sende-Puffer eingefügt und auf die vollständige Übertragung gewartet. Schließlich werden die Flags, die mit den empfangenen Universen zusammenhängen, zurückgesetzt. Listing 5 ist das kürzeste und enthält nur die loop()-Funktion. Innerhalb der Schleife wird überprüft, ob das ESP korrekt mit dem Zugangspunkt verbunden ist, und falls ja, werden ArtNet-Pakete empfangen und verarbeitet.
void loop() {
if ((WiFi.status() == WL_CONNECTED)) {
artnet.read();
}
}
Montage: Vom Prototyp zum Endprodukt
Es ist Zeit, über die Montage des Konverters nachzudenken. Folgen Sie einfach den zuvor gezeigten Verbindungen in Abbildung 6. Denken Sie daran, dass Sie bei den RS-485-Transceivern die DE- und RE-Pins überbrücken müssen. Bereiten Sie als nächstes die XLR-Stecker vor, indem Sie die drei Drähte löten (Tabelle 3).
Tabelle 3: RS485-Modul zu XLR-Verbindungen.| MAX485 Pin | DMX-Signal | XLR-Anschluss Pin |
|---|---|---|
| GND | Gnd/Schirm | 1 |
| A | Daten+ | 3 |
| B | Daten- | 2 |
Bohren Sie für jeden Anschluss des Kunststoffgehäuses zwei Löcher für die Schrauben und ein größeres Loch für seine Aufnahme. Bohren Sie das letzte Loch für den DC-Stecker, an den zuvor zwei Drähte gelötet wurden. Fahren Sie dann fort, die Drähte vom DC-Stecker mit dem Eingang des DC-DC-Wandlers zu verbinden. Die Ausgang des Letzteren wird über Jumper und ein Paar Schraubklemmen mit der Stromversorgung des ESP32 und den beiden Transceivern verbunden. Laden Sie die Firmware, schließen Sie das Gehäuse und schließen Sie die Stromversorgung an. Fahren Sie dann mit der Konfiguration der Steuersoftware fort.
Die Softwarekonfiguration: ArtNet-Geräte mit MagicQ
Es gibt viele Softwareprogramme zur Verwaltung von ArtNet-Geräten: Open Source, Freemium und kostenpflichtig. Unter den kostenlosen Programmen (oder kostenlos für den nicht kommerziellen Gebrauch), die wir empfehlen möchten, ist zweifellos MagicQ von Chamsys. In diesem Fall werden wir uns nur mit der Verwendung von MagicQ befassen. Es handelt sich um ein plattformübergreifendes (Windows, Mac und Ubuntu) kostenloses Download-Program, das den Steuerung von bis zu 256 Universen ermöglicht, das Pixelmapping verwaltet und die Wiedergabe von HD-Videos auf bis zu 8 Ebenen arrangiert.
Wir fahren fort, indem wir uns auf der Website registrieren und den Installationsprogramm herunterladen. Sobald die Installation abgeschlossen ist, haben wir mehrere Anwendungen der Suite: Öffnen Sie MagicQ PC und warten Sie, bis ein Bildschirm erscheint, wie in Abbildung 7 gezeigt. Klicken Sie auf Simple generic console . In dem neuen Bildschirm, der erscheint, gehen wir zum Menü und wählen Setup → DMX I/O. In dem Bildschirm, der angezeigt wird, wie in Abbildung 8 dargestellt, können wir die Ausgänge der verschiedenen DMX-Universen einstellen. Für das Feld "Out Type" wählen wir Art-Net und wählen Art 0 als das "Out Uni" Feld aus. Der kritische Teil der Konfiguration kommt, wenn wir die "Unicast" und "Unicast2" Felder wählen müssen.
Diese Einträge werden tatsächlich verwendet, um anzugeben, an welche IP-Adressen wir unsere Pakete senden werden. Angenommen, wir sind mit einem Netzwerk mit einem 24-Bit-Subnetz (255.255.255.0) verbunden und daher ist die Broadcast-IP XXX.XXX.XXX.255. In diesem Fall können wir die letztere Adresse eingeben, und wir werden sicher sein, dass alle Geräte im Netzwerk Pakete empfangen. Wenn wir andererseits vermeiden möchten, dass alle Geräte im Netzwerk durch das unnötige Senden von Paketen überflutet werden, können wir die IP-Adresse des betroffenen Geräts direkt festlegen, aber in diesem Fall empfehlen wir, eine statische IP zu verwenden.
Wir haben diese Konfiguration auf das ArtNet-2-Universum angewendet, das dieselben Datenquellen wie Universum 1 verwendet, und es in der Copy column eingestellt. Sie können sehen, dass wir die localhost-Adresse des PCs in das Feld Unicast 2 eingetragen haben. Wir haben diese Konfiguration eingetragen, um die tatsächliche Paketübertragung in Debugging-Software wie ArtNetominator zu überprüfen, die von hier heruntergeladen werden kann. Für Universum 1 haben wir diese Option nicht eingetragen, da Pakete bei Verwendung von IP-Broadcast automatisch "go back" zum PC gelangen. Jetzt gehen wir mit dem Cursor in die obere rechte Ecke und klicken auf Single, Schieberegler werden angezeigt, wie in Abbildung 9 gezeigt.
Um die Paketübertragung zu starten, wählen wir "Enable" und bestätigen. Nun fahren wir fort, eine einfache Gerätekonfiguration durchzuführen, indem wir etwa auf halber Höhe des Bildschirms links klicken und auf "Test Show" klicken. Auf dem Bildschirm sehen wir eine lange Reihe von Zellen, die die Hersteller der Geräte darstellen, wie in Abbildung 10 gezeigt. Wir wählen die Marke aus, und alle verfügbaren vorkonfigurierten Modelle werden angezeigt.
Nachdem wir unsere Auswahl getroffen haben, sehen wir ein Fenster wie das in Abbildung 11, in dem wir entweder einzelne Schieberegler für grundlegende Befehle oder einige Makros haben, die eine Mischung davon im Laufe der Zeit ausführen. Lassen Sie uns den Betrieb testen, um sicherzustellen, dass die Geräte und die Software korrekt konfiguriert sind. Um das volle Potenzial der Anwendung auszuschöpfen, empfehlen wir dringend, an kostenlose Schulungssitzungen teilzunehmen.
ArtNet zu DMX Konverter: Abschließende Überlegungen
Wir haben den Betrieb des Systems unter verschiedenen Bedingungen getestet und verschiedene Schwierigkeiten festgestellt, die je nach verwendeten Zugriffspunkten variieren. Tatsächlich kann es vorkommen, dass - je nach Zugriffspunkt - die Karte nach einigen Stunden in einen Fehlerzustand gerät und man sie manuell zurücksetzen muss. Dies ist zwar bei einer Hobbylösung zu erwarten, aber durch den Austausch von Geräten lässt sich das Problem lösen und die Karte funktioniert dann wieder problemlos für mehrere Tage. Außerdem empfehlen wir die Verwendung eines dedizierten Netzwerks, um mögliche Systemabstürze zu vermeiden.
DMX-Upgrade: Bauteilliste
Kondensatoren
- C1, C4 = 100 nF, ceramic
- C2, C3 = 220 µF, 16 V, electrolytic
- C5 = 10 µF, 63 V, electrolytic
Module
- U1, U2 = TTL-to-RS-485 converter
- U3 = ESP32
- U4 = MP1584 DC-DC step-down converter, 5 V
Verschiedenes
- DMX1, DMX2 = XLR connector, female, PCB type
- PWR = barrel connector, female, PCB type
- 4× 2-pin strip connector, female, pitch 2.54 mm
- 4× 4-pin strip connector, female, pitch 2.54 mm
- 2× 15-pin strip connector, female, pitch 2.54 mm
- 4× 2-pin Strip connector, male, pitch 2.54 m
- PCB S1716 (102×61 mm)
Editorische Anmerkungen: Interessiert an ESP32 und DIY-Projekten? Dieses Projekt erschien ursprünglich in Elettronica IN.
Diskussion (0 Kommentare)