Programmiamo l'ESP8266 con display 0.91" integrato

Post Views: 34

Impariamo a gestire il display OLED e il WI-FI della scheda ESP8266 fornitaci da AZ-Delivery, tramjte Arduino IDE e una manciata di righe C.

Tempo fa abbiamo imparato a conoscere la scheda basata sull’ESP8266 con display OLED integrato. Vediamo oggi come accedere alle risorse di questa schedina, tanto piccola quanto versatile ed efficiente. Gli esempi riportati consentiranno, in particolare, di creare un semplicissimo scanner WI-FI e di gestire la grafica del piccolo schermo OLED da 0.91 pollici.

Per prima cosa occorrerà caricare attraverso, la gestione schede, la libreria ESP8266 community. Quindi, attraverso tools/Schede, scegliere Generic ESP8266 Module, ed associare la porta com relativa.

A questo punto sarà possibile caricare il codice di esempio (File/Esempi/Esp8266/WiFiScan):

/*
    This sketch demonstrates how to scan WiFi networks.
    The API is almost the same as with the WiFi Shield library,
    the most obvious difference being the different file you need to include:
*/

#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200);
  Serial.println(F("\nESP8266 WiFi scan example"));

  // Set WiFi to station mode
  WiFi.mode(WIFI_STA);

  // Disconnect from an AP if it was previously connected
  WiFi.disconnect();
  delay(100);
}

void loop() {
  String ssid;
  int32_t rssi;
  uint8_t encryptionType;
  uint8_t* bssid;
  int32_t channel;
  bool hidden;
  int scanResult;

  Serial.println(F("Starting WiFi scan..."));

  scanResult = WiFi.scanNetworks(/*async=*/false, /*hidden=*/true);

  if (scanResult == 0) {
    Serial.println(F("No networks found"));
  } else if (scanResult > 0) {
    Serial.printf(PSTR("%d networks found:\n"), scanResult);

    // Print unsorted scan results
    for (int8_t i = 0; i < scanResult; i++) {
      WiFi.getNetworkInfo(i, ssid, encryptionType, rssi, bssid, channel, hidden);

      Serial.printf(PSTR("  %02d: [CH %02d] [%02X:%02X:%02X:%02X:%02X:%02X] %ddBm %c %c %s\n"),
                    i,
                    channel,
                    bssid[0], bssid[1], bssid[2],
                    bssid[3], bssid[4], bssid[5],
                    rssi,
                    (encryptionType == ENC_TYPE_NONE) ? ' ' : '*',
                    hidden ? 'H' : 'V',
                    ssid.c_str());
      delay(0);
    }
  } else {
    Serial.printf(PSTR("WiFi scan error %d"), scanResult);
  }

  // Wait a bit before scanning again
  delay(5000);
}

This sketch demonstrates how to scan WiFi networks.

The API is almost the same as with the WiFi Shield library,

the most obvious difference being the different file you need to include:

#include <ESP8266WiFi.h>

void setup() {

Serial.begin(115200);

Serial.println(F("\nESP8266 WiFi scan example"));

// Set WiFi to station mode

WiFi.mode(WIFI_STA);

// Disconnect from an AP if it was previously connected

WiFi.disconnect();

delay(100);

}

void loop() {

String ssid;

int32_t rssi;

uint8_t encryptionType;

uint8_t* bssid;

int32_t channel;

bool hidden;

int scanResult;

Serial.println(F("Starting WiFi scan..."));

scanResult = WiFi.scanNetworks(/*async=*/false, /*hidden=*/true);

if (scanResult == 0) {

Serial.println(F("No networks found"));

} else if (scanResult > 0) {

Serial.printf(PSTR("%d networks found:\n"), scanResult);

// Print unsorted scan results

for (int8_t i = 0; i < scanResult; i++) {

WiFi.getNetworkInfo(i, ssid, encryptionType, rssi, bssid, channel, hidden);

Serial.printf(PSTR(" %02d: [CH %02d] [%02X:%02X:%02X:%02X:%02X:%02X] %ddBm %c %c %s\n"),

channel,

bssid[0], bssid[1], bssid[2],

bssid[3], bssid[4], bssid[5],

rssi,

(encryptionType == ENC_TYPE_NONE) ? ' ' : '*',

hidden ? 'H' : 'V',

ssid.c_str());

delay(0);

}

} else {

Serial.printf(PSTR("WiFi scan error %d"), scanResult);

}

// Wait a bit before scanning again

delay(5000);

}

