Einfaches 1-Draht Display mit deutschen Befehlen - Projekt EasyTFT

Hallo liebes Forum,

Heute möchte ich mein neues Projekt vorstellen: EasyTFT

Was ist EasyTFT?

  • EasyTFT ist ein einfach zu programmierendes Display mit Befehlen in deutscher Sprache

  • EasyTFT benötigt nur ein Datenkabel

  • EasyTFT benötigt keine Libraries und spart Speicher und Pins

Genauer gesagt:

EasyTFT besteht aus einem Display und einem Arduino, der die EasyTFT-Software und alle benötigten Libraries enthält. Die EasyTFT-Software ist ein Übersetzer, der einfache deutsche Befehle in Steuerbefehle der jeweiligen Library übersetzt.

Was kann EasyTFT?

  • Texte schreiben und Zeiger (Cursor) positionieren

  • Farben für Hintergrund, Text, Geometrie, und Texthintergrund wählbar

  • Viele vordefinierte Farben für Hintergrund, Text, Geometrie, und Texthintergrund

  • Genaue RGB Farbauswahl

  • Zufällige Farbauswahl

  • Invertieren / Farben Umkehren

  • Display drehen 0 - 90°

  • Geometrische Figuren zeichnen: Herz, Kreis, Punkt, Rechtecke, ... uvm!

  • Touchscreen Zeichenprogramme

  • Touchscreen Positionsrückmeldung (benötigt 2tes Datenkabel)

  • Kann direkt am USB-Port betrieben werden

  • 115200 Baud, max 100 Befehle/Sekunde

  • Spannungsversorgung 5V (Über den Pin "VIN" können auch 6-15V angelegt werden)

Wie wird EasyTFT gesteuert?

Entweder direkt am USB Port mit einem Serial-Monitor Programm, wie zB Putty, oder den im Arduino-Programm enthaltenen Serial-Monitor.

Für richtige Programme wird natürlich ein Arduino zum Steuern verwendet. Die Befehle können einfach mit Serial.print("irgendeinbefehlodertext") ans EasyTFT gesendet werden. Erfahrenere Benutzer können sich speichersparende Voids zum Senden der Befehle einrichten, und können mit SoftwareSerial jeden beliebigen Pin zum Senden der Befehle verwenden.

Wie ist das Projekt entstanden?

Aus Frust, da es immer Stunden oder Tage dauert, bis ein Display mal läuft. Auch die Befehle ändern sich je nach Library, was schon öfter für Verwechslungen sorgte. Dazu kommt noch, dass die Displays viele Pins und Speicherplatz brauchen. Daher kam die Idee, einen zweiten Arduino als "Übersetzer und Displaysteuerung" zu benutzen, so entstand dann EasyTFT.

Was kommt in Zukunft noch dazu?

  • Bilder und Texte von SD-Karte laden

  • Fertige Buttons und Menüs, falls es sich mit dem Speicherplatz noch ausgeht

  • Deutsche Tutorials und Übungen die jeden Befehl genau erklären

Hier könnt ihr euch 2 Videos in Aktion angucken:

1-Draht betrieb mit Arduino und Democode:

Betrieb direkt am USB Port via Serial Monitor:

Ich hoffe das Projekt gefällt euch! Wenn ja, gebt mir bitte ein Like und unterstützt auch meine anderen Projekte! :slight_smile:

Lg, Kolbi!

Ja find ich super, aber wo gibt es mehr Info zu dem Projekt?
Würd ich mir auch gern zulegen.

Weitere Infos gibts bald auf meiner HP. Ein Verkauf ist eigentlich nicht geplant, könnte es aber bei fürstlichen Spenden über 35€ als Geschenk anbieten, 14 € DPD Versand (bin aus Österreich) sind darin enthalten.
Lg!

Mir gefällt's auch - aber als Bastler kann ich für 35 € lange knobeln :smiling_imp:

hi,

Du fängst das falsch an, kolbi.

entweder willst Du geld damit verdienen, dann ist das hier nicht erwünscht.

oder Du machst das aus spaß, dann bitte anders:

