Forum: Mikrocontroller und Digitale Elektronik LED_Matrix mit esp32

von Wukasch D. (smd22)

11.08.2022 16:51

Lesenswert?

•

Hallo zusammen

Ich möchte eine LED Matrix 8hx32w mit einem Ws2812 Panel per esp32 
betreiben. Es sollen Zeit, Datum, Pixelbilder, Raumtemperatur(BMP280) 
etc. in Laufschrift angezeigt und mit einem Schalter soll zwischen den 
Anzeigemodi hin und her geswitched werden, auch über dabble app. Für 
Zeit und Wetter verwende ich einen ntp server. Eigentlich habe ich den 
Code so weit fertig, nur funktioniert es leider nicht so wie erwartet 
und es kommt nicht viel an der Matrix an, ausser der Smiley:) wäre 
super, wenn mir jemand einen Tipp geben könnte, woran es liegt?

Vielen Dank im Voraus!

Der Code:

// Adafruit_NeoMatrix example for single NeoPixel Shield.
// Scrolls 'Howdy' across the matrix in a portrait (vertical) 
orientation.
#define CUSTOM_SETTINGS
#define INCLUDE_DABBLEINPUTS_MODULE       //choose dabble ble 
sowftware's input module
#include <DabbleESP32.h>                  //dabble headers
unsigned long lasttime = 0;

#include <Adafruit_GFX.h>                 //GFX libraries for matrix
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#include <WiFi.h>                         //wlan libraries
#include <Wire.h>                         //bme bmp sensor needs this
#include <SPI.h>                          //bme bmp sensor needs this
#include <Adafruit_BMP280.h>              //BMP sensor library

// Choose your prefered pixmap            // every h file shows 
different bmp
//#include "heart24.h"
//#include "yellowsmiley24.h"
//#include "bluesmiley24.h"
#include "smileytongue24.h"

#ifdef ESP8266                            //ESP8266 needs it
#define PIN RX
#endif

#define PIN 17                            //matrix data pin

//#define P32BY8X4
#define P16BY16X4

#if defined(P32BY8X4) || defined(P16BY16X4)
#define BM32
#endif
#ifdef BM32
#include "google32.h"                     //google logo bmp header
// Anything with black does not look so good with the naked eye (better 
on pictures)
//#include "linux32.h"                    //linux logo(tux)
#endif

#ifdef P32BY8X4                           //this is not relevant
// Define full matrix width and height.
#define mw 32
#define mh 8
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(mw, mh, PIN,   //matrix 
definition
                            NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
                            NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG,
                            NEO_GRB            + NEO_KHZ800);
#elif defined(P16BY16X4)                //this is our matrix
#define mw 32                           //width
#define mh 16                           //height
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(32, 16, PIN,  //matrix 
definition
                            NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
                            NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG,
                            NEO_GRB            + NEO_KHZ800);
#else
// Define matrix width and height.
#define mw 16
#define mh 16

Adafruit_NeoMatrix *matrix = new Adafruit_NeoMatrix(mw, mh,
    PIN,
    NEO_MATRIX_TOP     + NEO_MATRIX_RIGHT +
    NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB            + NEO_KHZ800 );
#endif


#define BMP_SCK  (27)               //bme bmp screen pin defines
#define BMP_MISO (33)
#define BMP_MOSI (26)
#define BMP_CS   (25)

//Adafruit_BMP280 bmp;              // I2C
//Adafruit_BMP280 bmp(BMP_CS);      // hardware SPI
Adafruit_BMP280 bmp(BMP_CS, BMP_MOSI, BMP_MISO,  BMP_SCK);  // software 
spi

#include "time.h"                   //time headers

const char* ssid     = "SSID";    //wlan
const char* password = "Passwort";   //wlan

const char* ntpServer = "pool.ntp.org";   //ntp server address
const long  gmtOffset_sec = 0;
const int   daylightOffset_sec = 3600;