Nell’esempio, la scheda viene disconnessa nel setup() (qualora si fosse connessa automaticamente) e posta in station mode. Viene anche apera una connessione con il monitor seriale.

Nel loop(), vengono inizializzate le variabili necessarie alla scansione. Viene poi chiamato il modulo WiFi.scanNetworks(), con i relativi parametri relativi alla ricerca asincrona (posto a false) e alla modalità nascosta (posto a true). Qualora la scansione abbia esito positivo, viene chiamato il metodo getNetworkInfo(). In tal modo vengono acquisiti i parametri di numero rete, ssid, tipo di cifratura, rssi, bssid, canale e stato. Infine, una chiamata a Serial.Print() stampa il record così ottenuto. La variabile scanResult contiene il numero di reti trovate per ogni lettura, e gestisce il loop interno. Una volta stampati tutti i record acquisiti, viene imposta una pausa di 5 secondi.

Nota: Questo procedura è valida per qualsiasi scheda ESP8266.

Gestire il display OLED

Allo stesso modo è possibile al display OLED integrato sulla scheda.

Per prima cosa installeremo la libreria u8g2 (da Sketch/#include librerie/Gestione librerie). Dal menù File/Esempi/u8g2/full_buffer caricheremo l’esempio GraphicsTest.

Non lasciatevi spaventare dalla sfilza di informazioni contenute nel file: la libreria è stata scritta per lavorare su periferiche video diverse. A noi occorre semplicemente decommentare la periferica che ci interessa.

In particolare, la linea seguente:

//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED

1	//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED

Il file risultante sarà quindi così definito:

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
// End of constructor list

void u8g2_prepare(void) {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}

void u8g2_box_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawBox");
  u8g2.drawBox(5,10,20,10);
  u8g2.drawBox(10+a,15,30,7);
  u8g2.drawStr( 0, 30, "drawFrame");
  u8g2.drawFrame(5,10+30,20,10);
  u8g2.drawFrame(10+a,15+30,30,7);
}

void u8g2_disc_circle(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawDisc");
  u8g2.drawDisc(10,18,9);
  u8g2.drawDisc(24+a,16,7);
  u8g2.drawStr( 0, 30, "drawCircle");
  u8g2.drawCircle(10,18+30,9);
  u8g2.drawCircle(24+a,16+30,7);
}

void u8g2_r_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawRFrame/Box");
  u8g2.drawRFrame(5, 10,40,30, a+1);
  u8g2.drawRBox(50, 10,25,40, a+1);
}

void u8g2_string(uint8_t a) {
  u8g2.setFontDirection(0);
  u8g2.drawStr(30+a,31, " 0");
  u8g2.setFontDirection(1);
  u8g2.drawStr(30,31+a, " 90");
  u8g2.setFontDirection(2);
  u8g2.drawStr(30-a,31, " 180");
  u8g2.setFontDirection(3);
  u8g2.drawStr(30,31-a, " 270");
}

void u8g2_line(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawLine");
  u8g2.drawLine(7+a, 10, 40, 55);
  u8g2.drawLine(7+a*2, 10, 60, 55);
  u8g2.drawLine(7+a*3, 10, 80, 55);
  u8g2.drawLine(7+a*4, 10, 100, 55);
}

void u8g2_triangle(uint8_t a) {
  uint16_t offset = a;
  u8g2.drawStr( 0, 0, "drawTriangle");
  u8g2.drawTriangle(14,7, 45,30, 10,40);
  u8g2.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);
  u8g2.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);
  u8g2.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);
}

void u8g2_ascii_1() {
  char s[2] = " ";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, "ASCII page 1");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 32;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_ascii_2() {
  char s[2] = " ";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, "ASCII page 2");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 160;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_extra_page(uint8_t a)
{
  u8g2.drawStr( 0, 0, "Unicode");
  u8g2.setFont(u8g2_font_unifont_t_symbols);
  u8g2.setFontPosTop();
  u8g2.drawUTF8(0, 24, "☀ ☁");
  switch(a) {
    case 0:
    case 1:
    case 2:
    case 3:
      u8g2.drawUTF8(a*3, 36, "☂");
      break;
    case 4:
    case 5:
    case 6:
    case 7:
      u8g2.drawUTF8(a*3, 36, "☔");
      break;
  }
}

