esp8266 – BitWise

Spectrum Analyzer Revisited

May 4, 2019February 5, 2020 paul

Encouraged by the happy ending of the Swinging Needles project, I decided to revisit an earlier audio spectrum analyzer. This time, instead of programmatically processing analog signals, I used a VS1053 plugin to let the chip do the Fourier stuff.

Before even starting to read actual frequency band values, I wanted to test my sketch by reading the plugin’s default frequency settings from VS1053’s memory. However, some of these readings made no sense at all, up to the point that I suspected a faulty chip. It took me some time to find out that the chip needs a few seconds of audio input before it will tell you something useful, even if it concerns a fixed setting like number of frequency bands.

Once the above mystery was solved, things became very straightforward. What a versatile chip this VS1053 is! While playing a 320 Kbps internet radio station, it can easily handle 14 frequency bands and let an esp8266 at 160 MHz show the results on a 128×64 Oled display.

First impression produced by the sketch below; better videos with sound (and colors?) will follow.

Here’s my esp8266 demo sketch for a basic internet radio (fixed station, no metadata, no audio buffer), just to show a 14 band spectrum analyzer on a 128×64 SH1106 Oled display. Used pins are for the rather rare Wemos D1 R1, so you’ll probably have to change them.

// Spectrum analyzer plugin demo on a 128x64 monochrome OLED display (SH1106).
// Uses the plugin's 14 default frequency bins:
// 50, 79, 126, 200, 317, 504, 800, 1270, 2016, 3200, 5080, 8063, 12800, and 20319 Hz

#include "plugin.h"  // spectrum analyzer plugin 
#include <brzo_i2c.h>
#include "SH1106Brzo.h"
#include <SPI.h>
#include <Adafruit_VS1053.h>
#include <ESP8266WiFi.h>

SH1106Brzo display(0x3c, D14, D15);      // address, SDA, SCL

#define BASE 0x1800
char* ssid     = "<your_SSID";
const char* password = "<your_WiFi_password";

const char *host = "icecast.omroep.nl";
const char *path = "/radio4-bb-mp3";
int httpPort = 80;

uint32_t val;
int waarde,piek;

uint8_t mp3buff[32];   
int loopcounter = 0;

// defines are for the old Wemos D1 R1; change these for your board 
#define VS1053_RESET   -1  // nevertheless: better connect RST pins of ESP and VS1053
#define VS1053_CS      D10 
#define VS1053_DCS     D2  labeled 'XDCS'
#define VS1053_DREQ    D9

Adafruit_VS1053 musicPlayer =  Adafruit_VS1053(VS1053_RESET, VS1053_CS, VS1053_DCS, VS1053_DREQ);

WiFiClient client;

void drawBin(int bin_nr, int waarde, int piek) {
  display.setColor(WHITE);
  display.fillRect(9 * bin_nr - 6, 63 - 2 * waarde, 6, 2 * waarde);
  display.fillRect(9 * bin_nr - 6, 63 - 2 * piek, 6, 1);
}

void setup() {
  display.init();
  display.flipScreenVertically();
  display.clear();
  Serial.begin(115200); // for debugging
  delay(5);
  if (! musicPlayer.begin()) { // initialise the music player
    while (1) delay(10);
  }
  Serial.println("VS1053 started");
  delay(1000);
  musicPlayer.applyPatch(plugin, PLUGIN_SIZE);
  delay(200);
  yield();
  musicPlayer.setVolume(50, 50);
  delay(200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  if (!client.connect(host, httpPort)) {
    return;
  }

  client.print(String("GET ") + path + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "Connection: close\r\n\r\n");
}

void loop() {
  loopcounter++;
  if (musicPlayer.readyForData()) {
    if (client.available() > 0) {
      uint8_t bytesread = client.read(mp3buff, 32);
      musicPlayer.playData(mp3buff, bytesread);
    }
  } else {
    if (loopcounter >= 2000) {  // being nice to the chip here...
      loopcounter = 0;
      musicPlayer.sciWrite(VS1053_REG_WRAMADDR, BASE + 4);
      delay(2);
      display.clear();
      for (int b = 0; b < 14; b++) {
        val = musicPlayer.sciRead(VS1053_REG_WRAM);
        delay(2);
        waarde = val & 63;
        piek = (val>>6) & 63;
        drawBin(b, waarde, piek);
      }
      display.display();
    }
  }
}

// Spectrum analyzer plugin demo on a 128x64 monochrome OLED display (SH1106).

// Uses the plugin's 14 default frequency bins:

// 50, 79, 126, 200, 317, 504, 800, 1270, 2016, 3200, 5080, 8063, 12800, and 20319 Hz

#include "plugin.h" // spectrum analyzer plugin

#include <brzo_i2c.h>

#include "SH1106Brzo.h"

#include <SPI.h>

#include <Adafruit_VS1053.h>

#include <ESP8266WiFi.h>

SH1106Brzo display(0x3c, D14, D15); // address, SDA, SCL

#define BASE 0x1800

char* ssid = "<your_SSID";

const char* password = "<your_WiFi_password";

const char *host = "icecast.omroep.nl";

const char *path = "/radio4-bb-mp3";

int httpPort = 80;

uint32_t val;

int waarde,piek;

uint8_t mp3buff[32];

int loopcounter = 0;

// defines are for the old Wemos D1 R1; change these for your board

#define VS1053_RESET -1 // nevertheless: better connect RST pins of ESP and VS1053

#define VS1053_CS D10

#define VS1053_DCS D2 labeled 'XDCS'

#define VS1053_DREQ D9

Adafruit_VS1053 musicPlayer = Adafruit_VS1053(VS1053_RESET, VS1053_CS, VS1053_DCS, VS1053_DREQ);

WiFiClient client;

void drawBin(int bin_nr, int waarde, int piek) {

display.setColor(WHITE);

display.fillRect(9 * bin_nr - 6, 63 - 2 * waarde, 6, 2 * waarde);

display.fillRect(9 * bin_nr - 6, 63 - 2 * piek, 6, 1);

}

void setup() {

display.init();

display.flipScreenVertically();

display.clear();

Serial.begin(115200); // for debugging

delay(5);

if (! musicPlayer.begin()) { // initialise the music player

while (1) delay(10);

}

Serial.println("VS1053 started");

delay(1000);

musicPlayer.applyPatch(plugin, PLUGIN_SIZE);

delay(200);

yield();

musicPlayer.setVolume(50, 50);

delay(200);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

}

if (!client.connect(host, httpPort)) {

return;

}

client.print(String("GET ") + path + " HTTP/1.1\r\n" +

"Host: " + host + "\r\n" +

"Connection: close\r\n\r\n");

}