#ifndef PSTR
#define PSTR // Make Arduino Due happy
#endif
static const uint16_t PROGMEM
// These bitmaps were written for a backend that only supported
// 4 bits per color with Blue/Green/Red ordering while neomatrix
// uses native 565 color mapping as RGB.
// I'm leaving the arrays as is because it's easier to read
// which color is what when separated on a 4bit boundary
// The demo code will modify the arrays at runtime to be compatible
// with the neomatrix color ordering and bit depth.
RGB_bmp[][64] = {
  // 00: blue, blue/red, red, red/green, green, green/blue, blue, white
  { 0x100, 0x200, 0x300, 0x400, 0x600, 0x800, 0xA00, 0xF00,
    0x101, 0x202, 0x303, 0x404, 0x606, 0x808, 0xA0A, 0xF0F,
    0x001, 0x002, 0x003, 0x004, 0x006, 0x008, 0x00A, 0x00F,
    0x011, 0x022, 0x033, 0x044, 0x066, 0x088, 0x0AA, 0x0FF,
    0x010, 0x020, 0x030, 0x040, 0x060, 0x080, 0x0A0, 0x0F0,
    0x110, 0x220, 0x330, 0x440, 0x660, 0x880, 0xAA0, 0xFF0,
    0x100, 0x200, 0x300, 0x400, 0x600, 0x800, 0xA00, 0xF00,
    0x111, 0x222, 0x333, 0x444, 0x666, 0x888, 0xAAA, 0xFFF,
  },

  // 01: grey to white
  { 0x111, 0x222, 0x333, 0x555, 0x777, 0x999, 0xAAA, 0xFFF,
    0x222, 0x222, 0x333, 0x555, 0x777, 0x999, 0xAAA, 0xFFF,
    0x333, 0x333, 0x333, 0x555, 0x777, 0x999, 0xAAA, 0xFFF,
    0x555, 0x555, 0x555, 0x555, 0x777, 0x999, 0xAAA, 0xFFF,
    0x777, 0x777, 0x777, 0x777, 0x777, 0x999, 0xAAA, 0xFFF,
    0x999, 0x999, 0x999, 0x999, 0x999, 0x999, 0xAAA, 0xFFF,
    0xAAA, 0xAAA, 0xAAA, 0xAAA, 0xAAA, 0xAAA, 0xAAA, 0xFFF,
    0xFFF, 0xFFF, 0xFFF, 0xFFF, 0xFFF, 0xFFF, 0xFFF, 0xFFF,
  },

  // 02: low red to high red
  { 0x001, 0x002, 0x003, 0x005, 0x007, 0x009, 0x00A, 0x00F,
    0x002, 0x002, 0x003, 0x005, 0x007, 0x009, 0x00A, 0x00F,
    0x003, 0x003, 0x003, 0x005, 0x007, 0x009, 0x00A, 0x00F,
    0x005, 0x005, 0x005, 0x005, 0x007, 0x009, 0x00A, 0x00F,
    0x007, 0x007, 0x007, 0x007, 0x007, 0x009, 0x00A, 0x00F,
    0x009, 0x009, 0x009, 0x009, 0x009, 0x009, 0x00A, 0x00F,
    0x00A, 0x00A, 0x00A, 0x00A, 0x00A, 0x00A, 0x00A, 0x00F,
    0x00F, 0x00F, 0x00F, 0x00F, 0x00F, 0x00F, 0x00F, 0x00F,
  },

  // 03: low green to high green
  { 0x010, 0x020, 0x030, 0x050, 0x070, 0x090, 0x0A0, 0x0F0,
    0x020, 0x020, 0x030, 0x050, 0x070, 0x090, 0x0A0, 0x0F0,
    0x030, 0x030, 0x030, 0x050, 0x070, 0x090, 0x0A0, 0x0F0,
    0x050, 0x050, 0x050, 0x050, 0x070, 0x090, 0x0A0, 0x0F0,
    0x070, 0x070, 0x070, 0x070, 0x070, 0x090, 0x0A0, 0x0F0,
    0x090, 0x090, 0x090, 0x090, 0x090, 0x090, 0x0A0, 0x0F0,
    0x0A0, 0x0A0, 0x0A0, 0x0A0, 0x0A0, 0x0A0, 0x0A0, 0x0F0,
    0x0F0, 0x0F0, 0x0F0, 0x0F0, 0x0F0, 0x0F0, 0x0F0, 0x0F0,
  },

  // 04: low blue to high blue
  { 0x100, 0x200, 0x300, 0x500, 0x700, 0x900, 0xA00, 0xF00,
    0x200, 0x200, 0x300, 0x500, 0x700, 0x900, 0xA00, 0xF00,
    0x300, 0x300, 0x300, 0x500, 0x700, 0x900, 0xA00, 0xF00,
    0x500, 0x500, 0x500, 0x500, 0x700, 0x900, 0xA00, 0xF00,
    0x700, 0x700, 0x700, 0x700, 0x700, 0x900, 0xA00, 0xF00,
    0x900, 0x900, 0x900, 0x900, 0x900, 0x900, 0xA00, 0xF00,
    0xA00, 0xA00, 0xA00, 0xA00, 0xA00, 0xA00, 0xA00, 0xF00,
    0xF00, 0xF00, 0xF00, 0xF00, 0xF00, 0xF00, 0xF00, 0xF00,
  },

  // 05: 1 black, 2R, 2O, 2G, 1B with 4 blue lines rising right
  { 0x000, 0x200, 0x000, 0x400, 0x000, 0x800, 0x000, 0xF00,
    0x000, 0x201, 0x002, 0x403, 0x004, 0x805, 0x006, 0xF07,
    0x008, 0x209, 0x00A, 0x40B, 0x00C, 0x80D, 0x00E, 0xF0F,
    0x000, 0x211, 0x022, 0x433, 0x044, 0x855, 0x066, 0xF77,
    0x088, 0x299, 0x0AA, 0x4BB, 0x0CC, 0x8DD, 0x0EE, 0xFFF,
    0x000, 0x210, 0x020, 0x430, 0x040, 0x850, 0x060, 0xF70,
    0x080, 0x290, 0x0A0, 0x4B0, 0x0C0, 0x8D0, 0x0E0, 0xFF0,
    0x000, 0x200, 0x000, 0x500, 0x000, 0x800, 0x000, 0xF00,
  },

  // 06: 4 lines of increasing red and then green
  { 0x000, 0x000, 0x001, 0x001, 0x002, 0x002, 0x003, 0x003,
    0x004, 0x004, 0x005, 0x005, 0x006, 0x006, 0x007, 0x007,
    0x008, 0x008, 0x009, 0x009, 0x00A, 0x00A, 0x00B, 0x00B,
    0x00C, 0x00C, 0x00D, 0x00D, 0x00E, 0x00E, 0x00F, 0x00F,
    0x000, 0x000, 0x010, 0x010, 0x020, 0x020, 0x030, 0x030,
    0x040, 0x040, 0x050, 0x050, 0x060, 0x060, 0x070, 0x070,
    0x080, 0x080, 0x090, 0x090, 0x0A0, 0x0A0, 0x0B0, 0x0B0,
    0x0C0, 0x0C0, 0x0D0, 0x0D0, 0x0E0, 0x0E0, 0x0F0, 0x0F0,
  },

  // 07: 4 lines of increasing red and then blue
  { 0x000, 0x000, 0x001, 0x001, 0x002, 0x002, 0x003, 0x003,
    0x004, 0x004, 0x005, 0x005, 0x006, 0x006, 0x007, 0x007,
    0x008, 0x008, 0x009, 0x009, 0x00A, 0x00A, 0x00B, 0x00B,
    0x00C, 0x00C, 0x00D, 0x00D, 0x00E, 0x00E, 0x00F, 0x00F,
    0x000, 0x000, 0x100, 0x100, 0x200, 0x200, 0x300, 0x300,
    0x400, 0x400, 0x500, 0x500, 0x600, 0x600, 0x700, 0x700,
    0x800, 0x800, 0x900, 0x900, 0xA00, 0xA00, 0xB00, 0xB00,
    0xC00, 0xC00, 0xD00, 0xD00, 0xE00, 0xE00, 0xF00, 0xF00,
  },

  // 08: criss cross of green and red with diagonal blue.
  { 0xF00, 0x001, 0x003, 0x005, 0x007, 0x00A, 0x00F, 0x000,
    0x020, 0xF21, 0x023, 0x025, 0x027, 0x02A, 0x02F, 0x020,
    0x040, 0x041, 0xF43, 0x045, 0x047, 0x04A, 0x04F, 0x040,
    0x060, 0x061, 0x063, 0xF65, 0x067, 0x06A, 0x06F, 0x060,
    0x080, 0x081, 0x083, 0x085, 0xF87, 0x08A, 0x08F, 0x080,
    0x0A0, 0x0A1, 0x0A3, 0x0A5, 0x0A7, 0xFAA, 0x0AF, 0x0A0,
    0x0F0, 0x0F1, 0x0F3, 0x0F5, 0x0F7, 0x0FA, 0xFFF, 0x0F0,
    0x000, 0x001, 0x003, 0x005, 0x007, 0x00A, 0x00F, 0xF00,
  },

  // 09: 2 lines of green, 2 red, 2 orange, 2 green
  { 0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
    0x0F0, 0x0F0, 0x0FF, 0x0FF, 0x00F, 0x00F, 0x0F0, 0x0F0,
  },

  // 10: multicolor smiley face
  { 0x000, 0x000, 0x00F, 0x00F, 0x00F, 0x00F, 0x000, 0x000,
    0x000, 0x00F, 0x000, 0x000, 0x000, 0x000, 0x00F, 0x000,
    0x00F, 0x000, 0xF00, 0x000, 0x000, 0xF00, 0x000, 0x00F,
    0x00F, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x00F,
    0x00F, 0x000, 0x0F0, 0x000, 0x000, 0x0F0, 0x000, 0x00F,
    0x00F, 0x000, 0x000, 0x0F4, 0x0F3, 0x000, 0x000, 0x00F,
    0x000, 0x00F, 0x000, 0x000, 0x000, 0x000, 0x00F, 0x000,
    0x000, 0x000, 0x00F, 0x00F, 0x00F, 0x00F, 0x000, 0x000,
  },
};




