http Matrix

Guten Morgen Schwarm, Ich bin grade dabei mein Sommerprojekt zu realisieren.

Gedankenpalast: 8x8 Matrix über einen Webserver Schalten. Über einen Timer oder einen Taster wird die Ausgabe wieder gestoppt.

Material: Wemos D1 Mini Wemos Matrix LED Shield.

Problem: Auf der Matrix soll ein Bildfolge laufen. Ich habe es hinbekommen, dass die Bildfolge einmalig abläuft. Wie bekomme ich es am schlausten hin, die Bildfolge zu loopen ohne den Http Sever anzuhalten.

Schönen Sonntag

tillmann96: Wie bekomme ich es am schlausten hin, die Bildfolge zu loopen ohne den Http Sever anzuhalten.

Verzichte auf alles was blockiert.

Gruß Fips

Hallo,

kannst Du etwas genauer beschreiben was Du vorhast. Zeig uns was du bis jetzt hast.

Heinz

Rentner: Hallo,

kannst Du etwas genauer beschreiben was Du vorhast. Zeig uns was du bis jetzt hast.

Heinz

Das ist eine eher ungewöhnliche Forderung!

Derfips: Das ist eine eher ungewöhnliche Forderung!

@Fips ,

stimmt eigendlich liegt es am Fehler in Zeile 41, ist ja in 99% der Fälle so.

Gruß Heinz

Rentner: @Fips ,

stimmt eigendlich liegt es am Fehler in Zeile 41, ist ja in 99% der Fälle so.

Gruß Heinz

Zeile 42

Rentner:
Hallo,

kannst Du etwas genauer beschreiben was Du vorhast. Zeig uns was du bis jetzt hast.

Heinz

Moin!
Das ist ja hier rasend schnell!
Also zur Beschreibung.

Ich möchte auf einer LED Matrix eine Abfolge von Bildern anzeigen lassen.
Diese Abfolge soll zum einen über einen Webserver gestartet werden.
An der Matrix soll es zudem einen Schalter geben um die Bildfolge zu stoppen.
Wird der Taster nicht gedrückt, so soll nach Zeit X die Bildfolge automatisch stoppen.

Mir ist grade selber aufgefallen, dass ich wohl die delayzeiten auch noch ersetzen muss.

Als Sketch habe ich einen einen Beispiel HTTP Server von Rui Santos genommen und diesen abgewandelt.

// Load libraries
#include <ESP8266WiFi.h>
#include <WEMOS_Matrix_GFX.h>

MLED matrix(0);

// Replace with your network credentials
const char* ssid = “SSID”;
const char* password = “Passwot”;

// Set web server port number to 80
WiFiServer server(80);

// Variable to store the HTTP request
String header;

// Auxiliar variables to store the current output state
String output5State = “off”;

// Assign output variables to GPIO pins
const int output5 = 5;

// Current time
unsigned long currentTime = millis();
// Previous time
unsigned long previousTime = 0;
// Define timeout time in milliseconds (example: 2000ms = 2s)
const long timeoutTime = 2000;

static const uint8_t PROGMEM

clean_bmp =
{
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
},

dot_bmp =
{
B00000000,
B00000000,
B00000000,
B00000000,
B00011000,
B00011000,
B00000000,
B00000000
},

small_bmp =
{
B00000000,
B00000000,
B00000000,
B00100100,
B00111100,
B00011000,
B00000000,
B00000000
},

big_bmp =
{
B00000000,
B00000000,
B00100100,
B01111110,
B01111110,
B00111100,
B00011000,
B00000000
},

bigger_bmp =
{
B00000000,
B00100100,
B01111110,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000
},

max_bmp =
{
B00100100,
B01111110,
B11111111,
B11111111,
B11111111,
B11111111,
B01111110,
B00111100
};

void setup() {
Serial.begin(115200);

// Connect to Wi-Fi network with SSID and password
Serial.print(“Connecting to “);
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(”.”);
}
// Print local IP address and start web server
Serial.println("");
Serial.println(“WiFi connected.”);
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}