#define cross_width 24
#define cross_height 24
static const unsigned char cross_bits[] U8X8_PROGMEM  = {
  0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 
  0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80, 
  0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03, 
  0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, };

#define cross_fill_width 24
#define cross_fill_height 24
static const unsigned char cross_fill_bits[] U8X8_PROGMEM  = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26, 
  0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08, 
  0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01, 
  0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04, 
  0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21, 
  0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

#define cross_block_width 14
#define cross_block_height 14
static const unsigned char cross_block_bits[] U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0x01, 0x20, 0xFF, 0x3F, };

void u8g2_bitmap_overlay(uint8_t a) {
  uint8_t frame_size = 28;

  u8g2.drawStr(0, 0, "Bitmap overlay");

  u8g2.drawStr(0, frame_size + 12, "Solid / transparent");
  u8g2.setBitmapMode(false /* solid */);
  u8g2.drawFrame(0, 10, frame_size, frame_size);
  u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);

  u8g2.setBitmapMode(true /* transparent*/);
  u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);
  u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);
}

void u8g2_bitmap_modes(uint8_t transparent) {
  const uint8_t frame_size = 24;

  u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);
  u8g2.drawStr(frame_size * 0.5, 50, "Black");
  u8g2.drawStr(frame_size * 2, 50, "White");
  u8g2.drawStr(frame_size * 3.5, 50, "XOR");
  
  if(!transparent) {
    u8g2.setBitmapMode(false /* solid */);
    u8g2.drawStr(0, 0, "Solid bitmap");
  } else {
    u8g2.setBitmapMode(true /* transparent*/);
    u8g2.drawStr(0, 0, "Transparent bitmap");
  }
  u8g2.setDrawColor(0);// Black
  u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(1); // White
  u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(2); // XOR
  u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);
}

uint8_t draw_state = 0;

void draw(void) {
  u8g2_prepare();
  switch(draw_state >> 3) {
    case 0: u8g2_box_frame(draw_state&7); break;
    case 1: u8g2_disc_circle(draw_state&7); break;
    case 2: u8g2_r_frame(draw_state&7); break;
    case 3: u8g2_string(draw_state&7); break;
    case 4: u8g2_line(draw_state&7); break;
    case 5: u8g2_triangle(draw_state&7); break;
    case 6: u8g2_ascii_1(); break;
    case 7: u8g2_ascii_2(); break;
    case 8: u8g2_extra_page(draw_state&7); break;
    case 9: u8g2_bitmap_modes(0); break;
    case 10: u8g2_bitmap_modes(1); break;
    case 11: u8g2_bitmap_overlay(draw_state&7); break;
  }
}


void setup(void) {
  u8g2.begin();
}

void loop(void) {
  // picture loop  
  u8g2.clearBuffer();
  draw();
  u8g2.sendBuffer();
  
  // increase the state
  draw_state++;
  if ( draw_state >= 12*8 )
    draw_state = 0;

  // deley between each page
  delay(100);

}

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

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

#include <Arduino.h>

#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI

#include <SPI.h>

#endif

#ifdef U8X8_HAVE_HW_I2C

#include <Wire.h>

#endif

// U8g2 Contructor List (Frame Buffer)

// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp

// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected

//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED

// End of constructor list

void u8g2_prepare(void) {

u8g2.setFont(u8g2_font_6x10_tf);

u8g2.setFontRefHeightExtendedText();

u8g2.setDrawColor(1);

u8g2.setFontPosTop();

u8g2.setFontDirection(0);

}

void u8g2_box_frame(uint8_t a) {

u8g2.drawStr( 0, 0, "drawBox");

u8g2.drawBox(5,10,20,10);

u8g2.drawBox(10+a,15,30,7);

u8g2.drawStr( 0, 30, "drawFrame");

u8g2.drawFrame(5,10+30,20,10);

u8g2.drawFrame(10+a,15+30,30,7);

}

void u8g2_disc_circle(uint8_t a) {

u8g2.drawStr( 0, 0, "drawDisc");

u8g2.drawDisc(10,18,9);

u8g2.drawDisc(24+a,16,7);

u8g2.drawStr( 0, 30, "drawCircle");

u8g2.drawCircle(10,18+30,9);

u8g2.drawCircle(24+a,16+30,7);

}