leg Deine schaltungen offen, ebenso den quellcode. ob Du daran interessiert bist, daß auch andere mitarbeiten, ist Deine sache.

gruß stefan

Forderungen ohne Gegenleistung finde ich prinzipiell unverschämt, daher bleibt mir nur zu sagen:
Lernen und selbermachen! Ich stelle hier nur mein Projekt vor, und gehe auf Fragen ein.

Seit dem ersten Post habe ich fast ununterbrochen weiterprogrammiert, und viele neue Features eingebaut:

  • Bildschirm drehen

  • Positionseingabe für Geometrie jetzt auch über Touchscreen möglich

  • Integriertes Zeichenprogramm mit allen Geometriefunktionen

  • Ein paar Befehle wurden noch einfacher geschrieben, zb statt "umbruch1" und "umbruch0" gibt man jetzt einfach nur "umbruch" ein, um zwischen Textumbruch ein/aus zu wechseln.

Die Sketchgröße konnte ich gerade noch so von 120% auf 97% schrumpfen, daher ist es vorerst leider unmöglich, die SD-Karte bzw Bilder zu nutzen. Vielleicht fällt mir da noch was ein...

Video folgt,

Lg!

Kolbi:
Forderungen ohne Gegenleistung finde ich prinzipiell unverschämt, daher bleibt mir nur zu sagen:
Lernen und selbermachen! Ich stelle hier nur mein Projekt vor, und gehe auf Fragen ein.

Dein ganzer Code basiert darauf, dass andere ihren Code offen gelegt haben, damit Du Dich daran bedienen kannst.

Du vertrittst eine von mir nicht unterstützte Anschauung, um es vornehm auszudrücken.

Gruß Tommy

Nun, das stimmt nicht ganz, dann nur ungefähr 20% des Codes stammt von Anderen, und diese Codes/Libraries kann je eh jeder downloaden. Bei Arduino geht es doch auch darum, was zu lernen, um sein eigenes Ding zu machen, und genau das habe ich getan. Dass mir deswegen Leute böse sind war eigentlich nicht geplant…

Arduino is an open-source electronics platform

“Dir böse sein” ist eventluell nicht der richtige Ausdruck. Aber wenn du was machst und nicht veröffentlichen willst, wie du es gemacht hast, bist du hier einfach im falschen Forum.

Dass du dabei bist, es alleine hinzukriegen ist sicher schön für dich, aber wie gesagt: wenn du es geheim halten willst, dann tu das auch.

Kennst du übrigens Nextion ?

Wie versprochen noch ein Video, welches das neue Paint-Programm demonstriert.

Das Programm lässt sich entweder über den Befehl Serial.print("demo"); starten (bzw im Serial Monoitor "demo" schreiben), und läuft so lange, bis ein neuer Befehl ankommt. Oder man erreicht das Paint-Programm auch, wenn man das EasyTFT mit Strom versorgt, und einfach aufs Display drückt während das Logo läuft.

Video:

EasyTFT 1-Draht Serial Display V2 - Paint Sketch Onboard - YouTube

Und hier meine aktuelle Befehlsliste:

BEFEHLSLISTE:

Hintergrund:
Weiss
Schwarz
Rot
Gruen
Blau
Orange
Gelb
Aqua
Lila
Gold
Silber
Zufall
Farbe

Text/Geometrie/Stift:
weiss
schwarz
rot
gruen
blau
orange
gelb
cyan
lila
gold
silber
zufall
farbe

Texthintergrund:
hweiss
hschwarz
hrot
hgruen
hblau
horange
hgelb
hcyan
hlila
hgold
hsilber
hfarbe
hzufall

Textposition:
zeiger0 - Setzt den Textcursor an den Anfang, links oben
zeiger - Startet die Eingabe für X und Y Koordinaten und plaziert dann den Zeiger
zeile - Fügt eine leere Zeile ein (Abstandshalter nach Überschriften, etc)
umbruch

Textgroesse:
mini
klein
mittel
gross