const uint16_t colors[] = {
  matrix.Color(255, 0, 0), matrix.Color(0, 255, 0), matrix.Color(0, 0, 
255)
};


int pixelPerChar = 6;
int maxDisplacement;
int mode = 0;
int brthns = 10;
char page = 0, show_color = 0;

int y = matrix.height();
int x = matrix.width();
int pass = 0;
int line_pass = 0;
char i = 0, j, k ;
char screen[10];
signed int IndexX = 0, IndexY = 2;
typedef enum {
  ToLeft = 0,
  ToRight
} SlipDir_;
SlipDir_ SlipDir = ToLeft;

typedef enum {                      //modus define struct
  DATE = 0,
  CALENDAR,
  ALARM,
  WEATHER,
  TEMPRATURE,
  ALTITUDE,
  PRESSURE,
  ANIMATION

} STATE_;
STATE_ state = DATE;
char str_temp[50] = "TEMP";
int count = 0;
struct tm timeinfo;
float temp, pres, alt;
void setup() {
  pinMode(12, INPUT_PULLUP);                  //pin 12 pullup enable
  attachInterrupt(12, int1, RISING);          //pin 12 interrupt enable
  Serial.begin(115200);                          //serial port enable 
@115200 bps
  Dabble.begin("MyEsp32");                       //bluetooth enabel & 
set bluetooth name of your device
  unsigned status;                                //bmp sensor's 
received status variable
  status = bmp.begin();
  if (!status) {                                //if bmp not recognized
    Serial.println(F("Could not find BMP280"));
    Serial.print(F("SensorID:0x")); Serial.println(bmp.sensorID(), 16);

    while (1) delay(10);
  }

  /* Default settings from datasheet. */
  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,     /* Operating Mode. 
*/
                  Adafruit_BMP280::SAMPLING_X2,     /* Temp. 
oversampling */
                  Adafruit_BMP280::SAMPLING_X16,    /* Pressure 
oversampling */
                  Adafruit_BMP280::FILTER_X16,      /* Filtering. */
                  Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */

  WiFi.begin(ssid, password);                       //start wifi
  while (WiFi.status() != WL_CONNECTED) {         //until connect delay 
500 ms and push . to uart
    delay(500);
    Serial.print(".");
  }
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);   //get time 
from ntp server
  printLocalTime();                                           //print 
