Display mit passendem Gehäuse

Moin Leute,

bin ein Arduino Neueinsteiger und habe schon ein paar Kleinigkeiten programmiert und das klappt auch alles wunderbar.
Mein Problem ist eher die verfügbare Hardware als der dazugehörige Code.

Mein Code soll 9 LEDs ansteuern von denen immer nur eine Leuchten soll und welche mit einem Fußschalter ausgewählt werden können.

Der Fußschalter hat 3 Tasten: Vor, Zurück und Reset

Taste Vor schaltet die nächste LED ein,
Zurück die schaltet die vorherige LED ein
und die Taste Reset schaltet zurück auf die Start-LED bzw. wenn diese bereits leuchtet dann wird diese abgeschaltet.

Mein Code sieht momentan wie folgt aus und wird demnächst um den passenden Code für eine kleine Displayanzeige ergänzt: (Alles mit nen bisschen viel Kommentaren aber so konnte ich das unserem Azubi gut erklären :D)

int led = 5;                                                                                        // Variable für den Pin der Default-LED; 5 = LED Mitte
int pressed = 0;                                                                                    // Variable für den Schalterstatus

void setup() {
  pinMode(1,OUTPUT);                                                                                // LED 1
  pinMode(2,OUTPUT);                                                                                // LED 2
  pinMode(3,OUTPUT);                                                                                // LED 3
  pinMode(4,OUTPUT);                                                                                // LED 4
  pinMode(5,OUTPUT);                                                                                // LED 5
  pinMode(6,OUTPUT);                                                                                // LED 6
  pinMode(7,OUTPUT);                                                                                // LED 7
  pinMode(8,OUTPUT);                                                                                // LED 8
  pinMode(9,OUTPUT);                                                                                // LED 9

  pinMode(10,INPUT);                                                                                // Zurück-Taster
  pinMode(11,INPUT);                                                                                // Reset-Taster
  pinMode(12,INPUT);                                                                                // Vor-Taster
}

void loop() {
  if ((digitalRead(10) == LOW) && (digitalRead(11) == LOW) && (digitalRead(12) == LOW)){            // Wenn keiner der drei Schalter gedrückt ist    
    pressed = 0;                                                                                    // dann setze die Variable "pressed" auf den Wert 0.
    delay(100);
  }
  
  if ((digitalRead(12) == HIGH) && (pressed == 0)){                                                 // Wenn der Taster "Vor" gedrückt ist 
    pressed = 1;                                                                                    // dann setze den Wert der Variable "pressed" auf den Wert 1 und
    digitalWrite(led,LOW);                                                                          // schalte die momentan selektierte LED aus und
    led++;                                                                                          // der Wert der Variable "led" wird um 1 erhöht.
    if (led > 9) {                                                                                  // Sollte die Variable "led" nun den Wert 9 übersteigen dann wird
      led = 1;                                                                                      // der Wert von "led" auf 1 gesetzt.
    }
    digitalWrite(led,HIGH);                                                                         // Einschalten der momentan selektierten LED
    delay(150);
  }

  if ((digitalRead(10) == HIGH) && (pressed == 0)){                                                 // Wenn der Taster "Zurück" gedrückt ist 
    pressed = 1;                                                                                    // dann setze den Wert der Variable "pressed" auf den Wert 1 und
    digitalWrite(led,LOW);                                                                          // schalte die momentan selektierte LED aus und
    led--;                                                                                          // der Wert der Variable "led" wird um 1 verringert.
    if (led < 1) {                                                                                  // Sollte die Variable "led" nun den Wert 1 unterschreiten dann 
      led = 9;                                                                                      // wird der Wert von "led" auf 9 gesetzt.
    }
    digitalWrite(led,HIGH);                                                                         // Einschalten der momentan selektierten LED.
    delay(150);
  }

  if ((digitalRead(11) == HIGH) && (pressed == 0)){                                                 // Wenn der Taster "Reset" gedrückt ist
    pressed = 1;                                                                                    // dann setze den Wert der Variable "pressed" auf den Wert 1 und
    if (digitalRead(5) == HIGH){                                                                    // wenn die momentan eingeschaltete LED die mittlere ist
      digitalWrite(led,LOW);                                                                        // dann wird die LED ausgeschaltet.
    } 
    else {                                                                                          // Sollte die momentan eingeschaltete LED nicht die mittlere sein
      digitalWrite(led,LOW);                                                                        // dann wird die momentan leuchtende LED ausgeschaltet,
      led = 5;                                                                                      // der Wert von "led" auf 5 gesetzt (entspricht der mittleren LED) und
      digitalWrite(led,HIGH);                                                                       // die LED wird eingeschaltet
    }
  }
}