Geometrie:
pixel
punkt
kreis
herz
herzvoll - Gefülltes Herz
linie
rechteck
box - Gefülltes Rechteck
rundeck - Rechteck mit runden Ecken
rundbox - Box mit runden Ecken

Touch:
abfrage - Sendet bei Berührung des Display die X und Y Koordinaten an den Arduino/SerialMonitor
stift - Startet den Stift
stiftz - Startet den Stift im Zufallsfarbenmodus
demo - Startet das Paint-Programm wie im Video

Display:
drehen - Displayausrichtung um 90° drehen
invert - Invertieren (Farben umkehren)
turbo - TX am EasyTFT ausschalten, erhöht die Geschwindigkeit geringfügig

Lg

Hallo Kolbi,

es ist schön das du so eine tolle Lib für dein Display schreiben konntest. Wirklich fein.
Nur musst du dir auch im klaren darüber sein, dass deine gesamte Auflistung der Möglichkeiten sinnlos ist, wenn du die Lib nicht offen legst. Du musst sie nicht offen legen, aber dann reicht eine einfachere Vorstellung aus. Alles andere löst nur den "haben wollen Effekt" aus mit anschließender Diskussion darüber.
Man muss sich vorher überlegen was man mit einer Projektvorstellung erreichen möchte.
Klar, im Projekt Thread http://forum.arduino.cc/index.php?topic=372623.0 zeigt auch nicht jeder den gesamten Code.
Aber dort schreibt auch niemand was von "ohne Gegenleistung ..." usw.
Es ist auch einleuchtend, dass kaum jemand den Code verstehen wird, weil er zu umfangreich ist, weswegen eine komplette Offenlegung der Projekt-Codes in den wenigstens Fällen überhaupt Sinn machen würde. Aber die Leute geben gern die benötigten Funktionen/Teilfunktionen auf Nachfrage heraus oder erklären bestimmte Lösungshilfen. Da bin ich mir sicher. Weil hier jeder von jeden lernt.

Die Sache ist verzwickt, zugegeben. Nur eben mit solchen Aussagen "ohne Gegenleistung ..." macht man sich keine Freunde. Zudem deine Lib ohne die fremden 20% "Open Source" nicht entstanden wäre.

Wenn die vielen Helfer hier immer eine Gegenleistung haben möchten, dann gebe es das Forum in der netten Form nicht. Das nur als reine Information laut meiner Meinung und Auffassung. Ich möchte damit kein Öl ins Feuer gießen, nur dir die Sicht aus Forumssicht offen legen.

Egal wie schön du es formulierst, zum Schluss bleibt nur "Gib mir deinen Code!" übrig, und das habe ich bereits klar und deutlich abgelehnt.
Wenn du wie Jesus leben willst, dann verschenk deinen Besitz und deine Arduinos, und verzichte aufs porgrammieren :slight_smile:

Ich mag es einfach nicht, wenn mir jemand seine Lebensweise aufdrängt.

Und ich teile sehr viel, aber meistens im richtigen Leben, wenn ich mich mit meinen Freunden treffe, und ihnen beim Programmieren lernen helfe. Hier im Forum bin ich mehr Fragesteller als Beantworter, so gleicht es sich wieder aus.

Bisher ist auch noch keine einzige konkrete Frage oder Vorschlag zu den Funktionen gekommen, was ich mir eigentlich gewünscht hatte. Da noch ein Fitzelchen Speicher übrig ist, ließen sich noch weitere Geometrien einbauen, zB Kusslippen passend zum Herz...

Lg

Hallo,

da haste mich leider komplett falsch verstanden. Ich benötige deinen Code nicht.
Und wenn du mehr Fragesteller als Beantworter bist, dann erklärt das auch schon viel.
Dann kämen zu den 20% fremden Codes nochmal paar % dazu.

Die Antwort zu deiner eigenen Fragen "Bisher ist auch noch keine einzige konkrete Frage oder Vorschlag zu den Funktionen gekommen, was ich mir eigentlich gewünscht hatte." steckt in meiner Antwort #10.

Aber gut, die Interpretation obliegt jedem selbst.