void u8g2_r_frame(uint8_t a) {

u8g2.drawStr( 0, 0, "drawRFrame/Box");

u8g2.drawRFrame(5, 10,40,30, a+1);

u8g2.drawRBox(50, 10,25,40, a+1);

}

void u8g2_string(uint8_t a) {

u8g2.setFontDirection(0);

u8g2.drawStr(30+a,31, " 0");

u8g2.setFontDirection(1);

u8g2.drawStr(30,31+a, " 90");

u8g2.setFontDirection(2);

u8g2.drawStr(30-a,31, " 180");

u8g2.setFontDirection(3);

u8g2.drawStr(30,31-a, " 270");

}

void u8g2_line(uint8_t a) {

u8g2.drawStr( 0, 0, "drawLine");

u8g2.drawLine(7+a, 10, 40, 55);

u8g2.drawLine(7+a*2, 10, 60, 55);

u8g2.drawLine(7+a*3, 10, 80, 55);

u8g2.drawLine(7+a*4, 10, 100, 55);

}

void u8g2_triangle(uint8_t a) {

uint16_t offset = a;

u8g2.drawStr( 0, 0, "drawTriangle");

u8g2.drawTriangle(14,7, 45,30, 10,40);

u8g2.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);

u8g2.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);

u8g2.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);

}

void u8g2_ascii_1() {

char s[2] = " ";

uint8_t x, y;

u8g2.drawStr( 0, 0, "ASCII page 1");

for( y = 0; y < 6; y++ ) {

for( x = 0; x < 16; x++ ) {

s[0] = y*16 + x + 32;

u8g2.drawStr(x*7, y*10+10, s);

}

void u8g2_ascii_2() {

char s[2] = " ";

uint8_t x, y;

u8g2.drawStr( 0, 0, "ASCII page 2");

for( y = 0; y < 6; y++ ) {

for( x = 0; x < 16; x++ ) {

s[0] = y*16 + x + 160;

u8g2.drawStr(x*7, y*10+10, s);

}

void u8g2_extra_page(uint8_t a)

{

u8g2.drawStr( 0, 0, "Unicode");

u8g2.setFont(u8g2_font_unifont_t_symbols);

u8g2.setFontPosTop();

u8g2.drawUTF8(0, 24, "☀ ☁");

switch(a) {

case 0:

case 1:

case 2:

case 3:

u8g2.drawUTF8(a*3, 36, "☂");

break;

case 4:

case 5:

case 6:

case 7:

u8g2.drawUTF8(a*3, 36, "☔");

break;

}

#define cross_width 24

#define cross_height 24

static const unsigned char cross_bits[] U8X8_PROGMEM = {

0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00,

0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00,

0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80,

0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03,

0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00,

0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, };

#define cross_fill_width 24

#define cross_fill_height 24

static const unsigned char cross_fill_bits[] U8X8_PROGMEM = {

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26,

0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08,

0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01,

0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04,

0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21,

0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

#define cross_block_width 14

#define cross_block_height 14

static const unsigned char cross_block_bits[] U8X8_PROGMEM = {

0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20,

0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20,

0x01, 0x20, 0xFF, 0x3F, };

void u8g2_bitmap_overlay(uint8_t a) {

uint8_t frame_size = 28;

u8g2.drawStr(0, 0, "Bitmap overlay");

u8g2.drawStr(0, frame_size + 12, "Solid / transparent");

u8g2.setBitmapMode(false /* solid */);

u8g2.drawFrame(0, 10, frame_size, frame_size);

u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);

if(a & 4)

u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);

u8g2.setBitmapMode(true /* transparent*/);

u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);

u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);

if(a & 4)

u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);

}

void u8g2_bitmap_modes(uint8_t transparent) {

const uint8_t frame_size = 24;

u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);

u8g2.drawStr(frame_size * 0.5, 50, "Black");

u8g2.drawStr(frame_size * 2, 50, "White");

u8g2.drawStr(frame_size * 3.5, 50, "XOR");

if(!transparent) {

u8g2.setBitmapMode(false /* solid */);

u8g2.drawStr(0, 0, "Solid bitmap");

} else {

u8g2.setBitmapMode(true /* transparent*/);

u8g2.drawStr(0, 0, "Transparent bitmap");

}

u8g2.setDrawColor(0);// Black

u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);