time to uart (disabled)

  //disconnect WiFi as it's no longer needed
  WiFi.disconnect(true);                                      //close 
wifi if open because we are done with ntp
  WiFi.mode(WIFI_OFF);                                        //mode 
select
  matrix.begin();                                             //enable 
matrix
  matrix.setTextWrap(false);                                  //disable 
text wrap
  matrix.setBrightness(10);
  matrix.setTextColor(colors[0]);                             //first 
text color

  int1();                                                     //run 
interrupt rutine to load status machine

}
unsigned char btn = 0;
void loop() {
  Dabble.processInput();                                      //dabble 
process
  btn = Inputs.getTactileSwitch1Value();                      //get 
phone software button state
  if (btn == 1) {                                             //if 
pressed run interrupt routine
    int1();
    delay(50);                                                //software 
debounce delay

  }
  brthns = Inputs.getPot1Value() >> 2;                        // get 
rotary pot value from phone
  if (brthns < 1) brthns = 5;                                 // set 
brigthnes, but if brghnts lower than 1, set 5, because if 0 there is no 
display
  matrix.setBrightness(brthns * 2);                           // 
brightness can be set 0-255, we get from 0-100 from phone, normally we 
multiple with 2.55 to convert, but 2 is enough

  if (state == ANIMATION) {                                   //check 
state machine,

#ifdef BM32
    if (state == ANIMATION) display_panOrBounceBitmap(32);    //show 
first bmp animation (google logo or linux logo)
#endif
    // pan a big pixmap
    if (state == ANIMATION) display_panOrBounceBitmap(24);    //shoe bmp 
second animation
    // bounce around a small one
    if (state == ANIMATION) display_panOrBounceBitmap(8);     //show 
last animation
    int1();                                                   //run 
interrupt routine and take the state machine next position
  } else {                                                     //if 
state is not ANIMATION
    matrix.clear();                                           //clear 
matric
    matrix.fillScreen(0);                                     //clear 
colors
    matrix.setCursor(x, 2);                                   //set 
cursor to y 2
    matrix.print(str_temp);                                   //str_temp 
loading in int1() routine,

    if (--x < -100) {                                         //this is 
shifting routine, when x reaches to -100, take back to 0
      if (++pass >= 3) pass = 0;
      matrix.setTextColor(colors[pass]);
    }
    matrix.show();                                            //show 
matrix
  }


  if (count++ > 49 ) {                                          //every 
50 loop, print sensor values to uart, its for debugging
    temp = bmp.readTemperature();
    pres = bmp.readPressure();
    alt = bmp.readAltitude(1013.25);

    Serial.print(F("Temperature = "));
    Serial.print(temp);
    Serial.println(F(" *C"));

    Serial.print(F("Pressure = "));
    Serial.print(pres);
    Serial.println(F(" Pa"));

    Serial.print(F("Approx altitude = "));
    Serial.print(alt);
    Serial.println(F(" m"));

    Serial.print(F("Brightness = "));
    Serial.print(brthns);

    Serial.print(F("Button = "));
    Serial.print(btn);
    Serial.println();

    printLocalTime();
    count = 0;



  }


  delay(75); 
//shifting time
}

void printLocalTime() {                                         //print 
time information to uart, disabled

  if (!getLocalTime(&timeinfo)) {
    Serial.println(F("Failed"));
    return;
  }
  /*  Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
    Serial.print("Day of week: ");
    Serial.println(&timeinfo, "%A");
    Serial.print("Month: ");
    Serial.println(&timeinfo, "%B");
    Serial.print("Day of Month: ");
    Serial.println(&timeinfo, "%d");
    Serial.print("Year: ");
    Serial.println(&timeinfo, "%Y");
    Serial.print("Hour: ");
    Serial.println(&timeinfo, "%H");
    Serial.print("Hour (12 hour format): ");
    Serial.println(&timeinfo, "%I");
    Serial.print("Minute: ");
    Serial.println(&timeinfo, "%M");
    Serial.print("Second: ");
    Serial.println(&timeinfo, "%S");

    Serial.println("Time variables");
    char timeHour[3];
    strftime(timeHour,3, "%H", &timeinfo);
    Serial.println(timeHour);
    char timeWeekDay[10];
    strftime(timeWeekDay,10, "%A", &timeinfo);
    Serial.println(timeWeekDay);
    Serial.println();*/
}
void int1(void) { 
//interrupt routine, runs every tact pushed, and every phone button 
pushed
  //delay(200);
  IndexX = 0;
  switch (state) {
    case DATE:
      strftime(str_temp, sizeof(str_temp), "DATE:%d.%m.%Y %H:%M", 
&timeinfo); //load str_temp with date information,
      state = TEMPRATURE; 
//go to n ext state
      break;
    /*
      case CALENDAR:

      state = ALARM;
      break;
      case ALARM:
      strftime(str_temp,sizeof(str_temp),"TIME:%H.%M",&timeinfo);
      state = WEATHER;
      break;
      case WEATHER:
      state = TEMPRATURE;
      break;*/

    case TEMPRATURE: 
//load str with temprature information, 02.1f --> even if temp is 5 
degree, it prints 05.0
      sprintf(str_temp, "TEMP:%02.1f", temp);
      state = ALTITUDE;
      break;
    case ALTITUDE:
      sprintf(str_temp, "ALTITUDE:%02.02f", alt); 
//load str with altitude information, 02.1f --> even if temp is 5 
degree, it prints 05.0
      state = PRESSURE;
      break;
    case PRESSURE:
      sprintf(str_temp, "PRESSURE:%02.1f", pres);
      state = ANIMATION;
      break;
    case ANIMATION:
      strftime(str_temp, sizeof(str_temp), "DATE:%d.%m.%Y %H:%M", 
&timeinfo);
      state = DATE;
      break;

    default: break;
  }
  Serial.print(F("State = ")); 
//print state to uart, for debugging
  Serial.println(state);
}