void loop(){
WiFiClient client = server.available(); // Listen for incoming clients

if (client) { // If a new client connects,
Serial.println(“New Client.”); // print a message out in the serial port
String currentLine = “”; // make a String to hold incoming data from the client
currentTime = millis();
previousTime = currentTime;
while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client’s connected
currentTime = millis();
if (client.available()) { // if there’s bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == ‘\n’) { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that’s the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what’s coming, then a blank line:
client.println(“HTTP/1.1 200 OK”);
client.println(“Content-type:text/html”);
client.println(“Connection: close”);
client.println();

// turns the GPIOs on and off
if (header.indexOf(“GET /5/on”) >= 0) {
Serial.println(“GPIO 5 on”);
output5State = “on”;
matrix.clear();
matrix.drawBitmap(0, 0, clean_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, dot_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, small_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, big_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, bigger_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, max_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, bigger_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, big_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, small_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, dot_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);

matrix.clear();
matrix.drawBitmap(0, 0, clean_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);}

else if (header.indexOf(“GET /5/off”) >= 0) {
Serial.println(“GPIO 5 off”);
output5State = “off”;
matrix.clear();
matrix.drawBitmap(0, 0, clean_bmp, 8, 8, LED_ON);
matrix.writeDisplay();
delay(200);
}

// Display the HTML web page
client.println("");
client.println("<meta name=“viewport” content=“width=device-width, initial-scale=1”>");
client.println("<link rel=“icon” href=“data:,”>");
// CSS to style the on/off buttons
// Feel free to change the background-color and font-size attributes to fit your preferences
client.println(“html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}”);
client.println(".button { background-color: #195B6A; border: none; color: white; padding: 16px 40px;");
client.println(“text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}”);
client.println(".button2 {background-color: #77878A;}");

// Web Page Heading
client.println(“

ESP8266 Web Server

”);

// Display current state, and ON/OFF buttons for GPIO 5
client.println(“

GPIO 5 - State " + output5State + “

”);
// If the output5State is off, it displays the ON button
if (output5State==“off”) {
client.println(”

<a href="/5/on"><button class=“button”>ON

");
} else {
client.println("

<a href="/5/off"><button class=“button button2”>OFF

");
}

client.println("");

// The HTTP response ends with another blank line
client.println();
// Break out of the while loop
break;}
else { // if you got a newline, then clear currentLine
currentLine = “”;}

}else if (c != ‘\r’) { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = “”;
// Close the connection
client.stop();
Serial.println(“Client disconnected.”);
Serial.println("");
}
}

Hallo, wie man was auf einer Matrix darstellen kann dazu gibts sicher Beispiele, ich hab mich damit noch nicht befasst, kann also sein das mein Ansatz völliger Quatsch ist.

ohne das ich das jetzt zuende gedacht habe würde ich da im ersten Ansatz mal mit einem zweidimensionalen Byte Array LED (n] (i) anfangen. Dabei stellt jede Variable (i) den Zustand einer der 8 Zeilen dar, und (n) die Bildnummer. Die Zeilen gibst Du in einer for schleife aus und den Index für n änderst du mit millis.

Amerkung die runden Klammern müssten eckige sein , das geht hier aber nicht.

Dann kann man mehrer Bilder hintereinander ablaufen lassen, oder mit einem Taster jederzeit stoppen.

Irgendwie musst Du dann das Array mit Werten füllen, das kann manuell sein , Zahlen eingeben oder mit einer Button matrix 8X8 auf einer Webseite und zusätzlich ein next Button zum absenden der Werte und für das nexte Bild. In dem Fall wirst Du dich dann noch mit Java Skript befassen müssen um die 8 Zahlenwerte für eine Seite auf dem Brauser zu berechnen. Man könnte auch die 64 button Zustände auf dem uP auswerten.

Vermutlich ahnst Du es schon es wird nicht ganz einfach. Kann aber sein das es schon was Fertiges gibt für das was macht was Du willst.

Heinz

tillmann96:
Als Sketch habe ich einen einen Beispiel HTTP Server von Rui Santos genommen und diesen abgewandelt.

Warum tu man sich das an?

Es gibt den kompfortablen Webserver, den findest du in der Arduino Ide unter Datei/Beispiele/ESP8266WebServer

Wie ich schon geschrieben hatte, verzichte auf alles was blockiert.
Auch in den Beispielen zu finden “BlinkWithoutDelay”

Gruß Fips