u8g2.setDrawColor(1); // White

u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);

u8g2.setDrawColor(2); // XOR

u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);

}

uint8_t draw_state = 0;

void draw(void) {

u8g2_prepare();

switch(draw_state >> 3) {

case 0: u8g2_box_frame(draw_state&7); break;

case 1: u8g2_disc_circle(draw_state&7); break;

case 2: u8g2_r_frame(draw_state&7); break;

case 3: u8g2_string(draw_state&7); break;

case 4: u8g2_line(draw_state&7); break;

case 5: u8g2_triangle(draw_state&7); break;

case 6: u8g2_ascii_1(); break;

case 7: u8g2_ascii_2(); break;

case 8: u8g2_extra_page(draw_state&7); break;

case 9: u8g2_bitmap_modes(0); break;

case 10: u8g2_bitmap_modes(1); break;

case 11: u8g2_bitmap_overlay(draw_state&7); break;

}

void setup(void) {

u8g2.begin();

}

void loop(void) {

// picture loop

u8g2.clearBuffer();

draw();

u8g2.sendBuffer();

// increase the state

draw_state++;

if ( draw_state >= 12*8 )

draw_state = 0;

// deley between each page

delay(100);

}

Di nuovo, non lasciatevi spaventare dall’apparente complessità del codice: CI troviamo di fronte alla classica macchina a stati definita nel loop():

void loop(void) {
  // picture loop  
  u8g2.clearBuffer();
  draw();
  u8g2.sendBuffer();
  
  // increase the state
  draw_state++;
  if ( draw_state >= 12*8 )
    draw_state = 0;

  // deley between each page
  delay(100);
}

void loop(void) {

// picture loop

u8g2.clearBuffer();

draw();

u8g2.sendBuffer();

// increase the state

draw_state++;

if ( draw_state >= 12*8 )

draw_state = 0;

// deley between each page

delay(100);

}

vIene ripulito il buffer di schermo,
viene chiamata la funzione draw(),che chiama la sottofunzione di disegno relativa a draw_state,
l’immagine creata viene inviata allo schermo ,
viene aggiornato il parametro draw_state()
viene eseguito un controllo sul parametro draw_state
viene imposto un delay di 100 millisecondi

La “magia” avviene nella funzione draw(), che in base alla variabile draw_state ciama una differente funzione di disegno e stampa. In questo modo sarà possibile dedicarsi con calma a ciascuna funzione, studiarla per bene e capire come svilupparne le caratteristiche, prima di passare alla successiva (hint: sostituendo una costante al parametro draw_state nella funzione draw(), si imporrà la ripetizione dello stesso pattern grafico anziché il passaggio al successivo).

Considerazioni finali

Oggi abbiamo presentato codice di esempio per poter pilotare la scheda AZ-Delivery ESP8266 con display OLED da0.91″. In realtà quanto abbiamo scritto vale per tutte le schede basate su ESP, e per tutti i display presenti nella lista u8g2. Si tratta quindi di un tutorial davvero corposo, che garantisce la possibilità di gestire un elevatissimo numero di schede differenti in modo seamless.

Buon divertimento!

Iscriviti ai nostri gruppi Telegram

Link utili

Seguici per non perdere le prossime novità!

Luigi_Morelli

Definire ciò che si è non risulta mai semplice o intuitivo, in specie quando nella vita si cerca costantemente di migliorarsi, di crescere tanto professionalmente quanto emotivamente. Lavoro per contribuire al mutamento dei settori cardine della computer science e per offrire sintesi ragionate e consulenza ad aziende e pubblicazioni ICT, ma anche perche’ ciò che riesco a portare a termine mi dà soddisfazione, piacere. Così come mi piace suonare (sax, tastiere, chitarra), cantare, scrivere (ho pubblicato 350 articoli scientfici e 3 libri sinora, ma non ho concluso ciò che ho da dire), leggere, Adoro la matematica, la logica, la filosofia, la scienza e la tecnologia, ed inseguo quel concetto di homo novus rinascimentale, cercando di completare quelle sezioni della mia vita che ancora appaiono poco ricche.