void loop() {

loopcounter++;

if (musicPlayer.readyForData()) {

if (client.available() > 0) {

uint8_t bytesread = client.read(mp3buff, 32);

musicPlayer.playData(mp3buff, bytesread);

}

} else {

if (loopcounter >= 2000) { // being nice to the chip here...

loopcounter = 0;

musicPlayer.sciWrite(VS1053_REG_WRAMADDR, BASE + 4);

delay(2);

display.clear();

for (int b = 0; b < 14; b++) {

val = musicPlayer.sciRead(VS1053_REG_WRAM);

delay(2);

waarde = val & 63;

piek = (val>>6) & 63;

drawBin(b, waarde, piek);

}

display.display();

}

This is the content of the plugin.h file that needs to be in the directory of the sketch:

#ifndef SKIP_PLUGIN_VARNAME
PROGMEM const unsigned short plugin[] = { /* Compressed plugin */
#endif
  0x0007, 0x0001, 0x8050, 0x0006, 0x0018, 0x3613, 0x0024, 0x3e00, /*    0 */
  0x3801, 0x0000, 0x16d7, 0xf400, 0x55c0, 0x0000, 0x0c17, 0xf400, /*    8 */
  0x57c0, 0x0007, 0x9257, 0xb080, 0x0024, 0x3f00, 0x0024, 0x2000, /*   10 */
  0x0000, 0x36f0, 0x1801, 0x2800, 0x31c0, 0x0007, 0x0001, 0x805c, /*   18 */
  0x0006, 0x00d6, 0x3e12, 0xb817, 0x3e12, 0x3815, 0x3e05, 0xb814, /*   20 */
  0x3615, 0x0024, 0x0000, 0x800a, 0x3e10, 0x3801, 0x0006, 0x0000, /*   28 */
  0x3e10, 0xb803, 0x0000, 0x0303, 0x3e11, 0x3805, 0x3e11, 0xb807, /*   30 */
  0x3e14, 0x3812, 0xb884, 0x130c, 0x3410, 0x4024, 0x4112, 0x10d0, /*   38 */
  0x4010, 0x008c, 0x4010, 0x0024, 0xf400, 0x4012, 0x3000, 0x3840, /*   40 */
  0x3009, 0x3801, 0x0000, 0x0041, 0xfe02, 0x0024, 0x2900, 0x8200, /*   48 */
  0x48b2, 0x0024, 0x36f3, 0x0844, 0x6306, 0x8845, 0xae3a, 0x8840, /*   50 */
  0xbf8e, 0x8b41, 0xac32, 0xa846, 0xffc8, 0xabc7, 0x3e01, 0x7800, /*   58 */
  0xf400, 0x4480, 0x6090, 0x0024, 0x6090, 0x0024, 0xf400, 0x4015, /*   60 */
  0x3009, 0x3446, 0x3009, 0x37c7, 0x3009, 0x1800, 0x3009, 0x3844, /*   68 */
  0x48b3, 0xe1e0, 0x4882, 0x4040, 0xfeca, 0x0024, 0x5ac2, 0x0024, /*   70 */
  0x5a52, 0x0024, 0x4cc2, 0x0024, 0x48ba, 0x4040, 0x4eea, 0x4801, /*   78 */
  0x4eca, 0x9800, 0xff80, 0x1bc1, 0xf1eb, 0xe3e2, 0xf1ea, 0x184c, /*   80 */
  0x4c8b, 0xe5e4, 0x48be, 0x9804, 0x488e, 0x41c6, 0xfe82, 0x0024, /*   88 */
  0x5a8e, 0x0024, 0x525e, 0x1b85, 0x4ffe, 0x0024, 0x48b6, 0x41c6, /*   90 */
  0x4dd6, 0x48c7, 0x4df6, 0x0024, 0xf1d6, 0x0024, 0xf1d6, 0x0024, /*   98 */
  0x4eda, 0x0024, 0x0000, 0x0fc3, 0x2900, 0x8200, 0x4e82, 0x0024, /*   a0 */
  0x4084, 0x130c, 0x0006, 0x0100, 0x3440, 0x4024, 0x4010, 0x0024, /*   a8 */
  0xf400, 0x4012, 0x3200, 0x4024, 0xb132, 0x0024, 0x4214, 0x0024, /*   b0 */
  0xf224, 0x0024, 0x6230, 0x0024, 0x0001, 0x0001, 0x2800, 0x2b49, /*   b8 */
  0x0000, 0x0024, 0xf400, 0x40c2, 0x3200, 0x0024, 0xff82, 0x0024, /*   c0 */
  0x48b2, 0x0024, 0xb130, 0x0024, 0x6202, 0x0024, 0x003f, 0xf001, /*   c8 */
  0x2800, 0x2e51, 0x0000, 0x1046, 0xfe64, 0x0024, 0x48be, 0x0024, /*   d0 */
  0x2800, 0x2f40, 0x3a01, 0x8024, 0x3200, 0x0024, 0xb010, 0x0024, /*   d8 */
  0xc020, 0x0024, 0x3a00, 0x0024, 0x36f4, 0x1812, 0x36f1, 0x9807, /*   e0 */
  0x36f1, 0x1805, 0x36f0, 0x9803, 0x36f0, 0x1801, 0x3405, 0x9014, /*   e8 */
  0x36f3, 0x0024, 0x36f2, 0x1815, 0x2000, 0x0000, 0x36f2, 0x9817, /*   f0 */
  0x0007, 0x0001, 0x80c7, 0x0006, 0x01ae, 0x3e12, 0xb817, 0x3e12, /*   f8 */
  0x3815, 0x3e05, 0xb814, 0x3625, 0x0024, 0x0000, 0x800a, 0x3e10, /*  100 */
  0x7802, 0x3e10, 0xf804, 0x3e11, 0x7810, 0x3e14, 0x7813, 0x0006, /*  108 */
  0x0051, 0x3e13, 0xf80e, 0x3e13, 0x4024, 0x3009, 0x3840, 0x3009, /*  110 */
  0x3852, 0x2911, 0xf140, 0x0006, 0x06d0, 0x3100, 0x5bd2, 0x0006, /*  118 */
  0xc351, 0x3009, 0x1bc0, 0x3009, 0x0402, 0x6126, 0x0024, 0x0006, /*  120 */
  0x00d1, 0x2800, 0x4d45, 0x0000, 0x0024, 0x0006, 0x0011, 0xb882, /*  128 */
  0x184c, 0x3009, 0x3850, 0x0006, 0x0010, 0x3009, 0x3800, 0x2914, /*  130 */
  0xbec0, 0x0000, 0x1800, 0x0006, 0x0010, 0xb882, 0x0024, 0x2915, /*  138 */
  0x7ac0, 0x0000, 0x1700, 0x0000, 0x0301, 0x3900, 0x5bc0, 0x0006, /*  140 */
  0xc351, 0x3009, 0x1bd0, 0x3009, 0x0404, 0x0006, 0x0051, 0x2800, /*  148 */
  0x3d40, 0x3901, 0x0024, 0x4448, 0x0401, 0x4192, 0x0024, 0x6498, /*  150 */
  0x2401, 0x001f, 0x4001, 0x6412, 0x0024, 0x0006, 0x0011, 0x2800, /*  158 */
  0x3c91, 0x0000, 0x058e, 0x2400, 0x4c4e, 0x0000, 0x0013, 0x0006, /*  160 */
  0x0051, 0x0006, 0x1a03, 0x3100, 0x4024, 0xf212, 0x44c4, 0x4346, /*  168 */
  0x0024, 0xf400, 0x40d5, 0x3500, 0x8024, 0x612a, 0x0024, 0x0000, /*  170 */
  0x0024, 0x2800, 0x4c91, 0x0000, 0x0024, 0x3613, 0x0024, 0x3100, /*  178 */
  0x3800, 0x2915, 0x7dc0, 0xf200, 0x0024, 0x003f, 0xfec2, 0x4082, /*  180 */
  0x4411, 0x3113, 0x1bc0, 0xa122, 0x0024, 0x0000, 0x2002, 0x6124, /*  188 */
  0x2401, 0x0000, 0x1002, 0x2800, 0x4648, 0x0000, 0x0024, 0x003f, /*  190 */
  0xf802, 0x3100, 0x4024, 0xb124, 0x0024, 0x2800, 0x4c00, 0x3900, /*  198 */
  0x8024, 0x6124, 0x0024, 0x0000, 0x0802, 0x2800, 0x4888, 0x0000, /*  1a0 */
  0x0024, 0x003f, 0xfe02, 0x3100, 0x4024, 0xb124, 0x0024, 0x2800, /*  1a8 */
  0x4c00, 0x3900, 0x8024, 0x6124, 0x0024, 0x0000, 0x0402, 0x2800, /*  1b0 */
  0x4ac8, 0x0000, 0x0024, 0x003f, 0xff02, 0x3100, 0x4024, 0xb124, /*  1b8 */
  0x0024, 0x2800, 0x4c00, 0x3900, 0x8024, 0x6124, 0x0401, 0x003f, /*  1c0 */
  0xff82, 0x2800, 0x4c08, 0xb124, 0x0024, 0x3900, 0x8024, 0xb882, /*  1c8 */
  0x8c4c, 0x3830, 0x4024, 0x0006, 0x0091, 0x3904, 0xc024, 0x0006, /*  1d0 */
  0x00d1, 0x0000, 0x0013, 0x3100, 0x904c, 0x4202, 0x0024, 0x39f0, /*  1d8 */
  0x4024, 0x3100, 0x4024, 0x3c00, 0x4024, 0xf400, 0x44c1, 0x34f0, /*  1e0 */
  0x8024, 0x6126, 0x0024, 0x0006, 0x06d0, 0x2800, 0x5b98, 0x4294, /*  1e8 */
  0x0024, 0x2400, 0x5b42, 0x0000, 0x0024, 0xf400, 0x4411, 0x3123, /*  1f0 */
  0x0024, 0x3100, 0x8024, 0x4202, 0x0024, 0x4182, 0x2401, 0x0000, /*  1f8 */
  0x2002, 0x2800, 0x5b49, 0x0000, 0x0024, 0x3013, 0x184c, 0x30f0, /*  200 */
  0x7852, 0x6124, 0xb850, 0x0006, 0x0001, 0x2800, 0x55c8, 0x4088, /*  208 */
  0x44c2, 0x4224, 0x0024, 0x4122, 0x0024, 0x4122, 0x0024, 0xf400, /*  210 */
  0x4051, 0x2900, 0x7200, 0x0000, 0x5708, 0x4224, 0x0024, 0x4122, /*  218 */
  0x0024, 0x4122, 0x0024, 0x2900, 0x6780, 0xf400, 0x4051, 0x0002, /*  220 */
  0x0002, 0x3009, 0x1bd0, 0x3023, 0x1bd2, 0x30e0, 0x4024, 0x6124, /*  228 */
  0x0024, 0x0000, 0x0024, 0x2800, 0x5b48, 0x0000, 0x0024, 0x3613, /*  230 */
  0x0024, 0x3e14, 0xc024, 0x2900, 0x1700, 0x3e14, 0x0024, 0x36e3, /*  238 */
  0x008c, 0x30e0, 0x8024, 0x6822, 0x4411, 0x3123, 0x0024, 0x3900, /*  240 */
  0x4024, 0x3033, 0x0c4c, 0x0006, 0x0011, 0x6892, 0x04c2, 0xa122, /*  248 */
  0x0402, 0x6126, 0x0024, 0x0006, 0x0093, 0x2800, 0x64c1, 0x0000, /*  250 */
  0x0024, 0xb882, 0x184c, 0x3413, 0x3812, 0x0006, 0x00d2, 0x3a00, /*  258 */
  0x5bd2, 0x3300, 0x4024, 0x0000, 0x0013, 0x3c00, 0x4024, 0xf400, /*  260 */
  0x44c1, 0x34f0, 0x8024, 0x6126, 0x0024, 0x0006, 0x0111, 0x2800, /*  268 */
  0x64d8, 0x4294, 0x0024, 0x2400, 0x6482, 0x0000, 0x0024, 0x0003, /*  270 */
  0xf001, 0x3101, 0x0024, 0xb412, 0x0024, 0x0028, 0x0001, 0x2800, /*  278 */
  0x6485, 0x6144, 0x0024, 0x0004, 0x0002, 0x2800, 0x6441, 0x4422, /*  280 */
  0x0024, 0x0000, 0x1002, 0x6422, 0x0024, 0x2800, 0x6480, 0x3900, /*  288 */
  0x4024, 0x3900, 0x4024, 0x3113, 0x0c4c, 0x36f3, 0x4024, 0x36f3, /*  290 */
  0xd80e, 0x36f4, 0x5813, 0x36f1, 0x5810, 0x36f0, 0xd804, 0x36f0, /*  298 */
  0x5802, 0x3405, 0x9014, 0x36f3, 0x0024, 0x36f2, 0x1815, 0x2000, /*  2a0 */
  0x0000, 0x36f2, 0x9817, 0x0007, 0x0001, 0x1868, 0x0006, 0x000f, /*  2a8 */
  0x0032, 0x004f, 0x007e, 0x00c8, 0x013d, 0x01f8, 0x0320, 0x04f6, /*  2b0 */
  0x07e0, 0x0c80, 0x13d8, 0x1f7f, 0x3200, 0x4f5f, 0x61a8, 0x0006, /*  2b8 */
  0x8008, 0x0000, 0x0007, 0x0001, 0x819e, 0x0006, 0x0054, 0x3e12, /*  2c0 */
  0xb814, 0x0000, 0x800a, 0x3e10, 0x3801, 0x3e10, 0xb803, 0x3e11, /*  2c8 */
  0x7806, 0x3e11, 0xf813, 0x3e13, 0xf80e, 0x3e13, 0x4024, 0x3e04, /*  2d0 */
  0x7810, 0x449a, 0x0040, 0x0001, 0x0003, 0x2800, 0x70c4, 0x4036, /*  2d8 */
  0x03c1, 0x0003, 0xffc2, 0xb326, 0x0024, 0x0018, 0x0042, 0x4326, /*  2e0 */
  0x4495, 0x4024, 0x40d2, 0x0000, 0x0180, 0xa100, 0x4090, 0x0010, /*  2e8 */
  0x0fc2, 0x4204, 0x0024, 0xbc82, 0x4091, 0x459a, 0x0024, 0x0000, /*  2f0 */
  0x0054, 0x2800, 0x6fc4, 0xbd86, 0x4093, 0x2400, 0x6f85, 0xfe01, /*  2f8 */
  0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x020c, 0x5c56, 0x8a0c, 0x5e53, /*  300 */
  0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x020c, 0x5c56, 0x8a0c, 0x5e52, /*  308 */
  0x0024, 0x4cb2, 0x4405, 0x0018, 0x0044, 0x654a, 0x0024, 0x2800, /*  310 */
  0x7dc0, 0x36f4, 0x5810, 0x0007, 0x0001, 0x81c8, 0x0006, 0x0080, /*  318 */
  0x3e12, 0xb814, 0x0000, 0x800a, 0x3e10, 0x3801, 0x3e10, 0xb803, /*  320 */
  0x3e11, 0x7806, 0x3e11, 0xf813, 0x3e13, 0xf80e, 0x3e13, 0x4024, /*  328 */
  0x3e04, 0x7810, 0x449a, 0x0040, 0x0000, 0x0803, 0x2800, 0x7c84, /*  330 */
  0x30f0, 0x4024, 0x0fff, 0xfec2, 0xa020, 0x0024, 0x0fff, 0xff02, /*  338 */
  0xa122, 0x0024, 0x4036, 0x0024, 0x0000, 0x1fc2, 0xb326, 0x0024, /*  340 */
  0x0010, 0x4002, 0x4326, 0x4495, 0x4024, 0x40d2, 0x0000, 0x0180, /*  348 */
  0xa100, 0x4090, 0x0010, 0x0042, 0x4204, 0x0024, 0xbc82, 0x4091, /*  350 */
  0x459a, 0x0024, 0x0000, 0x0054, 0x2800, 0x7b84, 0xbd86, 0x4093, /*  358 */
  0x2400, 0x7b45, 0xfe01, 0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x0024, /*  360 */
  0x5c56, 0x0024, 0x5e53, 0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x0024, /*  368 */
  0x5c56, 0x0024, 0x5e52, 0x0024, 0x4cb2, 0x4405, 0x0010, 0x4004, /*  370 */
  0x654a, 0x9810, 0x0000, 0x0144, 0xa54a, 0x1bd1, 0x0006, 0x0013, /*  378 */
  0x3301, 0xc444, 0x687e, 0x2005, 0xad76, 0x8445, 0x4ed6, 0x8784, /*  380 */
  0x36f3, 0x64c2, 0xac72, 0x8785, 0x4ec2, 0xa443, 0x3009, 0x2440, /*  388 */
  0x3009, 0x2741, 0x36f3, 0xd80e, 0x36f1, 0xd813, 0x36f1, 0x5806, /*  390 */
  0x36f0, 0x9803, 0x36f0, 0x1801, 0x2000, 0x0000, 0x36f2, 0x9814, /*  398 */
  0x0007, 0x0001, 0x8208, 0x0006, 0x000e, 0x4c82, 0x0024, 0x0000, /*  3a0 */
  0x0024, 0x2000, 0x0005, 0xf5c2, 0x0024, 0x0000, 0x0980, 0x2000, /*  3a8 */
  0x0000, 0x6010, 0x0024, 0x000a, 0x0001, 0x0050,
#define PLUGIN_SIZE 950
#ifndef SKIP_PLUGIN_VARNAME
};
#endif

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

#ifndef SKIP_PLUGIN_VARNAME

PROGMEM const unsigned short plugin[] = { /* Compressed plugin */

#endif

0x0007, 0x0001, 0x8050, 0x0006, 0x0018, 0x3613, 0x0024, 0x3e00, /* 0 */

0x3801, 0x0000, 0x16d7, 0xf400, 0x55c0, 0x0000, 0x0c17, 0xf400, /* 8 */

0x57c0, 0x0007, 0x9257, 0xb080, 0x0024, 0x3f00, 0x0024, 0x2000, /* 10 */

0x0000, 0x36f0, 0x1801, 0x2800, 0x31c0, 0x0007, 0x0001, 0x805c, /* 18 */

0x0006, 0x00d6, 0x3e12, 0xb817, 0x3e12, 0x3815, 0x3e05, 0xb814, /* 20 */

0x3615, 0x0024, 0x0000, 0x800a, 0x3e10, 0x3801, 0x0006, 0x0000, /* 28 */

0x3e10, 0xb803, 0x0000, 0x0303, 0x3e11, 0x3805, 0x3e11, 0xb807, /* 30 */

0x3e14, 0x3812, 0xb884, 0x130c, 0x3410, 0x4024, 0x4112, 0x10d0, /* 38 */

0x4010, 0x008c, 0x4010, 0x0024, 0xf400, 0x4012, 0x3000, 0x3840, /* 40 */

0x3009, 0x3801, 0x0000, 0x0041, 0xfe02, 0x0024, 0x2900, 0x8200, /* 48 */

0x48b2, 0x0024, 0x36f3, 0x0844, 0x6306, 0x8845, 0xae3a, 0x8840, /* 50 */

0xbf8e, 0x8b41, 0xac32, 0xa846, 0xffc8, 0xabc7, 0x3e01, 0x7800, /* 58 */

0xf400, 0x4480, 0x6090, 0x0024, 0x6090, 0x0024, 0xf400, 0x4015, /* 60 */

0x3009, 0x3446, 0x3009, 0x37c7, 0x3009, 0x1800, 0x3009, 0x3844, /* 68 */

0x48b3, 0xe1e0, 0x4882, 0x4040, 0xfeca, 0x0024, 0x5ac2, 0x0024, /* 70 */

0x5a52, 0x0024, 0x4cc2, 0x0024, 0x48ba, 0x4040, 0x4eea, 0x4801, /* 78 */

0x4eca, 0x9800, 0xff80, 0x1bc1, 0xf1eb, 0xe3e2, 0xf1ea, 0x184c, /* 80 */

0x4c8b, 0xe5e4, 0x48be, 0x9804, 0x488e, 0x41c6, 0xfe82, 0x0024, /* 88 */

0x5a8e, 0x0024, 0x525e, 0x1b85, 0x4ffe, 0x0024, 0x48b6, 0x41c6, /* 90 */

0x4dd6, 0x48c7, 0x4df6, 0x0024, 0xf1d6, 0x0024, 0xf1d6, 0x0024, /* 98 */

0x4eda, 0x0024, 0x0000, 0x0fc3, 0x2900, 0x8200, 0x4e82, 0x0024, /* a0 */

0x4084, 0x130c, 0x0006, 0x0100, 0x3440, 0x4024, 0x4010, 0x0024, /* a8 */

0xf400, 0x4012, 0x3200, 0x4024, 0xb132, 0x0024, 0x4214, 0x0024, /* b0 */

0xf224, 0x0024, 0x6230, 0x0024, 0x0001, 0x0001, 0x2800, 0x2b49, /* b8 */

0x0000, 0x0024, 0xf400, 0x40c2, 0x3200, 0x0024, 0xff82, 0x0024, /* c0 */

0x48b2, 0x0024, 0xb130, 0x0024, 0x6202, 0x0024, 0x003f, 0xf001, /* c8 */

0x2800, 0x2e51, 0x0000, 0x1046, 0xfe64, 0x0024, 0x48be, 0x0024, /* d0 */

0x2800, 0x2f40, 0x3a01, 0x8024, 0x3200, 0x0024, 0xb010, 0x0024, /* d8 */

0xc020, 0x0024, 0x3a00, 0x0024, 0x36f4, 0x1812, 0x36f1, 0x9807, /* e0 */

0x36f1, 0x1805, 0x36f0, 0x9803, 0x36f0, 0x1801, 0x3405, 0x9014, /* e8 */

0x36f3, 0x0024, 0x36f2, 0x1815, 0x2000, 0x0000, 0x36f2, 0x9817, /* f0 */

0x0007, 0x0001, 0x80c7, 0x0006, 0x01ae, 0x3e12, 0xb817, 0x3e12, /* f8 */

0x3815, 0x3e05, 0xb814, 0x3625, 0x0024, 0x0000, 0x800a, 0x3e10, /* 100 */

0x7802, 0x3e10, 0xf804, 0x3e11, 0x7810, 0x3e14, 0x7813, 0x0006, /* 108 */

0x0051, 0x3e13, 0xf80e, 0x3e13, 0x4024, 0x3009, 0x3840, 0x3009, /* 110 */

0x3852, 0x2911, 0xf140, 0x0006, 0x06d0, 0x3100, 0x5bd2, 0x0006, /* 118 */

0xc351, 0x3009, 0x1bc0, 0x3009, 0x0402, 0x6126, 0x0024, 0x0006, /* 120 */

0x00d1, 0x2800, 0x4d45, 0x0000, 0x0024, 0x0006, 0x0011, 0xb882, /* 128 */

0x184c, 0x3009, 0x3850, 0x0006, 0x0010, 0x3009, 0x3800, 0x2914, /* 130 */

0xbec0, 0x0000, 0x1800, 0x0006, 0x0010, 0xb882, 0x0024, 0x2915, /* 138 */

0x7ac0, 0x0000, 0x1700, 0x0000, 0x0301, 0x3900, 0x5bc0, 0x0006, /* 140 */

0xc351, 0x3009, 0x1bd0, 0x3009, 0x0404, 0x0006, 0x0051, 0x2800, /* 148 */

0x3d40, 0x3901, 0x0024, 0x4448, 0x0401, 0x4192, 0x0024, 0x6498, /* 150 */

0x2401, 0x001f, 0x4001, 0x6412, 0x0024, 0x0006, 0x0011, 0x2800, /* 158 */

0x3c91, 0x0000, 0x058e, 0x2400, 0x4c4e, 0x0000, 0x0013, 0x0006, /* 160 */

0x0051, 0x0006, 0x1a03, 0x3100, 0x4024, 0xf212, 0x44c4, 0x4346, /* 168 */

0x0024, 0xf400, 0x40d5, 0x3500, 0x8024, 0x612a, 0x0024, 0x0000, /* 170 */

0x0024, 0x2800, 0x4c91, 0x0000, 0x0024, 0x3613, 0x0024, 0x3100, /* 178 */

0x3800, 0x2915, 0x7dc0, 0xf200, 0x0024, 0x003f, 0xfec2, 0x4082, /* 180 */

0x4411, 0x3113, 0x1bc0, 0xa122, 0x0024, 0x0000, 0x2002, 0x6124, /* 188 */

0x2401, 0x0000, 0x1002, 0x2800, 0x4648, 0x0000, 0x0024, 0x003f, /* 190 */

0xf802, 0x3100, 0x4024, 0xb124, 0x0024, 0x2800, 0x4c00, 0x3900, /* 198 */

0x8024, 0x6124, 0x0024, 0x0000, 0x0802, 0x2800, 0x4888, 0x0000, /* 1a0 */

0x0024, 0x003f, 0xfe02, 0x3100, 0x4024, 0xb124, 0x0024, 0x2800, /* 1a8 */

0x4c00, 0x3900, 0x8024, 0x6124, 0x0024, 0x0000, 0x0402, 0x2800, /* 1b0 */

0x4ac8, 0x0000, 0x0024, 0x003f, 0xff02, 0x3100, 0x4024, 0xb124, /* 1b8 */

0x0024, 0x2800, 0x4c00, 0x3900, 0x8024, 0x6124, 0x0401, 0x003f, /* 1c0 */

0xff82, 0x2800, 0x4c08, 0xb124, 0x0024, 0x3900, 0x8024, 0xb882, /* 1c8 */

0x8c4c, 0x3830, 0x4024, 0x0006, 0x0091, 0x3904, 0xc024, 0x0006, /* 1d0 */

0x00d1, 0x0000, 0x0013, 0x3100, 0x904c, 0x4202, 0x0024, 0x39f0, /* 1d8 */

0x4024, 0x3100, 0x4024, 0x3c00, 0x4024, 0xf400, 0x44c1, 0x34f0, /* 1e0 */

0x8024, 0x6126, 0x0024, 0x0006, 0x06d0, 0x2800, 0x5b98, 0x4294, /* 1e8 */

0x0024, 0x2400, 0x5b42, 0x0000, 0x0024, 0xf400, 0x4411, 0x3123, /* 1f0 */

0x0024, 0x3100, 0x8024, 0x4202, 0x0024, 0x4182, 0x2401, 0x0000, /* 1f8 */

0x2002, 0x2800, 0x5b49, 0x0000, 0x0024, 0x3013, 0x184c, 0x30f0, /* 200 */

0x7852, 0x6124, 0xb850, 0x0006, 0x0001, 0x2800, 0x55c8, 0x4088, /* 208 */

0x44c2, 0x4224, 0x0024, 0x4122, 0x0024, 0x4122, 0x0024, 0xf400, /* 210 */

0x4051, 0x2900, 0x7200, 0x0000, 0x5708, 0x4224, 0x0024, 0x4122, /* 218 */

0x0024, 0x4122, 0x0024, 0x2900, 0x6780, 0xf400, 0x4051, 0x0002, /* 220 */

0x0002, 0x3009, 0x1bd0, 0x3023, 0x1bd2, 0x30e0, 0x4024, 0x6124, /* 228 */

0x0024, 0x0000, 0x0024, 0x2800, 0x5b48, 0x0000, 0x0024, 0x3613, /* 230 */

0x0024, 0x3e14, 0xc024, 0x2900, 0x1700, 0x3e14, 0x0024, 0x36e3, /* 238 */

0x008c, 0x30e0, 0x8024, 0x6822, 0x4411, 0x3123, 0x0024, 0x3900, /* 240 */

0x4024, 0x3033, 0x0c4c, 0x0006, 0x0011, 0x6892, 0x04c2, 0xa122, /* 248 */

0x0402, 0x6126, 0x0024, 0x0006, 0x0093, 0x2800, 0x64c1, 0x0000, /* 250 */

0x0024, 0xb882, 0x184c, 0x3413, 0x3812, 0x0006, 0x00d2, 0x3a00, /* 258 */

0x5bd2, 0x3300, 0x4024, 0x0000, 0x0013, 0x3c00, 0x4024, 0xf400, /* 260 */

0x44c1, 0x34f0, 0x8024, 0x6126, 0x0024, 0x0006, 0x0111, 0x2800, /* 268 */

0x64d8, 0x4294, 0x0024, 0x2400, 0x6482, 0x0000, 0x0024, 0x0003, /* 270 */

0xf001, 0x3101, 0x0024, 0xb412, 0x0024, 0x0028, 0x0001, 0x2800, /* 278 */

0x6485, 0x6144, 0x0024, 0x0004, 0x0002, 0x2800, 0x6441, 0x4422, /* 280 */

0x0024, 0x0000, 0x1002, 0x6422, 0x0024, 0x2800, 0x6480, 0x3900, /* 288 */

0x4024, 0x3900, 0x4024, 0x3113, 0x0c4c, 0x36f3, 0x4024, 0x36f3, /* 290 */

0xd80e, 0x36f4, 0x5813, 0x36f1, 0x5810, 0x36f0, 0xd804, 0x36f0, /* 298 */

0x5802, 0x3405, 0x9014, 0x36f3, 0x0024, 0x36f2, 0x1815, 0x2000, /* 2a0 */

0x0000, 0x36f2, 0x9817, 0x0007, 0x0001, 0x1868, 0x0006, 0x000f, /* 2a8 */

0x0032, 0x004f, 0x007e, 0x00c8, 0x013d, 0x01f8, 0x0320, 0x04f6, /* 2b0 */

0x07e0, 0x0c80, 0x13d8, 0x1f7f, 0x3200, 0x4f5f, 0x61a8, 0x0006, /* 2b8 */

0x8008, 0x0000, 0x0007, 0x0001, 0x819e, 0x0006, 0x0054, 0x3e12, /* 2c0 */

0xb814, 0x0000, 0x800a, 0x3e10, 0x3801, 0x3e10, 0xb803, 0x3e11, /* 2c8 */

0x7806, 0x3e11, 0xf813, 0x3e13, 0xf80e, 0x3e13, 0x4024, 0x3e04, /* 2d0 */

0x7810, 0x449a, 0x0040, 0x0001, 0x0003, 0x2800, 0x70c4, 0x4036, /* 2d8 */

0x03c1, 0x0003, 0xffc2, 0xb326, 0x0024, 0x0018, 0x0042, 0x4326, /* 2e0 */

0x4495, 0x4024, 0x40d2, 0x0000, 0x0180, 0xa100, 0x4090, 0x0010, /* 2e8 */

0x0fc2, 0x4204, 0x0024, 0xbc82, 0x4091, 0x459a, 0x0024, 0x0000, /* 2f0 */

0x0054, 0x2800, 0x6fc4, 0xbd86, 0x4093, 0x2400, 0x6f85, 0xfe01, /* 2f8 */

0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x020c, 0x5c56, 0x8a0c, 0x5e53, /* 300 */

0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x020c, 0x5c56, 0x8a0c, 0x5e52, /* 308 */

0x0024, 0x4cb2, 0x4405, 0x0018, 0x0044, 0x654a, 0x0024, 0x2800, /* 310 */

0x7dc0, 0x36f4, 0x5810, 0x0007, 0x0001, 0x81c8, 0x0006, 0x0080, /* 318 */

0x3e12, 0xb814, 0x0000, 0x800a, 0x3e10, 0x3801, 0x3e10, 0xb803, /* 320 */

0x3e11, 0x7806, 0x3e11, 0xf813, 0x3e13, 0xf80e, 0x3e13, 0x4024, /* 328 */

0x3e04, 0x7810, 0x449a, 0x0040, 0x0000, 0x0803, 0x2800, 0x7c84, /* 330 */

0x30f0, 0x4024, 0x0fff, 0xfec2, 0xa020, 0x0024, 0x0fff, 0xff02, /* 338 */

0xa122, 0x0024, 0x4036, 0x0024, 0x0000, 0x1fc2, 0xb326, 0x0024, /* 340 */

0x0010, 0x4002, 0x4326, 0x4495, 0x4024, 0x40d2, 0x0000, 0x0180, /* 348 */

0xa100, 0x4090, 0x0010, 0x0042, 0x4204, 0x0024, 0xbc82, 0x4091, /* 350 */

0x459a, 0x0024, 0x0000, 0x0054, 0x2800, 0x7b84, 0xbd86, 0x4093, /* 358 */

0x2400, 0x7b45, 0xfe01, 0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x0024, /* 360 */

0x5c56, 0x0024, 0x5e53, 0x5e0c, 0x5c43, 0x5f2d, 0x5e46, 0x0024, /* 368 */

0x5c56, 0x0024, 0x5e52, 0x0024, 0x4cb2, 0x4405, 0x0010, 0x4004, /* 370 */

0x654a, 0x9810, 0x0000, 0x0144, 0xa54a, 0x1bd1, 0x0006, 0x0013, /* 378 */

0x3301, 0xc444, 0x687e, 0x2005, 0xad76, 0x8445, 0x4ed6, 0x8784, /* 380 */

0x36f3, 0x64c2, 0xac72, 0x8785, 0x4ec2, 0xa443, 0x3009, 0x2440, /* 388 */

0x3009, 0x2741, 0x36f3, 0xd80e, 0x36f1, 0xd813, 0x36f1, 0x5806, /* 390 */

0x36f0, 0x9803, 0x36f0, 0x1801, 0x2000, 0x0000, 0x36f2, 0x9814, /* 398 */

0x0007, 0x0001, 0x8208, 0x0006, 0x000e, 0x4c82, 0x0024, 0x0000, /* 3a0 */

0x0024, 0x2000, 0x0005, 0xf5c2, 0x0024, 0x0000, 0x0980, 0x2000, /* 3a8 */

0x0000, 0x6010, 0x0024, 0x000a, 0x0001, 0x0050,

#define PLUGIN_SIZE 950

#ifndef SKIP_PLUGIN_VARNAME

};

#endif

Mini MP3 Player

March 18, 2019May 30, 2019 paul

This little €4 module filled my entire weekend, mainly spent on finding the right documentation and a library that will work on Arduino, ESP8266 and ESP32. It’s a DFPlayer Mini MP3 Player from DFRobot (or, more likely, one of its many clones).

It can play MP3 and WAV files, stored on an SD card in the onboard card reader or from an attached USB drive. So far, I only tested MP3 files from SD.

You can connect one (4 Ω) speaker to the (quite impressive) onboard mono amplifier. Stereo line output is said to be provided on the DAC_R and DAC_L pins.

The main control method of this player is via commands over the module’s 9600 baud serial port. A subset of most commonly used commands can also be executed by means of two GPIO pins and/or two resistor-sensitive ‘ADKEY’ pins.

I made a false start by testing it on an ESP32 over hardware serial. That didn’t seem to work, so I tried an ESP8266 over software serial. That didn’t work either, and I had reached the point of giving up, assuming it was just another Chinese fake, when I gave it one more try on my good old Arduino Uno. With a quick & dirty 1K resistor for level shifting the module’s RX pin, the example sketch of one of many libraries finally made the little guy play me a song! In the end, it was the power supply that made the difference.

Some important things that I learned so far:

The module works best when powered by a stable 5 Volt. My Arduino Uno and Wemos D1 R2 could deliver it from their 5V pin, smaller ESP8266 and ESP32 boards couldn’t. In that case: use a separate 5 Volt power supply.
Wiring as suggested here caused a shutdown of my laptop’s usb port! I’m still searching for a way to connect the module to ESP32.
The module operates on 3.3 V logic level, so make sure to level shift the connection to the module’s RX pin when using a 5 V microcontoller.
Startup noise disappeared after I connected both GND pins from the player to ground.
Although it’s for a Flyron FN-M16P module, this excellent manual/datasheet has more and better written information than DFRobot’s own poorly translated summary. Apparently both modules use the same commands and probably have the same chip.
Getting stereo ouput from the DAC pins is still a problem. According to the manual, DAC is enabled on startup, but is it? Explicitely enabling it by sending 0x0000 to memory address 0x1A made no difference while sending 0x0001 instead (supposed to turn it off) started a terrible noise…
I tested quite some libraries from github, most of which have issues [update: starting sketches with delay(1000); solved most of them] and seem unnecessarily complicated to me. An exception is this simple and transparent library that is basically just a wrapper for sending serial commands. It can easily be extended with additional methods, even by unexperienced C++ programmers. You just have to lookup the command- and parameter bytes for the desired function in the datasheet and create a new function to send them (see example at the bottom of this page). [update: the author of the library has meanwhile added more commands]
The module has an SPK_1 and an SPK_2 pin, with a GND pin in between, which could suggest that it has a stereo amplifier. Although the documentation clearly says it’s mono, someone actually published a wiring diagram with two speakers connected. This person may own a different version of the module, but mine definitely has a mono amplifier. So the two wires of a single speaker should go to the SPK pins.

[ Wiring for Arduino Uno, with SoftSerial on pins 10 and 11; don’t forget the 1K resistor! ]

The location of files and their names is also very important because of the way commands address them. All information can be found in the datasheet, but here’s a summary:

The SD card’s maximum size is 32 GB. It must be FAT or FAT32 formatted.
There can be up to 3000 .mp3 (or .wav) files in the root directory of the SD card, named 0001.mp3 to 3000.mp3.
The root can have up to 99 subdirectories, named 01, 02, … 99. Each of these subdirectories can hold up to 255 files. Their names must start with 001, 002, … 255, but you can append decriptive titles to these files, e.g. 007_James_Bond_Tune.mp3.
You can have a special subdirectory in the root named MP3. This can hold up to 3000 files, named 0001.mp3 to 3000.mp3.
You can also have a subdirecory ADVERT in the root. Special commands are available for making tracks in this folder interrupt currently playing tracks from the MP3 folder (for advertisement puposes). The rules for the MP3 subdirectory apply here as well.
Don’t create subdirectories inside subdirectories.
The module does not actually use file- or directory names, but the order of files and directories in the SD card’s FAT. The previously mentioned naming conventions just try to give you control over that order. If you properly organize your audio files in a folder on your PC first, and then copy that entire structure to a freshly formatted SD card, then (in theory) the FAT order should match the file- and directory numbering. See also this tool

Apart from adding some extra functions to the above mentioned library, I still have to find out how to reliably receive and read the module’s response to commands and queries. Once that I’m in full control over this (for its price) remarkably versatile module, it will be useful for a couple of ‘talking’ projects that I have in mind. Probably just mono and not ESP32 driven, but anyway: lots of fun for just €4.

Here’s an example of a function that I added to the DFPlayerMini_Fast library. Calling play_in_dir(2, 5) will play file 005.mp3 in subdirectory 02.

Using an existing function as a template, I first added my new function to the DFPlayerMini_Fast.cpp file:

void DFPlayerMini_Fast::play_in_dir(uint16_t dirNum,uint16_t fileNum)
{
  commandValue = PLAY_IN_DIR_COMMAND;
  paramMSB = dirNum;
  paramLSB = fileNum;
  
  findChecksum();
  sendData();
  
  return;
}

void DFPlayerMini_Fast::play_in_dir(uint16_t dirNum,uint16_t fileNum)

{

commandValue = PLAY_IN_DIR_COMMAND;

paramMSB = dirNum;

paramLSB = fileNum;

findChecksum();

sendData();

return;

}

Then I added these two accompanying lines to the DFPlayerMini_Fast.h header file:

#define PLAY_IN_DIR_COMMAND 0x0F

1	#define PLAY_IN_DIR_COMMAND 0x0F

and (inside the code for the class):

void play_in_dir(uint16_t dirNum,uint16_t fileNum);

1	void play_in_dir(uint16_t dirNum,uint16_t fileNum);

Explanation: according to the datasheet, the 10 (hexadecimal) bytes that have to be sent (by the sendData() function) to play track 005.mp3 in directory 02 are:

7E FF 06 0F 00 02 05 xx xx EF

7E FF 06 are the first three bytes for every command. The following 0F is de code for ‘play a file in a direcory’, the following 00 means ‘no confirmation feedback needed’ and is followed by the two parameters for the desired directory- and file number: 02 and 05. Then comes xx xx which are two checksum bytes that will be calculated and replaced by the findChecksum() function of the library before the command is sent by sendData(). Finally, every command has to be closed by EF.

As you can see, my newly added function play_in_dir() takes two parameters only, corresponding with two bytes in the command sequence. All other bytes of the sequence are either fixed or calculated by the findChecksum() function.

LOLIN TFT-2.4 Shield

February 10, 2019January 16, 2020 paul

Here’s a well designed new display from Wemos Electronics. They call it a (D1 Mini) Shield, but instead of going on top of a Wemos D1 Mini (Pro), it lets you plug in the Mini at the back of the 2.4″ TFT touch screen display, leaving all GPIO pins accessible, thanks to double header rows. Very useful!

This table shows the internal pin mapping when used as a shield. For TFT_LED, TFT_RST and TS_CS, this mapping can be changed by closing solder bridges at the back of the display (default NC for TFT_LED means “backlight always on”).

The default pin mapping leaves I²C pins D1 and D2, as well as D4, A0, TX and RX available for other purposes. With my Wemos Mini Pro v2 plugged in, this shield has become my first choice for battery powered esp8266 projects that require a display.

But there’s more. All pins are also broken out to a breadboard-friendly header and to a TFT connector. Connecting the display to a D32 Pro (that also has a TFT connector) now requires only one (special) cable! The picture shows the connector’s pinout.

The 320×240 display uses the well-proven ili9341 chip, for which I already wrote a lot of sketches, both for esp8266 and esp32 boards. The XPT2046 library can be used to drive the touch screen.

I tested several sketches on a plugged-in Mini Pro, as well as a TFT cable-connected D32 Pro, and everything worked fine. Example sketches on the Wemos site use Adafruit’s ili9341 library, but I prefer the much faster TFT_eSPI library with built-in touch screen support.

Here’s a video showing the display in action:

Conclusion: this is a well-thought product that makes wiring very convenient and stable. Recommended!

Quest for Fire

October 21, 2018February 5, 2020 paul

By no means a gamer myself, I’ve always been interested in the math behind the graphics in video games. A previous post showed how simple clouds can be produced by the Diamond-Square algorithm, running on an esp8266. That algorithm can generate maps and landscapes as well.

Another visual effect on my todo list was algorithmically simulated fire.

The video shows my first attempt on a small TFT display. I had to write a relatively simple algorithm, because it needs to run on a microcontroller. Some further experimenting with the color palette, weighting factors and randomization, as well as adding Perlin noise, will hopefully result in a more realistic fire. I also plan to add a rotary encoder for regulating the ‘fire’.

[Update: a newer version is here]

// Simple fire simulation on tft display; sketch is for esp32.
// Uses bodmer's TFT_eSPI library.
// paulF 2018

#include <TFT_eSPI.h>
TFT_eSPI tft;
// min() and max() macros for esp32; not needed for esp8266
#define min(X, Y) (((X)<(Y))?(X):(Y))
#define max(X, Y) (((X)>(Y))?(X):(Y))

const int rows=80;
const int cols=160;
int ci,ri;
float fire[cols][rows+2]; //160 columns; 80 visible and 2 invisible rows
float colfactor[cols];
float coolrow[cols];

float pidivcols = 3.14159265/160.0; 
float f1 = 0.188; // weighting factor left & right
float f2 = 0.22;  // weighting factor 1 row below
float f3 = 0.20;  // weighting factor 2 rows below
float f4 = 0.19;  // weighting factor old value
uint16_t palette[128];

void setup() {
  randomSeed(esp_random());  // works for esp32
  tft.begin();
  tft.setRotation(1);    // landscape
  tft.fillScreen(0);     // black           

  fill_palette();

  for (ci=0;ci<cols;ci++) {
    colfactor[ci] = 1.0+0.006*(sin(ci*pidivcols)-1);
  }
}

void loop() {
  // fill two lowest (invisible) rows with random fire source
  for (ci=0; ci<cols; ci++) {
    int r1 = random(8);  
    int r2 = random(8); 
    fire[ci][rows+1] = 128- pow(2,r1);  // random values 127, 126, 124, 120, 112, 96, 64, 0
    fire[ci][rows] = 128- pow(2,r2);    // random values 127, 126, 124, 120, 112, 96, 64, 0
    coolrow[ci] = random(45);  // some random cooling
  }

  for (ri=rows-1; ri>=0;ri--) {
    // left pixel (wrapping):
    fire[0][ri] = colfactor[0]*(f1*(fire[cols-1][ri+1] + fire[1][ri+1]) + f2*fire[0][ri+1] + f3*fire[0][ri+2] + f4*fire[0][ri]);
    tft.fillRect(0,2*ri,2,2,palette[(int)fire[0][ri]]);

    // right pixel (wrapping):
    fire[cols-1][ri] = colfactor[cols-1]*(f1*(fire[cols-2][ri+1] + fire[0][ri+1]) + f2*fire[cols-1][ri+1] + f3*fire[cols-1][ri+2] + f4*fire[cols-1][ri]);
    tft.fillRect((cols-1)*2,2*ri,2,2,palette[(int)fire[cols-1][ri]]);
    
    // rest of row pixels:
    for (ci=1;ci<cols-1;ci++) {
      if (coolrow[ci] == ri) {
        fire[ci][ri] = (random(40)+2*(colfactor[ci]*(f1*(fire[ci-1][ri+1] + fire[ci+1][ri+1]) + f2*fire[ci][ri+1] + f3*fire[ci][ri+2] + f4*fire[ci][ri])))/3;
      } else {
        fire[ci][ri] = colfactor[ci]*(f1*(fire[ci-1][ri+1] + fire[ci+1][ri+1]) + f2*fire[ci][ri+1] + f3*fire[ci][ri+2] + f4*fire[ci][ri]);
      }
      tft.fillRect(ci*2,2*ri,2,2,palette[(int)fire[ci][ri]]);
    }
  } 
}

void fill_palette() {
  float r,g,b;
  r = 31.0; g = 63.0; b = 23.0;
  palette[127] = ((int)r<<11) + ((int)g<<5) +(int) b;
  for (int i=126;i>95;i--) {
    b=b-0.5;
    palette[i] = ((int)r<<11) + ((int)g<<5) +(int) b;
  }
  for (int i=95;i>63;i--) {
    g=g-1.5;
    palette[i] = ((int)r<<11) + ((int)g<<5) +(int) b;
  }
  for (int i=63;i>47;i--) {
    r=max(0.0,r-1.0);
    g=max(g-1.0,0.0);
    b=max(b-0.5,0.0);
    palette[i] = ((int)r<<11) + ((int)g<<5) +(int) b;
  }
  for (int i=47;i>15;i--) {
    r=max(0.0,r-0.5);
    palette[i] = ((int)r<<11) + ((int)g<<5) +(int) b;
  }
  for (int i=15;i>=0;i--) {
    r=max(0.0,r-1.0);
    palette[i] = ((int)r<<11) + ((int)g<<5) +(int) b;
  }
}

// Simple fire simulation on tft display; sketch is for esp32.

// Uses bodmer's TFT_eSPI library.

// paulF 2018

#include <TFT_eSPI.h>

TFT_eSPI tft;

// min() and max() macros for esp32; not needed for esp8266

#define min(X, Y) (((X)<(Y))?(X):(Y))

#define max(X, Y) (((X)>(Y))?(X):(Y))

const int rows=80;

const int cols=160;

int ci,ri;

float fire[cols][rows+2]; //160 columns; 80 visible and 2 invisible rows

float colfactor[cols];

float coolrow[cols];

float pidivcols = 3.14159265/160.0;

float f1 = 0.188; // weighting factor left & right

float f2 = 0.22; // weighting factor 1 row below

float f3 = 0.20; // weighting factor 2 rows below

float f4 = 0.19; // weighting factor old value

uint16_t palette[128];

void setup() {

randomSeed(esp_random()); // works for esp32

tft.begin();

tft.setRotation(1); // landscape

tft.fillScreen(0); // black

fill_palette();

for (ci=0;ci<cols;ci++) {

colfactor[ci] = 1.0+0.006*(sin(ci*pidivcols)-1);

}

void loop() {

// fill two lowest (invisible) rows with random fire source

for (ci=0; ci<cols; ci++) {

int r1 = random(8);

int r2 = random(8);

fire[ci][rows+1] = 128- pow(2,r1); // random values 127, 126, 124, 120, 112, 96, 64, 0

fire[ci][rows] = 128- pow(2,r2); // random values 127, 126, 124, 120, 112, 96, 64, 0

coolrow[ci] = random(45); // some random cooling

}

for (ri=rows-1; ri>=0;ri--) {

// left pixel (wrapping):

fire[0][ri] = colfactor[0]*(f1*(fire[cols-1][ri+1] + fire[1][ri+1]) + f2*fire[0][ri+1] + f3*fire[0][ri+2] + f4*fire[0][ri]);

tft.fillRect(0,2*ri,2,2,palette[(int)fire[0][ri]]);

// right pixel (wrapping):

fire[cols-1][ri] = colfactor[cols-1]*(f1*(fire[cols-2][ri+1] + fire[0][ri+1]) + f2*fire[cols-1][ri+1] + f3*fire[cols-1][ri+2] + f4*fire[cols-1][ri]);

tft.fillRect((cols-1)*2,2*ri,2,2,palette[(int)fire[cols-1][ri]]);

// rest of row pixels:

for (ci=1;ci<cols-1;ci++) {

if (coolrow[ci] == ri) {

fire[ci][ri] = (random(40)+2*(colfactor[ci]*(f1*(fire[ci-1][ri+1] + fire[ci+1][ri+1]) + f2*fire[ci][ri+1] + f3*fire[ci][ri+2] + f4*fire[ci][ri])))/3;

} else {

fire[ci][ri] = colfactor[ci]*(f1*(fire[ci-1][ri+1] + fire[ci+1][ri+1]) + f2*fire[ci][ri+1] + f3*fire[ci][ri+2] + f4*fire[ci][ri]);

}

tft.fillRect(ci*2,2*ri,2,2,palette[(int)fire[ci][ri]]);

}

void fill_palette() {

float r,g,b;

r = 31.0; g = 63.0; b = 23.0;

palette[127] = ((int)r<<11) + ((int)g<<5) +(int) b;

for (int i=126;i>95;i--) {

b=b-0.5;