Kolbi:
Egal wie schön du es formulierst, zum Schluss bleibt nur "Gib mir deinen Code!" übrig, und das habe ich bereits klar und deutlich abgelehnt.

Wofür stellst du es dann überhaupt so ausführlich in der Form hier vor?

Das ist keine Verkaufsplattform, weshalb kommerzielle Absichten unerwünscht sind. Hier geht es um Hilfe bei Projekten und das bereitwillige Teilen von Ideen und Umsetzungen.

Und ein "Hey, ich bin ein toller Hecht und bewundert mich alle für mein geniales Display, was nur ich habe"-Thread dient vielleicht der Ego-Steigerung und geht am Sinn eines Forums vorbei.

Hallo,

muss doch nochmal was schreiben. Nicht was wir uns wieder falsch verstehen.

Dein Projekt mit der Köttelerkennung hat eine ganz andere Wirkung auf uns gehabt.

Wie das hier dargestellte.
Wir haben den gesamten Code auch nicht gesehen, müssen wir auch nicht, aber wir sehen was aus allen Fragen und Antworten am Ende gewurden ist. Und das war toll und lustig.

Es könnte auch hier lustig sein, und will auch keinen Schwanzvergleich starten... :slight_smile:

Es würde mich wundern, wenn bisher nicht mindestens einer überlegt hat, sich die Serial-G´schichten nochmal anzuschauen, um was eigenes auf die Beine zu stellen. Ich möchte motivieren!

Aber von nichts kommt nichts.

Was soll ich mir da anschauen?

Einen zweiten Arduino einzusetzen, damit beim ersten mehr Pins frei sind, ist ja nicht neu. Wird ja oft genug im Zusammenhang mit ESP8266 gemacht.

Nur ist auch mir nicht ganz klar, was du mit deiner Projektvorstellung bezwecken willst. Anfängern machst du nur eine lange Nase und die Fortgeschrittenen und Profis, die dir in der Vergangenheit hier deine Fragen beantwortet haben, gefällt deine Actitud offensichtlich nicht so.

Kolbi:
Egal wie schön du es formulierst, zum Schluss bleibt nur "Gib mir deinen Code!" übrig, und das habe ich bereits klar und deutlich abgelehnt.
Wenn du wie Jesus leben willst, dann verschenk deinen Besitz und deine Arduinos, und verzichte aufs porgrammieren :slight_smile:

Ich mag es einfach nicht, wenn mir jemand seine Lebensweise aufdrängt.

Und ich teile sehr viel, aber meistens im richtigen Leben, wenn ich mich mit meinen Freunden treffe, und ihnen beim Programmieren lernen helfe. Hier im Forum bin ich mehr Fragesteller als Beantworter, so gleicht es sich wieder aus.

Bisher ist auch noch keine einzige konkrete Frage oder Vorschlag zu den Funktionen gekommen, was ich mir eigentlich gewünscht hatte. Da noch ein Fitzelchen Speicher übrig ist, ließen sich noch weitere Geometrien einbauen, zB Kusslippen passend zum Herz...

Lg

Ich beantrage die Löschung dieses Threads.

Schade dass hier im Forum so viele Neider sind...

Da kann ich genausogut doch einen Schwanzvergleich starten: Link

Code folgt :slight_smile:

Hier der Code für etwas Fortgeschrittene, ich benutze Voids statt einfach nur Serial.print(“befehl”), dadurch kann ich die maximale Geschwindigkeit nutzen. Wer es schafft eine Library für sein Display zu installieren, sollte auch in der Lage sein, den Code passend für seine Lib umzuschreiben. Vorausgesetzt man steht auf Penis… :slight_smile:

/*********** EasyTFT Demo ***********
*************************************
******* http://roboter.hol.es *******
*************************************
********** Happy hacking! ***********


HERZLICH WILLKOMMEN ZUM EASYTFT-DEMO!
*************************************

EasyTFT +  an  Arduino 5V
EasyTFT -  an  Arduino GND
EasyTFT D  an  Arduino TX

*/
// Hier richten wir ein Paar Variablen (Speicherplätze auf dem Arduino-Chip) ein, die wir im Code brauchen:
int x; // X-Position
int y; // Y-Position
int g; // Größe
int l; // Länge