void display_panOrBounceBitmap (uint8_t bitmapSize) { 
//This is ready library from examples, not written by me
  // keep integer math, deal with values 16 times too big
  // start by showing upper left of big bitmap or centering if the 
display is big
  int16_t xf = max(0, (mw - bitmapSize) / 2) << 4;
  int16_t yf = max(0, (mh - bitmapSize) / 2) << 4;
  // scroll speed in 1/16th
  int16_t xfc = 6;
  int16_t yfc = 3;
  // scroll down and right by moving upper left corner off screen
  // more up and left (which means negative numbers)
  int16_t xfdir = -1;
  int16_t yfdir = -1;

  for (uint16_t i = 1; i < 200; i++) {
    bool updDir = false;

    // Get actual x/y by dividing by 16.
    int16_t x = xf >> 4;
    int16_t y = yf >> 4;

    matrix.clear();
    // bounce 8x8 tri color smiley face around the screen
    if (bitmapSize == 8) fixdrawRGBBitmap(x, y, RGB_bmp[10], 8, 8);
    // pan 24x24 pixmap
    if (bitmapSize == 24) matrix.drawRGBBitmap(x, y, (const uint16_t *) 
bitmap24, bitmapSize, bitmapSize);
#ifdef BM32
    if (bitmapSize == 32) matrix.drawRGBBitmap(x, y, (const uint16_t *) 
bitmap32, bitmapSize, bitmapSize);
#endif
    matrix.show();

    // Only pan if the display size is smaller than the pixmap
    // but not if the difference is too small or it'll look bad.
    if (bitmapSize - mw > 2) {
      xf += xfc * xfdir;
      if (xf >= 0)                      {
        xfdir = -1;
        updDir = true ;
      };
      // we don't go negative past right corner, go back positive
      if (xf <= ((mw - bitmapSize) << 4)) {
        xfdir = 1;
        updDir = true ;
      };
    }
    if (bitmapSize - mh > 2) {
      yf += yfc * yfdir;
      // we shouldn't display past left corner, reverse direction.
      if (yf >= 0)                      {
        yfdir = -1;
        updDir = true ;
      };
      if (yf <= ((mh - bitmapSize) << 4)) {
        yfdir = 1;
        updDir = true ;
      };
    }
    // only bounce a pixmap if it's smaller than the display size
    if (mw > bitmapSize) {
      xf += xfc * xfdir;
      // Deal with bouncing off the 'walls'
      if (xf >= (mw - bitmapSize) << 4) {
        xfdir = -1;
        updDir = true ;
      };
      if (xf <= 0)           {
        xfdir =  1;
        updDir = true ;
      };
    }
    if (mh > bitmapSize) {
      yf += yfc * yfdir;
      if (yf >= (mh - bitmapSize) << 4) {
        yfdir = -1;
        updDir = true ;
      };
      if (yf <= 0)           {
        yfdir =  1;
        updDir = true ;
      };
    }

    if (updDir) {
      // Add -1, 0 or 1 but bind result to 1 to 1.
      // Let's take 3 is a minimum speed, otherwise it's too slow.
      xfc = constrain(xfc + random(-1, 2), 3, 16);
      yfc = constrain(xfc + random(-1, 2), 3, 16);
    }
    delay(10);
  }
}
void fixdrawRGBBitmap(int16_t x, int16_t y, const uint16_t *bitmap, 
int16_t w, int16_t h) {     //This is ready library from examples, not 
written by me
  // work around "a15 cannot be used in asm here" compiler bug when 
using an array on ESP8266
  // uint16_t RGB_bmp_fixed[w * h];
  static uint16_t *RGB_bmp_fixed = (uint16_t *) malloc( w  h  2);
  for (uint16_t pixel = 0; pixel < w * h; pixel++) {
    uint8_t r, g, b;
    uint16_t color = pgm_read_word(bitmap + pixel);

    //Serial.print(color, HEX);
    b = (color & 0xF00) >> 8;
    g = (color & 0x0F0) >> 4;
    r = color & 0x00F;
    //Serial.print(" ");
    //Serial.print(b);
    //Serial.print("/");
    //Serial.print(g);
    //Serial.print("/");
    //Serial.print(r);
    //Serial.print(" -> ");
    // expand from 4/4/4 bits per color to 5/6/5
    b = map(b, 0, 15, 0, 31);
    g = map(g, 0, 15, 0, 63);
    r = map(r, 0, 15, 0, 31);
    //Serial.print(r);
    //Serial.print("/");
    //Serial.print(g);
    //Serial.print("/");
    //Serial.print(b);
    RGB_bmp_fixed[pixel] = (r << 11) + (g << 5) + b;
    //Serial.print(" -> ");
    //Serial.println(RGB_bmp_fixed[pixel], HEX);
  }
  matrix.drawRGBBitmap(x, y, RGB_bmp_fixed, w, h);
}

11.08.2022 17:03: Bearbeitet durch User

Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mir esp32

