464 lines
13 KiB
C++
464 lines
13 KiB
C++
#include <ArduinoJson.h>
|
|
#include <Adafruit_GFX.h>
|
|
#include <Adafruit_ST7735.h>
|
|
#include <ESP8266WiFi.h>
|
|
#include <ESP8266HTTPClient.h>
|
|
#include <memory>
|
|
#include <SPI.h>
|
|
#include <WiFiClientSecureBearSSL.h>
|
|
|
|
#include "bitmaps.h"
|
|
#include "wifi_credentials.h"
|
|
|
|
#define TFT_CS D8
|
|
#define TFT_DC D4
|
|
#define TFT_RESET D3
|
|
|
|
// Button stuff
|
|
#define BUTTON_PIN D6
|
|
|
|
// Display stuff
|
|
#define FRAME_DELAY 80
|
|
#define COLOR_BG (rgb(0, 0, 0))
|
|
#define COLOR_DIVIDER (rgb(0xff, 0x60, 0x0d))
|
|
#define COLOR_TOP (rgb(0xa0, 0xa0, 0xa0))
|
|
#define COLOR_TEXT (rgb(0xff, 0x60, 0x0d))
|
|
|
|
// Layout
|
|
#define WIDTH 160
|
|
#define HEIGHT 128
|
|
|
|
#define CX 6
|
|
#define CY 8
|
|
|
|
#define MARGIN_LEFT 5
|
|
#define MARGIN_RIGHT 5
|
|
|
|
#define TOP_X MARGIN_LEFT
|
|
#define TOP_Y 4
|
|
#define TOP_WIDTH (WIDTH - 2 * MARGIN_LEFT)
|
|
#define TOP_HEIGHT CY
|
|
|
|
#define MAIN_X MARGIN_LEFT
|
|
#define MAIN_Y 19
|
|
#define MAIN_WIDTH (WIDTH - 2 * MARGIN_LEFT)
|
|
#define MAIN_HEIGHT (8 * CY)
|
|
|
|
#define CLOCK_X MARGIN_LEFT
|
|
#define CLOCK_Y 113
|
|
#define CLOCK_WIDTH (5 * CX)
|
|
#define CLOCK_HEIGHT CY
|
|
|
|
#define STATUS_X 83
|
|
#define STATUS_Y CLOCK_Y
|
|
#define STATUS_WIDTH (12 * CX)
|
|
#define STATUS_HEIGHT CY
|
|
|
|
struct Timetable {
|
|
const char *label;
|
|
const char *path;
|
|
};
|
|
|
|
// Selectable timetables
|
|
Timetable timetables[] = {
|
|
{"Johanneskirche Bstg. 1", "/departures?stop_id=de:08311:30104&platform=1"},
|
|
{"Johanneskirche Bstg. 2", "/departures?stop_id=de:08311:30104&platform=2"},
|
|
{"Blumenthalstr Bstg. A", "/departures?stop_id=de:08221:1225&platform=A"},
|
|
{"Blumenthalstr Bstg. B", "/departures?stop_id=de:08221:1225&platform=B"}
|
|
};
|
|
size_t selectedTimetable = 0;
|
|
|
|
// Function definitions
|
|
void drawLayout();
|
|
void clearTop();
|
|
void clearStatus();
|
|
void clearMain();
|
|
void clearClock();
|
|
uint16_t rgb(uint16_t, uint16_t, uint16_t);
|
|
String fetchDepartures(String);
|
|
|
|
// Peripherals
|
|
|
|
Adafruit_ST7735 display(TFT_CS, TFT_DC, TFT_RESET);
|
|
|
|
// App state interface
|
|
|
|
// init
|
|
// │
|
|
// │
|
|
// │
|
|
// │ ┌───┐
|
|
// ┌──▼──────▼┐ │
|
|
// │Connecting│ │!connected
|
|
// └──┬───▲──┬┘ │
|
|
// │ │ └───┘
|
|
// │ │
|
|
// connected│ │!connected
|
|
// │ │
|
|
// │ │
|
|
// │ │ ┌───┐
|
|
// ┌──▼───┴─┐ timeout (3s) ┌────────▼┐ │
|
|
// │Fetching◄──────────────────┤Selecting│ │
|
|
// └──┬───▲─┘ └────▲───┬┘ │button pressed
|
|
// │ │ │ └───┘
|
|
// got response│ │timeout (25s) │
|
|
// │ │ │
|
|
// │ │ │
|
|
// │ │ │button pressed
|
|
// ┌────▼───┴─────────┐ │
|
|
// │Showing Departures│───────────────┘
|
|
// └──────────────────┘
|
|
|
|
class State {
|
|
public:
|
|
// When the state is entered
|
|
virtual void enter();
|
|
// Called in the business loop
|
|
virtual void tick();
|
|
// Called when the button is pushed
|
|
virtual void button();
|
|
virtual ~State() = default;
|
|
};
|
|
|
|
class StateConnecting : public State {
|
|
public:
|
|
void enter() override;
|
|
void tick() override;
|
|
};
|
|
|
|
class StateFetching : public State {
|
|
public:
|
|
void enter() override;
|
|
};
|
|
|
|
class StateShowingDepartures : public State {
|
|
private:
|
|
// Todo: discard JsonDocument asap, parse into better format
|
|
JsonDocument departures;
|
|
unsigned long entered;
|
|
public:
|
|
StateShowingDepartures(String&);
|
|
void enter() override;
|
|
void tick() override;
|
|
void button() override;
|
|
};
|
|
|
|
class StateSelecting : public State {
|
|
private:
|
|
unsigned long entered;
|
|
public:
|
|
void enter() override;
|
|
void tick() override;
|
|
void button() override;
|
|
};
|
|
|
|
// Empty default implementations
|
|
|
|
void State::enter() {}
|
|
void State::tick() {}
|
|
void State::button() {}
|
|
|
|
// App state implementation
|
|
|
|
uint64_t currentTick = 0;
|
|
// Initially true so that enter() of the initial state is called.
|
|
bool stateChanged = true;
|
|
std::unique_ptr<State> state = std::make_unique<StateConnecting>();
|
|
|
|
template <typename StateType, typename... Args>
|
|
void setState(Args&&... args) {
|
|
state = std::make_unique<StateType>(std::forward<Args>(args)...);
|
|
stateChanged = true;
|
|
}
|
|
|
|
void StateConnecting::enter() {
|
|
Serial.println("Entering StateConnecting");
|
|
|
|
display.fillRect(STATUS_X, STATUS_Y, STATUS_WIDTH, STATUS_HEIGHT, COLOR_BG);
|
|
display.setCursor(STATUS_X, STATUS_Y);
|
|
display.setTextColor(COLOR_TEXT);
|
|
display.printf("connecting");
|
|
}
|
|
|
|
void StateConnecting::tick() {
|
|
if (WiFi.status() != WL_CONNECTED) {
|
|
display.fillRect(STATUS_X + 11 * CX, STATUS_Y, CX, CY, COLOR_BG);
|
|
display.setCursor(STATUS_X + 11 * CX, STATUS_Y);
|
|
display.setTextColor(COLOR_TEXT);
|
|
display.print("|/-\\"[currentTick % 4]);
|
|
delay(125);
|
|
return;
|
|
}
|
|
|
|
setState<StateFetching>();
|
|
}
|
|
|
|
// Fetching is a bit of an ugly duckling; it performs all its logic in enter().
|
|
// This is because the request it does is synchronous.
|
|
// Sadly this means no animation is possible right now.
|
|
// At least the fetch call still does yield() under the hood :)
|
|
void StateFetching::enter() {
|
|
Serial.println("Entering StateFetching");
|
|
|
|
if (WiFi.status() != WL_CONNECTED) {
|
|
setState<StateConnecting>();
|
|
return;
|
|
}
|
|
display.fillRect(STATUS_X, STATUS_Y, STATUS_WIDTH, STATUS_HEIGHT, COLOR_BG);
|
|
display.setTextColor(COLOR_TEXT);
|
|
display.setCursor(STATUS_X, STATUS_Y);
|
|
display.print(" fetching");
|
|
|
|
String departuresRaw = fetchDepartures(timetables[selectedTimetable].path);
|
|
|
|
setState<StateShowingDepartures>(departuresRaw);
|
|
};
|
|
|
|
StateShowingDepartures::StateShowingDepartures(String &departuresRaw) {
|
|
deserializeJson(departures, departuresRaw);
|
|
}
|
|
|
|
void StateShowingDepartures::enter() {
|
|
Serial.println("Entering StateShowingDepartures");
|
|
entered = millis();
|
|
|
|
clearStatus();
|
|
clearMain();
|
|
|
|
// draw timetable
|
|
display.setTextColor(COLOR_TEXT);
|
|
int line = 0;
|
|
for (JsonVariant departure : departures["departures"].as<JsonArray>()) {
|
|
if (line > 8) {
|
|
break;
|
|
}
|
|
|
|
char symbol[3] = {0};
|
|
char direction[16] = {0};
|
|
|
|
utf8ToCP437German(departure["symbol"].as<const char *>(), symbol, std::size(symbol));
|
|
utf8ToCP437German(departure["direction"].as<const char *>(), direction, std::size(direction));
|
|
|
|
display.setCursor(MAIN_X, MAIN_Y + (CY + 3) * line);
|
|
display.printf("%2s %-15.15s ", symbol, direction);
|
|
if (departure["leaving"].as<String>().equals("sofort")) {
|
|
int16_t x = display.getCursorX();
|
|
int16_t y = display.getCursorY();
|
|
display.drawBitmap(x + 6 * CX - tiny_train_dims[0], y, tiny_train[0], tiny_train_dims[0], tiny_train_dims[1], COLOR_TEXT);
|
|
} else {
|
|
display.printf("%6s", departure["leaving"].as<const char*>());
|
|
}
|
|
|
|
line++;
|
|
}
|
|
|
|
clearClock();
|
|
display.setCursor(CLOCK_X, CLOCK_Y);
|
|
display.printf("%5s", departures["serverTime"].as<const char *>());
|
|
}
|
|
|
|
void StateShowingDepartures::tick() {
|
|
unsigned long elapsed = millis() - entered;
|
|
if (elapsed > 25000) {
|
|
setState<StateFetching>();
|
|
}
|
|
}
|
|
|
|
void StateShowingDepartures::button() {
|
|
setState<StateSelecting>();
|
|
}
|
|
|
|
void StateSelecting::enter() {
|
|
Serial.println("Entering StateSelecting");
|
|
entered = millis();
|
|
|
|
clearMain();
|
|
clearStatus();
|
|
}
|
|
|
|
void StateSelecting::tick() {
|
|
unsigned long elapsed = millis() - entered;
|
|
if (elapsed > 3000) {
|
|
setState<StateFetching>();
|
|
}
|
|
}
|
|
|
|
void StateSelecting::button() {
|
|
entered = millis();
|
|
selectedTimetable = (selectedTimetable + 1) % (sizeof timetables / sizeof timetables[0]);
|
|
clearTop();
|
|
display.setCursor(TOP_X, TOP_Y);
|
|
display.setTextColor(COLOR_TOP);
|
|
display.print(timetables[selectedTimetable].label);
|
|
}
|
|
|
|
// button ISR setup
|
|
|
|
int buttonPushed = false;
|
|
|
|
void ICACHE_RAM_ATTR onButtonFalling() {
|
|
buttonPushed = true;
|
|
}
|
|
|
|
void setup() {
|
|
Serial.begin(9600);
|
|
|
|
Serial.println("serial init");
|
|
display.initR();
|
|
display.setSPISpeed(40000000);
|
|
display.cp437(true);
|
|
display.setRotation(3);
|
|
Serial.println("display initialized");
|
|
Serial.printf("display dimensions: %" PRId16 "x%" PRId16 "\n", display.width(), display.height());
|
|
|
|
drawLayout();
|
|
display.setCursor(TOP_X, TOP_Y);
|
|
display.setTextColor(COLOR_TOP);
|
|
display.print(timetables[selectedTimetable].label);
|
|
|
|
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
|
|
|
|
pinMode(BUTTON_PIN, INPUT_PULLUP);
|
|
attachInterrupt(BUTTON_PIN, onButtonFalling, FALLING);
|
|
|
|
state = std::make_unique<StateConnecting>();
|
|
}
|
|
|
|
void loop() {
|
|
if (stateChanged) {
|
|
stateChanged = false;
|
|
// Note: enter() may call setState(). In that case we want to end up right back here.
|
|
state->enter();
|
|
} else if (buttonPushed) {
|
|
// "Handle" jitter
|
|
delay(100);
|
|
buttonPushed = false;
|
|
state->button();
|
|
} else {
|
|
state->tick();
|
|
currentTick++;
|
|
}
|
|
// Let background system do its thing
|
|
yield();
|
|
}
|
|
|
|
uint16_t rgb(uint16_t r, uint16_t g, uint16_t b) {
|
|
// Color layout: RRRRRGGGGGGBBBBB (5, 6, 5)
|
|
return ((b >> 3) & 0b11111) << 11 | ((g >> 2) & 0b111111) << 5 | ((r >> 3) & 0b11111);
|
|
}
|
|
|
|
void clearTop() {
|
|
display.fillRect(TOP_X, TOP_Y, TOP_WIDTH, TOP_HEIGHT, COLOR_BG);
|
|
}
|
|
|
|
void clearMain() {
|
|
display.fillRect(MAIN_X, MAIN_Y, MAIN_WIDTH, MAIN_HEIGHT, COLOR_BG);
|
|
}
|
|
|
|
void clearStatus() {
|
|
display.fillRect(STATUS_X, STATUS_Y, STATUS_WIDTH, STATUS_HEIGHT, COLOR_BG);
|
|
}
|
|
|
|
void clearClock() {
|
|
display.fillRect(CLOCK_X, CLOCK_Y, CLOCK_WIDTH, CLOCK_HEIGHT, COLOR_BG);
|
|
}
|
|
|
|
void drawLayout() {
|
|
display.fillScreen(COLOR_BG);
|
|
display.drawFastHLine(5, 15, 150, COLOR_DIVIDER);
|
|
display.drawFastHLine(5, 109, 150, COLOR_DIVIDER);
|
|
display.drawFastHLine(5, 123, 150, COLOR_DIVIDER);
|
|
}
|
|
|
|
// TODO: Error handling
|
|
String fetchDepartures(String path) {
|
|
std::unique_ptr<BearSSL::WiFiClientSecure> https(new BearSSL::WiFiClientSecure);
|
|
https->setInsecure();
|
|
|
|
HTTPClient client;
|
|
if (!client.begin(*https, "vrnp.beany.club", 443, path)) {
|
|
display.fillScreen(COLOR_BG);
|
|
display.setCursor(0, 0);
|
|
display.print("begin failed");
|
|
for (;;);
|
|
}
|
|
|
|
client.addHeader("Authorization", AUTH_TOKEN);
|
|
client.addHeader("Accept", "application/json");
|
|
int statusCode = client.GET();
|
|
if (statusCode != 200) {
|
|
display.fillScreen(COLOR_BG);
|
|
display.setCursor(0, 0);
|
|
display.printf("http non-ok: %d\n", statusCode);
|
|
for (;;);
|
|
}
|
|
|
|
return client.getString();
|
|
}
|
|
|
|
char mapUtf8CodepointToCP437German(uint32_t codepoint) {
|
|
switch (codepoint) {
|
|
case 0x00e4: return 0x84; // ä
|
|
case 0x00c4: return 0x8e; // Ä
|
|
case 0x00f6: return 0x94; // ö
|
|
case 0x00d6: return 0x99; // Ö
|
|
case 0x00fc: return 0x81; // ü
|
|
case 0x00dc: return 0x9a; // Ü
|
|
case 0x00df: return 0xe1; // ß
|
|
default: return '?';
|
|
}
|
|
}
|
|
|
|
/*
|
|
Maps german umlauts and sharp s from utf8 to cp437 encoding.
|
|
Other utf8 characters and malformed utf8 are replaced by '?'.
|
|
The resulting string is truncated to cp437StrSize.
|
|
*/
|
|
void utf8ToCP437German(const char *utf8Str, char *cp437Str, size_t cp437StrSize) {
|
|
size_t utf8StrLength = strlen(utf8Str);
|
|
size_t utf8StrIndex = 0;
|
|
size_t cp437StrIndex = 0;
|
|
|
|
char c;
|
|
|
|
// One char at the end of the cp437Str is reserved to the terminating null
|
|
while (utf8StrIndex < utf8StrLength && cp437StrIndex + 1 < cp437StrSize) {
|
|
uint8_t cu0 = utf8Str[utf8StrIndex];
|
|
|
|
if (cu0 < 0x80) {
|
|
// ASCII maps to ASCII
|
|
c = cu0;
|
|
utf8StrIndex++;
|
|
} else if ((cu0 & 0b11100000) == 0b11000000) {
|
|
// codepoints encoded as two code units may contain german special characters
|
|
if (utf8StrIndex + 1 >= utf8StrLength) {
|
|
// if there's no 10xxxxxxx byte after this one, we've reached the end (malformed)
|
|
c = '?';
|
|
break;
|
|
} else {
|
|
// otherwise decode the codepoint and map it to cp437
|
|
uint8_t cu1 = utf8Str[utf8StrIndex + 1];
|
|
uint32_t cp = (cu0 & 0x1f << 6) | cu1 & 0x3f;
|
|
c = mapUtf8CodepointToCP437German(cp);
|
|
utf8StrIndex += 2;
|
|
}
|
|
// for 3 and 4-code unit codepoints just put a ? and skip all their code units
|
|
// here we dont care whether the string is malformed
|
|
} else if ((cu0 & 0b11110000) == 0b11100000) {
|
|
c = '?';
|
|
utf8StrIndex += 3;
|
|
} else if ((cu0 & 0b11111000) == 0b11110000) {
|
|
c = '?';
|
|
utf8StrIndex += 4;
|
|
} else {
|
|
// catch all for malformed utf8
|
|
c = '?';
|
|
utf8StrIndex++;
|
|
}
|
|
|
|
cp437Str[cp437StrIndex] = c;
|
|
cp437StrIndex++;
|
|
}
|
|
|
|
cp437Str[cp437StrIndex] = '\0';
|
|
} |