// Wenn der Arduino mit Strom versorgt wird, startet zuerst das "setup()"
void setup() { // Setup Start
  Serial.begin(115200); // Verbindung zu EasyTFT aufbauen
  tft("Schwarz"); // EasyTFT Logo löschen, schwarzer Hintergrund
} // Setup Ende


// Jetzt geht es hier bei "loop()" weiter, und wiederholt diesen immer und immer wieder:

void loop() { // Loop Start
  
  // Zuerst wählen wir eine zufällige Farbe zum Zeichnen:
  tft("zufall");
  
  // Wir zeichnen mehrere Geometrien, aber wo? Stellen wir mal eine zufällige Startposition und Werte ein:
  x = random(20,220); // Zufällige Position auf dem Display zwischen 20 und 220 Pixel (von Links nach Rechts)
  y = random(69,310); // Zufällige Position auf dem Display zwischen 69 und 320 Pixel (von Oben nach Unten)
  g = random(5,25); // Zufällige Größe zwischen 5-25
  l = random(g,g*5); // Zufällige Länge, abhängig von Größe
  // Die Startposition dient uns als Grundlage, alle Startpunkte der Geometrien beziehen sich darauf

  // Jetzt springt das Programm zum Void "figur()" und übergibt die Werte in den Klammern:
  figur(x,y,g,l);
  // Wenn das Void "figur()" abgearbeitet wurde, geht es hier weiter:
} // Loop Ende -> Programm springt zurück zu Loop Start!


// Dieses Void (Unterprogramm) erleichtert uns die Eingabe der Befehle, und erhöht die Geschwindigkeit von EasyTFT.
// Jedes mal wenn der Befehl tft(); im Programm aufgerufen wird, wird hierhergesprungen, die Werte bzw
// Befehle in den Klammern von tft() werden mitgenommen und hier dann über Serial gesendet. 
// Danach springt das Programm automatisch zurück an den Aufrufort von tft(), und arbeitet dort normal weiter.
// Diese Void kann einfach in andere Sketches kopiert werden, danach kann wieder gemütlich mit "tft()" programmiert werden
void tft(String befehlodertext) {
  Serial.print(befehlodertext); // Sendet den Befehl oder Text in den Klammern beim Aufruf von tft();
  Serial.print("\r"); // Schließt den Befehl ab, für schnellere Verarbeitung der Befehle
  delay(12); // Gibt EasyTFT kurz Zeit zum überprüfen und abarbeiten des Befehls
}


// Diese Void zeichnet die Figur. Das Void könnte noch um einiges speichersparender sein, wenn man die Befehle "punkt" und die Werteübergabe in
// ein weiters Void steckt... Eine gute Gelegenheit zum Üben ;)
void figur(int positionX, int positionY, int groesse, int laenge) {
  tft("punkt"); // "punkt" Befehl starten
  tft(String(positionX-(groesse/1.2))); // Übergibt die X-StartPosition. Reine Zahlenwerte werden einfach in den Befehl String() gesetzt
  tft(String(positionY+groesse)); // Übergibt die Y-StartPosition.
  tft(String(groesse)); // Übergibt den Radius
  // Fertig, wir haben einen "punkt" gezeichnet

  // Gleich nochmal, diesmal rechts von der Startposition:
  tft("punkt");
  tft(String(positionX+(groesse/1.2)));
  tft(String(positionY+groesse));
  tft(String(groesse));

  // Nun die Magie, wir zeichnen mehrere Punkte hintereinander, immer Einer über dem Anderen, das ergibt eine einfache aber nette Animation
  // Um einen Befehl mehrfach, aber mit sich verändernden Werten auszuführen, brauchen wir nur eine Codezeile und eine abschließende Klammer:
  for(int zaehler = 0; zaehler < laenge; zaehler+=(groesse/3)) { // Der for() Befehl startet die Schleife
    tft("punkt");
    tft(String(positionX));
    tft(String(positionY-zaehler));
    tft(String(groesse));
  } // Ende for() Schleife
}

Lg!