~talya/suena · nóssa code store

~talya/suena

ahora suena

r/o

suena / suena / suena.ino

#if !defined(ARDUINO_ESP32_DEV) && !defined(ARDUINO_INKPLATE6V2)

#error "Wrong board selection for this example, please select e-radionica Inkplate6 or Soldered Inkplate6 in the boards menu."

#endif

#include <Inkplate.h>

#include <WiFi.h>

#include "./creds.h"

Inkplate display(INKPLATE_1BIT);

WiFiServer server(PORT);

const char CONNECTING[] = "Connecting WiFi~";

const char CONNECT_FAILED[] = "WiFi fail :<";

const char SYNCING_NTP[] = "Syncing NTP!";

enum struct RequestKind {

UNKNOWN,

SUENA,

NO_SUENA,

};

static struct {

RequestKind kind;

std::string title;

std::string artist;

std::string album;

std::string msg;

} request;

// changes according to font size!

#define MAX_LINE_LEN 18

static uint16_t sizeUp(std::string const& text)

{

uint16_t lines = 1,

ix = 0,

remaining = text.size();

if (remaining == 0)

return 0;

while (remaining > MAX_LINE_LEN) {

// look for a space to break at between [ix, ix+MLL)

int16_t s = ix + MAX_LINE_LEN - 1;

bool found = false;

for (; s >= ix; --s) {

if (text[s] == ' ') {

++lines;

ix = s + 1;

remaining = text.size() - ix;

found = true;

break;

}

if (!found) {

// just break at MLL then

++lines;

ix += MAX_LINE_LEN;

remaining -= MAX_LINE_LEN;

}

return lines;

}

static void displaySizedUp(std::string const& text, uint16_t& y)

{

uint8_t lines = sizeUp(text);

int16_t _x, _y;

uint16_t w, h;

uint16_t ix = 0,

remaining = text.size();

while (remaining > MAX_LINE_LEN) {

// look for a space to break at between [ix, ix+MLL)

int16_t s = ix + MAX_LINE_LEN - 1;

bool found = false;

for (; s >= ix; --s) {

if (text[s] == ' ') {

auto substr = text.substr(ix, s - ix);

while (substr[substr.length() - 1] == ' ')

substr.pop_back();

display.getTextBounds(substr.c_str(), 0, 0, &_x, &_y, &w, &h);

display.setCursor((display.width() - w) / 2, y);

display.print(substr.c_str());

y += h + 1;

ix = s + 1;

remaining = text.size() - ix;

found = true;

break;

}

if (!found) {

// just break at MLL then

auto substr = text.substr(ix, MAX_LINE_LEN);

while (substr[substr.length() - 1] == ' ')

substr.pop_back();

100

display.getTextBounds(substr.c_str(), 0, 0, &_x, &_y, &w, &h);

101

display.setCursor((display.width() - w) / 2, y);

102

display.print(substr.c_str());

103

y += h + 1;

104

ix += MAX_LINE_LEN;

105

remaining -= MAX_LINE_LEN;

}

}

if (remaining > 0) {

auto substr = text.substr(ix);

111

while (substr[substr.length() - 1] == ' ')

112

substr.pop_back();

113

display.getTextBounds(substr.c_str(), 0, 0, &_x, &_y, &w, &h);

114

display.setCursor((display.width() - w) / 2, y);

115

display.print(substr.c_str());

y += h;

}

}

const uint16_t DASH_WIDTH = 50;

121

122

static void displayTextCenteredThirds(std::string const& a, std::string const& b, std::string const& c)

123

{

124

auto a_sz = sizeUp(a);

125

auto b_sz = sizeUp(b);

126

auto c_sz = sizeUp(c);

127

128

// determine font height.

129

int16_t _x, _y;

130

uint16_t w, h;

131

display.getTextBounds("A", 0, 0, &_x, &_y, &w, &h);

uint16_t i = 88;

uint16_t centre_y = display.height() / 2;

136

uint16_t y = centre_y - ((h + 1) * (a_sz + b_sz + c_sz) + i * 2) / 2;

137

138

displaySizedUp(a, y);

139

y += i/2 - 1;

140

if (a_sz != 0 && b_sz != 0)

141

display.drawThickLine(display.width() / 2 - DASH_WIDTH / 2, y, display.width() / 2 + DASH_WIDTH / 2, y, 1, 3);

142

y += i/2 + 2;

143

displaySizedUp(b, y);

144

y += i/2 - 1;

145

if (b_sz != 0 && c_sz != 0)

146

display.drawThickLine(display.width() / 2 - DASH_WIDTH / 2, y, display.width() / 2 + DASH_WIDTH / 2, y, 1, 3);

147

y += i/2 + 2;

148

displaySizedUp(c, y);

149

}

150

151

static void displayTextCenteredThird(char const *text, int third)

152

{

153

uint16_t centre_h = display.height() / 3;

154

centre_h = centre_h * third + centre_h / 2;

int16_t _x, _y;

uint16_t w, h;

display.getTextBounds(text, 0, 0, &_x, &_y, &w, &h);

159

160

display.setCursor((display.width() - w) / 2, centre_h - h / 2);

display.print(text);

}

// static void displayTextRightLn(char const* text)

// {

// int16_t x, y;

// uint16_t w, h;

// display.getTextBounds(text, 0, 0, &x, &y, &w, &h);

169

// display.setCursor(display.width() - w, display.getCursorY());

170

// display.println(text);

// }

const char note[] =

".........-####---"

".........-######-"

".........-##--###"

".........-##-----"

".........-##-...."

"..--------##-...."

"---######-##-...."

"-###########-...."

"-###########-...."

"---######----...."

"..--------.......";

const char heart[] =

"....####...####.."

"...######.######."

"..###############"

"..###############"

"...#############."

"....###########.."

".....#########..."

".......#####....."

"........###......"

".........#......."

".................";

const uint16_t note_w = 17;

200

const uint16_t note_h = 11;

201

const uint16_t note_y = 5;

202

203

const uint16_t note_wscale = 3;

204

const uint16_t note_hscale = 6;

205

206

static void drawGraphic(char const *gfx)

207

{

208

uint16_t i = 0;

209

const uint16_t note_x = display.width() - 5 - note_w * note_wscale;

210

for (uint16_t y = note_y; y < note_y + note_h * note_hscale; y += note_hscale)

211

for (uint16_t x = note_x; x < note_x + note_w * note_wscale; x += note_wscale, ++i)

212

if (gfx[i] == '#') {

213

for (uint16_t sy = y; sy < y + note_hscale; ++sy)

214

for (uint16_t sx = x; sx < x + note_wscale; ++sx)

215

display.drawPixel(sx, sy, 1);

216

} else if (gfx[i] == '-') {

217

for (uint16_t sy = y; sy < y + note_hscale; ++sy)

218

for (uint16_t sx = x; sx < x + note_wscale; ++sx)

219

display.drawPixel(sx, sy, 0);

}

}

static void refresh()

224

{

225

display.clearDisplay();

226

display.setTextSize(7);

227

if (request.kind == RequestKind::SUENA) {

228

displayTextCenteredThirds(

request.title,

request.artist,

request.album);

drawGraphic(note);

} else if (request.kind == RequestKind::NO_SUENA) {

234

displayTextCenteredThirds("", request.msg, "");

235

drawGraphic(heart);

236

} else {

237

displayTextCenteredThird("no esta sonando", 1);

}

display.display();

}

static void connectWifi()

243

{

244

display.clearDisplay();

245

displayTextCenteredThird(CONNECTING, 1);

display.display();

WiFi.mode(WIFI_STA);

WiFi.setHostname(HOSTNAME);

250

bool attempted = false;

251

252

while (true) {

253

int status = WiFi.status();

254

if (status == WL_CONNECTED) {

255

break;

256

} else if (!attempted) {

257

WiFi.begin(WIFI_SSID, WIFI_PASS);

258

attempted = true;

259

} else if (status == WL_CONNECT_FAILED) {

260

display.clearDisplay();

261

displayTextCenteredThird(CONNECT_FAILED, 1);

262

display.display();

263

delay(1000);

264

WiFi.begin(WIFI_SSID, WIFI_PASS);

}

delay(500);

}

server.begin();

}

void setup()

{

display.begin();

display.setTextColor(1, 0);

276

display.setTextWrap(false);

277

display.setTextSize(7);

connectWifi();

refresh();

}

#define URI_SUENA "/suena"

285

#define URI_NO_SUENA "/no_suena"

286

287

#define X_TITLE "x-title: "

288

#define X_ARTIST "x-artist: "

289

#define X_ALBUM "x-album: "

290

#define X_MSG "x-msg: "

291

292

static bool parseClientRequest(WiFiClient& client)

{

enum {

VERB, // "POST"

URI, // "/SECRET/suena"

297

HTTP, // "HTTP/1.1"

298

HEADERS, // etc.

299

} parse_state = VERB;

char buf[255];

uint8_t len = 0;

uint8_t parcels = 0;

request.kind = RequestKind::UNKNOWN;

304

305

unsigned long start = millis();

306

307

while (client.connected()) {

308

if (!client.available()) {

309

if (millis() - start > 5000) {

return false;

}

delay(10);

continue;

}

char c = client.read();

316

switch (parse_state) {

317

case VERB:

318

if (c >= 'A' && c <= 'Z' && len < 254) {

319

buf[len++] = c;

320

} else if (c == ' ') {

321

buf[len] = 0;

322

if (strcmp(buf, "POST") != 0) {

return false;

}

parse_state = URI;

len = 0;

} else {

return false;

}

break;

case URI:

if ((c == '/'

|| c == '_'

|| (c >= 'a' && c <= 'z')

335

|| (c >= '0' && c <= '9'))

336

&& len < 254) {

337

buf[len++] = c;

338

} else if (c == ' ') {

339

buf[len] = 0;

340

if (len < (sizeof(SECRET) - 1) + 1) {

341

return false;

342

}

343

if (strncmp(buf, "/" SECRET, sizeof(SECRET) - 1 + 1) != 0) {

344

return false;

345

}

346

if (strcmp(&buf[sizeof(SECRET) - 1 + 1], URI_SUENA) == 0) {

347

request.kind = RequestKind::SUENA;

348

} else if (strcmp(&buf[sizeof(SECRET) - 1 + 1], URI_NO_SUENA) == 0) {

349

request.kind = RequestKind::NO_SUENA;

} else {

return false;

}

parse_state = HTTP;

len = 0;

} else {

return false;

}

break;

case HTTP:

if ((c == '/'

|| c == '1'

|| c == '.'

|| c == '0'

|| (c >= 'A' && c <= 'Z'))

365

&& len < 254) {

366

buf[len++] = c;

367

} else if (c == '\r') {

368

buf[len] = 0;

369

if (strcmp(buf, "HTTP/1.0") == 0

370

|| strcmp(buf, "HTTP/1.1") == 0) {

// ok cool

} else {

// ok not cool

return false;

}

parse_state = HEADERS;

377

len = 1; // HEADERS loop not to think we're done when it sees \n

} else {

return false;

}

break;

case HEADERS:

if (c == '\n' && len == 0) {

384

// empty line, request fish

385

return (request.kind == RequestKind::SUENA && parcels == 3) ||

386

(request.kind == RequestKind::NO_SUENA && parcels == 1);

387

} else if (c == '\n') {

388

len = 0;

389

} else if (c == '\r') {

390

// process line if any

391

if (len > sizeof(X_TITLE) - 1 && strncmp(buf, X_TITLE, sizeof(X_TITLE) - 1) == 0) {

392

request.title = std::string(buf + sizeof(X_TITLE) - 1, len - sizeof(X_TITLE) + 1);

393

++parcels;

394

} else if (len > sizeof(X_ARTIST) - 1 && strncmp(buf, X_ARTIST, sizeof(X_ARTIST) - 1) == 0) {

395

request.artist = std::string(buf + sizeof(X_ARTIST) - 1, len - sizeof(X_ARTIST) + 1);

396

++parcels;

397

} else if (len > sizeof(X_ALBUM) - 1 && strncmp(buf, X_ALBUM, sizeof(X_ALBUM) - 1) == 0) {

398

request.album = std::string(buf + sizeof(X_ALBUM) - 1, len - sizeof(X_ALBUM) + 1);

399

++parcels;

400

} else if (len > sizeof(X_MSG) - 1 && strncmp(buf, X_MSG, sizeof(X_MSG) - 1) == 0) {

401

request.msg = std::string(buf + sizeof(X_MSG) - 1, len - sizeof(X_MSG) + 1);

++parcels;

}

} else {

buf[len] = c;

len++;

}

}

}

return false;

}

void loop()

{

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

connectWifi();

refresh();

}

WiFiClient client = server.available();

422

if (client) {

423

bool success = false;

424

if (parseClientRequest(client)) {

425

switch (request.kind) {

426

case RequestKind::UNKNOWN:

427

break;

428

case RequestKind::SUENA:

429

success = true;

430

break;

431

case RequestKind::NO_SUENA:

success = true;

break;

}

}

if (success) {

client.println("HTTP/1.1 200 OK");

438

client.println("Content-Type: text/plain");

439

client.println("Connection: close");

440

client.println();

441

client.println("que bella");

442

refresh();

443

} else {

444

client.println("HTTP/1.1 400 Bad Request");

445

client.println("Content-Type: text/plain");

446

client.println("Connection: close");

447

client.println();

448

client.println("yo bro wtf is this");

}

client.stop();

}

delay(5);

}