Verbesserungsvorschläge nehme ich gern entgegen allerdings funktioniert alles soweit ganz gut :grinning:

Nun aber zu meiner eigentlichen Frage:

Ich suche ein kleines Display (~3" reicht vollkommen) welches entweder mit einem passendem Gehäuse geliefert wird oder eines welches relativ gute Befestigungsmöglichkeiten bietet.
Zum testen des Displays und der Touchscreen-Funktion hatte ich mir mal folgendes Display bestellt:

Das funktioniert auch alles ganz schön und gut nur habe ich mit diesem Display das Problem das es keinerlei Befestigungsmöglichkeiten gibt.
Weder Löcher zum Anschrauben noch ein passendes Gehäuse in das man das einklicksen könnte sind vorhanden.

Habt ihr da irgendwelche Empfehlungen?
Habe kein Problem auch nen Bopla Gehäuse zu nehmen und das dann passend zu fräsen aber vielleicht habt ihr ja bessere Vorschläge für mich :slight_smile:

Lieben Gruß,
BlubQ

Nimm anstelle eines Shields ein Breakout Board, dann hat das auch Befestigungslöcher.

BlubQ:
... Azubi ...

Verbesserungsvorschläge nehme ich gern entgegen ...

Als Ausbilder hast Du eine besondere Verantwortung, das weißt Du, daher könnte das Programm auch etwas vorbildlicher sein. Da ist Luft nach oben. Auf jeden Fall millis() anstelle delay(), Pin 1 ist beim UNO für USB reserviert, ein Feld würde das Ansprechen der LEDs deutlich vereinfachen.

Was hälst Du davon?

(deleted)

Die Nextion sind auch mein Favorit.
Diese werden per serieller Schnittstelle angesprochen und sind zudem sehr sparsam was dir Resourcen des Arduino betrifft.

agmue:
Nimm anstelle eines Shields ein Breakout Board, dann hat das auch Befestigungslöcher.

Danke, das sieht schonmal vielversprechender aus als das Display welches ich besitze.
Besser wäre natürlich gleich ein passendes Gehäuse mit vorinstallierten Halterungsmöglichkeiten.
Gibt es sowas auch irgendwo?

Außerdem: Gibt es auch Displays ohne Touchfunktion?
Die meisten die ich finde für den Arduino haben immer auch eine Touch-Funktion die ich nicht benötige.
Ich weis nicht ob sich das großartig auf den Preis auswirkt aber benötigt ist die Touchfunktion, wie gesagt, nicht.

anwofis:
@BlubQ:

Du kannst auch ein Nextion-Display ausprobieren. z.B. so eines

HotSystems:
Die Nextion sind auch mein Favorit.
Diese werden per serieller Schnittstelle angesprochen und sind zudem sehr sparsam was dir Resourcen des Arduino betrifft.

Danke euch beiden. Guck ich mir mal an.
Darstellen muss mein Display nur welche LED gerade leuchtet von daher nichts aufwendiges nötig aber das sieht schonmal sehr nett aus.

agmue:
Als Ausbilder hast Du eine besondere Verantwortung, das weißt Du, daher könnte das Programm auch etwas vorbildlicher sein. Da ist Luft nach oben. Auf jeden Fall millis() anstelle delay(), Pin 1 ist beim UNO für USB reserviert, ein Feld würde das Ansprechen der LEDs deutlich vereinfachen.

Was hälst Du davon?

millis() zu verwenden anstelle von delay() scheint generell eine gute Idee zu sein.
In meinem Fall funktioniert delay() zwar genauso gut aber in anderen Fällen wo ein komplettes blockieren von Inputs durch delay() stören würde ist milis() sicherlich um einiges sinnvoller.
Vielleicht stricke ich meinen Code diesbezüglich noch um.

Das Pin 1 für die serielle Kommunikation benutzt wird habe ich auch schon gelesen.
Da ich aber (noch) keine serielle Schnittstelle benutze ergab sich mir aber kein Grund den Pin 1 nicht als normalen I/O Pin zu nehmen.

"ein Feld würde das Ansprechen der LEDs deutlich vereinfachen" <-- Das müsstest du mir einmal erklären was du damit meinst. Da kann ich mir keinen Reim draus machen.

Außerdem hat mir übrigens keiner gesagt das, wenn man einem Azubi ein bisschen Code zeigt, man automatisch zum Ausbilder wird ;D

BlubQ:
Außerdem: Gibt es auch Displays ohne Touchfunktion?

Ja, gibt es. Z.B.dies hier.

Ist zwar etwas kleiner, aber geht sicher auch.
Und wird per SPI angesprochen, du brauchst da auch nicht so viele Pins.

Edit:
Ein passendes Gehäuse wirst du wohl für keins der Displays finden.

Displays?

Hier gibt es mehr als man verbauen kann :wink:

Ich habe da noch nix bestellt, kann also nix zum Händler sagen.

Gruß

MiReu

Habt ihr da irgendwelche Empfehlungen?

Also das mit Gehäusen ist für mich auch immer schwierig, was bezahlbares zu finden ;-(

Daher mal 4 Vorschläge:

für 16x2 Displays habe ich diesen Lieferanten gefunden:

Und sonst nehme ich eigentlich Gehäuse mit transparenten Deckel. Z.B. in dieser Art:
https://www.aliexpress.com/item/158-90-60mm-Plastic-Waterproof-Enclosure-Transparent-Meter-Case-Plastic-Electronic-Project-Box-Housing/32525248980.html?spm=a2g0s.8937460.0.0.00th35

Gehäuse mit unterschiedlichen Display-Ausschnitten sollten sich in diesem Shop finden lassen - ich habe von denen aber noch nichts bestellt.
https://www.aliexpress.com/store/1879562?spm=2114.10010108.0.0.34549d7bUW7qlF

Die Nokia Displays lassen sich natürlich prima in ein altes Nokia 3110 einbauen - dafür waren sie ja mal gedacht :wink:
20180129_201725_klein.jpg

20180129_201725_klein.jpg

Hallo,
für TFT und HMI ist es fast unmöglich vernünftige Gehäuse und Rahmen zu
finden.
Ein Tip…
Diese Display´s haben als letzte Oberfläche eine Scheibe.
Das ist das Mass für Deinen AusSchnitt.
Wenn Du eine Fräse hast, ist das kein Problem. Es geht aber auch mit Geduld,
Feile und MessSchieber.
Das Display wird nicht unbedingt täglich gewechselt, also kannst Du es
einkleben.
Wenn Du den AusSchnitt sauber ausgearbeites hast, dann setzt Du Dir eine
FrontPlatte (0,5 oder 0,2mm Alu) mit 100%tigem sauberen AusSchnitt darüber.
Ähnlich wie ein Passepartout beim Bild.
Dieser AusSchnitt ist kleiner und gibt nur die aktive Fläche des Display
frei. So mache ich es auch bei meinem AusSchnitt.
Gruß und Spaß
Andreas
AusSchnitt.png

BlubQ:
Außerdem hat mir übrigens keiner gesagt das, wenn man einem Azubi ein bisschen Code zeigt, man automatisch zum Ausbilder wird ;D

Und zack ist es passiert :wink:

BlubQ:
Außerdem: Gibt es auch Displays ohne Touchfunktion?

Dann käme auch ein kleines OLED in Betracht:

oled_7.png

Testprogramm dazu:

#include <Wire.h>
#include <MicroLCD.h>
LCD_SSD1306 oled; /* for SSD1306 OLED module */

const byte zurT = 2;                                                                               // Zurück-Taster
const byte resT = 3;                                                                               // Reset-Taster
const byte vorT = 4;                                                                               // Vor-Taster
const byte leds[] = {5, 6, 7, 8, 9, 10, 11, 12, 13};
byte ANZAHLLEDS = sizeof(leds);
byte led = (ANZAHLLEDS - 1) / 2;                                                                                    // Variable für den Pin der Default-LED
const uint32_t entprellIntervall = 30;
uint32_t aktMillis, entprellMillis;
bool altZur, aktZur, altRes, aktRes, altVor, aktVor;

void setup() {
  oled.begin();
  oled.setFontSize(FONT_SIZE_XLARGE);
  oled.setCursor(60, 3);
  oled.printInt(led);
  Serial.begin(9600);
  Serial.println(led);
  for (byte j = 0; j < ANZAHLLEDS; j++)
  {
    pinMode(leds[j], OUTPUT);                                                                               // LEDs
  }
  pinMode(zurT, INPUT_PULLUP);                                                                               // Zurück-Taster
  pinMode(resT, INPUT_PULLUP);                                                                               // Reset-Taster
  pinMode(vorT, INPUT_PULLUP);                                                                               // Vor-Taster
}

void loop()
{
  aktMillis = millis();
  altZur = aktZur;
  altRes = aktRes;
  altVor = aktVor;
  if (aktMillis - entprellMillis >= entprellIntervall)
  {
    entprellMillis = aktMillis;
    aktZur = digitalRead(zurT);
    aktRes = digitalRead(resT);
    aktVor = digitalRead(vorT);
  }

  if (altVor && !aktVor) {
    digitalWrite(leds[led], LOW);
    if (led == ANZAHLLEDS - 1)
    {
      led = 0;
    } else {
      led++;
    }
    digitalWrite(led, HIGH);                                                                        // Einschalten der momentan selektierten LED
    oled.setCursor(60, 3);
    oled.printInt(led);
    Serial.println(led);
  }

  if (altZur && !aktZur) {
    digitalWrite(leds[led], LOW);
    if (led == 0)
    {
      led = ANZAHLLEDS - 1;
    } else {
      led--;
    }
    oled.setCursor(60, 3);
    oled.printInt(led);
    digitalWrite(led, HIGH);                                                                        // Einschalten der momentan selektierten LED
    Serial.println(led);
  }

  if (altRes && !aktRes) {
    digitalWrite(leds[led], LOW);
    led = (ANZAHLLEDS - 1) / 2;
    digitalWrite(led, HIGH);                                                                        // Einschalten der momentan selektierten LED
    oled.setCursor(60, 3);
    oled.printInt(led);
    Serial.println(led);
  }
}

Anm.: Die Bibliothek wirft einige Warnungen raus, da muß ich nochmal genauer hinschauen, eventuell eine andere nehmen.

Sollen nur Zahlen dargestellt werden, kann das eine 8x8-Matrix mit MAX7219 auf einfache Weise:

MAX7219_Matrix_7.png

// Festlegungen für MAX7219 LED Display
#include <MaxMatrix.h>

const unsigned char CH[] PROGMEM = {
  B0111110, B1000001, B1000001, B0111110, // 0
  B0000000, B1000010, B1111111, B1000000, // 1
  B1100010, B1010001, B1001001, B1000110, // 2
  B0100010, B1000001, B1001001, B0110110, // 3
  B0011000, B0010100, B0010010, B1111111, // 4
  B0100111, B1000101, B1000101, B0111001, // 5
  B0111110, B1001001, B1001001, B0110000, // 6
  B1100001, B0010001, B0001001, B0000111, // 7
  B0110110, B1001001, B1001001, B0110110, // 8
  B0000110, B1001001, B1001001, B0111110, // 9
  B0000000, B0000000, B0000000, B0000000  // space
};

const int maxInUse = 1;        // Anzahl der MAX7219-Anzeigen (8x8-Matrix)
// UNO A2 verbunden mit DIN
// UNO A1 verbunden mit CS
// UNO A0 verbunden mit CLK
MaxMatrix m(A2, A1, A0, maxInUse);
byte sprite[] = {0, 0, 0, 0, 0, 0, 0};

const byte zurT = 2;                                                                               // Zurück-Taster
const byte resT = 3;                                                                               // Reset-Taster
const byte vorT = 4;                                                                               // Vor-Taster
const byte leds[] = {5, 6, 7, 8, 9, 10, 11, 12, 13};
byte ANZAHLLEDS = sizeof(leds);
byte led = (ANZAHLLEDS - 1) / 2;                                                                                    // Variable für den Pin der Default-LED
const uint32_t entprellIntervall = 30;
uint32_t aktMillis, entprellMillis;
bool altZur, aktZur, altRes, aktRes, altVor, aktVor;

void setup() {
  m.init();
  m.setIntensity(1);
    displayChar(led, 2);
  Serial.begin(9600);
  Serial.println(led);
  for (byte j = 0; j < ANZAHLLEDS; j++)
  {
    pinMode(leds[j], OUTPUT);                                                                               // LEDs
  }
  pinMode(zurT, INPUT_PULLUP);                                                                               // Zurück-Taster
  pinMode(resT, INPUT_PULLUP);                                                                               // Reset-Taster
  pinMode(vorT, INPUT_PULLUP);                                                                               // Vor-Taster
}

void loop()
{
  aktMillis = millis();
  altZur = aktZur;
  altRes = aktRes;
  altVor = aktVor;
  if (aktMillis - entprellMillis >= entprellIntervall)
  {
    entprellMillis = aktMillis;
    aktZur = digitalRead(zurT);
    aktRes = digitalRead(resT);
    aktVor = digitalRead(vorT);
  }

  if (altVor && !aktVor) {
    digitalWrite(leds[led], LOW);
    if (led == ANZAHLLEDS - 1)
    {
      led = 0;
    } else {
      led++;
    }
    digitalWrite(led, HIGH);                                                                        // Einschalten der momentan selektierten LED
    displayChar(led, 2);
    Serial.println(led);
  }

  if (altZur && !aktZur) {
    digitalWrite(leds[led], LOW);
    if (led == 0)
    {
      led = ANZAHLLEDS - 1;
    } else {
      led--;
    }
    digitalWrite(led, HIGH);                                                                        // Einschalten der momentan selektierten LED
    displayChar(led, 2);
    Serial.println(led);
  }

  if (altRes && !aktRes) {
    digitalWrite(leds[led], LOW);
    led = (ANZAHLLEDS - 1) / 2;
    digitalWrite(led, HIGH);                                                                        // Einschalten der momentan selektierten LED
    displayChar(led, 2);
    Serial.println(led);
  }
}

byte displayChar(byte zeichen, byte x) {
  memcpy_P(sprite + 2, CH + zeichen * 4, 4);
  sprite[0] = 4;
  sprite[1] = 8;
  m.writeSprite(x, 0, sprite);
  return sprite[0];
}

oled_7.png

MAX7219_Matrix_7.png

(deleted)

Für 7" TFTs gibt es "RPI-Gehäuse"... die gibt's aus Holz, Metall, Kunststoff.... Alternativ kann man bei Schaeffer AG Produkte mit einem einfachem CAD- Programm Frontplatten selbst gestalten und diese für vertretbare Preise fertigen lassen- das hab ich schon ein paar mal für kleine Radios mit Holgehäuse und Alufront genutzt- die Qualität und Designmöglichkeiten sind verdammt gut.

Hallo,
vielen Dank für den FrontplattenLink. Genau, was ich suche.

Hier der Link zum HMI das ich nutze.
Gruß und Spaß
Andreas

Itead hat doch für die Nextions nen Link, wo man sich (ich glaub, bei shapeways) Display-Verkleidungen machen lassen kann?
Zumindest die dafür nötigen Daten gibts dort. Damit geht man halt zu einem 3D-Drucker eigener Wahl.
Auch ne Anpassung an eigene Erfordernisse (wenn man es z.B. auf nem bestimmten Gehäuse montieren will) sind damit ganz easy möglich.

Hab mir mein Gehäuse auch selbst gedruckt. Mit etwas Nacharbeit sieht es echt gut aus. Wenn du möchtest kann ich es mir ja mal für dein Display ansehen. Schick mir doch eine PN

Hallo,
"Itead hat doch für die Nextions nen Link, wo man sich (ich glaub, bei shapeways) Display-Verkleidungen"

Da wäre ich vorsichtig. Ich habe mir nach diesen Dateien Rahmen für ein 5" und 7" machen lassen.
Die sind nicht schlecht, aber die aktive Fläche des Nextion liegt NICHT- zentriert im Rahmen. Müll!
Gruß und Spaß
Andreas

Ah-gut zu wissen.
Also selber konstruieren (ich brauch irgendwann so ein Ding....).

Ich sag schonmal vielen Dank für die ganzen Vorschläge auch wenn es anscheinend keinen Anbieter gibt der passende Gehäuse mit den Displays verkauft/anbietet.

Eindeutig ne Marktlücke :stuck_out_tongue:

BlubQ:
Ich sag schonmal vielen Dank für die ganzen Vorschläge auch wenn es anscheinend keinen Anbieter gibt der passende Gehäuse mit den Displays verkauft/anbietet.

Eindeutig ne Marktlücke :stuck_out_tongue:

Wie viel Größen und Formen sollte ein Hersteller da für die unterschiedlichsten Displays und Anwendungen vorhalten.

Gehäuse sind schon immer eine individuelle Sache gewesen.

Das wäre doch eine Super Geschäfts Idee (wurde bereits gesagt, aber es wäre ne überlegung Wert).

Front Design - Wir drucken Ihre Individuelle Front oder Ihr Gehäuse! :wink:

Auf tinkercad oder mit einem CAD Programm eine *.stl Uploaden und drauf los Drucken.

So ne Frontplatte ist nicht besonders dick, daher halten sich die Produktionskosten sehr niedrig und man kann das um unter 10€ verkaufen (Pi*Daumen).

Falls wer wirklich ne Front Braucht -> PM
lg dony