von Markus M. (adrock)

11.08.2022 17:04

Lesenswert?

•

▲
▼

Du solltest Deinen Code nochmal neu strukturieren. Das ist kompletter 
"copy & paste" Spaghetticode.

Die globalen (wenn es denn sein muss) Variablendefinitionen gehören alle 
an Anfang (hinter die #define Sektion). Auch die Funktionsdeklarationen.

Normalerweise sollte es so sein:

- Includes
- Defines
- Funktionsdeklarationen
- Globale Variablen
- Main (Code)
- Funktionen (Code)

Davon abgesehen, soll es nun 32x16 oder 32x8 sein? In Deinem Code hast 
Du jedenfalls 32x16 definiert:

#elif defined(P16BY16X4)                //this is our matrix
#define mw 32                           //width
#define mh 16                           //height
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(32, 16, PIN,   //matrix


Mit #define definierte Konstanten schreibt man normalweise per 
Konvention GROSS.

11.08.2022 17:05: Bearbeitet durch User

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von Martin (Gast)

11.08.2022 22:10

Lesenswert?

•

▲
▼

Setz den Code mal in Tags, dann kann man den auch direkt lesen.

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von J. S. (jojos)

11.08.2022 22:23

Lesenswert?

•

▲
▼

Martin schrieb:
> Setz den Code mal in Tags, dann kann man den auch direkt lesen.

Nein, als Anhang hochladen wie es fett gedruckt im Hinweis steht.
Wollte helfen, habe mir beim scrollen aber den Finger verstaucht.

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von Wukasch D. (smd22)

12.08.2022 00:27

Lesenswert?

•

▲
▼

Hallo

Habe es etwas entrümpelt, hoffe es ist nun besser lesbar.

#define CUSTOM_SETTINGS
#define INCLUDE_DABBLEINPUTS_MODULE       //choose dabble ble sowftware's input module
#include <DabbleESP32.h>                  //dabble headers
unsigned long lasttime = 0;
#include <Adafruit_GFX.h>                 //GFX libraries for matrix
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>
#include <WiFi.h>                         //wlan libraries
#include <Wire.h>                         //bme bmp sensor needs this
#include <SPI.h>                          //bme bmp sensor needs this
#include <Adafruit_BMP280.h>              //BMP sensor library
#include "smileytongue24.h"
#ifdef ESP8266                            //ESP8266 needs it
#define PIN RX
#include "headers.h" 
#define PIN 17                            //matrix data pin
#include "google32.h"                     //google logo bmp header 
#define MW 32
#define MH 8
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(MW, MH, PIN,   //matrix definition
                            NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
                            NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG,
                            NEO_GRB            + NEO_KHZ800);
#define BMP_SCK  (27)               //bme bmp screen pin defines
#define BMP_MISO (33)
#define BMP_MOSI (26)
#define BMP_CS   (25)
Adafruit_BMP280 bmp(BMP_CS, BMP_MOSI, BMP_MISO,  BMP_SCK);  // software spi
#include "time.h"                   //time headers
const char* ssid     = "SSID";    //wlan
const char* password = "PASSWORT";   //wlan
const char* ntpServer = "pool.ntp.org";   //ntp server address
const long  gmtOffset_sec = 0;
const int   daylightOffset_sec = 3600;
const uint16_t colors[] = {
  matrix.Color(255, 0, 0), matrix.Color(0, 255, 0), matrix.Color(0, 0, 255)
int pixelPerChar = 6;
int maxDisplacement;
int mode = 0;
int brthns = 10;
char page = 0, show_color = 0;
int y = matrix.height();
int x = matrix.width();
int pass = 0;
int line_pass = 0;
char i = 0, j, k ;
char screen[10];
signed int IndexX = 0, IndexY = 2;
typedef enum {
  ToLeft = 0,
  ToRight
} SlipDir_;
SlipDir_ SlipDir = ToLeft;
typedef enum {                      //modus define struct
  DATE = 0,
  CALENDAR,
  ALARM,
  WEATHER,
  TEMPRATURE,
  ALTITUDE,
  PRESSURE,
  ANIMATION
} STATE_;
STATE_ state = DATE;
char str_temp[50] = "TEMP";
int count = 0;
struct tm timeinfo;
float temp, pres, alt;
void setup() {
  pinMode(12, INPUT_PULLUP);                  //pin 12 pullup enable
  attachInterrupt(12, int1, RISING);          //pin 12 interrupt enable
  Serial.begin(115200);                          //serial port enable @115200 bps
  Dabble.begin("MyEsp32");                       //bluetooth enabel & set bluetooth name of your device
  unsigned status;                                //bmp sensor's received status variable
  status = bmp.begin();
  if (!status) {                                //if bmp not recognized
    Serial.println(F("Could not find BMP280"));
    Serial.print(F("SensorID:0x")); Serial.println(bmp.sensorID(), 16);
    while (1) delay(10);
  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,     /* Operating Mode. */
                  Adafruit_BMP280::SAMPLING_X2,     /* Temp. oversampling */
                  Adafruit_BMP280::SAMPLING_X16,    /* Pressure oversampling */
                  Adafruit_BMP280::FILTER_X16,      /* Filtering. */
                  Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */
  WiFi.begin(ssid, password);                       //start wifi
  while (WiFi.status() != WL_CONNECTED) {         //until connect delay 500 ms and push . to uart
    delay(500);
    Serial.print(".");
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);   //get time from ntp server
  printLocalTime();                                           //print time to uart (disabled)
  //disconnect WiFi as it's no longer needed
  WiFi.disconnect(true);                                      //close wifi if open because we are done with ntp
  WiFi.mode(WIFI_OFF);                                        //mode select
  matrix.begin();                                             //enable matrix
  matrix.setTextWrap(false);                                  //disable text wrap
  matrix.setBrightness(10);
  matrix.setTextColor(colors[0]);                             //first text color
  int1();                                                     //run interrupt rutine to load status machine
unsigned char btn = 0;
void loop() {
  Dabble.processInput();                                      //dabble process
  btn = Inputs.getTactileSwitch1Value();                      //get phone software button state
  if (btn == 1) {                                             //if pressed run interrupt routine
    int1();
    delay(50);                                                //software debounce delay
  brthns = Inputs.getPot1Value() >> 2;                        // get rotary pot value from phone
  if (brthns < 1) brthns = 5;                                 // set brigthnes, but if brghnts lower than 1, set 5, because if 0 there is no display
  matrix.setBrightness(brthns * 2);                           // brightness can be set 0-255, we get from 0-100 from phone, normally we multiple with 2.55 to convert, but 2 is enough
  if (state == ANIMATION) {                                   //check state machine,
    // pan a big pixmap
    if (state == ANIMATION) display_panOrBounceBitmap(24);    //shoe bmp second animation
    // bounce around a small one
    if (state == ANIMATION) display_panOrBounceBitmap(8);     //show last animation
    int1();                                                   //run interrupt routine and take the state machine next position
  } else {                                                     //if state is not ANIMATION
    matrix.clear();                                           //clear matric
    matrix.fillScreen(0);                                     //clear colors
    matrix.setCursor(x, 2);                                   //set cursor to y 2
    matrix.print(str_temp);                                   //str_temp loading in int1() routine,
    if (--x < -100) {                                         //this is shifting routine, when x reaches to -100, take back to 0
      if (++pass >= 3) pass = 0;
      matrix.setTextColor(colors[pass]);
    matrix.show();                                            //show matrix
  if (count++ > 49 ) {                                          //every 50 loop, print sensor values to uart, its for debugging
    temp = bmp.readTemperature();
    pres = bmp.readPressure();
    alt = bmp.readAltitude(1013.25);
    Serial.print(F("Temperature = "));
    Serial.print(temp);
    Serial.println(F(" *C"));
    Serial.print(F("Pressure = "));
    Serial.print(pres);
    Serial.println(F(" Pa"));
    Serial.print(F("Approx altitude = "));
    Serial.print(alt);
    Serial.println(F(" m"));
    Serial.print(F("Brightness = "));
    Serial.print(brthns);
    Serial.print(F("Button = "));
    Serial.print(btn);
    Serial.println();
    printLocalTime();
    count = 0;
  delay(75);                                                    //shifting time
void printLocalTime() {                                         //print time information to uart, disabled
  if (!getLocalTime(&timeinfo)) {
    Serial.println(F("Failed"));
    return;
void int1(void) {                                                           //interrupt routine, runs every tact pushed, and every phone button pushed
  //delay(200);
  IndexX = 0;
  switch (state) {
    case DATE:
      strftime(str_temp, sizeof(str_temp), "DATE:%d.%m.%Y %H:%M", &timeinfo); //load str_temp with date information,
      state = TEMPRATURE;                                                   //go to n ext state
      break;
    case TEMPRATURE:                                                        //load str with temprature information, 02.1f --> even if temp is 5 degree, it prints 05.0
      sprintf(str_temp, "TEMP:%02.1f", temp);
      state = ALTITUDE;
      break;
    case ALTITUDE:
      sprintf(str_temp, "ALTITUDE:%02.02f", alt);                           //load str with altitude information, 02.1f --> even if temp is 5 degree, it prints 05.0
      state = PRESSURE;
      break;
    case PRESSURE:
      sprintf(str_temp, "PRESSURE:%02.1f", pres);
      state = ANIMATION;
      break;
    case ANIMATION:
      strftime(str_temp, sizeof(str_temp), "DATE:%d.%m.%Y %H:%M", &timeinfo);
      state = DATE;
      break;
    default: break;
  Serial.print(F("State = "));                                                //print state to uart, for debugging
  Serial.println(state);
void display_panOrBounceBitmap (uint8_t bitmapSize) {                       //This is ready library from examples, not written by me
  // keep integer math, deal with values 16 times too big
  // start by showing upper left of big bitmap or centering if the display is big
  int16_t xf = max(0, (MW - bitmapSize) / 2) << 4;
  int16_t yf = max(0, (MH - bitmapSize) / 2) << 4;
  // scroll speed in 1/16th
  int16_t xfc = 6;
  int16_t yfc = 3;
  // scroll down and right by moving upper left corner off screen
  // more up and left (which means negative numbers)
  int16_t xfdir = -1;
  int16_t yfdir = -1;
  for (uint16_t i = 1; i < 200; i++) {
    bool updDir = false;
    // Get actual x/y by dividing by 16.
    int16_t x = xf >> 4;
    int16_t y = yf >> 4;
    matrix.clear();
    // bounce 8x8 tri color smiley face around the screen
    if (bitmapSize == 8) fixdrawRGBBitmap(x, y, RGB_bmp[10], 8, 8);
    // pan 24x24 pixmap
    if (bitmapSize == 24) matrix.drawRGBBitmap(x, y, (const uint16_t *) bitmap24, bitmapSize, bitmapSize);
    if (bitmapSize == 32) matrix.drawRGBBitmap(x, y, (const uint16_t *) bitmap32, bitmapSize, bitmapSize);
    matrix.show();
    // Only pan if the display size is smaller than the pixmap
    // but not if the difference is too small or it'll look bad.
    if (bitmapSize - MW  > 2) {
      xf += xfc * xfdir;
        xfdir = -1;
        updDir = true ;
      // we don't go negative past right corner, go back positive
      if (xf <= ((MW - bitmapSize) << 4)) {
        xfdir = 1;
        updDir = true ;
    if (bitmapSize - MH > 2) {
      yf += yfc * yfdir;
      // we shouldn't display past left corner, reverse direction.
        yfdir = -1;
        updDir = true ;
      if (yf <= ((MH - bitmapSize) << 4)) {
        yfdir = 1;
        updDir = true ;
    // only bounce a pixmap if it's smaller than the display size
    if (MW > bitmapSize) {
      xf += xfc * xfdir;
      // Deal with bouncing off the 'walls'
      if (xf >= (MW - bitmapSize) << 4) {
        xfdir = -1;
        updDir = true ;
      if (xf <= 0)           {
        xfdir =  1;
        updDir = true ;
    if (MH > bitmapSize) {
      yf += yfc * yfdir;
      if (yf >= (MH - bitmapSize) << 4) {
        yfdir = -1;
        updDir = true ;
      if (yf <= 0)           {
        yfdir =  1;
        updDir = true ;
    if (updDir) {
      // Add -1, 0 or 1 but bind result to 1 to 1.
      // Let's take 3 is a minimum speed, otherwise it's too slow.
      xfc = constrain(xfc + random(-1, 2), 3, 16);
      yfc = constrain(xfc + random(-1, 2), 3, 16);
    delay(10);
void fixdrawRGBBitmap(int16_t x, int16_t y, const uint16_t *bitmap, int16_t w, int16_t h) {     
  //This is ready library from examples, not written by me
  // work around "a15 cannot be used in asm here" compiler bug when using an array on ESP8266
  // uint16_t RGB_bmp_fixed[w * h];
  static uint16_t *RGB_bmp_fixed = (uint16_t *) malloc( w * h * 2);
  for (uint16_t pixel = 0; pixel < w * h; pixel++) {
    uint8_t r, g, b;
    uint16_t color = pgm_read_word(bitmap + pixel);
    //Serial.print(color, HEX);
    b = (color & 0xF00) >> 8;
    g = (color & 0x0F0) >> 4;
    r = color & 0x00F;
    // expand from 4/4/4 bits per color to 5/6/5
    b = map(b, 0, 15, 0, 31);
    g = map(g, 0, 15, 0, 63);
    r = map(r, 0, 15, 0, 31);
    RGB_bmp_fixed[pixel] = (r << 11) + (g << 5) + b;
  matrix.drawRGBBitmap(x, y, RGB_bmp_fixed, w, h);

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von Joachim B. (jar)

12.08.2022 00:58

Lesenswert?

•

▲
▼

lieber TO was hast du an

J. S. schrieb:
> Nein, als Anhang hochladen wie es fett gedruckt im Hinweis steht.
> Wollte helfen, habe mir beim scrollen aber den Finger verstaucht.

nicht verstanden?

Wukasch D. schrieb:
> Habe es etwas entrümpelt, hoffe es ist nun besser lesbar.

das ist kein bisschen besser!

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von Martin (Gast)

12.08.2022 12:50

Lesenswert?

•

▲
▼

So habe ich auch keine Lust zu helfen.

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von Tom (Gast)

12.08.2022 13:01

Lesenswert?

•

▲
▼

Mir auch unverständlich warum man nicht lesen kann bevor man postet. Das 
ist sehr unübersichtlich so und werde ich ebenfalls nicht lesen
..und dann das gleich ein zweites Mal drunter zu posten..da fällt einem 
nichts mehr ein

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von Ralf G. (ralg)

12.08.2022 13:17

Lesenswert?

•

▲
▼

Wukasch D. schrieb:
> Eigentlich habe ich den
> Code so weit fertig, nur funktioniert es leider nicht so wie erwartet
> und es kommt nicht viel an der Matrix an, ausser der Smiley:) wäre
> super, wenn mir jemand einen Tipp geben könnte, woran es liegt?

Da wirst du wohl was falsch gemacht haben...

Herangehensweise:
1. Verstehen, was man da zusammenkopiert hat!
2. Alles rausschmeißen, was nicht zur Darstellung einer Bitmap gehört
3. Vergleiche mal die Arraygrößen, -anordnungen und sonstige 
'Eigenheiten' in der "smileytongue24.h" mit deinen gebastelten Bitmaps.
4. Falls nichts direkt ins Auge springt, erstmal Bitmaps mit einfarbigen 
Flächen, danach mit Streifen erstellen. Da kann man wahrscheinlich schon 
ein 'System' erkennen und danach den Fehler beheben.

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Re: LED_Matrix mit esp32

von mIstA (Gast)

13.08.2022 17:23

Lesenswert?

•

▲
▼

Wukasch D. schrieb:
> es kommt nicht viel an der Matrix an, ausser der Smiley:)

Und was kommt an der seriellen Schnittstelle an Debug-Info an?

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Thread beobachten |

Seitenaufteilung abschalten

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.

Bestehender Account

Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen

Noch kein Account? Hier anmelden.

Kontakt/Impressum – Datenschutzerklärung – Nutzungsbedingungen – Werbung auf Mikrocontroller.net