Editor

" + "
RadioSonde "); + strcat(ptr, version_id); + strcat(ptr, ""); +} + +const char *createQRGForm() { + char *ptr = message; + strcpy(ptr, HTMLHEAD); + strcat(ptr, ""); + HTMLBODY(ptr, "qrg.html"); + //strcat(ptr, "

"); + strcat(ptr, "\n"); + strcat(ptr, "

"); + strcat(ptr, "\n"); + //

"); + HTMLSAVEBUTTON(ptr); + HTMLBODYEND(ptr); + Serial.printf("QRG form: size=%d bytes\n", strlen(message)); + return message; +} + +const char *handleQRGPost(AsyncWebServerRequest *request) { + char label[10]; + // parameters: a_i, f_1, t_i (active/frequency/type) + File file = SPIFFS.open("/qrg.txt", "w"); + if (!file) { + Serial.println("Error while opening '/qrg.txt' for writing"); + return "Error while opening '/qrg.txt' for writing"; + } + Serial.println("Handling post request"); +#if 0 + int params = request->params(); + for (int i = 0; i < params; i++) { + String pname = request->getParam(i)->name(); + Serial.println(pname.c_str()); + } +#endif + for (int i = 1; i <= sonde.config.maxsonde; i++) { + snprintf(label, 10, "A%d", i); + AsyncWebParameter *active = request->getParam(label, true); + snprintf(label, 10, "F%d", i); + AsyncWebParameter *freq = request->getParam(label, true); + snprintf(label, 10, "S%d", i); + AsyncWebParameter *launchsite = request->getParam(label, true); + if (!freq) continue; + snprintf(label, 10, "T%d", i); + AsyncWebParameter *type = request->getParam(label, true); + if (!type) continue; + String fstring = freq->value(); + String tstring = type->value(); + String sstring = launchsite->value(); + const char *fstr = fstring.c_str(); + const char *tstr = tstring.c_str(); + const char *sstr = sstring.c_str(); + if (*tstr == '6' || *tstr == '9') tstr = "D"; + Serial.printf("Processing a=%s, f=%s, t=%s, site=%s\n", active ? "YES" : "NO", fstr, tstr, sstr); + char typech = tstr[0]; + file.printf("%3.3f %c %c %s\n", atof(fstr), typech, active ? '+' : '-', sstr); + } + file.close(); + + Serial.println("Channel setup finished\n"); + setupChannelList(); + return ""; +} + + +/////////////////// Functions for reading/writing Wifi networks from networks.txt + +#define MAX_WIFI 10 +int nNetworks; +struct { + String id; + String pw; +} networks[MAX_WIFI]; + +// FIXME: For now, we don't uspport wifi networks that contain newline or null characters +// ... would require a more sophisicated file format (currently one line SSID; one line Password +void setupWifiList() { + File file = SPIFFS.open("/networks.txt", "r"); + if (!file) { + Serial.println("There was an error opening the file '/networks.txt' for reading"); + networks[0].id = "RDZsonde"; + networks[0].pw = "RDZsonde"; + return; + } + int i = 0; + + while (file.available()) { + String line = readLine(file); //file.readStringUntil('\n'); + if (!file.available()) break; + networks[i].id = line; + networks[i].pw = readLine(file); // file.readStringUntil('\n'); + i++; + } + nNetworks = i; + Serial.print(i); Serial.println(" networks in networks.txt\n"); + for (int j = 0; j < i; j++) { + Serial.print(networks[j].id); + Serial.print(": "); + Serial.println(networks[j].pw); + } +} + + +const char *createWIFIForm() { + char *ptr = message; + char tmp[4]; + strcpy(ptr, HTMLHEAD); + strcat(ptr, ""); + HTMLBODY(ptr, "wifi.html"); + strcat(ptr, "

ID	Active	Freq	Launchsite	Mode

"); + for (int i = 0; i < MAX_WIFI; i++) { + sprintf(tmp, "%d", i); + sprintf(ptr + strlen(ptr), "" + "", + i == 0 ? "AP" : tmp, + i + 1, i < nNetworks ? networks[i].id.c_str() : "", + i + 1, i < nNetworks ? networks[i].pw.c_str() : ""); + } + strcat(ptr, "

Nr	SSID	Password
%s

"); + //

"); + HTMLSAVEBUTTON(ptr); + HTMLBODYEND(ptr); + Serial.printf("WIFI form: size=%d bytes\n", strlen(message)); + return message; +} + +#if 0 + // moved to map.html (active warning is still TODO +const char *createSondeHubMap() { + SondeInfo *s = &sonde.sondeList[0]; + char *ptr = message; + strcpy(ptr, HTMLHEAD); strcat(ptr, ""); + HTMLBODY(ptr, "map.html"); + if (!sonde.config.sondehub.active) { + strcat(ptr, "

NOTE: SondeHub uploading is not enabled, detected sonde will not be visable on map

"); + if ((*s->d.ser == 0) && ( !isnan(sonde.config.rxlat))) { + sprintf(ptr + strlen(ptr), "", sonde.config.rxlat, sonde.config.rxlon); + } else { + sprintf(ptr + strlen(ptr), "", s->d.ser); + } + } else { + if ((*s->d.ser == 0) && (!isnan(sonde.config.rxlat))) { + sprintf(ptr, "", sonde.config.rxlat, sonde.config.rxlon); + } else { + sprintf(ptr, "", s->d.ser); + } + } + HTMLBODYEND(ptr); + return message; +} +#endif + +const char *handleWIFIPost(AsyncWebServerRequest *request) { + char label[10]; + // parameters: a_i, f_1, t_i (active/frequency/type) +#if 1 + File f = SPIFFS.open("/networks.txt", "w"); + if (!f) { + Serial.println("Error while opening '/networks.txt' for writing"); + return "Error while opening '/networks.txt' for writing"; + } +#endif + Serial.println("Handling post request"); +#if 0 + int params = request->params(); + for (int i = 0; i < params; i++) { + String param = request->getParam(i)->name(); + Serial.println(param.c_str()); + } +#endif + for (int i = 1; i <= MAX_WIFI; i++) { + snprintf(label, 10, "S%d", i); + AsyncWebParameter *ssid = request->getParam(label, true); + if (!ssid) continue; + snprintf(label, 10, "P%d", i); + AsyncWebParameter *pw = request->getParam(label, true); + if (!pw) continue; + String sstring = ssid->value(); + String pstring = pw->value(); + const char *sstr = sstring.c_str(); + const char *pstr = pstring.c_str(); + if (strlen(sstr) == 0) continue; + Serial.printf("Processing S=%s, P=%s\n", sstr, pstr); + f.printf("%s\n%s\n", sstr, pstr); + } + f.close(); + setupWifiList(); + return ""; +} + +// Show current status +void addSondeStatus(char *ptr, int i) +{ + struct tm ts; + SondeInfo *s = &sonde.sondeList[i]; + strcat(ptr, ""); + sprintf(ptr + strlen(ptr), "\n", s->d.lat, s->d.lon, s->d.alt); + const time_t t = s->d.time; + ts = *gmtime(&t); + sprintf(ptr + strlen(ptr), "", + s->d.frame, s->d.sats, ts.tm_year + 1900, ts.tm_mon + 1, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec); + if (s->type == STYPE_RS41) { + sprintf(ptr + strlen(ptr), "\n", + s->d.burstKT, s->d.launchKT, s->d.countKT, ((uint16_t)s->d.frame - s->d.crefKT)); + } + sprintf(ptr + strlen(ptr), "", s->d.lat, s->d.lon); + + strcat(ptr, "

%3.3f MHz, Type: %s

ID: %s", s->freq, sondeTypeLongStr[sonde.realType(s)], + s->d.validID ? s->d.id : ""); + if (s->d.validID && (TYPE_IS_DFM(s->type) || TYPE_IS_METEO(s->type) || s->type == STYPE_MP3H) ) { + sprintf(ptr + strlen(ptr), " (ser: %s)", s->d.ser); + } + sprintf(ptr + strlen(ptr), "

QTH: %.6f,%.6f h=%.0fm

Frame# %u, Sats=%d, %04d-%02d-%02d %02d:%02d:%02d

Burst-KT=%d Launch-KT=%d Countdown=%d (vor %ds)

GEO-App - ", s->d.lat, s->d.lon); + sprintf(ptr + strlen(ptr), "radiosondy.info - ", s->d.id); + sprintf(ptr + strlen(ptr), "SondeHub Tracker - ", s->d.ser); + sprintf(ptr + strlen(ptr), "OSM - ", s->d.lat, s->d.lon); + sprintf(ptr + strlen(ptr), "Google

\n"); +} + +const char *createStatusForm() { + char *ptr = message; + strcpy(ptr, HTMLHEAD); + strcat(ptr, ""); + HTMLBODY(ptr, "status.html"); + strcat(ptr, "

"); + + for (int i = 0; i < sonde.config.maxsonde; i++) { + int snum = (i + sonde.currentSonde) % sonde.config.maxsonde; + if (sonde.sondeList[snum].active) { + addSondeStatus(ptr, snum); + } + } + strcat(ptr, "

" + "RadioSonde "); + strcat(ptr, version_id); + strcat(ptr, ""); + + HTMLBODYEND(ptr); + Serial.printf("Status form: size=%d bytes\n", strlen(message)); + return message; +} + +const char *createLiveJson() { + char *ptr = message; + SondeInfo *s = &sonde.sondeList[sonde.currentSonde]; + + strcpy(ptr, "{\"sonde\": {"); + // use the same JSON format here as for MQTT and for the Android App + sonde2json( ptr+strlen(ptr), 1024, s ); +#if 0 + sprintf(ptr + strlen(ptr), "\"sonde\": {\"rssi\": %d, \"vframe\": %d, \"time\": %d,\"id\": \"%s\", \"freq\": %3.3f, \"type\": \"%s\"", + s->rssi, s->d.vframe, s->d.time, s->d.id, s->freq, sondeTypeStr[sonde.realType(s)]); + + if ( !isnan(s->d.lat) && !isnan(s->d.lon) ) + sprintf(ptr + strlen(ptr), ", \"lat\": %.6f, \"lon\": %.6f", s->d.lat, s->d.lon); + if ( !isnan(s->d.alt) ) + sprintf(ptr + strlen(ptr), ", \"alt\": %.0f", s->d.alt); + if ( !isnan(s->d.dir) ) + sprintf(ptr + strlen(ptr), ", \"dir\": %.0f", s->d.dir); + if ( !isnan(s->d.vs) ) + sprintf(ptr + strlen(ptr), ", \"climb\": %.1f", s->d.vs); + if ( !isnan(s->d.hs) ) + sprintf(ptr + strlen(ptr), ", \"speed\": %.1f", s->d.hs); + + sprintf(ptr + strlen(ptr), ", \"launchsite\": \"%s\", \"res\": %d }", s->launchsite, s->rxStat[0]); +#endif + strcat(ptr, " }"); + if (gpsPos.valid) { + sprintf(ptr + strlen(ptr), ", \"gps\": {\"lat\": %g, \"lon\": %g, \"alt\": %d, \"sat\": %d, \"speed\": %g, \"dir\": %d, \"hdop\": %d }", gpsPos.lat, gpsPos.lon, gpsPos.alt, gpsPos.sat, gpsPos.speed, gpsPos.course, gpsPos.hdop); + //} + } else { + // no GPS position, but maybe a fixed position + if ((!isnan(sonde.config.rxlat)) && (!isnan(sonde.config.rxlon))) { + int alt = isnan(sonde.config.rxalt) ? 0 : (int)sonde.config.rxalt; + sprintf(ptr + strlen(ptr), ", \"gps\": {\"lat\": %g, \"lon\": %g, \"alt\": %d, \"sat\": 0, \"speed\": 0, \"dir\": 0, \"hdop\": 0 }", sonde.config.rxlat, sonde.config.rxlon, alt); + } + } + + strcat(ptr, "}"); + return message; +} +///////////////////// Config form + + +void setupConfigData() { + File file = SPIFFS.open("/config.txt", "r"); + if (!file) { + Serial.println("There was an error opening the file '/config.txt' for reading"); + return; + } + while (file.available()) { + String line = readLine(file); //file.readStringUntil('\n'); + sonde.setConfig(line.c_str()); + } + sonde.checkConfig(); // eliminate invalid entries +#if FEATURE_SONDEHUB + shImportInterval = 5; // refresh now in 5 seconds +#endif +} + + +struct st_configitems config_list[] = { + /* General config settings */ + {"wifi", 0, &sonde.config.wifi}, + {"debug", 0, &sonde.config.debug}, + {"maxsonde", 0, &sonde.config.maxsonde}, + {"rxlat", -7, &sonde.config.rxlat}, + {"rxlon", -7, &sonde.config.rxlon}, + {"rxalt", -7, &sonde.config.rxalt}, + {"screenfile", 0, &sonde.config.screenfile}, + {"display", -6, sonde.config.display}, + {"dispsaver", 0, &sonde.config.dispsaver}, + {"dispcontrast", 0, &sonde.config.dispcontrast}, + /* Spectrum display settings */ + {"spectrum", 0, &sonde.config.spectrum}, + {"startfreq", 0, &sonde.config.startfreq}, + {"channelbw", 0, &sonde.config.channelbw}, + {"marker", 0, &sonde.config.marker}, + {"noisefloor", 0, &sonde.config.noisefloor}, + /* decoder settings */ + {"freqofs", 0, &sonde.config.freqofs}, + {"rs41.agcbw", 0, &sonde.config.rs41.agcbw}, + {"rs41.rxbw", 0, &sonde.config.rs41.rxbw}, + {"rs92.rxbw", 0, &sonde.config.rs92.rxbw}, + {"rs92.alt2d", 0, &sonde.config.rs92.alt2d}, + {"dfm.agcbw", 0, &sonde.config.dfm.agcbw}, + {"dfm.rxbw", 0, &sonde.config.dfm.rxbw}, + {"m10m20.agcbw", 0, &sonde.config.m10m20.agcbw}, + {"m10m20.rxbw", 0, &sonde.config.m10m20.rxbw}, + {"mp3h.agcbw", 0, &sonde.config.mp3h.agcbw}, + {"mp3h.rxbw", 0, &sonde.config.mp3h.rxbw}, + {"ephftp", 39, &sonde.config.ephftp}, + /* APRS settings */ + {"call", 9, sonde.config.call}, + {"passcode", 0, &sonde.config.passcode}, + /* KISS tnc settings */ + {"kisstnc.active", 0, &sonde.config.kisstnc.active}, + /* AXUDP settings */ + {"axudp.active", -3, &sonde.config.udpfeed.active}, + {"axudp.host", 63, sonde.config.udpfeed.host}, + {"axudp.port", 0, &sonde.config.udpfeed.port}, + {"axudp.highrate", 0, &sonde.config.udpfeed.highrate}, + /* APRS TCP settings, current not used */ + {"tcp.active", -3, &sonde.config.tcpfeed.active}, + {"tcp.host", 63, sonde.config.tcpfeed.host}, + {"tcp.port", 0, &sonde.config.tcpfeed.port}, + {"tcp.chase", 0, &sonde.config.chase}, + {"tcp.comment", 30, sonde.config.comment}, + {"tcp.objcall", 9, sonde.config.objcall}, + {"tcp.beaconsym", 4, sonde.config.beaconsym}, + {"tcp.highrate", 0, &sonde.config.tcpfeed.highrate}, +#if FEATURE_CHASEMAPPER + /* Chasemapper settings */ + {"cm.active", -3, &sonde.config.cm.active}, + {"cm.host", 63, &sonde.config.cm.host}, + {"cm.port", 0, &sonde.config.cm.port}, +#endif +#if FEATURE_MQTT + /* MQTT */ + {"mqtt.active", 0, &sonde.config.mqtt.active}, + {"mqtt.id", 63, &sonde.config.mqtt.id}, + {"mqtt.host", 63, &sonde.config.mqtt.host}, + {"mqtt.port", 0, &sonde.config.mqtt.port}, + {"mqtt.username", 63, &sonde.config.mqtt.username}, + {"mqtt.password", 63, &sonde.config.mqtt.password}, + {"mqtt.prefix", 63, &sonde.config.mqtt.prefix}, +#endif + + /* Hardware dependeing settings */ + {"disptype", 0, &sonde.config.disptype}, + {"norx_timeout", 0, &sonde.config.norx_timeout}, + {"oled_sda", 0, &sonde.config.oled_sda}, + {"oled_scl", 0, &sonde.config.oled_scl}, + {"oled_rst", 0, &sonde.config.oled_rst}, + {"button_pin", -4, &sonde.config.button_pin}, + {"button2_pin", -4, &sonde.config.button2_pin}, + {"button2_axp", 0, &sonde.config.button2_axp}, + {"touch_thresh", 0, &sonde.config.touch_thresh}, + {"power_pout", 0, &sonde.config.power_pout}, + {"led_pout", 0, &sonde.config.led_pout}, + {"gps_rxd", 0, &sonde.config.gps_rxd}, + {"gps_txd", 0, &sonde.config.gps_txd}, + {"batt_adc", 0, &sonde.config.batt_adc}, +#if 1 + {"sx1278_ss", 0, &sonde.config.sx1278_ss}, + {"sx1278_miso", 0, &sonde.config.sx1278_miso}, + {"sx1278_mosi", 0, &sonde.config.sx1278_mosi}, + {"sx1278_sck", 0, &sonde.config.sx1278_sck}, +#endif + {"mdnsname", 14, &sonde.config.mdnsname}, + {"buzzerOn", 0, &sonde.config.buzzerOn}, + {"buzzerPort", 0, &sonde.config.buzzerPort}, + {"buzzerFreq", 0, &sonde.config.buzzerFreq}, + {"dbsmetre", 0, &sonde.config.dbsmetre}, + {"degdec", 0, &sonde.config.degdec}, + +#if FEATURE_SONDEHUB + /* SondeHub settings */ + {"sondehub.active", 0, &sonde.config.sondehub.active}, + {"sondehub.chase", 0, &sonde.config.sondehub.chase}, + {"sondehub.host", 63, &sonde.config.sondehub.host}, + {"sondehub.callsign", 63, &sonde.config.sondehub.callsign}, + {"sondehub.antenna", 63, &sonde.config.sondehub.antenna}, + {"sondehub.email", 63, &sonde.config.sondehub.email}, + {"sondehub.fiactive", 0, &sonde.config.sondehub.fiactive}, + {"sondehub.fiinterval", 0, &sonde.config.sondehub.fiinterval}, + {"sondehub.fimaxdist", 0, &sonde.config.sondehub.fimaxdist}, + {"sondehub.fimaxage", -7, &sonde.config.sondehub.fimaxage}, +#endif +}; + +const int N_CONFIG = (sizeof(config_list) / sizeof(struct st_configitems)); + +const char *createConfigForm() { + char *ptr = message; + strcpy(ptr, HTMLHEAD); + strcat(ptr, ""); + HTMLBODY(ptr, "config.html"); + strcat(ptr, "

"); + strcat(ptr, ""); + strcat(ptr, ""); + strcat(ptr, ""); + HTMLSAVEBUTTON(ptr); + HTMLBODYEND(ptr); + Serial.printf("Config form: size=%d bytes\n", strlen(message)); + return message; +} + + +const char *handleConfigPost(AsyncWebServerRequest * request) { + // parameters: a_i, f_1, t_i (active/frequency/type) + Serial.println("Handling post request"); +#if 1 + File f = SPIFFS.open("/config.txt", "w"); + if (!f) { + Serial.println("Error while opening '/config.txt' for writing"); + return "Error while opening '/config.txt' for writing"; + } +#endif + Serial.println("File open for writing."); + int params = request->params(); +#if 0 + for (int i = 0; i < params; i++) { + String param = request->getParam(i)->name(); + Serial.println(param.c_str()); + } +#endif + for (int i = 0; i < params; i++) { + String strlabel = request->getParam(i)->name(); + const char *label = strlabel.c_str(); + if (label[strlen(label) - 1] == '#') continue; + AsyncWebParameter *value = request->getParam(label, true); + if (!value) continue; + String strvalue = value->value(); + if ( strcmp(label, "button_pin") == 0 || + strcmp(label, "button2_pin") == 0) { + AsyncWebParameter *touch = request->getParam(strlabel + "#", true); + if (touch) { + int i = atoi(strvalue.c_str()); + if (i != -1 && i != 255) i += 128; + strvalue = String(i); + } + } + Serial.printf("Processing %s=%s\n", label, strvalue.c_str()); + //int wlen = f.printf("%s=%s\n", config_list[idx].name, strvalue.c_str()); + int wlen = f.printf("%s=%s\n", label, strvalue.c_str()); + Serial.printf("Written bytes: %d\n", wlen); + } + Serial.printf("Flushing file\n"); + f.flush(); + Serial.printf("Closing file\n"); + f.close(); + Serial.printf("Re-reading file file\n"); + setupConfigData(); + // TODO: Check if this is better done elsewhere? + // Use new config (whereever this is feasible without a reboot) + disp.setContrast(); + return ""; +} + +const char *ctrlid[] = {"rx", "scan", "spec", "wifi", "rx2", "scan2", "spec2", "wifi2", "reboot"}; + +const char *ctrllabel[] = {"Receiver/next freq. (short keypress)", "Scanner (double keypress)", "Spectrum (medium keypress)", "WiFi (long keypress)", + "Button 2/next screen (short keypress)", "Button 2 (double keypress)", "Button 2 (medium keypress)", "Button 2 (long keypress)", + "Reboot" + }; + +const char *createControlForm() { + char *ptr = message; + strcpy(ptr, HTMLHEAD); + strcat(ptr, ""); + HTMLBODY(ptr, "control.html"); + for (int i = 0; i < 9; i++) { + strcat(ptr, ""); + if (i == 3 || i == 7 ) { + strcat(ptr, "

"); + } + } + strcat(ptr, "

" + "RadioSonde "); + strcat(ptr, version_id); + strcat(ptr, ""); + HTMLBODYEND(ptr); + Serial.printf("Control form: size=%d bytes\n", strlen(message)); + return message; +} + + +const char *handleControlPost(AsyncWebServerRequest * request) { + Serial.println("Handling post request"); + int params = request->params(); + for (int i = 0; i < params; i++) { + String param = request->getParam(i)->name(); + Serial.println(param.c_str()); + if (param.equals("rx")) { + Serial.println("equals rx"); + button1.pressed = KP_SHORT; + } + else if (param.equals("scan")) { + Serial.println("equals scan"); + button1.pressed = KP_DOUBLE; + } + else if (param.equals("spec")) { + Serial.println("equals spec"); + button1.pressed = KP_MID; + } + else if (param.equals("wifi")) { + Serial.println("equals wifi"); + button1.pressed = KP_LONG; + } + else if (param.equals("rx2")) { + Serial.println("equals rx2"); + button2.pressed = KP_SHORT; + } + else if (param.equals("scan2")) { + Serial.println("equals scan2"); + button2.pressed = KP_DOUBLE; + } + else if (param.equals("spec2")) { + Serial.println("equals spec2"); + button2.pressed = KP_MID; + } + else if (param.equals("wifi2")) { + Serial.println("equals wifi2"); + button2.pressed = KP_LONG; + } + else if (param.equals("reboot")) { + Serial.println("equals reboot"); + ESP.restart(); + } + } + return ""; +} + +void handleUpload(AsyncWebServerRequest * request, String filename, size_t index, uint8_t *data, size_t len, bool final) { + static File file; + if (!index) { + Serial.printf("UploadStart: %s\n", filename.c_str()); + file = SPIFFS.open("/" + filename, "w"); + if (!file) { + Serial.println("There was an error opening the file '/config.txt' for reading"); + } + } + if (!file) return; + for (size_t i = 0; i < len; i++) { + file.write(data[i]); + } + if (final) { + Serial.printf("UploadEnd: %s, %u B\n", filename.c_str(), index + len); + file.close(); + } +} + + +int streamEditForm(int &state, File & file, String filename, char *buffer, size_t maxlen, size_t index) { + Serial.printf("streamEdit: state=%d max:%d idx:%d\n", state, maxlen, index); + int i = 0; + switch (state) { + case 0: // header + { + // we optimistically assume that on first invocation, maxlen is large enough to handle the header..... + strncpy(buffer, "Editor

Edit: ", maxlen); + i = strlen(buffer); + strncpy(buffer + i, filename.c_str(), maxlen - i); + i += strlen(buffer + i); + strncpy(buffer + i, "

", maxlen); + state++; + return strlen(buffer); + case 3: // end + return 0; + } + return 0; +} + +// bad idea. prone to buffer overflow. use at your own risk... +const char *createEditForm(String filename) { + Serial.println("Creating edit form"); + char *ptr = message; + File file = SPIFFS.open("/" + filename, "r"); + if (!file) { + Serial.println("There was an error opening the file '/config.txt' for reading"); + return "File not foundFile not found"; + } + + strcpy(ptr, "Editor "); + strcat(ptr, filename.c_str()); + strcat(ptr, ""); + Serial.printf("Edit form: size=%d bytes\n", strlen(message)); + return message; +} + + +const char *handleEditPost(AsyncWebServerRequest * request) { + Serial.println("Handling post request"); + int params = request->params(); + Serial.printf("Post:, %d params\n", params); + for (int i = 0; i < params; i++) { + AsyncWebParameter* p = request->getParam(i); + String name = p->name(); + String value = p->value(); + if (name.c_str() == NULL) { + name = String("NULL"); + } + if (value.c_str() == NULL) { + value = String("NULL"); + } + if (p->isFile()) { + Serial.printf("_FILE[%s]: %s, size: %u\n", name.c_str(), value.c_str(), p->size()); + } else if (p->isPost()) { + Serial.printf("_POST[%s]: %s\n", name.c_str(), value.c_str()); + } else { + Serial.printf("_GET[%s]: %s\n", name.c_str(), value.c_str()); + } + } + + AsyncWebParameter *filep = request->getParam("file"); + if (!filep) return NULL; + String filename = filep->value(); + Serial.printf("Writing file <%s>\n", filename.c_str()); + AsyncWebParameter *textp = request->getParam("text", true); + if (!textp) return NULL; + Serial.printf("Parameter size is %d\n", textp->size()); + Serial.printf("Multipart: %d contentlen=%d \n", + request->multipart(), request->contentLength()); + String content = textp->value(); + if (content.length() == 0) { + Serial.println("File is empty. Not written."); + return NULL; + } + File file = SPIFFS.open("/" + filename, "w"); + if (!file) { + Serial.println("There was an error opening the file '/" + filename + "'for writing"); + return ""; + } + Serial.printf("File is open for writing, content is %d bytes\n", content.length()); + int len = file.print(content); + file.close(); + Serial.printf("Written: %d bytes\n", len); + if (strncmp(filename.c_str(), "screens", 7) == 0) { + // screens update => reload + forceReloadScreenConfig = true; + } + return ""; +} + +const char *createUpdateForm(boolean run) { + char *ptr = message; + strcpy(ptr, ""); + Serial.printf("Update form: size=%d bytes\n", strlen(message)); + return message; +} + +const char *handleUpdatePost(AsyncWebServerRequest * request) { + Serial.println("Handling post request"); + int params = request->params(); + for (int i = 0; i < params; i++) { + String param = request->getParam(i)->name(); + Serial.println(param.c_str()); + if (param.equals("devel")) { + Serial.println("equals devel"); + updateBin = &updateBinD; + } + else if (param.equals("master")) { + Serial.println("equals master"); + updateBin = &updateBinM; + } + } + Serial.println("Updating: " + *updateBin); + enterMode(ST_UPDATE); + return ""; +} + +const char *createKMLLive(const char *myIP) { + char *ptr = message; + + strcpy(ptr, "loads dynamic.kmlhttp://"); + strcat(ptr, myIP); + strcat(ptr, "/dynamic.kmlonInterval10"); + + return message; +} + +void addSondeStatusKML(char *ptr, int i) +{ + SondeInfo *s = &sonde.sondeList[i]; + + if (!s->d.validID) + { + return; + } + + sprintf(ptr + strlen(ptr), "%sabsolute%.6f,%.6f,%.0f%3.3f MHz, Type: %s, h=%.0fm", + s->d.id, s->d.id, + s->d.lon, s->d.lat, s->d.alt, + s->freq, sondeTypeStr[sonde.realType(s)], s->d.alt); +} + +const char *createKMLDynamic() { + char *ptr = message; + + strcpy(ptr, ""); + + for (int i = 0; i < sonde.config.maxsonde; i++) { + int snum = (i + sonde.currentSonde) % sonde.config.maxsonde; + if (sonde.sondeList[snum].active) { + addSondeStatusKML(ptr, snum); + } + } + + strcat(ptr, ""); + + return message; +} + + +const char *sendGPX(AsyncWebServerRequest * request) { + Serial.println("\n\n\n********GPX request\n\n"); + String url = request->url(); + int index = atoi(url.c_str() + 1); + char *ptr = message; + if (index < 0 || index >= MAXSONDE) { + return "ERROR"; + } + SondeInfo *si = &sonde.sondeList[index]; + strcpy(si->d.id, "test"); + si->d.lat = 48; si->d.lon = 11; si->d.alt = 500; + snprintf(ptr, 10240, "\n" + "\n" + "" + "Sonde #%d (%s)\n" + "rdzTTGOsonde\n" + "\n" + "\n %f\n %s\n Radio BeaconSonde\n" + "\n", index, si->d.id, si->d.lat, si->d.lon, si->d.alt, si->d.id); + Serial.println(message); + return message; +} + + +const char* PARAM_MESSAGE = "message"; +void SetupAsyncServer() { + Serial.println("SetupAsyncServer()\n"); + server.reset(); + // Route for root / web page + server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(SPIFFS, "/index.html", String(), false, processor); + }); + + server.on("/index.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(SPIFFS, "/index.html", String(), false, processor); + }); + + server.on("/download", HTTP_GET, [](AsyncWebServerRequest *request){ + request->send(SPIFFS, "/data.csv", "text/plain", true); + }); + + server.on("/test.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(SPIFFS, "/test.html", String(), false, processor); + }); + + server.on("/qrg.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createQRGForm()); + }); + server.on("/qrg.html", HTTP_POST, [](AsyncWebServerRequest * request) { + handleQRGPost(request); + request->send(200, "text/html", createQRGForm()); + }); + + server.on("/wifi.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createWIFIForm()); + }); + server.on("/wifi.html", HTTP_POST, [](AsyncWebServerRequest * request) { + handleWIFIPost(request); + request->send(200, "text/html", createWIFIForm()); + }); +/* + server.on("/map.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createSondeHubMap()); + }); + server.on("/map.html", HTTP_POST, [](AsyncWebServerRequest * request) { + handleWIFIPost(request); + request->send(200, "text/html", createSondeHubMap()); + }); +*/ + server.on("/config.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createConfigForm()); + }); + server.on("/config.html", HTTP_POST, [](AsyncWebServerRequest * request) { + handleConfigPost(request); + request->send(200, "text/html", createConfigForm()); + }); + + server.on("/status.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createStatusForm()); + }); + server.on("/live.json", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/json", createLiveJson()); + }); + server.on("/livemap.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(SPIFFS, "/livemap.html", String(), false, processor); + }); + server.on("/livemap.js", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(SPIFFS, "/livemap.js", String(), false, processor); + }); + server.on("/update.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createUpdateForm(0)); + }); + server.on("/update.html", HTTP_POST, [](AsyncWebServerRequest * request) { + handleUpdatePost(request); + request->send(200, "text/html", createUpdateForm(1)); + }); + + server.on("/control.html", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "text/html", createControlForm()); + }); + server.on("/control.html", HTTP_POST, [](AsyncWebServerRequest * request) { + handleControlPost(request); + request->send(200, "text/html", createControlForm()); + }); + + server.on("/file", HTTP_GET, [](AsyncWebServerRequest * request) { + String url = request->url(); + const char *filename = url.c_str() + 5; + if (*filename == 0) { + request->send(400, "error"); + return; + } + request->send(SPIFFS, filename, "text/plain"); + }); + server.on("/file", HTTP_POST, [](AsyncWebServerRequest * request) { + request->send(200); + }, handleUpload); + + server.on("/edit.html", HTTP_GET, [](AsyncWebServerRequest * request) { + // new version: + // Open file + // store file object in request->_tempObject + //request->send(200, "text/html", createEditForm(request->getParam(0)->value())); + const String filename = request->getParam(0)->value(); + File file = SPIFFS.open("/" + filename, "r"); + int state = 0; + request->send("text/html", 0, [state, file, filename](uint8_t *buffer, size_t maxLen, size_t index) mutable -> size_t { + Serial.printf("******* send callback: %d %d %d\n", state, maxLen, index); + return streamEditForm(state, file, filename, (char *)buffer, maxLen, index); + }); + }); + server.on("/edit.html", HTTP_POST, [](AsyncWebServerRequest * request) { + const char *ret = handleEditPost(request); + if (ret == NULL) + request->send(200, "text/html", "ERROR

Something went wrong (probably ESP32 out of memory). Uploaded file is empty.

"); + else { + String f = request->getParam(0)->value(); + request->redirect("/edit.html?file=" + f); + //request->send(200, "text/html", createEditForm(request->getParam(0)->value())); + } + }, + NULL, + [](AsyncWebServerRequest * request, uint8_t *data, size_t len, size_t index, size_t total) { + Serial.printf("post data: index=%d len=%d total=%d\n", index, len, total); + }); + + // Route to load style.css file + server.on("/style.css", HTTP_GET, [](AsyncWebServerRequest * request) { + AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/style.css", "text/css"); + response->addHeader("Cache-Control", "max-age=86400"); + request->send(response); + }); + + server.on("/live.kml", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "application/vnd.google-earth.kml+xml", createKMLLive(sonde.ipaddr.c_str())); + }); + + server.on("/dynamic.kml", HTTP_GET, [](AsyncWebServerRequest * request) { + request->send(200, "application/vnd.google-earth.kml+xml", createKMLDynamic()); + }); + + server.onNotFound([](AsyncWebServerRequest * request) { + if (request->method() == HTTP_OPTIONS) { + request->send(200); + } else { + String url = request->url(); + if (url.endsWith(".gpx")) + request->send(200, "application/gpx+xml", sendGPX(request)); + else { + // TODO: set correct type for .js + request->send(SPIFFS, url, "text/html"); + Serial.printf("URL is %s\n", url.c_str()); + //request->send(404); + } + } + }); + + // Start server + server.begin(); +} + +int fetchWifiIndex(const char *id) { + for (int i = 0; i < nNetworks; i++) { + if (strcmp(id, networks[i].id.c_str()) == 0) { + Serial.printf("Match for %s at %d\n", id, i); + return i; + } + //Serial.printf("No match: '%s' vs '%s'\n", id, networks[i].id.c_str()); + const char *cfgid = networks[i].id.c_str(); + int len = strlen(cfgid); + if (strlen(id) > len) len = strlen(id); + } + return -1; +} + +const char *fetchWifiSSID(int i) { + return networks[i].id.c_str(); +} +const char *fetchWifiPw(int i) { + return networks[i].pw.c_str(); +} + +const char *fetchWifiPw(const char *id) { + for (int i = 0; i < nNetworks; i++) { + //Serial.print("Comparing '"); + //Serial.print(id); + //Serial.print("' and '"); + //Serial.print(networks[i].id.c_str()); + //Serial.println("'"); + if (strcmp(id, networks[i].id.c_str()) == 0) return networks[i].pw.c_str(); + } + return NULL; +} + +// It is not safe to call millis() in ISR!!! +// millis() does a division int64_t by 1000 for which gcc creates a library call +// on a 32bit system, and the called function has no IRAM_ATTR +// so doing it manually... +// Code adapted for 64 bits from https://www.hackersdelight.org/divcMore.pdf +int64_t IRAM_ATTR divs10(int64_t n) { + int64_t q, r; + n = n + (n >> 63 & 9); + q = (n >> 1) + (n >> 2); + q = q + (q >> 4); + q = q + (q >> 8); + q = q + (q >> 16); + q = q + (q >> 32); + q = q >> 3; + r = n - q * 10; + return q + ((r + 6) >> 4); + // return q + (r > 9); +} + +int64_t IRAM_ATTR divs1000(int64_t n) { + return divs10(divs10(divs10(n))); +} + +unsigned long IRAM_ATTR my_millis() +{ + return divs1000(esp_timer_get_time()); +} + +void checkTouchStatus(); +void touchISR(); +void touchISR2(); + +// ISR won't work for SPI transfer, so forget about the following approach +///// Also initialized timers for sx1278 handling with interruts +///// fastest mode currentily is 4800 bit/s, i.e. 600 bytes/sec +///// 64 byte FIFO will last for at most about 106 ms. +///// lets use a timer every 20ms to handle sx1278 FIFO input, that should be fine. +// Instead create a tast... + +Ticker ticker; +Ticker ledFlasher; + +#define IS_TOUCH(x) (((x)!=255)&&((x)!=-1)&&((x)&128)) +void initTouch() { + // also used for LED + ticker.attach_ms(300, checkTouchStatus); + + if ( !(IS_TOUCH(sonde.config.button_pin) || IS_TOUCH(sonde.config.button2_pin)) ) return; // no touch buttons configured + /* + * ** no. readTouch is not safe to use in ISR! + so now using Ticker + hw_timer_t *timer = timerBegin(0, 80, true); + timerAttachInterrupt(timer, checkTouchStatus, true); + timerAlarmWrite(timer, 300000, true); + timerAlarmEnable(timer); + */ + if ( IS_TOUCH(sonde.config.button_pin) ) { + touchAttachInterrupt(sonde.config.button_pin & 0x7f, touchISR, sonde.config.touch_thresh); + Serial.printf("Initializing touch 1 on pin %d\n", sonde.config.button_pin & 0x7f); + } + if ( IS_TOUCH(sonde.config.button2_pin) ) { + touchAttachInterrupt(sonde.config.button2_pin & 0x7f, touchISR2, sonde.config.touch_thresh); + Serial.printf("Initializing touch 2 on pin %d\n", sonde.config.button2_pin & 0x7f); + } +} + + + + +/// Arrg. MicroNMEA changes type definition... so lets auto-infer type +template +//void unkHandler(const MicroNMEA& nmea) { +void unkHandler(T nmea) { + if (strcmp(nmea.getMessageID(), "VTG") == 0) { + const char *s = nmea.getSentence(); + while (*s && *s != ',') s++; + if (*s == ',') s++; else return; + if (*s == ',') return; /// no new course data + int lastCourse = nmea.parseFloat(s, 0, NULL); + Serial.printf("Course update: %d\n", lastCourse); + } else if (strcmp(nmea.getMessageID(), "GST") == 0) { + // get horizontal accuracy for android app on devices without gps + // GPGST,time,rms,-,-,-,stdlat,stdlon,stdalt,cs + const char *s = nmea.getSentence(); + while (*s && *s != ',') s++; // #0: GST + if (*s == ',') s++; else return; + while (*s && *s != ',') s++; // #1: time: skip + if (*s == ',') s++; else return; + while (*s && *s != ',') s++; // #1: rms: skip + if (*s == ',') s++; else return; + while (*s && *s != ',') s++; // #1: (-): skip + if (*s == ',') s++; else return; + while (*s && *s != ',') s++; // #1: (-): skip + if (*s == ',') s++; else return; + while (*s && *s != ',') s++; // #1: (-): skip + if (*s == ',') s++; else return; + // stdlat + int stdlat = nmea.parseFloat(s, 1, NULL); + while (*s && *s != ',') s++; + if (*s == ',') s++; else return; + // stdlong + int stdlon = nmea.parseFloat(s, 1, NULL); + // calculate position error as 1-signma horizontal RMS + // I guess that is equivalent to Androids getAccurac()? + int poserr = 0; + if (stdlat < 10000 && stdlon < 10000) { // larger errors: no GPS fix, avoid overflow in * + poserr = (int)(sqrt(0.5 * (stdlat * stdlat + stdlon * stdlon))); + } + //Serial.printf("\nHorizontal accuracy: %d, %d => %.1fm\n", stdlat, stdlon, 0.1*poserr); + gpsPos.accuracy = poserr; + } +} + +//#define DEBUG_GPS +static bool gpsCourseOld; +static int lastCourse; +void gpsTask(void *parameter) { + nmea.setUnknownSentenceHandler(unkHandler); + + while (1) { + while (Serial2.available()) { + char c = Serial2.read(); + //Serial.print(c); + if (nmea.process(c)) { + gpsPos.valid = nmea.isValid(); + if (gpsPos.valid) { + gpsPos.lon = nmea.getLongitude() * 0.000001; + gpsPos.lat = nmea.getLatitude() * 0.000001; + long alt = 0; + nmea.getAltitude(alt); + gpsPos.alt = (int)(alt / 1000); + gpsPos.course = (int)(nmea.getCourse() / 1000); + gpsCourseOld = false; + if (gpsPos.course == 0) { + // either north or not new + if (lastCourse != 0) // use old value... + { + gpsCourseOld = true; + gpsPos.course = lastCourse; + } + } + if(gpsPos.lon == 0 && gpsPos.lat == 0) gpsPos.valid = false; + } + gpsPos.hdop = nmea.getHDOP(); + gpsPos.sat = nmea.getNumSatellites(); + gpsPos.speed = nmea.getSpeed() / 1000.0 * 0.514444; // speed is in m/s nmea.getSpeed is in 0.001 knots +#ifdef DEBUG_GPS + uint8_t hdop = nmea.getHDOP(); + Serial.printf(" =>: valid: %d N %f E %f alt %d course:%d dop:%d\n", gpsPos.valid ? 1 : 0, gpsPos.lat, gpsPos.lon, gpsPos.alt, gpsPos.course, hdop); +#endif + } + } + delay(50); + } +} + +#define UBX_SYNCH_1 0xB5 +#define UBX_SYNCH_2 0x62 +uint8_t ubx_set9k6[] = {UBX_SYNCH_1, UBX_SYNCH_2, 0x06, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0xC0, 0x08, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8D, 0x8F}; +uint8_t ubx_factorydef[] = {UBX_SYNCH_1, UBX_SYNCH_2, 0x06, 0x09, 13, 0, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x13, 0x7c }; +uint8_t ubx_hardreset[] = {UBX_SYNCH_1, UBX_SYNCH_2, 0x06, 0x04, 4, 0, 0xff, 0xff, 0, 0, 0x0C, 0x5D }; +// GPGST: Class 0xF0 Id 0x07 +uint8_t ubx_enable_gpgst[] = {UBX_SYNCH_1, UBX_SYNCH_2, 0x06, 0x01, 3, 0, 0xF0, 0x07, 2, 0x03, 0x1F}; + +void dumpGPS() { + while (Serial2.available()) { + char c = Serial2.read(); + Serial.printf("%02x ", (uint8_t)c); + } +} +void initGPS() { + if (sonde.config.gps_rxd < 0) return; // GPS disabled + if (sonde.config.gps_txd >= 0) { // TX enable, thus try setting baud to 9600 and do a factory reset + File testfile = SPIFFS.open("/GPSRESET", FILE_READ); + if (testfile && !testfile.isDirectory()) { + testfile.close(); + Serial.println("GPS resetting baud to 9k6..."); + /* TODO: debug: + Sometimes I have seen the Serial2.begin to cause a reset + Guru Meditation Error: Core 1 panic'ed (Interrupt wdt timeout on CPU1) + Backtrace: 0x40081d2f:0x3ffc11b0 0x40087969:0x3ffc11e0 0x4000bfed:0x3ffb1db0 0x4008b7dd:0x3ffb1dc0 0x4017afee:0x3ffb1de0 0x4017b04b:0x3ffb1e20 0x4010722b:0x3ffb1e50 0x40107303:0x3ffb1e70 0x4010782d:0x3ffb1e90 0x40103814:0x3ffb1ed0 0x400d8772:0x3ffb1f10 0x400d9057:0x3ffb1f60 0x40107aca:0x3ffb1fb0 0x4008a63e:0x3ffb1fd0 + #0 0x40081d2f:0x3ffc11b0 in _uart_isr at /Users/hansi/.platformio/packages/framework-arduinoespressif32/cores/esp32/esp32-hal-uart.c:464 + #1 0x40087969:0x3ffc11e0 in _xt_lowint1 at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/freertos/xtensa_vectors.S:1154 + #2 0x4000bfed:0x3ffb1db0 in ?? ??:0 + #3 0x4008b7dd:0x3ffb1dc0 in vTaskExitCritical at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/freertos/tasks.c:3507 + #4 0x4017afee:0x3ffb1de0 in esp_intr_alloc_intrstatus at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/esp32/intr_alloc.c:784 + #5 0x4017b04b:0x3ffb1e20 in esp_intr_alloc at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/esp32/intr_alloc.c:784 + #6 0x4010722b:0x3ffb1e50 in uartEnableInterrupt at /Users/hansi/.platformio/packages/framework-arduinoespressif32/cores/esp32/esp32-hal-uart.c:464 + #7 0x40107303:0x3ffb1e70 in uartAttachRx at /Users/hansi/.platformio/packages/framework-arduinoespressif32/cores/esp32/esp32-hal-uart.c:464 + #8 0x4010782d:0x3ffb1e90 in uartBegin at /Users/hansi/.platformio/packages/framework-arduinoespressif32/cores/esp32/esp32-hal-uart.c:464 + #9 0x40103814:0x3ffb1ed0 in HardwareSerial::begin(unsigned long, unsigned int, signed char, signed char, bool, unsigned long) at /Users/hansi/.platformio/packages/framework-arduinoespressif32/cores/esp32/HardwareSerial.cpp:190 + */ + Serial2.begin(115200, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd); + Serial2.write(ubx_set9k6, sizeof(ubx_set9k6)); + delay(200); + Serial2.begin(38400, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd); + Serial2.write(ubx_set9k6, sizeof(ubx_set9k6)); + delay(200); + Serial2.begin(19200, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd); + Serial2.write(ubx_set9k6, sizeof(ubx_set9k6)); + Serial2.begin(9600, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd); + delay(1000); + dumpGPS(); + Serial.println("GPS factory reset..."); + Serial2.write(ubx_factorydef, sizeof(ubx_factorydef)); + delay(1000); + dumpGPS(); + delay(1000); + dumpGPS(); + delay(1000); + dumpGPS(); + SPIFFS.remove("/GPSRESET"); + } else if (testfile) { + Serial.println("GPS reset file: not found/isdir"); + testfile.close(); + Serial2.begin(9600, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd); + } + // Enable GPGST messages + Serial2.write(ubx_enable_gpgst, sizeof(ubx_enable_gpgst)); + } else { + Serial2.begin(9600, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd); + } + xTaskCreate( gpsTask, "gpsTask", + 5000, /* stack size */ + NULL, /* paramter */ + 1, /* priority */ + NULL); /* task handle*/ +} + +const char *getStateStr(int what) { + if (what < 0 || what >= (sizeof(mainStateStr) / sizeof(const char *))) + return "--"; + else + return mainStateStr[what]; +} + +void sx1278Task(void *parameter) { + /* new strategy: + background tasks handles all interactions with sx1278. + implementation is decoder specific. + This task is a simple infinit loop that + (a) initially and after frequency or mode change calls .setup() + (b) then repeatedly calls .receive() which should + (1) update data in the Sonde structure (additional updates may be done later in main loop/waitRXcomplete) + (2) set output flag receiveResult (success/error/timeout and keybord events) + + */ + while (1) { + if (rxtask.activate >= 128) { + // activating sx1278 background task... + Serial.printf("RXtask: start DECODER for sonde %d (was %s)\n", rxtask.activate & 0x7f, getStateStr(rxtask.mainState)); + rxtask.mainState = ST_DECODER; + rxtask.currentSonde = rxtask.activate & 0x7F; + sonde.setup(); + } else if (rxtask.activate != -1) { + Serial.printf("RXtask: start %s (was %s)\n", getStateStr(rxtask.activate), getStateStr(rxtask.mainState)); + rxtask.mainState = rxtask.activate; + } + rxtask.activate = -1; + /* only if mainState is ST_DECODER */ + if (rxtask.mainState != ST_DECODER) { + delay(100); + continue; + } + sonde.receive(); + delay(20); + } +} + + +void IRAM_ATTR touchISR() { + if (!button1.isTouched) { + unsigned long now = my_millis(); + if (now - button1.keydownTime < 500) button1.doublepress = 1; + else button1.doublepress = 0; + button1.keydownTime = now; + button1.isTouched = true; + } +} + +void IRAM_ATTR touchISR2() { + if (!button2.isTouched) { + unsigned long now = my_millis(); + if (now - button2.keydownTime < 500) button2.doublepress = 1; + else button2.doublepress = 0; + button2.keydownTime = now; + button2.isTouched = true; + } +} + +// touchRead in ISR is also a bad idea. Now moved to Ticker task +void checkTouchButton(Button & button) { + if (button.isTouched) { + int tmp = touchRead(button.pin & 0x7f); + Serial.printf("touch read %d: value is %d\n", button.pin & 0x7f, tmp); + if (tmp > sonde.config.touch_thresh + 5) { + button.isTouched = false; + unsigned long elapsed = my_millis() - button.keydownTime; + if (elapsed > 1500) { + if (elapsed < 4000) { + button.pressed = KP_MID; + } + else { + button.pressed = KP_LONG; + } + } else if (button.doublepress) { + button.pressed = KP_DOUBLE; + } else { + button.pressed = KP_SHORT; + } + } + } +} + +void ledOffCallback() { + digitalWrite(sonde.config.led_pout, LOW); +} +void flashLed(int ms) { + if (sonde.config.led_pout >= 0) { + digitalWrite(sonde.config.led_pout, HIGH); + ledFlasher.once_ms(ms, ledOffCallback); + } +} + +void buzzerLed(int temps) { + Serial.printf("\nBuzzer On\n"); + ledcWriteTone(0, sonde.config.buzzerFreq); + delay(temps); + ledcWrite(0, 180); + delay(temps); +} + +int doTouch = 0; +void checkTouchStatus() { + checkTouchButton(button1); + checkTouchButton(button2); +} + +unsigned long bdd1, bdd2; +static bool b1wasdown = false; +void IRAM_ATTR buttonISR() { + if (digitalRead(button1.pin) == 0) { // Button down + b1wasdown = true; + unsigned long now = my_millis(); + if (now - button1.keydownTime < 500) { + // Double press + if (now - button1.keydownTime > 100) + button1.doublepress = 1; + bdd1 = now; bdd2 = button1.keydownTime; + } else { + button1.doublepress = 0; + } + button1.numberKeyPresses += 1; + button1.keydownTime = now; + } else { //Button up + if (!b1wasdown) return; + b1wasdown = false; + unsigned long now = my_millis(); + if (button1.doublepress == -1) return; // key was never pressed before, ignore button up + unsigned int elapsed = now - button1.keydownTime; + if (elapsed > 1500) { + if (elapsed < 4000) { + button1.pressed = KP_MID; + } + else { + button1.pressed = KP_LONG; + } + } else { + if (button1.doublepress) button1.pressed = KP_DOUBLE; + else button1.pressed = KP_SHORT; + } + button1.numberKeyPresses += 1; + button1.keydownTime = now; + } +} + +void IRAM_ATTR button2ISR() { + if (digitalRead(button2.pin) == 0) { // Button down + unsigned long now = my_millis(); + if (now - button2.keydownTime < 500) { + // Double press + if (now - button2.keydownTime > 100) + button2.doublepress = 1; + //bdd1 = now; bdd2 = button1.keydownTime; + } else { + button2.doublepress = 0; + } + button2.numberKeyPresses += 1; + button2.keydownTime = now; + } else { //Button up + unsigned long now = my_millis(); + if (button2.doublepress == -1) return; // key was never pressed before, ignore button up + unsigned int elapsed = now - button2.keydownTime; + if (elapsed > 1500) { + if (elapsed < 4000) { + button2.pressed = KP_MID; + } + else { + button2.pressed = KP_LONG; + } + } else { + if (button2.doublepress) button2.pressed = KP_DOUBLE; + else button2.pressed = KP_SHORT; + } + button2.numberKeyPresses += 1; + button2.keydownTime = now; + } +} + +int getKeyPress() { + KeyPress p = button1.pressed; + button1.pressed = KP_NONE; +#if 0 + int x = digitalRead(button1.pin); + Serial.printf("Debug: bdd1=%ld, bdd2=%ld\n", bdd1, bdd2); + Serial.printf("button1 press (dbl:%d) (now:%d): %d at %ld (%d)\n", button1.doublepress, x, p, button1.keydownTime, button1.numberKeyPresses); +#endif + return p; +} + +// called by arduino main loop (from Sonde::waitRXcomplete) as soon as pmu_irq is set +void handlePMUirq() { + if (sonde.config.button2_axp) { + // Use AXP power button as second button + if (pmu_irq) { + Serial.println("PMU_IRQ is set\n"); + xSemaphoreTake( axpSemaphore, portMAX_DELAY ); + axp.readIRQ(); + if (axp.isPEKShortPressIRQ()) { + button2.pressed = KP_SHORT; + button2.keydownTime = my_millis(); + } + if (axp.isPEKLongtPressIRQ()) { + button2.pressed = KP_MID; + button2.keydownTime = my_millis(); + } + if (pmu_irq != 2) { + pmu_irq = 0; + } + axp.clearIRQ(); + xSemaphoreGive( axpSemaphore ); + } + } else { + Serial.println("handlePMIirq() called. THIS SHOULD NOT HAPPEN w/o button2_axp set"); + pmu_irq = 0; // prevent main loop blocking + } +} + +int getKey2Press() { + // TODO: Should be atomic + KeyPress p = button2.pressed; + button2.pressed = KP_NONE; + //Serial.printf("button2 press: %d at %ld (%d)\n", p, button2.keydownTime, button2.numberKeyPresses); + return p; +} + +int getKeyPressEvent() { + int p = getKeyPress(); + if (p == KP_NONE) { + p = getKey2Press(); + if (p == KP_NONE) + return EVT_NONE; + Serial.printf("Key 2 was pressed [%d]\n", p + 4); + return p + 4; + } + Serial.printf("Key 1 was pressed [%d]\n", p); + return p; /* map KP_x to EVT_KEY1_x / EVT_KEY2_x*/ +} + +#define SSD1306_ADDRESS 0x3c +bool ssd1306_found = false; +bool axp192_found = false; + +int scanI2Cdevice(void) +{ + byte err, addr; + int nDevices = 0; + for (addr = 1; addr < 127; addr++) { + Wire.beginTransmission(addr); + err = Wire.endTransmission(); + if (err == 0) { + Serial.print("I2C device found at address 0x"); + if (addr < 16) + Serial.print("0"); + Serial.print(addr, HEX); + Serial.println(" !"); + nDevices++; + + if (addr == SSD1306_ADDRESS) { + ssd1306_found = true; + Serial.println("ssd1306 display found"); + } + if (addr == AXP192_SLAVE_ADDRESS) { + axp192_found = true; + Serial.println("axp192 PMU found"); + } + } else if (err == 4) { + Serial.print("Unknow error at address 0x"); + if (addr < 16) + Serial.print("0"); + Serial.println(addr, HEX); + } + } + if (nDevices == 0) + Serial.println("No I2C devices found\n"); + else + Serial.println("done\n"); + return nDevices; +} + +extern int initlevels[40]; + +extern xSemaphoreHandle globalLock; + +#ifdef ESP_MEM_DEBUG +typedef void (*esp_alloc_failed_hook_t) (size_t size, uint32_t caps, const char * function_name); +extern esp_err_t heap_caps_register_failed_alloc_callback(esp_alloc_failed_hook_t callback); + +void heap_caps_alloc_failed_hook(size_t requested_size, uint32_t caps, const char *function_name) +{ + printf("%s was called but failed to allocate %d bytes with 0x%X capabilities. \n", function_name, requested_size, caps); +} +#endif + + +void setup() +{ + char buf[12]; + // Open serial communications and wait for port to open: + Serial.begin(/*921600 */115200); + for (int i = 0; i < 39; i++) { + int v = gpio_get_level((gpio_num_t)i); + Serial.printf("%d:%d ", i, v); + } + Serial.println(""); +#ifdef ESP_MEM_DEBUG + esp_err_t error = heap_caps_register_failed_alloc_callback(heap_caps_alloc_failed_hook); +#endif + axpSemaphore = xSemaphoreCreateBinary(); + xSemaphoreGive(axpSemaphore); + + for (int i = 0; i < 39; i++) { + Serial.printf("%d:%d ", i, initlevels[i]); + } + Serial.println(" (before setup)"); + sonde.defaultConfig(); // including autoconfiguration + aprs_gencrctab(); + + Serial.println("Initializing SPIFFS"); + // Initialize SPIFFS + if (!SPIFFS.begin(true)) { + Serial.println("An Error has occurred while mounting SPIFFS"); + return; + } + + Serial.println("Reading initial configuration"); + setupConfigData(); // configuration must be read first due to OLED ports!!! + WiFi.setHostname(sonde.config.mdnsname); + + // NOT TTGO v1 (fingerprint 64) or Heltec v1/v2 board (fingerprint 4) + // and NOT TTGO Lora32 v2.1_1.6 (fingerprint 31/63) + if ( ( (sonde.fingerprint & (64 + 31)) != 31) && ((sonde.fingerprint & 16) == 16) ) { + // FOr T-Beam 1.0 + for (int i = 0; i < 10; i++) { // try multiple times + Wire.begin(21, 22); + // Make sure the whole thing powers up!?!?!?!?!? + U8X8 *u8x8 = new U8X8_SSD1306_128X64_NONAME_HW_I2C(0, 22, 21); + u8x8->initDisplay(); + delay(500); + + scanI2Cdevice(); + if (!axp.begin(Wire, AXP192_SLAVE_ADDRESS)) { + Serial.println("AXP192 Begin PASS"); + } else { + Serial.println("AXP192 Begin FAIL"); + } + axp.setPowerOutPut(AXP192_LDO2, AXP202_ON); + if (sonde.config.type == TYPE_M5_CORE2) { + // Display backlight on M5 Core2 + axp.setPowerOutPut(AXP192_DCDC3, AXP202_ON); + axp.setDCDC3Voltage(3300); + // SetBusPowerMode(0): + // #define AXP192_GPIO0_CTL (0x90) + // #define AXP192_GPIO0_VOL (0x91) + // #define AXP202_LDO234_DC23_CTL (0x12) + + // The axp class lacks a functino to set GPIO0 VDO to 3.3V (as is done by original M5Stack software) + // so do this manually (default value 2.8V did not have the expected effect :)) + // data = Read8bit(0x91); + // write1Byte(0x91, (data & 0X0F) | 0XF0); + uint8_t reg; + Wire.beginTransmission((uint8_t)AXP192_SLAVE_ADDRESS); + Wire.write(AXP192_GPIO0_VOL); + Wire.endTransmission(); + Wire.requestFrom(AXP192_SLAVE_ADDRESS, 1); + reg = Wire.read(); + reg = (reg&0x0F) | 0xF0; + Wire.beginTransmission((uint8_t)AXP192_SLAVE_ADDRESS); + Wire.write(AXP192_GPIO0_VOL); + Wire.write(reg); + Wire.endTransmission(); + // data = Read8bit(0x90); + // Write1Byte(0x90, (data & 0XF8) | 0X02) + axp.setGPIOMode(AXP_GPIO_0, AXP_IO_LDO_MODE); // disable AXP supply from VBUS + pmu_irq = 2; // IRQ pin is not connected on Core2 + // data = Read8bit(0x12); //read reg 0x12 + // Write1Byte(0x12, data | 0x40); // enable 3,3V => 5V booster + // this is done below anyway: axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON); + + axp.adc1Enable(AXP202_ACIN_VOL_ADC1, 1); + axp.adc1Enable(AXP202_ACIN_CUR_ADC1, 1); + } else { + // GPS on T-Beam, buzzer on M5 Core2 + axp.setPowerOutPut(AXP192_LDO3, AXP202_ON); + axp.adc1Enable(AXP202_VBUS_VOL_ADC1, 1); + axp.adc1Enable(AXP202_VBUS_CUR_ADC1, 1); + } + axp.setPowerOutPut(AXP192_DCDC2, AXP202_ON); + axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON); + axp.setPowerOutPut(AXP192_DCDC1, AXP202_ON); + axp.setDCDC1Voltage(3300); + axp.adc1Enable(AXP202_BATT_CUR_ADC1, 1); + if (sonde.config.button2_axp ) { + if (pmu_irq != 2) { + pinMode(PMU_IRQ, INPUT_PULLUP); + attachInterrupt(PMU_IRQ, [] { + pmu_irq = 1; + }, FALLING); + } + //axp.enableIRQ(AXP202_VBUS_REMOVED_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_BATT_REMOVED_IRQ | AXP202_BATT_CONNECT_IRQ, 1); + axp.enableIRQ( AXP202_PEK_LONGPRESS_IRQ | AXP202_PEK_SHORTPRESS_IRQ, 1 ); + axp.clearIRQ(); + } + int ndevices = scanI2Cdevice(); + if (sonde.fingerprint != 17 || ndevices > 0) break; // only retry for fingerprint 17 (startup problems of new t-beam with oled) + delay(500); + } + } + if (sonde.config.batt_adc >= 0) { + pinMode(sonde.config.batt_adc, INPUT); + } + if (sonde.config.power_pout >= 0) { // for a heltec v2, pull GPIO21 low for display power + pinMode(sonde.config.power_pout & 127, OUTPUT); + digitalWrite(sonde.config.power_pout & 127, sonde.config.power_pout & 128 ? 1 : 0); + } + + if (sonde.config.led_pout >= 0) { + pinMode(sonde.config.led_pout, OUTPUT); + flashLed(1000); // testing + } + + button1.pin = sonde.config.button_pin; + button2.pin = sonde.config.button2_pin; + if (button1.pin != 0xff) { + if ( (button1.pin & 0x80) == 0 && button1.pin < 34 ) { + Serial.println("Button 1 configured as input with pullup"); + pinMode(button1.pin, INPUT_PULLUP); + } else + pinMode(button1.pin, INPUT); // configure as input if not disabled + } + if (button2.pin != 0xff) { + if ( (button2.pin & 0x80) == 0 && button2.pin < 34 ) { + Serial.println("Button 2 configured as input with pullup"); + pinMode(button2.pin, INPUT_PULLUP); + } else + pinMode(button2.pin, INPUT); // configure as input if not disabled + } + // Handle button press + if ( (button1.pin & 0x80) == 0) { + attachInterrupt( button1.pin, buttonISR, CHANGE); + Serial.printf("button1.pin is %d, attaching interrupt\n", button1.pin); + } + // Handle button press + if ( (button2.pin & 0x80) == 0) { + attachInterrupt( button2.pin, button2ISR, CHANGE); + Serial.printf("button2.pin is %d, attaching interrupt\n", button2.pin); + } + initTouch(); + + disp.init(); + delay(100); + Serial.println("Showing welcome display"); + disp.rdis->welcome(); + + //Music + if (sonde.config.buzzerOn==1){ + ledcSetup(0, sonde.config.buzzerFreq, 8); + ledcAttachPin(sonde.config.buzzerPort, 0); + // fréquence associée à chaque note + // do, do#, ré, ré#, mi, fa, fa#, sol, sol#, la, la#, si + const float note[12] = {65.41, 69.30, 73.42, 77.78, 82.41, 87.31, 92.50, 98.00, 103.83, 110.00, 116.54, 123.47}; + const int nombreDeNotes = 32; + const int tempo = 150; // plus c'est petit, plus c'est rapide + const int melodie[][3] = { {4, 2, 2}, {5, 2, 1}, {7, 2, 3}, {0, 3, 6}, {2, 2, 2}, {4, 2, 1},{5, 2, 8}, {7, 2, 2}, {9, 2, 1}, {11, 2, 3}, {5, 3, 6}, {9, 2, 2}, {11, 2, 1}, {0, 3, 3}, {2, 3, 3}, {4, 3, 3}, +{4, 2, 2}, {5, 2, 1}, {7, 2, 3}, {0, 3, 6}, {2, 3, 2}, {4, 3, 1},{5, 3, 8}, {7, 2, 2}, {7, 2, 1}, {4, 3, 3}, {2, 3, 2}, {7, 2, 1}, {5, 3, 3}, {4, 3, 2}, {2, 3, 1},{0, 3, 8} }; + int frequence; + + for ( int i = 0; i < nombreDeNotes ; i++ ) { + frequence = round(note[melodie[i][0]] * 2.0 * (melodie[i][1] - 1)); + ledcSetup(0, frequence, 12); + ledcWrite(0, 2048); // rapport cyclique 50% + delay(tempo * melodie[i][2] - 50); + ledcWrite(0, 0); // rapport cyclique 0% (silence, pour séparer les notes adjacentes) + delay(50); + } + } + + delay(3000); + Serial.println("Clearing display"); + sonde.clearDisplay(); + + setupWifiList(); + Serial.printf("before disp.initFromFile... layouts is %p\n", disp.layouts); + + disp.initFromFile(sonde.config.screenfile); + Serial.printf("disp.initFromFile... layouts is %p", disp.layouts); + + + // == show initial values from config.txt ========================= // + if (sonde.config.debug == 1) { + disp.rdis->setFont(FONT_SMALL); + disp.rdis->drawString(0, 0, "Config:"); + + delay(500); + itoa(sonde.config.oled_sda, buf, 10); + disp.rdis->drawString(0, 1, " SDA:"); + disp.rdis->drawString(6, 1, buf); + + delay(500); + itoa(sonde.config.oled_scl, buf, 10); + disp.rdis->drawString(0, 2, " SCL:"); + disp.rdis->drawString(6, 2, buf); + + delay(500); + itoa(sonde.config.oled_rst, buf, 10); + disp.rdis->drawString(0, 3, " RST:"); + disp.rdis->drawString(6, 3, buf); + + delay(1000); + itoa(sonde.config.led_pout, buf, 10); + disp.rdis->drawString(0, 4, " LED:"); + disp.rdis->drawString(6, 4, buf); + + delay(500); + itoa(sonde.config.spectrum, buf, 10); + disp.rdis->drawString(0, 5, " SPEC:"); + disp.rdis->drawString(6, 5, buf); + + delay(500); + itoa(sonde.config.maxsonde, buf, 10); + disp.rdis->drawString(0, 6, " MAX:"); + disp.rdis->drawString(6, 6, buf); + + delay(5000); + sonde.clearDisplay(); + } + // == show initial values from config.txt ========================= // + +#if 1 + + if (sonde.config.type == TYPE_M5_CORE2) { + // Core2 uses Pin 38 for MISO + SPI.begin(18, 38, 23, -1); + } else { + SPI.begin(); + } + //Set most significant bit first + SPI.setBitOrder(MSBFIRST); + //Divide the clock frequency + SPI.setClockDivider(SPI_CLOCK_DIV2); + //Set data mode + SPI.setDataMode(SPI_MODE0); + + sx1278.setup(globalLock); + + int i = 0; + while (++i < 3) { + delay(500); + // == check the radio chip by setting default frequency =========== // + sx1278.ON(); + if (sx1278.setFrequency(402700000) == 0) { + Serial.println(F("Setting freq: SUCCESS ")); + } else { + Serial.println(F("Setting freq: ERROR ")); + } + float f = sx1278.getFrequency(); + Serial.print("Frequency set to "); + Serial.println(f); + // == check the radio chip by setting default frequency =========== // + } +#endif + + //sx1278.setLNAGain(-48); + sx1278.setLNAGain(0); + + int gain = sx1278.getLNAGain(); + Serial.print("RX LNA Gain is "); + Serial.println(gain); + + // Print a success message + Serial.println(F("SX1278 configuration finished")); + + Serial.println("Setup finished"); + Serial.println(); + // int returnValue = pthread_create(&wifithread, NULL, wifiloop, (void *)0); + + // if (returnValue) { + // Serial.println("An error has occurred"); + // } + // xTaskCreate(mainloop, "MainServer", 10240, NULL, 10, NULL); + + + // == setup default channel list if qrg.txt read fails =========== // + sonde.clearSonde(); + setupChannelList(); + /// not here, done by sonde.setup(): rs41.setup(); + // == setup default channel list if qrg.txt read fails =========== // +#ifndef DISABLE_SX1278 + xTaskCreate( sx1278Task, "sx1278Task", + 10000, /* stack size */ + NULL, /* paramter */ + 1, /* priority */ + NULL); /* task handle*/ +#endif + sonde.setup(); + initGPS(); + + WiFi.onEvent(WiFiEvent); + getKeyPress(); // clear key buffer +} + +void enterMode(int mode) { + Serial.printf("enterMode(%d)\n", mode); + // Backround RX task should only be active in mode ST_DECODER for now + // (future changes might use RX background task for spectrum display as well) + if (mode != ST_DECODER) { + rxtask.activate = mode; + while (rxtask.activate == mode) { + delay(10); // until cleared by RXtask -- rx task is deactivated + } + } + mainState = (MainState)mode; + if (mainState == ST_SPECTRUM) { + Serial.println("Entering ST_SPECTRUM mode"); + sonde.clearDisplay(); + disp.rdis->setFont(FONT_SMALL); + specTimer = millis(); + //scanner.init(); + } else if (mainState == ST_WIFISCAN) { + sonde.clearDisplay(); + } + if (mode == ST_DECODER) { + // trigger activation of background task + // currentSonde should be set before enterMode() + rxtask.activate = ACT_SONDE(sonde.currentSonde); + // + Serial.println("clearing and updating display"); + sonde.clearDisplay(); + sonde.updateDisplay(); + } + printf("enterMode ok\n"); +} + +static char text[40]; +static const char *action2text(uint8_t action) { + if (action == ACT_DISPLAY_DEFAULT) return "Default Display"; + if (action == ACT_DISPLAY_SPECTRUM) return "Spectrum Display"; + if (action == ACT_DISPLAY_WIFI) return "Wifi Scan Display"; + if (action == ACT_NEXTSONDE) return "Go to next sonde"; + if (action == ACT_PREVSONDE) return "presonde (not implemented)"; + if (action == ACT_NONE) return "none"; + if (action >= 128) { + snprintf(text, 40, "Sonde=%d", action & 127); + } else { + snprintf(text, 40, "Display=%d", action); + } + return text; +} + +#define RDZ_DATA_LEN 128 + +void parseGpsJson(char *data) { + char *key = NULL; + char *value = NULL; + // very simple json parser: look for ", then key, then ", then :, then number, then , or } or \0 + for (int i = 0; i < RDZ_DATA_LEN; i++) { + if (key == NULL) { + if (data[i] != '"') continue; + key = data + i + 1; + i += 2; + continue; + } + if (value == NULL) { + if (data[i] != ':') continue; + value = data + i + 1; + i += 2; + continue; + } + if (data[i] == ',' || data[i] == '}' || data[i] == 0) { + // get value + double val = strtod(value, NULL); + // get data + if (strncmp(key, "lat", 3) == 0) { + gpsPos.lat = val; + } + else if (strncmp(key, "lon", 3) == 0) { + gpsPos.lon = val; + } + else if (strncmp(key, "alt", 3) == 0) { + gpsPos.alt = (int)val; + } + else if (strncmp(key, "course", 6) == 0) { + gpsPos.course = (int)val; + } + gpsPos.valid = true; + + // next item: + if (data[i] != ',') break; + key = NULL; + value = NULL; + } + } + if(gpsPos.lat == 0 && gpsPos.lon == 0) gpsPos.valid = false; + Serial.printf("Parse result: lat=%f, lon=%f, alt=%d, valid=%d\n", gpsPos.lat, gpsPos.lon, gpsPos.alt, gpsPos.valid); +} + +static char rdzData[RDZ_DATA_LEN]; +static int rdzDataPos = 0; + +void loopDecoder() { + // sonde knows the current type and frequency, and delegates to the right decoder + uint16_t res = sonde.waitRXcomplete(); + int action; + //Serial.printf("waitRX result is %x\n", (int)res); + action = (int)(res >> 8); + // TODO: update displayed sonde? + +#if 0 + static int i = 0; + if (i++ > 20) { + i = 0; + rtc_wdt_protect_off(); + rtc_wdt_disable(); + // Requires serial speed 921600, otherweise interrupt wdt will occur + heap_caps_dump(MALLOC_CAP_8BIT); + } +#endif + + if (action != ACT_NONE) { + int newact = sonde.updateState(action); + Serial.printf("MAIN: loopDecoder: action %02x (%s) => %d [current: main=%d, rxtask=%d]\n", action, action2text(action), newact, sonde.currentSonde, rxtask.currentSonde); + action = newact; + if (action != 255) { + if (action == ACT_DISPLAY_SPECTRUM) { + enterMode(ST_SPECTRUM); + return; + } + else if (action == ACT_DISPLAY_WIFI) { + enterMode(ST_WIFISCAN); + return; + } + } + } + + if (!tncclient.connected()) { + //Serial.println("TNC client not connected"); + tncclient = tncserver.available(); + if (tncclient.connected()) { + Serial.println("new TCP KISS connection"); + } + } + if (tncclient.available()) { + Serial.print("TCP KISS socket: recevied "); + while (tncclient.available()) { + Serial.print(tncclient.read()); // Check if we receive anything from from APRSdroid + } + Serial.println(""); + } + if (rdzserver.hasClient()) { + Serial.println("TCP JSON socket: new connection"); + rdzclient.stop(); + rdzclient = rdzserver.available(); + } + if (rdzclient.available()) { + Serial.print("RDZ JSON socket: received "); + while (rdzclient.available()) { + char c = (char)rdzclient.read(); + Serial.print(c); + if (c == '\n' || c == '}' || rdzDataPos >= RDZ_DATA_LEN) { + // parse GPS position from phone + rdzData[rdzDataPos] = c; + if (rdzDataPos > 2) parseGpsJson(rdzData); + rdzDataPos = 0; + } + else { + rdzData[rdzDataPos++] = c; + } + } + Serial.println(""); + } + +#if FEATURE_SONDEHUB + sondehub_reply_handler(&shclient); +#endif + + // wifi active and good packet received => send packet + SondeInfo *s = &sonde.sondeList[rxtask.receiveSonde]; + if ((res & 0xff) == 0 && connected) { + //Send a packet with position information + // first check if ID and position lat+lonis ok + + if (s->d.validID && ((s->d.validPos & 0x03) == 0x03)) { + char *str = aprs_senddata(s, sonde.config.call, sonde.config.objcall, sonde.config.udpfeed.symbol); + char raw[201]; + int rawlen = aprsstr_mon2raw(str, raw, APRS_MAXLEN); + Serial.println("Sending AXUDP"); + //Serial.println(raw); + udp.beginPacket(sonde.config.udpfeed.host, sonde.config.udpfeed.port); + udp.write((const uint8_t *)raw, rawlen); + udp.endPacket(); + if (tncclient.connected()) { + Serial.println("Sending position via TCP"); + char raw[201]; + int rawlen = aprsstr_mon2kiss(str, raw, APRS_MAXLEN); + Serial.print("sending: "); Serial.println(raw); + tncclient.write(raw, rawlen); + } + if (sonde.config.tcpfeed.active) { + static unsigned long lasttcp = 0; + if ( tcpclient.disconnected()) { + tcpclient.connect(sonde.config.tcpfeed.host, sonde.config.tcpfeed.port); + } + else if ( tcpclient.connected() ) { + unsigned long now = millis(); + Serial.printf("aprs: now-last = %ld\n", (now-lasttcp)); + if ( (now - lasttcp) > sonde.config.tcpfeed.highrate * 1000L ) { + strcat(str, "\r\n"); + Serial.print(str); + tcpclient.write(str, strlen(str)); + lasttcp = now; + } + } + } +#if FEATURE_CHASEMAPPER + if (sonde.config.cm.active) { + Chasemapper::send(udp, s); + } +#endif + } +#if FEATURE_SONDEHUB + if (sonde.config.sondehub.active) { + sondehub_send_data(&shclient, s, &sonde.config.sondehub); + } +#endif + +#if FEATURE_MQTT + // send to MQTT if enabledson + if (connected && mqttEnabled) { + Serial.println("Sending sonde info via MQTT"); + mqttclient.publishPacket(s); + } +#endif + } else { +#if FEATURE_SONDEHUB + sondehub_finish_data(&shclient, s, &sonde.config.sondehub); +#endif + } + // Send own position periodically + if (sonde.config.tcpfeed.active) { + aprs_station_update(); + } + // always send data, even if not valid.... + if (rdzclient.connected()) { + Serial.println("Sending position via TCP as rdzJSON"); + char raw[1024]; + char gps[128]; + const char *typestr = s->d.typestr; + if (*typestr == 0) typestr = sondeTypeStr[sonde.realType(s)]; + // TODO: only if GPS is valid... + if (gpsPos.valid) { + snprintf(gps, 128, ", \"gpslat\": %f," + "\"gpslon\": %f," + "\"gpsalt\": %d," + "\"gpsacc\": %d," + "\"gpsdir\": %d", + gpsPos.lat, gpsPos.lon, gpsPos.alt, gpsPos.accuracy, gpsPos.course); + } else { + *gps = 0; + } + // + raw[0] = '{'; + // Use same JSON format as for MQTT and HTML map........ + sonde2json(raw+1, 1023, s); + sprintf(raw+strlen(raw), + ",\"active\":%d" + ",\"validId\":%d" + ",\"validPos\":%d" + " %s}\n", + (int)s->active, + s->d.validID, + s->d.validPos, + gps); + int len = strlen(raw); +#if 0 + //maintain backwords compatibility + float lat = isnan(s->d.lat) ? 0 : s->d.lat; + float lon = isnan(s->d.lon) ? 0 : s->d.lon; + float alt = isnan(s->d.alt) ? -1 : s->d.alt; + float vs = isnan(s->d.vs) ? 0 : s->d.vs; + float hs = isnan(s->d.hs) ? 0 : s->d.hs; + float dir = isnan(s->d.dir) ? 0 : s->d.dir; + + int len = snprintf(raw, 1024, "{" + "\"res\": %d," + "\"type\": \"%s\"," + "\"active\": %d," + "\"freq\": %.2f," + "\"id\": \"%s\"," + "\"ser\": \"%s\"," + "\"validId\": %d," + "\"launchsite\": \"%s\"," + "\"lat\": %.5f," + "\"lon\": %.5f," + "\"alt\": %.1f," + "\"vs\": %.1f," + "\"hs\": %.1f," + "\"dir\": %.1f," + "\"sats\": %d," + "\"validPos\": %d," + "\"time\": %d," + "\"frame\": %d," + "\"validTime\": %d," + "\"rssi\": %d," + "\"afc\": %d," + "\"launchKT\": %d," + "\"burstKT\": %d," + "\"countKT\": %d," + "\"crefKT\": %d" + "%s" + "}\n", + res & 0xff, + typestr, + (int)s->active, + s->freq, + s->d.id, + s->d.ser, + (int)s->d.validID, + s->launchsite, + lat, + lon, + alt, + vs, + hs, + dir, + s->d.sats, + s->d.validPos, + s->d.time, + s->d.frame, + (int)s->d.validTime, + s->rssi, + s->afc, + s->d.launchKT, + s->d.burstKT, + s->d.countKT, + s->d.crefKT, + gps + ); +#endif + + //Serial.println("Writing rdzclient..."); + if (len > 1024) len = 1024; + int wlen = rdzclient.write(raw, len); + if (wlen != len) { + Serial.println("Writing rdzClient not OK, closing connection"); + rdzclient.stop(); + } + //Serial.println("Writing rdzclient OK"); + } + Serial.print("MAIN: updateDisplay started\n"); + sonde.dispsavectlOFF( (res & 0xff) == 0 ); // handle screen saver (disp auto off) + if (forceReloadScreenConfig) { + disp.initFromFile(sonde.config.screenfile); + sonde.clearDisplay(); + forceReloadScreenConfig = false; + } + int t = millis(); + sonde.updateDisplay(); + Serial.printf("MAIN: updateDisplay done (after %d ms)\n", (int)(millis() - t)); +} + +void setCurrentDisplay(int value) { + Serial.printf("setCurrentDisplay: setting index %d, entry %d\b", value, sonde.config.display[value]); + currentDisplay = sonde.config.display[value]; +} + +void loopSpectrum() { + int marker = 0; + char buf[10]; + uint8_t dispw, disph, dispxs, dispys; + disp.rdis->getDispSize(&disph, &dispw, &dispxs, &dispys); + + switch (getKeyPress()) { + case KP_SHORT: /* move selection of peak, TODO */ + sonde.nextConfig(); // TODO: Should be set specific frequency + enterMode(ST_DECODER); + return; + case KP_MID: /* restart, TODO */ break; + case KP_LONG: + Serial.println("loopSpectrum: KP_LONG"); + enterMode(ST_WIFISCAN); + return; + case KP_DOUBLE: + setCurrentDisplay(0); + enterMode(ST_DECODER); + return; + default: break; + } + + scanner.scan(); + scanner.plotResult(); + + /* + if(globalClient != NULL && globalClient->status() == WS_CONNECTED){ + String randomNumber = String(random(0,20)); + globalClient->text(randomNumber); + } + */ + + if (sonde.config.spectrum > 0) { + int remaining = sonde.config.spectrum - (millis() - specTimer) / 1000; + Serial.printf("config.spectrum:%d specTimer:%ld millis:%ld remaining:%d\n", sonde.config.spectrum, specTimer, millis(), remaining); + if (sonde.config.marker != 0) { + marker = 1; + } + snprintf(buf, 10, "%d Sec.", remaining); + disp.rdis->drawString(0, dispys <= 1 ? (1 + marker) : (dispys + 1)*marker, buf); + if (remaining <= 0) { + setCurrentDisplay(0); + enterMode(ST_DECODER); + } + } +} + +void startSpectrumDisplay() { + sonde.clearDisplay(); + disp.rdis->setFont(FONT_SMALL); + disp.rdis->drawString(0, 0, "Spectrum Scan..."); + delay(500); + enterMode(ST_SPECTRUM); +} + +String translateEncryptionType(wifi_auth_mode_t encryptionType) { + switch (encryptionType) { + case (WIFI_AUTH_OPEN): + return "Open"; + case (WIFI_AUTH_WEP): + return "WEP"; + case (WIFI_AUTH_WPA_PSK): + return "WPA_PSK"; + case (WIFI_AUTH_WPA2_PSK): + return "WPA2_PSK"; + case (WIFI_AUTH_WPA_WPA2_PSK): + return "WPA_WPA2_PSK"; + case (WIFI_AUTH_WPA2_ENTERPRISE): + return "WPA2_ENTERPRISE"; + default: + return ""; + } +} + +enum t_wifi_state { WIFI_DISABLED, WIFI_SCAN, WIFI_CONNECT, WIFI_CONNECTED, WIFI_APMODE }; + +static t_wifi_state wifi_state = WIFI_DISABLED; + +void enableNetwork(bool enable) { + if (enable) { + MDNS.begin(sonde.config.mdnsname); + SetupAsyncServer(); + udp.begin(WiFi.localIP(), LOCALUDPPORT); + MDNS.addService("http", "tcp", 80); + MDNS.addService("kiss-tnc", "tcp", 14580); + MDNS.addService("jsonrdz", "tcp", 14570); + if (sonde.config.kisstnc.active) { + tncserver.begin(); + rdzserver.begin(); + } +#if FEATURE_MQTT + if (sonde.config.mqtt.active && strlen(sonde.config.mqtt.host) > 0) { + mqttEnabled = true; + mqttclient.init(sonde.config.mqtt.host, sonde.config.mqtt.port, sonde.config.mqtt.id, sonde.config.mqtt.username, sonde.config.mqtt.password, sonde.config.mqtt.prefix); + } +#endif +#if FEATURE_SONDEHUB + if (sonde.config.sondehub.active && wifi_state != WIFI_APMODE) { + time_last_update = millis() + 1000; /* force sending update */ + sondehub_station_update(&shclient, &sonde.config.sondehub); + } +#endif + configTime(gmtOffset_sec, daylightOffset_sec, ntpServer); + connected = true; + } else { + MDNS.end(); + connected = false; + } + tcpclient.onConnect([](void *arg, AsyncClient * s) { + Serial.write("APRS: TCP connected\n"); + char buf[128]; + snprintf(buf, 128, "user %s pass %d vers %s %s\r\n", sonde.config.call, sonde.config.passcode, version_name, version_id); + s->write(buf, strlen(buf)); + }); + tcpclient.onData([](void *arg, AsyncClient * c, void *data, size_t len) { + Serial.write((const uint8_t *)data, len); + }); + Serial.println("enableNetwork done"); +} + +// Events used only for debug output right now +void WiFiEvent(WiFiEvent_t event) +{ + Serial.printf("[WiFi-event] event: %d\n", event); + + switch (event) { + case SYSTEM_EVENT_WIFI_READY: + Serial.println("WiFi interface ready"); + break; + case SYSTEM_EVENT_SCAN_DONE: + Serial.println("Completed scan for access points"); + break; + case SYSTEM_EVENT_STA_START: + Serial.println("WiFi client started"); + break; + case SYSTEM_EVENT_STA_STOP: + Serial.println("WiFi clients stopped"); + break; + case SYSTEM_EVENT_STA_CONNECTED: + Serial.println("Connected to access point"); + break; + case SYSTEM_EVENT_STA_DISCONNECTED: + Serial.println("Disconnected from WiFi access point"); + if (wifi_state == WIFI_CONNECT) { + // If we get a disconnect event while waiting for connection (as I do sometimes with my FritzBox), + // just start from scratch with WiFi scan + wifi_state = WIFI_DISABLED; + WiFi.disconnect(true); + } + break; + case SYSTEM_EVENT_STA_AUTHMODE_CHANGE: + Serial.println("Authentication mode of access point has changed"); + break; + case SYSTEM_EVENT_STA_GOT_IP: + Serial.print("Obtained IP address: "); + Serial.println(WiFi.localIP()); + break; + case SYSTEM_EVENT_STA_LOST_IP: + Serial.println("Lost IP address and IP address is reset to 0"); + break; + case SYSTEM_EVENT_STA_WPS_ER_SUCCESS: + Serial.println("WiFi Protected Setup (WPS): succeeded in enrollee mode"); + break; + case SYSTEM_EVENT_STA_WPS_ER_FAILED: + Serial.println("WiFi Protected Setup (WPS): failed in enrollee mode"); + break; + case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT: + Serial.println("WiFi Protected Setup (WPS): timeout in enrollee mode"); + break; + case SYSTEM_EVENT_STA_WPS_ER_PIN: + Serial.println("WiFi Protected Setup (WPS): pin code in enrollee mode"); + break; + case SYSTEM_EVENT_AP_START: + Serial.println("WiFi access point started"); + break; + case SYSTEM_EVENT_AP_STOP: + Serial.println("WiFi access point stopped"); + break; + case SYSTEM_EVENT_AP_STACONNECTED: + Serial.println("Client connected"); + break; + case SYSTEM_EVENT_AP_STADISCONNECTED: + Serial.println("Client disconnected"); + break; + case SYSTEM_EVENT_AP_STAIPASSIGNED: + Serial.println("Assigned IP address to client"); + break; + case SYSTEM_EVENT_AP_PROBEREQRECVED: + Serial.println("Received probe request"); + break; + case SYSTEM_EVENT_GOT_IP6: + Serial.println("IPv6 is preferred"); + break; + case SYSTEM_EVENT_ETH_START: + Serial.println("Ethernet started"); + break; + case SYSTEM_EVENT_ETH_STOP: + Serial.println("Ethernet stopped"); + break; + case SYSTEM_EVENT_ETH_CONNECTED: + Serial.println("Ethernet connected"); + break; + case SYSTEM_EVENT_ETH_DISCONNECTED: + Serial.println("Ethernet disconnected"); + break; + case SYSTEM_EVENT_ETH_GOT_IP: + Serial.println("Obtained IP address"); + break; + default: + break; + } +} + + +void wifiConnect(int16_t res) { + Serial.printf("WiFi scan result: found %d networks\n", res); + + // pick best network + int bestEntry = -1; + int bestRSSI = INT_MIN; + uint8_t bestBSSID[6]; + int32_t bestChannel = 0; + + for (int8_t i = 0; i < res; i++) { + String ssid_scan; + int32_t rssi_scan; + uint8_t sec_scan; + uint8_t* BSSID_scan; + int32_t chan_scan; + WiFi.getNetworkInfo(i, ssid_scan, sec_scan, rssi_scan, BSSID_scan, chan_scan); + int networkEntry = fetchWifiIndex(ssid_scan.c_str()); + if (networkEntry < 0) continue; + if (rssi_scan <= bestRSSI) continue; + bestEntry = networkEntry; + bestRSSI = rssi_scan; + bestChannel = chan_scan; + memcpy((void*) &bestBSSID, (void*) BSSID_scan, sizeof(bestBSSID)); + } + WiFi.scanDelete(); + if (bestEntry >= 0) { + Serial.printf("WiFi Connecting BSSID: %02X:%02X:%02X:%02X:%02X:%02X SSID: %s PW %s Channel: %d (RSSI %d)\n", bestBSSID[0], bestBSSID[1], bestBSSID[2], bestBSSID[3], bestBSSID[4], bestBSSID[5], fetchWifiSSID(bestEntry), fetchWifiPw(bestEntry), bestChannel, bestRSSI); + WiFi.begin(fetchWifiSSID(bestEntry), fetchWifiPw(bestEntry), bestChannel, bestBSSID); + wifi_state = WIFI_CONNECT; + } else { + // rescan + // wifiStart(); + WiFi.disconnect(true); + wifi_state = WIFI_DISABLED; + } +} + +static int wifi_cto; + +void loopWifiBackground() { + // Serial.printf("WifiBackground: state %d\n", wifi_state); + // handle Wifi station mode in background + if (sonde.config.wifi == 0 || sonde.config.wifi == 2) return; // nothing to do if disabled or access point mode + + if (wifi_state == WIFI_DISABLED) { // stopped => start can + wifi_state = WIFI_SCAN; + Serial.println("WiFi start scan"); + WiFi.scanNetworks(true); // scan in async mode + } else if (wifi_state == WIFI_SCAN) { + int16_t res = WiFi.scanComplete(); + if (res == 0 || res == WIFI_SCAN_FAILED) { + // retry + Serial.println("WiFi restart scan"); + WiFi.disconnect(true); + wifi_state = WIFI_DISABLED; + return; + } + if (res == WIFI_SCAN_RUNNING) { + return; + } + // Scan finished, try to connect + wifiConnect(res); + wifi_cto = 0; + } else if (wifi_state == WIFI_CONNECT) { + wifi_cto++; + if (WiFi.isConnected()) { + wifi_state = WIFI_CONNECTED; + // update IP in display + String localIPstr = WiFi.localIP().toString(); + sonde.setIP(localIPstr.c_str(), false); + sonde.updateDisplayIP(); + enableNetwork(true); + } + if (wifi_cto > 20) { // failed, restart scanning + wifi_state = WIFI_DISABLED; + WiFi.disconnect(true); + } + } else if (wifi_state == WIFI_CONNECTED) { + if (!WiFi.isConnected()) { + sonde.setIP("", false); + sonde.updateDisplayIP(); + + wifi_state = WIFI_DISABLED; // restart scan + enableNetwork(false); + WiFi.disconnect(true); + } + } +} + +void startAP() { + Serial.println("Activating access point mode"); + wifi_state = WIFI_APMODE; + WiFi.softAP(networks[0].id.c_str(), networks[0].pw.c_str()); + + Serial.println("Wait 100 ms for AP_START..."); + delay(100); + Serial.println(WiFi.softAPConfig(IPAddress (192, 168, 4, 1), IPAddress (0, 0, 0, 0), IPAddress (255, 255, 255, 0)) ? "Ready" : "Failed!"); + + IPAddress myIP = WiFi.softAPIP(); + String myIPstr = myIP.toString(); + sonde.setIP(myIPstr.c_str(), true); + sonde.updateDisplayIP(); + // enableNetwork(true); done later in WifiLoop. +} + +void initialMode() { + if (sonde.config.touch_thresh == 0) { + enterMode(ST_TOUCHCALIB); + return; + } + if (sonde.config.spectrum != -1) { // enable Spectrum in config.txt: spectrum=number_of_seconds + startSpectrumDisplay(); + } else { + setCurrentDisplay(0); + enterMode(ST_DECODER); + } +} + +void loopTouchCalib() { + uint8_t dispw, disph, dispxs, dispys; + disp.rdis->clear(); + disp.rdis->getDispSize(&disph, &dispw, &dispxs, &dispys); + char num[10]; + + while (1) { + int t1 = touchRead(button1.pin & 0x7f); + int t2 = touchRead(button2.pin & 0x7f); + disp.rdis->setFont(FONT_LARGE); + disp.rdis->drawString(0, 0, "Touch calib."); + disp.rdis->drawString(0, 3 * dispys, "Touch1: "); + snprintf(num, 10, "%d ", t1); + disp.rdis->drawString(8 * dispxs, 3 * dispys, num); + disp.rdis->drawString(0, 6 * dispys, "Touch2: "); + snprintf(num, 10, "%d ", t2); + disp.rdis->drawString(8 * dispxs, 6 * dispys, num); + delay(300); + } +} + +// Wifi modes +// 0: disabled. directly start initial mode (spectrum or scanner) +// 1: station mode in background. directly start initial mode (spectrum or scanner) +// 2: access point mode in background. directly start initial mode (spectrum or scanner) +// 3: traditional sync. WifiScan. Tries to connect to a network, in case of failure activates AP. +// Mode 3 shows more debug information on serial port and display. +#define MAXWIFIDELAY 40 +static const char* _scan[2] = {"/", "\\"}; +void loopWifiScan() { + if (sonde.config.wifi == 0) { // no Wifi + wifi_state = WIFI_DISABLED; + initialMode(); + return; + } + if (sonde.config.wifi == 1) { // station mode, setup in background + wifi_state = WIFI_DISABLED; // will start scanning in wifiLoopBackgroiund + initialMode(); + return; + } + if (sonde.config.wifi == 2) { // AP mode, setup in background + startAP(); + enableNetwork(true); + initialMode(); + return; + } + // wifi==3 => original mode with non-async wifi setup + disp.rdis->setFont(FONT_SMALL); + disp.rdis->drawString(0, 0, "WiFi Scan..."); + uint8_t dispw, disph, dispxs, dispys; + disp.rdis->getDispSize(&disph, &dispw, &dispxs, &dispys); + + int line = 0; + int cnt = 0; + + WiFi.disconnect(true); + WiFi.mode(WIFI_STA); + int index = -1; + int n = WiFi.scanNetworks(); + for (int i = 0; i < n; i++) { + String ssid = WiFi.SSID(i); + disp.rdis->drawString(0, dispys * (1 + line), ssid.c_str()); + line = (line + 1) % (disph / dispys); + String mac = WiFi.BSSIDstr(i); + String encryptionTypeDescription = translateEncryptionType(WiFi.encryptionType(i)); + Serial.printf("Network %s: RSSI %d, MAC %s, enc: %s\n", ssid.c_str(), WiFi.RSSI(i), mac.c_str(), encryptionTypeDescription.c_str()); + int curidx = fetchWifiIndex(ssid.c_str()); + if (curidx >= 0 && index == -1) { + index = curidx; + Serial.printf("Match found at scan entry %d, config network %d\n", i, index); + } + } + int lastl = (disph / dispys - 2) * dispys; + if (index >= 0) { // some network was found + Serial.print("Connecting to: "); Serial.print(fetchWifiSSID(index)); + Serial.print(" with password "); Serial.println(fetchWifiPw(index)); + + disp.rdis->drawString(0, lastl, "Conn:"); + disp.rdis->drawString(6 * dispxs, lastl, fetchWifiSSID(index)); + WiFi.begin(fetchWifiSSID(index), fetchWifiPw(index)); + while (WiFi.status() != WL_CONNECTED && cnt < MAXWIFIDELAY) { + delay(500); + Serial.print("."); + disp.rdis->drawString(15 * dispxs, lastl + dispys, _scan[cnt & 1]); + cnt++; + } + } + if (index < 0 || cnt >= MAXWIFIDELAY) { // no network found, or connect not successful + WiFi.disconnect(true); + delay(1000); + startAP(); + IPAddress myIP = WiFi.softAPIP(); + Serial.print("AP IP address: "); + Serial.println(myIP); + disp.rdis->drawString(0, lastl, "AP: "); + disp.rdis->drawString(6 * dispxs, lastl + 1, networks[0].id.c_str()); + delay(3000); + } else { + Serial.println(""); + Serial.println("WiFi connected"); + Serial.println("IP address: "); + String localIPstr = WiFi.localIP().toString(); + Serial.println(localIPstr); + sonde.setIP(localIPstr.c_str(), false); + sonde.updateDisplayIP(); + wifi_state = WIFI_CONNECTED; + bool hasRS92 = false; + for (int i = 0; i < MAXSONDE; i++) { + if (sonde.sondeList[i].type == STYPE_RS92) hasRS92 = true; + } + if (hasRS92) { + geteph(); + if (ephstate == EPH_PENDING) ephstate = EPH_ERROR; + get_eph("/brdc"); + } + delay(3000); + } + enableNetwork(true); + initialMode(); +} + + +/// Testing OTA Updates +/// somewhat based on Arduino's AWS_S3_OTA_Update +// Utility to extract header value from headers +String getHeaderValue(String header, String headerName) { + return header.substring(strlen(headerName.c_str())); +} + +// OTA Logic +void execOTA() { + int contentLength = 0; + bool isValidContentType = false; + sonde.clearDisplay(); + disp.rdis->setFont(FONT_SMALL); + disp.rdis->drawString(0, 0, "RadioSonde"); + disp.rdis->drawString(0, 1, "Upgrade Os"); + String dispHost = updateHost.substring(0, 14); + //disp.rdis->drawString(2, 0, dispHost.c_str()); + + Serial.println("Connecting to: " + updateHost); + // Connect to Update host + if (client.connect(updateHost.c_str(), updatePort)) { + // Connection succeeded, fecthing the bin + Serial.println("Fetching bin: " + String(*updateBin)); + disp.rdis->drawString(0, 2, "Fetching update"); + + // Get the contents of the bin file + client.print(String("GET ") + *updateBin + " HTTP/1.1\r\n" + + "Host: " + updateHost + "\r\n" + + "Cache-Control: no-cache\r\n" + + "Connection: close\r\n\r\n"); + + // Check what is being sent + // Serial.print(String("GET ") + bin + " HTTP/1.1\r\n" + + // "Host: " + host + "\r\n" + + // "Cache-Control: no-cache\r\n" + + // "Connection: close\r\n\r\n"); + + unsigned long timeout = millis(); + while (client.available() == 0) { + if (millis() - timeout > 5000) { + Serial.println("Client Timeout !"); + client.stop(); + return; + } + } + + while (client.available()) { + // read line till /n + String line = client.readStringUntil('\n'); + // remove space, to check if the line is end of headers + line.trim(); + + // if the the line is empty, + // this is end of headers + // break the while and feed the + // remaining `client` to the + // Update.writeStream(); + if (!line.length()) { + //headers ended + break; // and get the OTA started + } + + // Check if the HTTP Response is 200 + // else break and Exit Update + if (line.startsWith("HTTP/1.1")) { + if (line.indexOf("200") < 0) { + Serial.println("Got a non 200 status code from server. Exiting OTA Update."); + break; + } + } + + // extract headers here + // Start with content length + if (line.startsWith("Content-Length: ")) { + contentLength = atoi((getHeaderValue(line, "Content-Length: ")).c_str()); + Serial.println("Got " + String(contentLength) + " bytes from server"); + } + + // Next, the content type + if (line.startsWith("Content-Type: ")) { + String contentType = getHeaderValue(line, "Content-Type: "); + Serial.println("Got " + contentType + " payload."); + if (contentType == "application/octet-stream") { + isValidContentType = true; + } + } + } + } else { + // Connect to updateHost failed + // May be try? + // Probably a choppy network? + Serial.println("Connection to " + String(updateHost) + " failed. Please check your setup"); + // retry?? + // execOTA(); + } + + // Check what is the contentLength and if content type is `application/octet-stream` + Serial.println("contentLength : " + String(contentLength) + ", isValidContentType : " + String(isValidContentType)); + disp.rdis->drawString(0, 2, "Len: "); + String cls = String(contentLength); + disp.rdis->drawString(5, 2, cls.c_str()); + + // check contentLength and content type + if (contentLength && isValidContentType) { + // Check if there is enough to OTA Update + bool canBegin = Update.begin(contentLength); + disp.rdis->drawString(0, 4, "Starting update"); + + // If yes, begin + if (canBegin) { + Serial.println("Begin OTA. This may take 2 - 5 mins to complete. Things might be quite for a while.. Patience!"); + // No activity would appear on the Serial monitor + // So be patient. This may take 2 - 5mins to complete + disp.rdis->drawString(0, 5, "Please wait!"); + size_t written = Update.writeStream(client); + + if (written == contentLength) { + Serial.println("Written : " + String(written) + " successfully"); + } else { + Serial.println("Written only : " + String(written) + "/" + String(contentLength) + ". Retry?" ); + // retry?? + // execOTA(); + } + + /* + //ICI Update Data + + // Update DATAWeb!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + //Data data.tar + updatedataweb(updateHost,updatePort,updateDataWeb,"index.html"); + */ + + + if (Update.end()) { + Serial.println("OTA done!"); + if (Update.isFinished()) { + Serial.println("Update successfully completed. Rebooting."); + disp.rdis->drawString(0, 7, "Rebooting...."); + delay(1000); + ESP.restart(); + } else { + Serial.println("Update not finished? Something went wrong!"); + } + } else { + Serial.println("Error Occurred. Error #: " + String(Update.getError())); + } + } else { + // not enough space to begin OTA + // Understand the partitions and + // space availability + Serial.println("Not enough space to begin OTA"); + client.flush(); + } + } else { + Serial.println("There was no content in the response"); + client.flush(); + } + + // Back to some normal state + enterMode(ST_DECODER); +} + +void updatedataweb(String host, int port, String dataweb, String fichier){ + + //Data1 index.html + sonde.clearDisplay(); + disp.rdis->setFont(FONT_SMALL); + disp.rdis->drawString(0, 0, "RadioSonde"); + disp.rdis->drawString(0, 1, "Upgrade Data"); + String *data = &dataweb; + String dispHost = host.substring(0, 14); + Serial.println("Connecting to: " + host); + // Connect to Update host + if (client.connect(host.c_str(), port)) { + // Connection succeeded, fecthing the dataweb + Serial.println("Fetching data: " + String(*data)); + disp.rdis->drawString(0, 3, "Fetching data"); + char buf[16]; + snprintf(buf, 16, "%s", fichier); + disp.rdis->drawString(0, 4, buf); + // Get the contents of the bin file + client.print(String("GET ") + *data + " HTTP/1.1\r\n" + + "Host: " + host + "\r\n" + + "Cache-Control: no-cache\r\n" + + "Connection: close\r\n\r\n"); + + unsigned long timeout = millis(); + while (client.available() == 0) { + if (millis() - timeout > 5000) { + Serial.println("Client Timeout !"); + client.stop(); + return; + } + } + + File file = SPIFFS.open("/"+fichier, FILE_WRITE); + int cpt=0; + // Read all the lines of the reply from server and print them to Serial + while(client.available()){ + String line = client.readStringUntil('\r'); + line.trim(); + Serial.print(line); + cpt += 1; + if (!file) { + Serial.println("There was an error opening the file for writing"); + return; + } + if (cpt>10){ + if (file.print(line+"\n")) { + Serial.println("File was written"); + } else { + Serial.println("File write failed"); + } + } + } + file.close(); + } + client.flush(); + //Untar data.tar + +} + +int fetchHTTPheader(int *validType) { + int contentLength = -1; + unsigned long timeout = millis(); + while (client.available() == 0) { + if (millis() - timeout > 5000) { + Serial.println("Client Timeout !"); + client.stop(); + return -1; + } + } + + while (client.available()) { + // read line till \n + String line = client.readStringUntil('\n'); + // remove space, to check if the line is end of headers + line.trim(); + + // if the the line is empty, + // this is end of headers + // break the while and feed the + // remaining `client` to the + // Update.writeStream(); + if (!line.length()) { + //headers ended + break; // and get the OTA started + } + + // Check if the HTTP Response is 200 + // else break and Exit Update + if (line.startsWith("HTTP/1.1")) { + if (line.indexOf("200") < 0) { + Serial.println("Got a non 200 status code from server. Exiting OTA Update."); + return -1; + } + } + + // extract headers here + // Start with content length + if (line.startsWith("Content-Length: ")) { + contentLength = atoi((getHeaderValue(line, "Content-Length: ")).c_str()); + Serial.println("Got " + String(contentLength) + " bytes from server"); + } + + // Next, the content type + if (line.startsWith("Content-Type: ")) { + String contentType = getHeaderValue(line, "Content-Type: "); + Serial.println("Got " + contentType + " payload."); + if (contentType == "application/octet-stream") { + if (validType) *validType = 1; + } + } + } + return contentLength; +} + + + +void loop() { + Serial.printf("\nMAIN: Running loop in state %d [currentDisp:%d, lastDisp:%d]. free heap: %d, unused stack: %d\n", + mainState, currentDisplay, lastDisplay, ESP.getFreeHeap(), uxTaskGetStackHighWaterMark(0)); + switch (mainState) { + case ST_DECODER: +#ifndef DISABLE_MAINRX + loopDecoder(); +#else + delay(1000); +#endif + break; + case ST_SPECTRUM: loopSpectrum(); break; + case ST_WIFISCAN: loopWifiScan(); break; + case ST_UPDATE: execOTA(); break; + case ST_TOUCHCALIB: loopTouchCalib(); break; + } +#if 0 + int rssi = sx1278.getRSSI(); + Serial.print(" RSSI: "); + Serial.print(rssi); + + int gain = sx1278.getLNAGain(); + Serial.print(" LNA Gain: "), + Serial.println(gain); +#endif + loopWifiBackground(); + if (currentDisplay != lastDisplay && (mainState == ST_DECODER)) { + disp.setLayout(currentDisplay); + sonde.clearDisplay(); + sonde.updateDisplay(); + lastDisplay = currentDisplay; + } + +#if FEATURE_MQTT + int now = millis(); + if (mqttEnabled && (lastMqttUptime == 0 || (lastMqttUptime + 60000 < now) || (lastMqttUptime > now))) { + mqttclient.publishUptime(); + lastMqttUptime = now; + } +#endif + +} + +void aprs_station_update() { + int chase = sonde.config.chase; + // automatically decided if CHASE or FIXED mode is used (for config AUTO) + if (chase == SH_LOC_AUTO) { + if (SH_LOC_AUTO_IS_CHASE) chase = SH_LOC_CHASE; else chase = SH_LOC_FIXED; + } + unsigned long time_now = millis(); + unsigned long time_delta = time_now - time_last_aprs_update; + unsigned long update_time = (chase == SH_LOC_CHASE) ? APRS_MOBILE_STATION_UPDATE_TIME : APRS_STATION_UPDATE_TIME; + Serial.printf("aprs_station_update: delta: %ld, update in %ld\n", time_delta, update_time); + if (time_delta < update_time) return; + Serial.println("Update is due!!"); + + float lat, lon; + if (chase == SH_LOC_FIXED) { + // fixed location + lat = sonde.config.rxlat; + lon = sonde.config.rxlon; + if (isnan(lat) || isnan(lon)) return; + } else { + if (gpsPos.valid) { + lat = gpsPos.lat; + lon = gpsPos.lon; + } else { + return; + } + } + Serial.printf("Really updating!! (objcall is %s)", sonde.config.objcall); + char *bcn = aprs_send_beacon(sonde.config.call, lat, lon, sonde.config.beaconsym + ((chase==SH_LOC_CHASE)?2:0), sonde.config.comment); + if ( tcpclient.disconnected()) { + tcpclient.connect(sonde.config.tcpfeed.host, sonde.config.tcpfeed.port); + } + if ( tcpclient.connected() ) { + strcat(bcn, "\r\n"); + Serial.println("****BEACON****"); + Serial.print(bcn); + tcpclient.write(bcn, strlen(bcn)); + time_last_aprs_update = time_now; + } +} + +#if FEATURE_SONDEHUB +// Sondehub v2 DB related codes +/* + Update station data to the sondehub v2 DB +*/ +/* which_pos: 0=none, 1=fixed, 2=gps */ +void sondehub_station_update(WiFiClient * client, struct st_sondehub * conf) { +#define STATION_DATA_LEN 300 + char data[STATION_DATA_LEN]; + char *w; + + // If there is no connection to some WiFi AP, we cannot upload any data at all.... + if ( wifi_state != WIFI_CONNECTED ) return; + + unsigned long time_now = millis(); + // time_delta will be correct, even if time_now overflows + unsigned long time_delta = time_now - time_last_update; + + int chase = conf->chase; + // automatically decided if CHASE or FIXED mode is used (for config AUTO) + if (chase == SH_LOC_AUTO) { + if (SH_LOC_AUTO_IS_CHASE) chase = SH_LOC_CHASE; else chase = SH_LOC_FIXED; + } + + // Use 30sec update time in chase mode, 60 min in station mode. + unsigned long update_time = (chase == SH_LOC_CHASE) ? SONDEHUB_MOBILE_STATION_UPDATE_TIME : SONDEHUB_STATION_UPDATE_TIME; + + // If it is not yet time to send another update. do nothing.... + if ( (time_delta <= update_time) ) return; + + Serial.println("sondehub_station_update()"); + time_last_update = time_now; + + if (!client->connected()) { + if (!client->connect(conf->host, 80)) { + Serial.println("Connection FAILED"); + return; + } + } + + w = data; + // not necessary... memset(w, 0, STATION_DATA_LEN); + + sprintf(w, + "{" + "\"software_name\": \"%s\"," + "\"software_version\": \"%s\"," + "\"uploader_callsign\": \"%s\",", + version_name, version_id, conf->callsign); + w += strlen(w); + + // Only send email if provided + if (strlen(conf->email) != 0) { + sprintf(w, "\"uploader_contact_email\": \"%s\",", conf->email); + w += strlen(w); + } + + // Only send antenna if provided + if (strlen(conf->antenna) != 0) { + sprintf(w, "\"uploader_antenna\": \"%s\",", conf->antenna); + w += strlen(w); + } + + // We send GPS position: (a) in CHASE mode, (b) in AUTO mode if no fixed location has been specified in config + if (chase == SH_LOC_CHASE) { + if (gpsPos.valid) { + sprintf(w, + "\"uploader_position\": [%.6f,%.6f,%d]," + "\"mobile\": true", + gpsPos.lat, gpsPos.lon, gpsPos.alt); + } else { + sprintf(w, "\"uploader_position\": [null,null,null]"); + } + w += strlen(w); + } + // Otherweise, in FIXED mode we send the fixed position from config (if specified) + else if (chase == SH_LOC_FIXED) { + if ((!isnan(sonde.config.rxlat)) && (!isnan(sonde.config.rxlon))) { + if (isnan(sonde.config.rxalt)) + sprintf(w, "\"uploader_position\": [%.6f,%.6f,null]", sonde.config.rxlat, sonde.config.rxlon); + else + sprintf(w, "\"uploader_position\": [%.6f,%.6f,%d]", sonde.config.rxlat, sonde.config.rxlon, (int)sonde.config.rxalt); + } else { + sprintf(w, "\"uploader_position\": [null,null,null]"); + } + w += strlen(w); + } else { + sprintf(w, "\"uploader_position\": [null,null,null]"); + w += strlen(w); + } + + // otherwise (in SH_LOC_NONE mode) we dont include any position info + sprintf(w, "}"); + + client->println("PUT /listeners HTTP/1.1"); + client->print("Host: "); + client->println(conf->host); + client->println("accept: text/plain"); + client->println("Content-Type: application/json"); + client->print("Content-Length: "); + client->println(strlen(data)); + client->println(); + client->println(data); + Serial.println(strlen(data)); + Serial.println(data); + Serial.println("Waiting for response"); + // TODO: better do this asyncrhonously + // At least, do this safely. See Notes-on-Using-WiFiClient.txt for details + // If any of the client->print failed before (remote end closed connection), + // then calling client->read will cause a LoadProhibited exception + if (client->connected()) { + String response = client->readString(); + Serial.println(response); + Serial.println("Response done..."); + } else { + Serial.println("SH client connection closed\n"); + } + //client->stop(); +} + +/* + Update sonde data to the sondehub v2 DB +*/ +enum SHState { SH_DISCONNECTED, SH_CONNECTING, SH_CONN_IDLE, SH_CONN_APPENDING, SH_CONN_WAITACK }; + +SHState shState = SH_DISCONNECTED; +time_t shStart = 0; + + + +void sondehub_reply_handler(WiFiClient * client) { + // sondehub handler for tasks to be done even if no data is to be sent: + // process response messages from sondehub + // request frequency list (if active) +#define MSG_SIZE 1000 + char rs_msg[MSG_SIZE]; + + if (shImport == 1) { // we are waiting for a reply to a sondehub frequency import request + // while we are waiting, we do nothing else with sondehub... + int res = ShFreqImport::shImportHandleReply(&shclient); + Serial.printf("ret: %d\n", res); + // res==0 means more data is expected, res==1 means complete reply received (or error) + if (res == 1) { + shImport = 2; // finished + shImportInterval = sonde.config.sondehub.fiinterval * 60; + } + } + else { + // any reply here belongs to normal telemetry upload, lets just print it. + // and wait for a valid HTTP response + int cnt = 0; + while (client->available() > 0) { + // data is available from remote server, process it... + // readBytesUntil may wait for up to 1 second if enough data is not available... + // int cnt = client->readBytesUntil('\n', rs_msg, MSG_SIZE - 1); + int c = client->read(); + if (c < 0) break; // should never happen in available() returned >0 right before.... + rs_msg[cnt++] = c; + if (c == '\n') { + rs_msg[cnt] = 0; + Serial.println(rs_msg); + // If something that looks like a valid HTTP response is received, we are ready to send the next data item + if (shState == SH_CONN_WAITACK && cnt > 11 && strncmp(rs_msg, "HTTP/1", 6) == 0) { + shState = SH_CONN_IDLE; + } + cnt = 0; + } + if (cnt >= MSG_SIZE - 1) { + cnt = 0; + Serial.println("(overlong line from network, ignoring)"); + } + } + if (cnt > 0) { + rs_msg[cnt + 1] = 0; + Serial.println(rs_msg); + } + } + // send import requests if needed + if (sonde.config.sondehub.fiactive) { + if (shImport == 2) { + Serial.printf("next sondehub frequncy import in %d seconds\n", shImportInterval); + shImportInterval --; + if (shImportInterval <= 0) { + shImport = 0; + } + } + else if (shImport == 0) { + if (shState == SH_CONN_APPENDING || shState == SH_CONN_WAITACK) + Serial.printf("Time to request next sondehub import.... but still busy with upload request"); + else + sondehub_send_fimport(&shclient); + } + } + + // also handle periodic station updates here... + // interval check moved to sondehub_station_update to avoid having to calculate distance in auto mode twice + if (sonde.config.sondehub.active) { + if (shState == SH_CONN_IDLE || shState == SH_DISCONNECTED ) { + // (do not set station update while a telemetry report is being sent + sondehub_station_update(&shclient, &sonde.config.sondehub); + } + } +} + +void sondehub_send_fimport(WiFiClient * client) { + if (shState == SH_CONN_APPENDING || shState == SH_CONN_WAITACK) { + // Currently busy with SondeHub data upload + // So do nothing here. + // sond_fimport will be re-sent later, when shState becomes SH_CONN_IDLE + return; + } + // It's time to run, so check prerequisites + float lat = sonde.config.rxlat, lon = sonde.config.rxlon; + if (gpsPos.valid) { + lat = gpsPos.lat; + lon = gpsPos.lon; + } + + int maxdist = sonde.config.sondehub.fimaxdist; // km + int maxage = sonde.config.sondehub.fimaxage * 60; // fimaxage is hours, shImportSendRequest uses minutes + int fiinterval = sonde.config.sondehub.fiinterval; + Serial.printf("shimp : %f %f %d %d %d\n", lat, lon, maxdist, maxage, shImportInterval); + if ( !isnan(lat) && !isnan(lon) && maxdist > 0 && maxage > 0 && fiinterval > 0 ) { + int res = ShFreqImport::shImportSendRequest(&shclient, lat, lon, maxdist, maxage); + if (res == 0) shImport = 1; // Request OK: wait for response + else shImport = 2; // Request failed: wait interval, then retry + } +} + +// in hours.... max allowed diff UTC <-> sonde time +#define SONDEHUB_TIME_THRESHOLD (3) +void sondehub_send_data(WiFiClient * client, SondeInfo * s, struct st_sondehub * conf) { + Serial.println("sondehub_send_data()"); + Serial.printf("shState = %d\n", shState); + + // max age of data in JSON request (in seconds) +#define SONDEHUB_MAXAGE 15 + + char rs_msg[MSG_SIZE]; + char *w; + struct tm ts; + // config setting M10 and M20 will both decode both types, so use the real type that was decoded + uint8_t realtype = sonde.realType(s); + + // For DFM, s->d.time is data from subframe DAT8 (gps date/hh/mm), and sec is from DAT1 (gps sec/usec) + // For all others, sec should always be 0 and time the exact time in seconds + time_t t = s->d.time; + + int chase = conf->chase; + // automatically decided if CHASE or FIXED mode is used (for config AUTO) + if (chase == SH_LOC_AUTO) { + if (SH_LOC_AUTO_IS_CHASE) chase = SH_LOC_CHASE; else chase = SH_LOC_FIXED; + } + + + struct tm timeinfo; + time_t now; + time(&now); + gmtime_r(&now, &timeinfo); + if (timeinfo.tm_year <= (2016 - 1900)) { + Serial.println("Failed to obtain time"); + return; + } + + // Check if current sonde data is valid. If not, don't do anything.... + if (*s->d.ser == 0 || s->d.validID==0 ) return; // Don't send anything without serial number + if (((int)s->d.lat == 0) && ((int)s->d.lon == 0)) return; // Sometimes these values are zeroes. Don't send those to the sondehub + if ((int)s->d.alt > 50000) return; // If alt is too high don't send to SondeHub + // M20 data does not include #sat information + if ( realtype != STYPE_M20 && (int)s->d.sats < 4) return; // If not enough sats don't send to SondeHub + + // If not connected to sondehub, try reconnecting. + // TODO: do this outside of main loop + if (!client->connected()) { + Serial.println("NO CONNECTION"); + shState = SH_DISCONNECTED; + if (!client->connect(conf->host, 80)) { + Serial.println("Connection FAILED"); + return; + } + client->Client::setTimeout(0); // does this work? + shState = SH_CONN_IDLE; + } + + if ( shState == SH_CONN_WAITACK ) { + Serial.println("Previous SH-frame not yet ack'ed, not sending new data"); + return; + } + + if ( abs(now - (time_t)s->d.time) > (3600 * SONDEHUB_TIME_THRESHOLD) ) { + Serial.printf("Sonde time %d too far from current UTC time %ld", s->d.time, now); + return; + } + + // DFM uses UTC. Most of the other radiosondes use GPS time + // SondeHub expect datetime to be the same time sytem as the sonde transmits as time stamp + if ( realtype == STYPE_RS41 || realtype == STYPE_RS92 || realtype == STYPE_M20 ) { + t += 18; // convert back to GPS time from UTC time +18s + } + + gmtime_r(&t, &ts); + + memset(rs_msg, 0, MSG_SIZE); + w = rs_msg; + + sprintf(w, + " {" + "\"software_name\": \"%s\"," + "\"software_version\": \"%s\"," + "\"uploader_callsign\": \"%s\"," + "\"time_received\": \"%04d-%02d-%02dT%02d:%02d:%02d.000Z\"," + "\"manufacturer\": \"%s\"," + "\"serial\": \"%s\"," + "\"datetime\": \"%04d-%02d-%02dT%02d:%02d:%02d.000Z\"," + "\"lat\": %.5f," + "\"lon\": %.5f," + "\"alt\": %.5f," + "\"frequency\": %.3f," + "\"vel_h\": %.5f," + "\"vel_v\": %.5f," + "\"heading\": %.5f," + "\"rssi\": %.1f," + "\"frame\": %d," + "\"type\": \"%s\",", + version_name, version_id, conf->callsign, + timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec, + manufacturer_string[realtype], s->d.ser, + ts.tm_year + 1900, ts.tm_mon + 1, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec, + (float)s->d.lat, (float)s->d.lon, (float)s->d.alt, (float)s->freq, (float)s->d.hs, (float)s->d.vs, + (float)s->d.dir, -((float)s->rssi / 2), s->d.vframe, sondeTypeStrSH[realtype] + ); + w += strlen(w); + + // Only send sats if not M20 + if (realtype != STYPE_M20) { + sprintf(w, "\"sats\": %d,", (int)s->d.sats); + w += strlen(w); + } + + /* if there is a subtype (DFM only) */ + if ( TYPE_IS_DFM(s->type) && s->d.subtype > 0 && s->d.subtype < 16 ) { + const char *t = dfmSubtypeStrSH[s->d.subtype]; + // as in https://github.com/projecthorus/radiosonde_auto_rx/blob/e680221f69a568e1fdb24e76db679233f32cb027/auto_rx/autorx/sonde_specific.py#L84 + if (t) sprintf(w, "\"subtype\": \"%s\",", t); + else sprintf(w, "\"subtype\": \"DFMx%X\",", s->d.subtype); // Unknown subtype + w += strlen(w); + } else if ( s->type == STYPE_RS41 ) { + char buf[11]; + if (RS41::getSubtype(buf, 11, s) == 0) { + sprintf(w, "\"subtype\": \"%s\",", buf); + w += strlen(w); + } + } + + // Only send temp if provided + if (!isnan(s->d.temperature)) { + sprintf(w, "\"temp\": %.1f,", s->d.temperature); + w += strlen(w); + } + + // Only send humidity if provided + if (!isnan(s->d.relativeHumidity)) { + sprintf(w, "\"humidity\": %.1f,", s->d.relativeHumidity); + w += strlen(w); + } + + // Only send pressure if provided + if (!isnan(s->d.pressure)) { + sprintf(w, "\"pressure\": %.2f,", s->d.pressure); + w += strlen(w); + } + + // Only send burst timer if RS41 and fresh within the last 51s + if ((realtype == STYPE_RS41) && (s->d.crefKT > 0) && (s->d.vframe - s->d.crefKT < 51)) { + sprintf(w, "\"burst_timer\": %d,", (int)s->d.countKT); + w += strlen(w); + } + + // Only send battery if provided + if (s->d.batteryVoltage > 0) { + sprintf(w, "\"batt\": %.2f,", s->d.batteryVoltage); + w += strlen(w); + } + + // Only send antenna if provided + if (strlen(conf->antenna) != 0) { + sprintf(w, "\"uploader_antenna\": \"%s\",", conf->antenna); + w += strlen(w); + } + + // We send GPS position: (a) in CHASE mode, (b) in AUTO mode if no fixed location has been specified in config + if (chase == SH_LOC_CHASE) { + if (gpsPos.valid) { + sprintf(w, "\"uploader_position\": [%.6f,%.6f,%d]", gpsPos.lat, gpsPos.lon, gpsPos.alt); + } else { + sprintf(w, "\"uploader_position\": [null,null,null]"); + } + w += strlen(w); + } + // Otherweise, in FIXED mode we send the fixed position from config (if specified) + else if (chase == SH_LOC_FIXED) { + if ((!isnan(sonde.config.rxlat)) && (!isnan(sonde.config.rxlon))) { + if (isnan(sonde.config.rxalt)) + sprintf(w, "\"uploader_position\": [%.6f,%.6f,null]", sonde.config.rxlat, sonde.config.rxlon); + else + sprintf(w, "\"uploader_position\": [%.6f,%.6f,%d]", sonde.config.rxlat, sonde.config.rxlon, (int)sonde.config.rxalt); + } else { + sprintf(w, "\"uploader_position\": [null,null,null]"); + } + w += strlen(w); + } else { + sprintf(w, "\"uploader_position\": [null,null,null]"); + w += strlen(w); + } + + // otherwise (in SH_LOC_NONE mode) we dont include any position info + sprintf(w, "}"); + + if (shState != SH_CONN_APPENDING) { + sondehub_send_header(client, s, conf, &timeinfo); + sondehub_send_next(client, s, conf, rs_msg, strlen(rs_msg), 1); + shState = SH_CONN_APPENDING; + shStart = now; + } else { + sondehub_send_next(client, s, conf, rs_msg, strlen(rs_msg), 0); + } + if (now - shStart > SONDEHUB_MAXAGE) { // after MAXAGE seconds + sondehub_send_last(client, s, conf); + shState = SH_CONN_WAITACK; + shStart = 0; + } + //client->println(rs_msg); + //Serial.println(rs_msg); + //String response = client->readString(); + //Serial.println(response); +} + +void sondehub_finish_data(WiFiClient * client, SondeInfo * s, struct st_sondehub * conf) { + // If there is an "old" pending collection of JSON data sets, send it even if no now data is received + if (shState == SH_CONN_APPENDING) { + time_t now; + time(&now); + if (now - shStart > SONDEHUB_MAXAGE + 3) { // after MAXAGE seconds + sondehub_send_last(client, s, conf); + shState = SH_CONN_WAITACK; + shStart = 0; + } + } +} + +static const char *DAYS[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"}; +static const char *MONTHS[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Noc", "Dec"}; + +void sondehub_send_header(WiFiClient * client, SondeInfo * s, struct st_sondehub * conf, struct tm * now) { + Serial.print("PUT /sondes/telemetry HTTP/1.1\r\n" + "Host: "); + Serial.println(conf->host); + Serial.print("accept: text/plain\r\n" + "Content-Type: application/json\r\n" + "Transfer-Encoding: chunked\r\n"); + + client->print("PUT /sondes/telemetry HTTP/1.1\r\n" + "Host: "); + client->println(conf->host); + client->print("accept: text/plain\r\n" + "Content-Type: application/json\r\n" + "Transfer-Encoding: chunked\r\n"); + if (now) { + Serial.printf("Date: %s, %02d %s %04d %02d:%02d:%02d GMT\r\n", + DAYS[now->tm_wday], now->tm_mday, MONTHS[now->tm_mon], now->tm_year + 1900, + now->tm_hour, now->tm_min, now->tm_sec); + client->printf("Date: %s, %02d %s %04d %02d:%02d:%02d GMT\r\n", + DAYS[now->tm_wday], now->tm_mday, MONTHS[now->tm_mon], now->tm_year + 1900, + now->tm_hour, now->tm_min, now->tm_sec); + } + client->print("User-agent: "); + client->print(version_name); + client->print("/"); + client->println(version_id); + client->println(""); // another cr lf as indication of end of header +} +void sondehub_send_next(WiFiClient * client, SondeInfo * s, struct st_sondehub * conf, char *chunk, int chunklen, int first) { + // send next chunk of JSON request + client->printf("%x\r\n", chunklen + 1); + client->write(first ? "[" : ",", 1); + client->write(chunk, chunklen); + client->print("\r\n"); + + Serial.printf("%x\r\n", chunklen + 1); + Serial.write((const uint8_t *)(first ? "[" : ","), 1); + Serial.write((const uint8_t *)chunk, chunklen); + Serial.print("\r\n"); +} +void sondehub_send_last(WiFiClient * client, SondeInfo * s, struct st_sondehub * conf) { + // last chunk. just the closing "]" of the json request + client->printf("1\r\n]\r\n0\r\n\r\n"); + Serial.printf("1\r\n]\r\n0\r\n\r\n"); +} + + +// End of sondehub v2 related codes +#endif diff --git a/RX_FSK/data.tar b/RX_FSK/data.tar new file mode 100644 index 0000000..c25589f Binary files /dev/null and b/RX_FSK/data.tar differ diff --git a/RX_FSK/data/GPSRESET b/RX_FSK/data/GPSRESET new file mode 100644 index 0000000..fd38861 --- /dev/null +++ b/RX_FSK/data/GPSRESET @@ -0,0 +1 @@ ++ diff --git a/RX_FSK/data/cfg.js b/RX_FSK/data/cfg.js new file mode 100644 index 0000000..dd1861a --- /dev/null +++ b/RX_FSK/data/cfg.js @@ -0,0 +1,177 @@ +var cfgs = [ +[ "", "General configuration", "" ], +[ "wifi", "Wifi mode (0=off, 1=client, 2=AP, 3=client or AP autoselect on startup)" ], +[ "mdnsname", "Network mDNS name"], +[ "ephftp", "FTP server for ephemeris data (RS92 decoder)"], +[ "debug", "Debug mode (0/1)" ], +[ "maxsonde", "Maximum number of QRG entries (must be ≤ 50)" ], +[ "rxlat", "Receiver fixed latitude"], +[ "rxlon", "Receiver fixed longitude"], +[ "rxalt", "Receiver fixed altitude"], +[ "", "OLED display configuration", "" ], +[ "screenfile", "Screen config (0=automatic; 1-2=OLED predefined; other=custom)" ], +[ "display", "Display screens (scan, default, ...)" ], +[ "dispsaver", "Display saver (0=never/1=always/2=ifnorx [+10*n: after n sec.])" ], +[ "dispcontrast", "OLED contrast (-1=use default; 0..255=set contrast)" ], +[ "norx_timeout", "No-RX-timeout in seconds (-1=disabled)"], +[ "", "Spectrum display configuration", "" ], +[ "spectrum", "Show spectrum on start (-1=no, 0=forever, >0=time [sec])" ], +[ "startfreq", "Start frequency (MHz, default 400)" ], +[ "channelbw", "Bandwidth (kHz)" ], +[ "marker", "Spectrum MHz marker" ], // maybe remove, assume always ==1? +[ "noisefloor", "Spectrum noisefloor" ], +[ "", "Receiver configuration", "" ], +[ "freqofs", "RX frequency offset (Hz)"], +[ "rs41.agcbw", "RS41 AGC bandwidth"], +[ "rs41.rxbw", "RS41 RX bandwidth"], +[ "rs92.rxbw", "RS92 RX (and AGC) bandwidth"], +[ "rs92.alt2d", "RS92 2D fix default altitude"], +[ "dfm.agcbw", "DFM AGC bandwidth"], +[ "dfm.rxbw", "DFM RX bandwidth"], +[ "m10m20.agcbw", "M10/M20 AGC bandwidth"], +[ "m10m20.rxbw", "M10/M20 RX bandwidth"], +[ "mp3h.agcbw", "MP3H AGC bandwidth"], +[ "mp3h.rxbw", "MP3H RX bandwidth"], +[ "", "KISS TNC/AXUDP/AXTCP data feed configuration", ""], +[ "call", "Call"], +[ "passcode", "Passcode"], +[ "kisstnc.active", "KISS TNC (port 14590) (needs reboot)"], +[ "axudp.active", "AXUDP active"], +[ "axudp.host", "AXUDP host"], +[ "axudp.port", "AXUDP port"], +[ "axudp.highrate", "Rate limit"], +[ "tcp.active", "APRS TCP active"], +[ "tcp.host", "APRS TCP host"], +[ "tcp.port", "APRS TCP port"], +[ "tcp.highrate", "Rate limit"], +[ "tcp.objcall", "APRS object call"], +[ "tcp.beaconsym", "APRS tracker symbol"], +[ "tcp.chase", "APRS location reporting (0=off, 1=fixed, 2=chase/GPS, 3=auto)"], +[ "tcp.comment", "APRS location comment"], +[ "", "MQTT data feed configuration", ""], +[ "mqtt.active", "MQTT active (needs reboot)"], +[ "mqtt.id", "MQTT client ID"], +[ "mqtt.host", "MQTT server hostname"], +[ "mqtt.port", "MQTT port"], +[ "mqtt.username", "MQTT username"], +[ "mqtt.password", "MQTT password"], +[ "mqtt.prefix", "MQTT prefix"], +[ "", "Chasemapper settings", ""], +[ "cm.active", "Chasemapper active (0=disabled, 1=active)"], +[ "cm.host", "Chasemapper UDP host"], +[ "cm.port", "Chasemapper UDP port"], +[ "", "SondeHub settings", ""], +[ "sondehub.active", "SondeHub reporting (0=disabled, 1=active)"], +[ "sondehub.chase", "SondeHub location reporting (0=off, 1=fixed, 2=chase/GPS, 3=auto)"], +[ "sondehub.host", "SondeHub host (DO NOT CHANGE)"], +[ "sondehub.callsign", "Callsign"], +[ "sondehub.antenna", "Antenna (optional, visisble on SondeHub tracker)"], +[ "sondehub.email", "SondeHub email (optional, only used to contact in case of upload errors)"], +[ "", "SondeHub frequency import", "" ], +[ "sondehub.fiactive", "SondeHub frequency import active (0=disabled, 1=active)" ], +[ "sondehub.fiinterval", "Import frequency (minutes, ≥ 5)" ], +[ "sondehub.fimaxdist", "Import maximum distance (km, ≤ 700)" ], +[ "sondehub.fimaxage", "Import maximum age (hours, ≤ 48)" ], +[ "", "Hardware configuration (requires reboot)", ""], +[ "disptype", "Display type (0=OLED/SSD1306, 2=OLED/SH1106, 5=ST7789)"], +[ "oled_sda", "OLED SDA/TFT SDA"], +[ "oled_scl", "OLED SCL/TFT CLK"], +[ "oled_rst", "OLED RST/TFT RST (needs reboot)"], +[ "button_pin", "Button input port"], +[ "button2_pin", "Button 2 input port"], +[ "button2_axp", "Use AXP192 PWR as Button 2"], +[ "touch_thresh", "Touch button threshold
(0 for calib mode)"], +[ "power_pout", "Power control port"], +[ "led_pout", "LED output port (25)"], + +["buzzerOn", "Buzzer (0=Disabled, 1 Enable)"], +["buzzerPort", "Buzzer Port (4)"], +["buzzerFreq", "Buzzer Frequency (700)"], +["dbsmetre", "dB = 0 / Smetre =1)"], +["degdec", "Lat,Lon Decimal =0 ou Degres =1)"], + +[ "gps_rxd", "GPS RXD pin (-1 to disable)"], +[ "gps_txd", "GPS TXD pin (not really needed)"], +[ "batt_adc", "Battery measurement pin"], +[ "sx1278_ss", "SX1278 SS"], +[ "sx1278_miso", "SX1278 MISO"], +[ "sx1278_mosi", "SX1278 MOSI"], +[ "sx1278_sck", "SX1278 SCK"], +]; + +function mkcfg(id, key, label, value) { + var s = "" + label + "\n"; + return s; +} +function mkcfgbtn(id, key, label, value) { + var touch = ""; + var v = value; + if(v != -1 && (v&128)) { + touch = " checked"; + v = v & 127; + } + var s = "" + label + ""; + s += " Touch\n"; + return s; +} + +function mksep(id,label,url) { + return ""+label+" [wiki]\n"; +} +function rowdisp(id,disp) { + var matches = document.querySelectorAll("tr."+id); + matches.forEach(function(e) { if(disp) e.hidden=true; else e.removeAttribute('hidden');}); + hid=id; nid="N"+id; + if(!disp) { hid=nid; nid=id; } + document.querySelector("span."+hid).hidden=true; + document.querySelector("span."+nid).removeAttribute('hidden'); +} +function configTable() { + // iterate over cfgs + var tab = "\n"; + var id=0; + for(i=0; i" + } else { + tab += mkcfg("s"+id, key, lbl, cf.get(key)); + } + } else { + id++; + tab += mksep("s"+id, lbl, cfgs[i][2]); + } + } + tab += "

Option	Value
"+scr+"

"; + var cfgdiv = document.getElementById("cfgtab"); + cfgdiv.innerHTML = tab; + // enable collapse / expand of items below a header + var acc = document.getElementsByClassName("cfgheader"); + for(i=0; i0: screens${i}.txt +# predefined: 1: for OLED, 2: for ILI9225; 3: for ILI9225 (portrait mode); 4: for ILI9431; 5: for ILI9431 (portrait mode) +# screenfile=2 +# display configuration. List of "displays" +# first entry: "Scanner" display +# second entry: default "Receiver" display +# additional entries: alternative receiver display, activated by button +display=0,1,2,3,4,5,6,7 +# turn off display: 0=never, 1=always, 2=if no RX; (+n*10: after n seconds) +dispsaver=0 +# set OLED contrast (0..255) or leave at factory default (-1) +dispcontrast=-1 +# set to -1 to disable (used for "N" values in timers in screens.txt). Value in seconds +norx_timeout=20 +#Add F4IYT +buzzerOn=1 +buzzerPort=25 +buzzerFreq=700 +dbsmetre=1 +#-------------------------------# +# Spectrum display settings +#-------------------------------# +startfreq=400 +channelbw=10 +spectrum=-1 #10 +noisefloor=-125 +marker=1 +#-------------------------------# +# APRS settings +#-------------------------------# +call=N0CALL +passcode=12345 +#-------------------------------# +# Sonde specific settings: bandwidth +# valid values: 3100, 3900, 5200, 6300, 7800, 10400, 12500, +# 15600, 20800, 25000, ... +# other values will be rounded up to the next valid value +# rs92.alt2d: default altitude used by RS92 decoder if only 3 sats available +#-------------------------------# +rs41.agcbw=12500 +rs41.rxbw=6300 +rs92.rxbw=12500 +rs92.alt2d=480 +dfm.agcbw=20800 +dfm.rxbw=10400 +#-------------------------------# +# ftp server for RINEX data (for RS92) +# YYYY/DDD/brdcDDD0.YYn.gz is appended +# s1: igs.bkg.bund.de/IGS/BRDC/ +# s2: www.ngs.noaa.gov/cors/rinex/ +#-------------------------------# +#ephftp=www.ngs.noaa.gov/cors/rinex/ +#ephftp=igs.bkg.bund.de/IGS/BRDC/ +ephftp=gssc.esa.int/gnss/data/daily/ +#-------------------------------# +# axudp for sending to aprsmap +#-------------------------------# +# local use only, do not feed to public services +# data not sanitized / quality checked, outliers not filtered out +axudp.active=1 +axudp.host=192.168.42.20 +axudp.port=9002 +axudp.symbol=/O +axudp.highrate=1 +#-------------------------------# +# connect to some aprs server +#-------------------------------# +tcp.active=0 +tcp.host=radiosondy.info +tcp.port=14590 +tcp.symbol=/O +tcp.highrate=20 +# send beacon (possibly with different call or SSID) +tcp.chase=0 +tcp.objcall= +tcp.beaconsym=/`/( +tcp.comment= +#-------------------------------# +# mqtt settings +#-------------------------------# +# data not sanitized / quality checked, outliers not filtered out +mqtt.active=0 +mqtt.id=rdz_sonde_server +mqtt.ip=192.168.1.5 +mqtt.port=1883 +mqtt.username= +mqtt.password= +mqtt.prefix=rdz_sonde_server/ +#-------------------------------# +# Sondehub v2 settings +#-------------------------------# +# Sondehub v2 DB settings +sondehub.active=0 +sondehub.chase=3 +sondehub.host=api.v2.sondehub.org +sondehub.callsign=CHANGEME_RDZTTGO +sondehub.antenna= +sondehub.email= +#-------------------------------# +# Sondehub freq import settings +#-------------------------------# +shfimp.active=0 +shfimp.interval=60 +shfimp.maxdist=150 +shfimp.maxage=6 +#-------------------------------# +# EOF +#-------------------------------# diff --git a/RX_FSK/data/fontawesome-webfont.eot b/RX_FSK/data/fontawesome-webfont.eot new file mode 100755 index 0000000..33b2bb8 Binary files /dev/null and b/RX_FSK/data/fontawesome-webfont.eot differ diff --git a/RX_FSK/data/fontawesome-webfont.woff b/RX_FSK/data/fontawesome-webfont.woff new file mode 100755 index 0000000..8b280b9 Binary files /dev/null and b/RX_FSK/data/fontawesome-webfont.woff differ diff --git a/RX_FSK/data/index.html b/RX_FSK/data/index.html new file mode 100755 index 0000000..7562072 --- /dev/null +++ b/RX_FSK/data/index.html @@ -0,0 +1,193 @@ + + + + RadioSonde (version %VERSION_ID%) + + + + + +

RadioSonde (version %VERSION_ID%)

+ + + + + +

QRG - Setup

+ +

WiFi - Settings

+ +

Data

+ +

Configuration

+ +

Control

+ +

Update

+ +

Telemetry

+ +

+ %VERSION_NAME%
+ CopyLeft 2020-2022 Modifier par Xav, FRS2013 & Vigor
+ Check for update (requires TTGO internet connection via WiFi)

+
+ (version %VERSION_ID%) +
+ Original project by Hansi
+ Copyright © 2019-2022 by Hansi Reiser, DL9RDZ
+

+ Autodetect info: %AUTODETECT_INFO%
+
+ RS92 RINEX eph state: %EPHSTATE%
+
+ This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of + the License, or (at your option) any later version.
+ See https://www.gnu.org/licenses/gpl-2.0.txt + for details. +

+ +

+ + + + + + diff --git a/RX_FSK/data/livemap.html b/RX_FSK/data/livemap.html new file mode 100644 index 0000000..397186e --- /dev/null +++ b/RX_FSK/data/livemap.html @@ -0,0 +1,18 @@ + + + + RadioSonde LiveMap + + + + + + + + + + + +

+ + diff --git a/RX_FSK/data/livemap.js b/RX_FSK/data/livemap.js new file mode 100644 index 0000000..7aeea16 --- /dev/null +++ b/RX_FSK/data/livemap.js @@ -0,0 +1,530 @@ +try { + var check = $(document); +} catch (e) { + document.addEventListener("DOMContentLoaded", function(event) { + document.getElementById('map').innerHTML = '

In order to use this functionality, there must be an internet connection.

retry

go back'; + }); +} + +$(document).ready(function(){ + + var map = L.map('map', { attributionControl: false, zoomControl: false }); + map.on('mousedown touchstart',function () { follow=false; }); + + L.control.scale().addTo(map); + L.control.attribution({prefix:false}).addTo(map); + + var osmlight = L.tileLayer('https://{s}.tile.openstreetmap.de/{z}/{x}/{y}.png', { + maxZoom: 19, + attribution: '© OpenStreetMap contributors' + }); + + var osmdark = L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png', { + attribution: '© OpenStreetMap contributors © CARTO', + maxZoom: 19 + }); + + var opentopo = L.tileLayer('https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png', { + maxZoom: 17, + attribution: 'Map data: © OpenStreetMap contributors, SRTM
Map style: © OpenTopoMap (CC-BY-SA)' + }); + + var esri = L.tileLayer('https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', { + attribution: 'Tiles © Esri — Source: Esri, i-cubed, USDA, USGS, AEX, GeoEye,
Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community', + maxZoom: 21 + }); + + var basemap; + if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) { + map.addLayer(osmdark); + basemap='osmdark'; + } else { + map.addLayer(osmlight); + basemap='osmlight'; + } + + basemap_change = function () { + if (basemap == 'osmlight') { + map.removeLayer(osmlight); + map.addLayer(opentopo); + basemap = 'opentopo'; + } else if (basemap == 'opentopo') { + map.removeLayer(opentopo); + map.addLayer(esri); + basemap = 'esri'; + } else if (basemap == 'esri') { + map.removeLayer(esri); + map.addLayer(osmdark); + basemap = 'osmdark'; + } else { + map.removeLayer(osmdark); + map.addLayer(osmlight); + basemap = 'osmlight'; + } + }; + + if(mapcenter) map.setView(mapcenter, 5); + else map.setView([51.163361,10.447683], 5); // Mitte DE + +var reddot = ''; +var yellowdot = ''; +var greendot = ''; +var lastframe = 0; + +$('#map .leaflet-control-container').append(L.DomUtil.create('div', 'leaflet-top leaflet-center leaflet-header')); +var header = ''; +header += '

rdzTTGOSonde LiveMap
🎈 - MHz -

'; +header += '

m | m/s | km/h | °
| -dBm

'; +header += '

Prediction-Settings
'; + +header += 'Burst at: m
'; +header += 'Descending: m/s
'; +header += 'Use this descending until: m
'; +header += 'after the transmitted descend will be used'; +header += '

'; +header += '

'; +$('.leaflet-header').append(header); + + +$('#map .leaflet-control-container').append(L.DomUtil.create('div', 'leaflet-bottom leaflet-center leaflet-footer')); +var footer = ''; +footer += '

Direction: ...°
Distance: ...m

'; +$('.leaflet-footer').append(footer); + +var statbar = ''; +headtxt = function(data,stat) { + var staticon = (stat == '1')?greendot:yellowdot; + statbar = staticon + statbar; + if ((statbar.length) > 10*greendot.length) { statbar = statbar.substring(0,10*greendot.length); } + if (data.id && data.vframe != lastframe ) { + lastframe = data.vframe; + $('#sonde_id').html(data.id); + $('#sonde_alt').html(data.alt); + $('#sonde_climb').html(data.climb); + $('#sonde_speed').html( mr(data.speed * 3.6 * 10) / 10 ); + $('#sonde_dir').html(data.dir); + $('#sonde_time').html(new Date(data.time * 1000).toISOString()); + $('#sonde_rssi').html(data.rssi / 2 ); + $('#sonde_detail').show(); + } else { + if (!data.id) { + $('#sonde_id').html(data.launchsite.trim()); + // $('#sonde_detail').hide(); + } + } + $('#sonde_freq').html(data.freq); + $('#sonde_type').html(data.type); + $('#sonde_statbar').html(' '+statbar); +}; + +map.addControl(new L.Control.Button([ { position: 'topleft', text: '🔙', href: 'index.html' } ])); + +L.control.zoom({ position:'topleft' }).addTo(map); + +map.addControl(new L.Control.Button([ { position: 'topleft', text: '🗺️', href: 'javascript:basemap_change();' } ])); + +map.addControl(new L.Control.Button([ { position: 'topright', id: "status", text: '', href: 'javascript:get_data();' } ])); + +map.addControl(new L.Control.Button([ + { position:'topright', text: '🎈', href: 'javascript:show(marker[last_id],\'marker\');' }, + { text: '〰️', href: 'javascript:show_line();' }, + { text: '💥', href: 'javascript:show(marker_burst[last_id],\'burst\');' }, + { text: '🎯', href: 'javascript:show(marker_landing[last_id],\'landing\');' } +])); + +map.addControl(new L.Control.Button([ { position:'topright', text: '⚙️', href: 'javascript:show_settings();' } ])); + + + + show = function(e,p) { + if (p == 'landing') { get_predict(last_data); } + if (e) { + map.closePopup(); + map.setView(map._layers[e._leaflet_id].getLatLng()); + map._layers[e._leaflet_id].openPopup(); + follow = p; + } + }; + + + getTwoBounds = function (a,b) { + var sW = new L.LatLng((a._southWest.lat > b._southWest.lat)?b._southWest.lat:a._southWest.lat, (a._southWest.lng > b._southWest.lng)?b._southWest.lng:a._southWest.lng); + var nE = new L.LatLng((a._northEast.lat < b._northEast.lat)?b._northEast.lat:a._northEast.lat, (a._northEast.lng < b._northEast.lng)?b._northEast.lng:a._northEast.lng); + + return new L.LatLngBounds(sW, nE); + }; + + show_line = function() { + $('.i_position, .i_landing').remove(); + map.closePopup(); + if (line[last_id]._latlngs.length != 0 && line_predict[last_id]._latlngs.length != 0) { + map.fitBounds(getTwoBounds(line[last_id].getBounds(),line_predict[last_id].getBounds())); + } else if (line[last_id]._latlngs.length != 0) { + map.fitBounds(line[last_id].getBounds()); + } else if (line_predict[last_id]._latlngs.length != 0) { + map.fitBounds(line_predict[last_id].getBounds()); + } + }; + + + + last_data = false; + last_id = false; + follow = 'marker'; + + marker_landing = []; + icon_landing = L.divIcon({className: 'leaflet-landing'}); + dots_predict = []; + line_predict = []; + marker_burst = []; + icon_burst = L.divIcon({className: 'leaflet-burst'}); + + marker = []; + dots = []; + line = []; + + draw = function(data) { + var stat; + if (data.id) { + last_id = data.id; + // data.res: 0: ok 1: no rx (timeout), 2: crc err, >2 some other error + if ((data.lat && data.lon && data.alt) && (lastframe != 0)) { + var location = [data.lat,data.lon,data.alt]; + if (!marker[data.id]) { + map.setView(location, 14); + marker[data.id] = L.marker(location).addTo(map) + .bindPopup(poptxt('position',data),{closeOnClick:false, autoPan:false}).openPopup(); + get_predict(data); + } else { + marker[data.id].slideTo(location, { + duration: 500, + keepAtCenter: (follow=='marker')?true:false + }) + .setPopupContent(poptxt('position',data)); + } + if (!dots[data.id]) { dots[data.id] = []; } + dots[data.id].push(location); + if (!line[data.id]) { + line[data.id] = L.polyline(dots[data.id]).addTo(map); + } else { + line[data.id].setLatLngs(dots[data.id]); + } + + } + if (data.res == 0) { + storage_write(data); + $('#status').html(greendot); + stat = 1; + } else { + $('#status').html(yellowdot); + stat = 0; + } + headtxt(data,stat); + last_data = data; + } else { + $('#status').html(yellowdot); + headtxt(data,0); + } + }; + + + marker_gps = false; + icon_gps = L.divIcon({className: 'leaflet-gps'}); + circ_gps = false; + + gps = function(e) { + gps_location = [e.lat,e.lon]; + gps_accuracy = e.hdop*2; + + if (last_data && last_data.lat != '0.000000') { + if ($('.leaflet-footer').css('display') == 'none') { $('.leaflet-footer').show(); } + + var distance = Math.round(map.distance(gps_location,[last_data.lat, last_data.lon])); + distance = (distance > 1000)?(distance / 1000) + 'k':distance; + $('.leaflet-footer .gps_dist').html(distance); + + $('.leaflet-footer .gps_dir').html( bearing(gps_location,[last_data.lat, last_data.lon]) ); + } + + if (!marker_gps) { + map.addControl(new L.Control.Button([{ position: 'topleft', text: '🛰️', href: 'javascript:show(marker_gps,\'gps\');' }])); + + marker_gps = L.marker(gps_location,{icon:icon_gps}).addTo(map) + .bindPopup(poptxt('gps',e),{closeOnClick:false, autoPan:false}); + circ_gps = L.circle(gps_location, gps_accuracy).addTo(map); + } else { + marker_gps.slideTo(gps_location, { + duration: 500, + keepAtCenter: (follow=='gps')?true:false + }) + .setPopupContent(poptxt('gps',e)); + circ_gps.slideTo(gps_location, { duration: 500 }); + circ_gps.setRadius(gps_accuracy); + } + }; + + get_data = function() { + $('#status').html(reddot); + $.ajax({url: 'live.json', success: (function( data ) { + if (typeof data != "object") { data = $.parseJSON(data); } + if (data.sonde) { + draw(data.sonde); + } else { + setTimeout(function() {$('#status').html(yellowdot);},100); + } + if (data.gps) { + gps(data.gps); + } + }), + timeout: 1000} + ); + }; + + storage = (typeof(Storage) !== "undefined")?true:false; + + settings_std = { + burst: 32500, + overwrite_descend: 6, + overwrite_descend_till: 12000 + }; + + settings_read = function() { + if (storage) { + if (sessionStorage.settings) { + return JSON.parse(sessionStorage.settings); + } else { + settings_write(settings_std); + return settings_std; + } + } else { + return settings_std; + } + return false; + }; + + settings_write = function (data) { + if (storage) { + sessionStorage.settings = JSON.stringify(data); + settings = data; + } + }; + + settings = settings_read(); + + settings_save = function() { + settings.burst = parseInt($('#settings #burst').val()); + settings.overwrite_descend = parseInt($('#settings #overwrite_descend').val()); + settings.overwrite_descend_till = parseInt($('#settings #overwrite_descend_till').val()); + if (Number.isInteger(settings.burst) && Number.isInteger(settings.overwrite_descend) && Number.isInteger(settings.overwrite_descend_till)) { + settings_write(settings); + $("#settings").slideUp(); + get_predict(last_data); + } else { + alert('Error: only numeric values allowed!'); + } + }; + + settings_reset = function() { + if (confirm('Reset to default?')) { + settings_write(settings_std); + show_settings(); + } + }; + + show_settings = function() { + $('#settings #burst').val(settings.burst); + $('#settings #overwrite_descend').val(settings.overwrite_descend); + $('#settings #overwrite_descend_till').val(settings.overwrite_descend_till); + $("#settings").slideToggle(); + }; + + predictor = false; + get_predict = function(data) { + if (!data) { return; } + var ascent = (data.climb > 0)? data.climb : 15; + var descent = (data.climb > 0)? settings.overwrite_descend : data.climb * -1; + + var burst; + if (data.climb > 0) { + burst = (data.alt > settings.burst )?data.alt + 100 : settings.burst; + } else { + burst = parseInt(data.alt) + 7; + if (data.alt > settings.overwrite_descend_till ) { descent = settings.overwrite_descend; } + } + + var m = new Date(); + var datetime = m.getUTCFullYear() + "-" + az(m.getUTCMonth()+1) + "-" + az(m.getUTCDate()) + "T" + + az(m.getUTCHours()) + ":" + az(m.getUTCMinutes()) + ":" + az(m.getUTCSeconds()) + "Z"; + var url = 'https://api.v2.sondehub.org/tawhiri'; + url += '?launch_latitude='+data.lat + '&launch_longitude='+tawhiri_lon(data.lon); + url += '&launch_altitude='+data.alt + '&launch_datetime='+datetime; + url += '&ascent_rate='+ascent + '&burst_altitude=' + burst + '&descent_rate='+descent; + + $.getJSON(url, function( prediction ) { + draw_predict(prediction,data); + }); + }; + + draw_predict = function(prediction,data) { + var ascending = prediction.prediction[0].trajectory; + var highest = ascending[ascending.length-1]; + var highest_location = [highest.latitude,sanitize_lon(highest.longitude)]; + + var descending = prediction.prediction[1].trajectory; + var landing = descending[descending.length-1]; + var landing_location = [landing.latitude,sanitize_lon(landing.longitude)]; + + if (!marker_landing[data.id]) { + marker_landing[data.id] = L.marker(landing_location,{icon: icon_landing}).addTo(map) + .bindPopup(poptxt('landing',landing),{closeOnClick:false, autoPan:false}); + } else { + marker_landing[data.id].slideTo(landing_location, { + duration: 500, + keepAtCenter: (follow=='landing')?true:false + }) + .setPopupContent(poptxt('landing',landing)); + } + + dots_predict[data.id]=[]; + + if (data.climb > 0) { + ascending.forEach(p => dots_predict[data.id].push([p.latitude,sanitize_lon(p.longitude)])); + + if (!marker_burst[data.id]) { + marker_burst[data.id] = L.marker(highest_location,{icon:icon_burst}).addTo(map).bindPopup(poptxt('burst',highest),{closeOnClick:false, autoPan:false}); + } else { + marker_burst[data.id].slideTo(highest_location, { + duration: 500, + keepAtCenter: (follow=='burst')?true:false + }).setPopupContent(poptxt('burst',highest)); + } + } + + descending.forEach(p => dots_predict[data.id].push([p.latitude,sanitize_lon(p.longitude)])); + + if (!line_predict[data.id]) { + line_predict[data.id] = L.polyline(dots_predict[data.id],{color: 'yellow'}).addTo(map); + } else { + line_predict[data.id].setLatLngs(dots_predict[data.id]); + } + + if (data.climb > 0) { + predictor_time = 5 * 60; // ascending, every 5 min + } else if (data.climb < 0 && data.alt > 5000) { + predictor_time = 2 * 60; // descending, above 5km, every 2 min + } else { + predictor_time = 30; // descending, below 5km, every 30 sec + } + clearTimeout(predictor); + predictor = setTimeout(function() {get_predict(last_data);}, predictor_time*1000); + }; + + sanitize_lon = function(lon) { + if (lon > 180) { return lon - 360; } + return lon; + } + tawhiri_lon = function(lon) { + if (lon < 0) { return lon + 360; } + return lon; + } + + poptxt = function(t,i) { + var lat_input = (i.id)?i.lat:i.latitude; + var lon_input = sanitize_lon((i.id)?i.lon:i.longitude); + + var lat = Math.round(lat_input * 1000000) / 1000000; + var lon = Math.round(lon_input * 1000000) / 1000000; + + var add = + '
Position: '+lat+', '+lon+'
'+ + 'Open: GMaps | OSM | GeoApp'; + + if (t == 'position') { return '

🎈 '+i.id+''+add+'

'; } + if (t == 'burst') { return '

💥 Predicted Burst:
'+fd(i.datetime)+' in '+mr(i.altitude)+'m'+add+'

'; } + if (t == 'highest') { return '

💥 Burst: '+mr(i.altitude)+'m'+add+'

';} + if (t == 'landing') { return '

🎯 Predicted Landing:
'+fd(i.datetime)+' at '+mr(i.altitude)+'m'+add+'

'; } + if (t == 'gps') { return '

Position: '+(i.lat)+','+(i.lon)+'
Altitude: '+i.alt+'m
Speed: '+mr(i.speed * 3.6 * 10)/10+'km/h '+i.dir+'°
Sat: '+i.sat+' Hdop:'+(i.hdop/10)+'

'; } + }; + + fd = function(date) { + var d = new Date(Date.parse(date)); + return az(d.getUTCHours()) +':'+ az(d.getUTCMinutes())+' UTC'; + }; + az = function(n) { return (n<10)?'0'+n:n; }; + mr = function(n) { return Math.round(n); }; + + storage = (typeof(Storage) !== "undefined")?true:false; + storage_write = function (data) { + if (storage) { + if (sessionStorage.sonde) { + storage_data = JSON.parse(sessionStorage.sonde); + } else { + storage_data = []; + } + if (JSON.stringify(data) != JSON.stringify(storage_data[storage_data.length - 1])) { + storage_data.push(data); + sessionStorage.sonde = JSON.stringify(storage_data); + } + } + }; + + storage_read = function() { + if (storage) { + if (sessionStorage.sonde) { + storage_data = JSON.parse(sessionStorage.sonde); + return storage_data; + } + } + return false; + }; + + storage_remove = function() { + sessionStorage.removeItem('sonde'); + }; + + session_storage = storage_read(); + if (session_storage) { + session_storage.forEach(function(d) { + dots.push([d.lat,d.lon,d.alt]); + session_storage_last = d; + }); + draw(session_storage_last); + } + + setInterval(get_data,1000); + +}); + +L.Control.Button = L.Control.extend({ + onAdd: function (map) { + var container = L.DomUtil.create('div', 'leaflet-bar leaflet-control'); + options = this.options; + Object.keys(options).forEach(function(key) { + this.link = L.DomUtil.create('a', '', container); + this.link.text = options[key].text; + this.link.href = options[key].href; + this.link.id = options[key].id; + }); + + this.options.position = this.options[0].position; + return container; + } +}); + + +// https://github.com/makinacorpus/Leaflet.GeometryUtil/blob/master/src/leaflet.geometryutil.js#L682 +// modified to fit +function bearing(latlng1, latlng2) { + var rad = Math.PI / 180, + lat1 = latlng1[0] * rad, + lat2 = latlng2[0] * rad, + lon1 = latlng1[1] * rad, + lon2 = latlng2[1] * rad, + y = Math.sin(lon2 - lon1) * Math.cos(lat2), + x = Math.cos(lat1) * Math.sin(lat2) - + Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1); + var bearing = ((Math.atan2(y, x) * 180 / Math.PI) + 360) % 360; + bearing = bearing < 0 ? bearing-360 : bearing; + return Math.round(bearing); +} diff --git a/RX_FSK/data/map.html b/RX_FSK/data/map.html new file mode 100644 index 0000000..6990bc1 --- /dev/null +++ b/RX_FSK/data/map.html @@ -0,0 +1,25 @@ + + + + + + + diff --git a/RX_FSK/data/networks.txt b/RX_FSK/data/networks.txt new file mode 100755 index 0000000..8d87bc8 --- /dev/null +++ b/RX_FSK/data/networks.txt @@ -0,0 +1,6 @@ +Radiosonde +Radiosonde +Terreandro +terrexavier +TERREWIFI +terrexavier diff --git a/RX_FSK/data/qrg.txt b/RX_FSK/data/qrg.txt new file mode 100644 index 0000000..8eb57fb --- /dev/null +++ b/RX_FSK/data/qrg.txt @@ -0,0 +1,26 @@ +# Frequency in Mhz (format nnn.nnn) +# Type (4=RS41, R=RS92, D=DFM (automated normal/inverted), M=M10/M20, 3=MP3H) +# (older versions: 6=DFM6, 9=DFM9, now both treated the same as D) +# (older versions: M=M10, 2=M20, now both treaded the same: automated M10/M20 decoding) +# +: active, -: not active +# +400.000 9 + Test(FR) +402.000 2 + Nimes(FR) +402.800 4 + Cuneo(IT) +403.000 6 - Ajactio(FR) +403.200 M - OHP(FR) +403.010 6 - Canjuers(FR) +404.200 4 - Rome(IT) +404.789 9 - Frejus1(FR) +404.800 4 - Milan(IT) +405.000 R - Frejus2(FR) +405.789 9 - Pegomas(FR) +403.700 4 - Cuneo2(IT) +400.000 D - +400.000 D - +400.000 D - +400.000 D - +400.000 D - +400.000 D - +400.000 D - +# end diff --git a/RX_FSK/data/rdz.js b/RX_FSK/data/rdz.js new file mode 100644 index 0000000..9f2a133 --- /dev/null +++ b/RX_FSK/data/rdz.js @@ -0,0 +1,54 @@ +let stypes=new Map(); +stypes.set('4', 'RS41'); +stypes.set('R', 'RS92'); +stypes.set('D', 'DFM'); +stypes.set('M', 'M10/M20'); +stypes.set('3', 'MP3H'); + +function footer() { + document.addEventListener("DOMContentLoaded", function(){ + var form = document.querySelector(".wrapper"); + form.addEventListener("input", function() { + document.querySelector(".save").disabled = false; + }); + document.querySelector(".save").disabled = true; + }); +} + +/* Used by qrg.html in RX_FSK.ino */ +function prep() { + var stlist=document.querySelectorAll("input.stype"); + for(txt of stlist){ + var val=txt.getAttribute('value'); var nam=txt.getAttribute('name'); + if(val=='2') { val='M'; } + var sel=document.createElement('select'); + sel.setAttribute('name',nam); + for(stype of stypes) { + var opt=document.createElement('option'); + opt.value=stype[0]; + opt.innerHTML=stype[1]; + if(stype[0]==val) { opt.setAttribute('selected','selected'); } + sel.appendChild(opt); + } + txt.replaceWith(sel); + } +} + +function qrgTable() { + var tab=document.getElementById("divTable"); + + var table = ""; + for(i=0; i" + (i+1) + ""; + table += ""; + table += ""; + table += ""; + } + table += "

Ch	Active	Frequency	Decoder	Launchsite

"; + tab.innerHTML = table; + prep(); + footer(); +} + diff --git a/RX_FSK/data/screens.txt b/RX_FSK/data/screens.txt new file mode 100644 index 0000000..5fd6d7e --- /dev/null +++ b/RX_FSK/data/screens.txt @@ -0,0 +1,460 @@ +# Definition of display content and action behaviour +# +# Timer: (view timer, rx timer, norx timer) +# - value -1: timer is disabled; value>=0: timer fires after (value) seconds +# - view timer: time since current view (display mode and sonde) was started +# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX) +# - norx timer: time since when no sonde data has been received continuously +# (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving +# anything for a 1s period) +# +# Actions: +# - W: activate WiFi scan +# - F: activate frequency spectrum display +# - 0: activate "Scan:" display (this is basically just display mode 0) +# - x: (1..N): activate display mode x [deprecated] +# - >: activate next display mode +# - D: activate default receiver display (display mode specified in config) +# - +: advance to next active sonde from QRG config +# - #: no action +# +# Display content (lower/upper case: small/large font) +# line,column=content +# for ILI9225 its also possible to indicate +# line,column,width=content for text within a box of width 'width' +# line,column,-width=content for right-justified text +# +# XText : Text +# F(suffix): frequency (with suffix, e.g., " MHz") +# L latitade +# O lOngitute +# A altitude +# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only) +# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Ix sonde ID (default/d: dxlaprs; s: short id, n: real serial number) +# RS41,RS92: all identical R1234567 +# DFMx: ID M12345678; short ID and serial 12345678 +# M10: ID ME95231F0; short ID: M95231F0; serial 9062104592 +# Q signal quality statistics bar +# T type string (RS41/DFM9/DFM6/RS92) +# C afC value +# N ip address (only tiny font) +# S scan list entry info: l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t +# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown +# format: K_4: h:mm k_6: h:mm:ss k_s: sssss, nothing shown for other sonde +# Mx telemetry value x (t temp p preassure h hyg) [not yet implemented, maybe some day in future] +# Gx GPS-related data +# raw data from GPS: GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground +# relative to sonde: GD, GI, GB: Distance, dIrection (absolute), relative Bearing +# G0 GPS circle diagram e.g. 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff +# "N" (what is on top: N=north C=course) +# "C" (where does the arrow point to: C=course, S=sonde) +# "S" (what is shown by the bullet: C=course, S=sonde) +# 50: circle radius, followed by fg and bg color +# 5: bullet radius, followed by fg color +# 4: arrow width, followed by fg color +# R RSSI +# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current +# U=USB volt I=USB current T=IC temp +# +# fonts=x,y can be used to select font (x=small, y=large) for all items below +# for SSD1306, x and y can be used to select one of those fonts: +# (y should be a 1x2 font (1,5,6,7), x a small font) +# u8x8_font_chroma48medium8_r, // 0 ** default small +# u8x8_font_7x14_1x2_f, // 1 ** default large +# u8x8_font_amstrad_cpc_extended_f, // 2 +# u8x8_font_5x7_f, // 3 +# u8x8_font_5x8_f, // 4 +# u8x8_font_8x13_1x2_f, // 5 +# u8x8_font_8x13B_1x2_f, // 6 +# u8x8_font_7x14B_1x2_f, // 7 +# u8x8_font_artossans8_r, // 8 +# u8x8_font_artosserif8_r, // 9 +# u8x8_font_torussansbold8_r, // 10 +# u8x8_font_victoriabold8_r, // 11 +# u8x8_font_victoriamedium8_r, // 12 +# u8x8_font_pressstart2p_f, // 13 +# u8x8_font_pcsenior_f, // 14 +# u8x8_font_pxplusibmcgathin_f, // 15 +# u8x8_font_pxplusibmcga_f, // 16 +# u8x8_font_pxplustandynewtv_f, // 17 +# +# for ILI9225, these fonts are available: +# Terminal6x8 // 0 +# Terminal11x16 // 1 +# Terminal12x16 // 2 +# FreeMono9pt7b, // 3 +# FreeMono12pt7b, // 4 +# FreeSans9pt7b, // 5 +# FreeSans12pt7b, // 6 +# Picopixel, // 7 +# +# color=rrggbb,rrggbb can be used to select color (foreground, background) +# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign) +# +# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels +# with scale=1,1 you can directly use pixel coordinates. (default: xscale=13,yscale=22 => 8 lines, 16 columns) +########### +# +# Default configuration for "Scanner" display: +# - view timer disabled; rx timer=0; norx timer = 0 +# => after 1 second immediately an action is triggered +# (norx: go to next sonde; rx: go to default receiver display) +# - key1 actions: D,0,F,W +# => Button press activates default receiver view, double press does nothing +# Mid press activates Spectrum display, long press activates Wifi scan +# - key2 has no function +@Scanner +timer=-1,0,0 +key1action=D,#,F,W +key2action=#,#,#,# +timeaction=#,D,+ +0,0=XScan +0,5=S#: +0,9=T +3,0=F MHz +5,0=S +7,5=n + +############ +# Default configuration for "Legacy" display: +# - view timer=-1, rx timer=-1 (disabled); norx timer=20 (or -1 for "old" behaviour) +# => norx timer fires after not receiving a singla for 20 seconds +# - key1 actions: +,0,F,W +# => Button1 press: next sonde; double press => @Scanner display +# => Mid press activates Spectrum display, long press activates Wifi scan +# - key2 actions: 2,#,#,# +# => BUtton2 activates display 2 (@Field) +# - timer actions: #,#,0 +# (norx timer: if no signal for >20 seconds: go back to scanner mode) +# +@Legacy +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +0,5=f MHz +1,8=c +0,0=t +1,0=is +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +6,0=R +6,7=Q + +############ +# Configuratoon for "Field" display (display 2) +# similar to @Legacy, but no norx timer, and Key2 goes to display 4 +@Field +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +# Configuration for "Field2" display (display 3) +# similar to @Field +@Field2 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +1,12=t +0,9=f +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############# +# Configuration for "GPS" display +# not yet the final version, just for testing +@GPSDIST +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=Is +0,9=f +1,12=t +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +5,9=gC +5,13=gB +6,7=Q +7,0=gV +7,2=xd= +7,4=gD +7,12=gI° + +############ +# Scan display for large 2" TFT dispaly +@ScannerTFT +timer=-1,0,0 +key1action=D,#,F,W +key2action=#,#,#,# +timeaction=#,D,+ +fonts=5,6 +0,0=XScan +0,8,-3=S#: +0,9,5=T +3,0=F MHz +5,0,16=S +7,5=n + +############ +@MainTFT +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +color=FFD700 +0,0=Is +color=0000FF +0,11,-5.5=f +1,1,6=c +1,12.5,-4=t +color=00ff00 +2,0=L +4,0=O +color=FFA500 +2,9.5,-7=A +3,9.5,-7=vm/s +color=AA5522 +4,9.5,-7=hkkm/h +color=FFFFFF +6,2=r +7,0=xd= +7,2,6=gD +7,12=gI + +############ +@PeilungTFT +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +color=ffff00,000033 +color=bbbbbb,000000 +0,2=xN Top: +0,8=xCourse Top: +color=ffff00,000033 +1,0=g0NCS,48,ffff00,000044,6,33ff33,5,eeaa00 +1,8=g0CCS,48,ffff00,000044,6,55ff55,5,eeaa00 +color=ffffff,000000 +6,0=xDirection: +6,8,4=gI +7,0=xCOG: +7,4,4=gC +7,8=xturn: +7,12,4=gB + + +############ +@GPSdataTFT +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=xOn-board GPS: +1,0,8=gA +2,0,8=gO +3,0,8=gH +4,0,8=gC +5,0=xGPS vs Sonde: +6,0,8=gD +7,0,8=gI +7,8,8=gB + +############ +@BatteryTFT +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=xBattery status: +0,14=bS +1,0=xBatt: +1,5,5=bVV +2,0,16=bCmA(charging) +3,0,16=bDmA(discharging) +4.4,0=xUSB: +4.4,5,5=bUV +5.4,0,10=bImA +6.4,0=xTemp: +6.4,5,5=bT C + +############ +@BatteryOLED +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xBat.Status: +0,12=bS +1,0=xBatt: +1,6=bVV +2,0=bCmA (charge) +3,0=bDmA (disch.) +4,0=xUSB: +4,5=bUV +5,5=bImA +6,0=xTemp: +6,5=bT C + +### Alternative display layouts based on https://gist.github.com/bazjo +# Scan display for large 2" TFT dispaly +@Scan.TFT.Bazjo +timer=-1,0,0 +key1action=D,#,F,W +key2action=#,#,#,# +timeaction=#,D,+ +scale=11,10 +fonts=0,2 +color=e0e0e0 +#Row 1 +0.5,0=XScanning... +#Row 2 +3,0=xIndex +4,0=S/ +3,9=xSite +4,9=S +#Row 3 +6,0=xType +7,0=T +6,9=xFrequency +7,9=F +#Row 4 +9,0=xWeb UI IP +10,0=N +#Row 5 +#Footer +color=6C757D +15,0=xScan Mode +15,18=bVV + +############ +@Decode/General.TFT.Bazjo +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +scale=11,10 +fonts=0,2 +#Row 1 +color=996A06 +0,0=xSerial +0,5=t +color=FFB10B +1,0=Is +color=996A06 +0,11=xFreq. +0,16=c +color=FFB10B +1,11=F +#Row 2 +color=3C5C99 +3,0=xLatitude +color=639AFF +4,0=L +color=3C5C99 +3,11=xLongitude +color=639AFF +4,11=O +#Row 3 +color=3C5C99 +6,0=xHoriz. Speed +color=639AFF +7,0=Hkkm/h +color=3C5C99 +6,11=xVert. Speed +color=639AFF +7,11=Vm/s +#Row 4 +color=99004A +9,0=xAltitude +color=FF007B +10,0=A +color=99004A +9,11=xBearing +color=FF007B +10,11=GB +#Row 5 +color=06998E +12,0=xRSSI +color=0AFFEF +13,0=R +color=06998E +12,11=xHistory +color=0AFFEF +13.5,11=Q4 +#Footer +color=6C757D +15,0=xDecode Mode / General View +15,18=bVV + + +############ +@Decode/Battery.TFT.Bazjo +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +scale=11,10 +fonts=0,2 +#Row 1 +color=99001F +0,0=xBattery Status +0,11=xBattery Voltage +color=FF0035 +1,0=BS +1,11=BVV +#Row 2 +color=99001F +3,0=xCharge Current +3,11=xDischarge Current +color=FF0035 +4,0=BCmA +4,11=BDmA +#Row 3 +color=99001F +6,0=xUSB Voltage +6,11=xUSB Current +color=FF0035 +7,0=BUV +7,11=BImA +#Row 4 +color=99001F +9,0=xIC Temperature +#9,11=xKey +color=FF0035 +10,0=BTC +#10,11=XValue +#Row 5 +#12,0=xKey +#12,11=xKey +#13,0=XValue +#13,11=XValue +#Footer +color=99001F +15,0=xDecode Mode/Battery View +15,18=bVV + diff --git a/RX_FSK/data/screens1.txt b/RX_FSK/data/screens1.txt new file mode 100644 index 0000000..289a5fe --- /dev/null +++ b/RX_FSK/data/screens1.txt @@ -0,0 +1,267 @@ +### screens1.txt: OLED display +# Definition of display content and action behaviour +# +# Timer: (view timer, rx timer, norx timer) +# - value -1: timer is disabled; value>=0: timer fires after (value) seconds +# - view timer: time since current view (display mode and sonde) was started +# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX) +# - norx timer: time since when no sonde data has been received continuously +# (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving +# anything for a 1s period) +# +# Actions: +# - W: activate WiFi scan +# - F: activate frequency spectrum display +# - 0: activate "Scan:" display (this is basically just display mode 0) +# - x: (1..N): activate display mode x [deprecated] +# - >: activate next display mode +# - D: activate default receiver display (display mode specified in config) +# - +: advance to next active sonde from QRG config +# - #: no action +# +# Display content (lower/upper case: small/large font) +# line,column=content +# for ILI9225 its also possible to indicate +# line,column,width=content for text within a box of width 'width' +# line,column,-width=content for right-justified text +# +# XText : Text +# F(suffix): frequency (with suffix, e.g., " MHz") +# L latitade +# O lOngitute +# A altitude +# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only) +# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Ix sonde ID (default/d: dxlaprs; s: short id, n: real serial number) +# RS41,RS92: all identical R1234567 +# DFMx: ID M12345678; short ID and serial 12345678 +# M10: ID ME95231F0; short ID: M95231F0; serial 9062104592 +# Q signal quality statistics bar +# T type string (RS41/DFM9/DFM6/RS92) +# C afC value +# N ip address (only tiny font) +# S scan list entry info: l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t +# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown +# format: K_4: h:mm k_6: h:mm:ss k_s: sssss, nothing shown for other sonde +# Mx telemetry value x (t temp p preassure h hyg b battery) +# Gx GPS-related data +# raw data from GPS: GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground +# relative to sonde: GD, GI, GB: Distance, dIrection (absolute), relative Bearing +# G0 GPS circle diagram e.g. 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff +# "N" (what is on top: N=north C=course) +# "C" (where does the arrow point to: C=course, S=sonde) +# "S" (what is shown by the bullet: C=course, S=sonde) +# 50: circle radius, followed by fg and bg color +# 5: bullet radius, followed by fg color +# 4: arrow width, followed by fg color +# R RSSI +# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current +# U=USB volt I=USB current T=IC temp +# +# fonts=x,y can be used to select font (x=small, y=large) for all items below +# for SSD1306, x and y can be used to select one of those fonts: +# (y should be a 1x2 font (1,5,6,7), x a small font) +# u8x8_font_chroma48medium8_r, // 0 ** default small +# u8x8_font_7x14_1x2_f, // 1 ** default large +# u8x8_font_amstrad_cpc_extended_f, // 2 +# u8x8_font_5x7_f, // 3 +# u8x8_font_5x8_f, // 4 +# u8x8_font_8x13_1x2_f, // 5 +# u8x8_font_8x13B_1x2_f, // 6 +# u8x8_font_7x14B_1x2_f, // 7 +# u8x8_font_artossans8_r, // 8 +# u8x8_font_artosserif8_r, // 9 +# u8x8_font_torussansbold8_r, // 10 +# u8x8_font_victoriabold8_r, // 11 +# u8x8_font_victoriamedium8_r, // 12 +# u8x8_font_pressstart2p_f, // 13 +# u8x8_font_pcsenior_f, // 14 +# u8x8_font_pxplusibmcgathin_f, // 15 +# u8x8_font_pxplusibmcga_f, // 16 +# u8x8_font_pxplustandynewtv_f, // 17 +# +# for ILI9225, these fonts are available: +# Terminal6x8 // 0 +# Terminal11x16 // 1 +# Terminal12x16 // 2 +# FreeMono9pt7b, // 3 +# FreeMono12pt7b, // 4 +# FreeSans9pt7b, // 5 +# FreeSans12pt7b, // 6 +# Picopixel, // 7 +# +# color=rrggbb,rrggbb can be used to select color (foreground, background) +# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign) +# +# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels +# with scale=1,1 you can directly use pixel coordinates. (default: xscale=13,yscale=22 => 8 lines, 16 columns) +########### +# +# Default configuration for "Scanner" display: +# - view timer disabled; rx timer=0; norx timer = 0 +# => after 1 second immediately an action is triggered +# (norx: go to next sonde; rx: go to default receiver display) +# - key1 actions: D,0,F,W +# => Button press activates default receiver view, double press does nothing +# Mid press activates Spectrum display, long press activates Wifi scan +# - key2 has no function +@Scanner +timer=-1,0,0 +key1action=D,#,F,W +key2action=D,#,#,# +timeaction=#,D,+ +0,0=XScan +0,5=S#: +0,9=T +3,0=F MHz +5,0,16=S +7,0=bVV +#7,0=gV +7,5=n + +############ +# Default configuration for "Legacy" display: +# - view timer=-1, rx timer=-1 (disabled); norx timer=20 (or -1 for "old" behaviour) +# => norx timer fires after not receiving a singla for 20 seconds +# - key1 actions: +,0,F,W +# => Button1 press: next sonde; double press => @Scanner display +# => Mid press activates Spectrum display, long press activates Wifi scan +# - key2 actions: 2,#,#,# +# => BUtton2 activates display 2 (@Field) +# - timer actions: #,#,0 +# (norx timer: if no signal for >20 seconds: go back to scanner mode) +# +@Legacy +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +0,5=f MHz +1,8=c +0,0=t +1,0=is +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +6,0=R +6,7=Q + +############ +# Configuratoon for "Field" display (display 2) +# similar to @Legacy, but no norx timer, and Key2 goes to display 4 +@Field +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +# Configuration for "Field2" display (display 3) +# similar to @Field +@Field2 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +1,12=t +0,9=f +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############# +# Configuration for "GPS" display +# not yet the final version, just for testing +@GPSDIST +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=Is +0,9=f +1,12=t +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +5,9=gC +5,13=gB +6,7=Q +7,0=gV +7,2=xd= +7,4=gD +7,12=gI° + +############ +@BatteryOLED +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xBat.Status: +0,12=bS +1,0=xBatt: +1,6=bVV +2,0=bCmA (charge) +3,0=bDmA (disch.) +4,0=xUSB: +4,5=bUV +5,5=bImA +6,0=xTemp: +6,5=bT C + +############# +@Meteo +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=Is +0,9=f +1,12=t +2,0=xSonde +3,0=xData +2,10=A +4,0=Mt°C +4,9=Mh%rH +6,0=MphPa +6,11=MbV + +############# +@GPS-Data +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xGPS-Data +1,0=xLAT : +1,6=gA +2,0=xLONG: +2,6=gO +3,0=xALT : +3,9=gH +4,0=xSonde +5,0=xAlt : +5,6=a +6,0=xDist: +6,6=gD + + diff --git a/RX_FSK/data/screens2.txt b/RX_FSK/data/screens2.txt new file mode 100644 index 0000000..351a6fd --- /dev/null +++ b/RX_FSK/data/screens2.txt @@ -0,0 +1,276 @@ +## screens2.txt: TFT display (landscape) +# Definition of display content and action behaviour +# +# Timer: (view timer, rx timer, norx timer) +# - value -1: timer is disabled; value>=0: timer fires after (value) seconds +# - view timer: time since current view (display mode and sonde) was started +# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX) +# - norx timer: time since when no sonde data has been received continuously +# (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving +# anything for a 1s period) +# +# Actions: +# - W: activate WiFi scan +# - F: activate frequency spectrum display +# - 0: activate "Scan:" display (this is basically just display mode 0) +# - x: (1..N): activate display mode x [deprecated] +# - >: activate next display mode +# - D: activate default receiver display (display mode specified in config) +# - +: advance to next active sonde from QRG config +# - #: no action +# +# Display content (lower/upper case: small/large font) +# line,column=content +# for ILI9225 its also possible to indicate +# line,column,width=content for text within a box of width 'width' +# line,column,-width=content for right-justified text +# +# XText : Text +# F(suffix): frequency (with suffix, e.g., " MHz") +# L latitade +# O lOngitute +# A altitude +# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only) +# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Ix sonde ID (default/d: dxlaprs; s: short id, n: real serial number) +# RS41,RS92: all identical R1234567 +# DFMx: ID M12345678; short ID and serial 12345678 +# M10: ID ME95231F0; short ID: M95231F0; serial 9062104592 +# Q signal quality statistics bar +# T type string (RS41/DFM9/DFM6/RS92) +# C afC value +# N ip address (only tiny font) +# S scan list entry info: l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t +# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown +# format: K_4: h:mm k_6: h:mm:ss k_s: sssss, nothing shown for other sonde +# Mx telemetry value x (t temp p preassure h hyg b batt) +# Gx GPS-related data +# raw data from GPS: GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground +# relative to sonde: GD, GI, GB: Distance, dIrection (absolute), relative Bearing +# G0 GPS circle diagram e.g. 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff +# "N" (what is on top: N=north C=course) +# "C" (where does the arrow point to: C=course, S=sonde) +# "S" (what is shown by the bullet: C=course, S=sonde) +# 50: circle radius, followed by fg and bg color +# 5: bullet radius, followed by fg color +# 4: arrow width, followed by fg color +# R RSSI +# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current +# U=USB volt I=USB current T=IC temp +# +# fonts=x,y can be used to select font (x=small, y=large) for all items below +# for SSD1306, x and y can be used to select one of those fonts: +# (y should be a 1x2 font (1,5,6,7), x a small font) +# u8x8_font_chroma48medium8_r, // 0 ** default small +# u8x8_font_7x14_1x2_f, // 1 ** default large +# u8x8_font_amstrad_cpc_extended_f, // 2 +# u8x8_font_5x7_f, // 3 +# u8x8_font_5x8_f, // 4 +# u8x8_font_8x13_1x2_f, // 5 +# u8x8_font_8x13B_1x2_f, // 6 +# u8x8_font_7x14B_1x2_f, // 7 +# u8x8_font_artossans8_r, // 8 +# u8x8_font_artosserif8_r, // 9 +# u8x8_font_torussansbold8_r, // 10 +# u8x8_font_victoriabold8_r, // 11 +# u8x8_font_victoriamedium8_r, // 12 +# u8x8_font_pressstart2p_f, // 13 +# u8x8_font_pcsenior_f, // 14 +# u8x8_font_pxplusibmcgathin_f, // 15 +# u8x8_font_pxplusibmcga_f, // 16 +# u8x8_font_pxplustandynewtv_f, // 17 +# +# for ILI9225, these fonts are available: +# Terminal6x8 // 0 +# Terminal11x16 // 1 +# Terminal12x16 // 2 +# FreeMono9pt7b, // 3 +# FreeMono12pt7b, // 4 +# FreeSans9pt7b, // 5 +# FreeSans12pt7b, // 6 +# Picopixel, // 7 +# +# color=rrggbb,rrggbb can be used to select color (foreground, background) +# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign) +# +# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels +# with scale=1,1 you can directly use pixel coordinates. (default: xscale=13,yscale=22 => 8 lines, 16 columns) +########### + +############ +# Scan display for large 2" TFT dispaly +@ScannerTFT +timer=-1,0,0 +key1action=D,#,F,W +key2action=D,#,#,# +timeaction=#,D,+ +0,0=XScan +0,5=S#: +0,9=T +3,0=F MHz +5,0,16=S +7,0=bVV +7,5=n + +############ +@Legacy +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +0,0=t +0,5=f MHz +1,0=is +#1,8=c +1,8=z +2,0=L +2,10=a +3,10=h +4,0=O +4,9=v +5,9=gC +5,13=gB +6,0=R +6,7=Q +7,6=gD +7,12=gI° + +############ +@Field +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@Field2 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +1,12=t +0,9=f +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@GPSDIST +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=Is +0,9=f +1,12=t +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +5,9=gC +5,13=gB +6,7=Q +7,0=gV +7,2=xd= +7,4=gD +7,12=gI° + +### Alternative display layouts based on https://gist.github.com/bazjo +# Scan display for large 2" TFT dispaly +@BatteryOLED +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xBat.Status: +0,12=bS +1,0=xBatt: +1,6=bVV +2,0=bCmA (charge) +3,0=bDmA (disch.) +4,0=xUSB: +4,5=bUV +5,5=bImA +6,0=xTemp: +6,5=bT C + +############ +@Meteo +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=Is +0,9=f +1,12=t +2,0=xSonde +3,0=xData +2,10=A +4,0=Mt°C +4,9=Mh%rH +6,0=MphPa +6,11=MbV + +################## +@GPS-Data +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xGPS-Data +1,0=xLAT : +1,6=gA +2,0=xLONG: +2,6=gO +3,0=xALT : +3,9=gH +4,0=xSonde +5,0=xAlt : +5,6=a +6,0=xDist: +6,6=gD + +################# +@TelemetryData +scale=22,13 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +fonts=5,6 +color=FFD700 +0,0,10.5=Is +color=0000FF +0,11,-5.5=f +1,0,4=t +1,10.5,-6=c +color=00ff00 +2,0,7=L +3,0,7=O +color=FFA500 +2,9.5,-7=a +2.8,9.5,-7=vm/s +color=AA5522 +3.6,9.5,-7=hkkm/h +color=FFFFFF +4.4,0=xTelemetry Data: +5.3,0=Mt C +5.3,9=Mh%rH +6.5,0=MphPa +6.5,11=MbV diff --git a/RX_FSK/data/screens3.txt b/RX_FSK/data/screens3.txt new file mode 100644 index 0000000..351a6fd --- /dev/null +++ b/RX_FSK/data/screens3.txt @@ -0,0 +1,276 @@ +## screens2.txt: TFT display (landscape) +# Definition of display content and action behaviour +# +# Timer: (view timer, rx timer, norx timer) +# - value -1: timer is disabled; value>=0: timer fires after (value) seconds +# - view timer: time since current view (display mode and sonde) was started +# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX) +# - norx timer: time since when no sonde data has been received continuously +# (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving +# anything for a 1s period) +# +# Actions: +# - W: activate WiFi scan +# - F: activate frequency spectrum display +# - 0: activate "Scan:" display (this is basically just display mode 0) +# - x: (1..N): activate display mode x [deprecated] +# - >: activate next display mode +# - D: activate default receiver display (display mode specified in config) +# - +: advance to next active sonde from QRG config +# - #: no action +# +# Display content (lower/upper case: small/large font) +# line,column=content +# for ILI9225 its also possible to indicate +# line,column,width=content for text within a box of width 'width' +# line,column,-width=content for right-justified text +# +# XText : Text +# F(suffix): frequency (with suffix, e.g., " MHz") +# L latitade +# O lOngitute +# A altitude +# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only) +# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Ix sonde ID (default/d: dxlaprs; s: short id, n: real serial number) +# RS41,RS92: all identical R1234567 +# DFMx: ID M12345678; short ID and serial 12345678 +# M10: ID ME95231F0; short ID: M95231F0; serial 9062104592 +# Q signal quality statistics bar +# T type string (RS41/DFM9/DFM6/RS92) +# C afC value +# N ip address (only tiny font) +# S scan list entry info: l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t +# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown +# format: K_4: h:mm k_6: h:mm:ss k_s: sssss, nothing shown for other sonde +# Mx telemetry value x (t temp p preassure h hyg b batt) +# Gx GPS-related data +# raw data from GPS: GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground +# relative to sonde: GD, GI, GB: Distance, dIrection (absolute), relative Bearing +# G0 GPS circle diagram e.g. 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff +# "N" (what is on top: N=north C=course) +# "C" (where does the arrow point to: C=course, S=sonde) +# "S" (what is shown by the bullet: C=course, S=sonde) +# 50: circle radius, followed by fg and bg color +# 5: bullet radius, followed by fg color +# 4: arrow width, followed by fg color +# R RSSI +# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current +# U=USB volt I=USB current T=IC temp +# +# fonts=x,y can be used to select font (x=small, y=large) for all items below +# for SSD1306, x and y can be used to select one of those fonts: +# (y should be a 1x2 font (1,5,6,7), x a small font) +# u8x8_font_chroma48medium8_r, // 0 ** default small +# u8x8_font_7x14_1x2_f, // 1 ** default large +# u8x8_font_amstrad_cpc_extended_f, // 2 +# u8x8_font_5x7_f, // 3 +# u8x8_font_5x8_f, // 4 +# u8x8_font_8x13_1x2_f, // 5 +# u8x8_font_8x13B_1x2_f, // 6 +# u8x8_font_7x14B_1x2_f, // 7 +# u8x8_font_artossans8_r, // 8 +# u8x8_font_artosserif8_r, // 9 +# u8x8_font_torussansbold8_r, // 10 +# u8x8_font_victoriabold8_r, // 11 +# u8x8_font_victoriamedium8_r, // 12 +# u8x8_font_pressstart2p_f, // 13 +# u8x8_font_pcsenior_f, // 14 +# u8x8_font_pxplusibmcgathin_f, // 15 +# u8x8_font_pxplusibmcga_f, // 16 +# u8x8_font_pxplustandynewtv_f, // 17 +# +# for ILI9225, these fonts are available: +# Terminal6x8 // 0 +# Terminal11x16 // 1 +# Terminal12x16 // 2 +# FreeMono9pt7b, // 3 +# FreeMono12pt7b, // 4 +# FreeSans9pt7b, // 5 +# FreeSans12pt7b, // 6 +# Picopixel, // 7 +# +# color=rrggbb,rrggbb can be used to select color (foreground, background) +# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign) +# +# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels +# with scale=1,1 you can directly use pixel coordinates. (default: xscale=13,yscale=22 => 8 lines, 16 columns) +########### + +############ +# Scan display for large 2" TFT dispaly +@ScannerTFT +timer=-1,0,0 +key1action=D,#,F,W +key2action=D,#,#,# +timeaction=#,D,+ +0,0=XScan +0,5=S#: +0,9=T +3,0=F MHz +5,0,16=S +7,0=bVV +7,5=n + +############ +@Legacy +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +0,0=t +0,5=f MHz +1,0=is +#1,8=c +1,8=z +2,0=L +2,10=a +3,10=h +4,0=O +4,9=v +5,9=gC +5,13=gB +6,0=R +6,7=Q +7,6=gD +7,12=gI° + +############ +@Field +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@Field2 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +1,12=t +0,9=f +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@GPSDIST +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=Is +0,9=f +1,12=t +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +5,9=gC +5,13=gB +6,7=Q +7,0=gV +7,2=xd= +7,4=gD +7,12=gI° + +### Alternative display layouts based on https://gist.github.com/bazjo +# Scan display for large 2" TFT dispaly +@BatteryOLED +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xBat.Status: +0,12=bS +1,0=xBatt: +1,6=bVV +2,0=bCmA (charge) +3,0=bDmA (disch.) +4,0=xUSB: +4,5=bUV +5,5=bImA +6,0=xTemp: +6,5=bT C + +############ +@Meteo +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=Is +0,9=f +1,12=t +2,0=xSonde +3,0=xData +2,10=A +4,0=Mt°C +4,9=Mh%rH +6,0=MphPa +6,11=MbV + +################## +@GPS-Data +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xGPS-Data +1,0=xLAT : +1,6=gA +2,0=xLONG: +2,6=gO +3,0=xALT : +3,9=gH +4,0=xSonde +5,0=xAlt : +5,6=a +6,0=xDist: +6,6=gD + +################# +@TelemetryData +scale=22,13 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +fonts=5,6 +color=FFD700 +0,0,10.5=Is +color=0000FF +0,11,-5.5=f +1,0,4=t +1,10.5,-6=c +color=00ff00 +2,0,7=L +3,0,7=O +color=FFA500 +2,9.5,-7=a +2.8,9.5,-7=vm/s +color=AA5522 +3.6,9.5,-7=hkkm/h +color=FFFFFF +4.4,0=xTelemetry Data: +5.3,0=Mt C +5.3,9=Mh%rH +6.5,0=MphPa +6.5,11=MbV diff --git a/RX_FSK/data/screens4.txt b/RX_FSK/data/screens4.txt new file mode 100644 index 0000000..351a6fd --- /dev/null +++ b/RX_FSK/data/screens4.txt @@ -0,0 +1,276 @@ +## screens2.txt: TFT display (landscape) +# Definition of display content and action behaviour +# +# Timer: (view timer, rx timer, norx timer) +# - value -1: timer is disabled; value>=0: timer fires after (value) seconds +# - view timer: time since current view (display mode and sonde) was started +# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX) +# - norx timer: time since when no sonde data has been received continuously +# (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving +# anything for a 1s period) +# +# Actions: +# - W: activate WiFi scan +# - F: activate frequency spectrum display +# - 0: activate "Scan:" display (this is basically just display mode 0) +# - x: (1..N): activate display mode x [deprecated] +# - >: activate next display mode +# - D: activate default receiver display (display mode specified in config) +# - +: advance to next active sonde from QRG config +# - #: no action +# +# Display content (lower/upper case: small/large font) +# line,column=content +# for ILI9225 its also possible to indicate +# line,column,width=content for text within a box of width 'width' +# line,column,-width=content for right-justified text +# +# XText : Text +# F(suffix): frequency (with suffix, e.g., " MHz") +# L latitade +# O lOngitute +# A altitude +# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only) +# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Ix sonde ID (default/d: dxlaprs; s: short id, n: real serial number) +# RS41,RS92: all identical R1234567 +# DFMx: ID M12345678; short ID and serial 12345678 +# M10: ID ME95231F0; short ID: M95231F0; serial 9062104592 +# Q signal quality statistics bar +# T type string (RS41/DFM9/DFM6/RS92) +# C afC value +# N ip address (only tiny font) +# S scan list entry info: l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t +# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown +# format: K_4: h:mm k_6: h:mm:ss k_s: sssss, nothing shown for other sonde +# Mx telemetry value x (t temp p preassure h hyg b batt) +# Gx GPS-related data +# raw data from GPS: GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground +# relative to sonde: GD, GI, GB: Distance, dIrection (absolute), relative Bearing +# G0 GPS circle diagram e.g. 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff +# "N" (what is on top: N=north C=course) +# "C" (where does the arrow point to: C=course, S=sonde) +# "S" (what is shown by the bullet: C=course, S=sonde) +# 50: circle radius, followed by fg and bg color +# 5: bullet radius, followed by fg color +# 4: arrow width, followed by fg color +# R RSSI +# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current +# U=USB volt I=USB current T=IC temp +# +# fonts=x,y can be used to select font (x=small, y=large) for all items below +# for SSD1306, x and y can be used to select one of those fonts: +# (y should be a 1x2 font (1,5,6,7), x a small font) +# u8x8_font_chroma48medium8_r, // 0 ** default small +# u8x8_font_7x14_1x2_f, // 1 ** default large +# u8x8_font_amstrad_cpc_extended_f, // 2 +# u8x8_font_5x7_f, // 3 +# u8x8_font_5x8_f, // 4 +# u8x8_font_8x13_1x2_f, // 5 +# u8x8_font_8x13B_1x2_f, // 6 +# u8x8_font_7x14B_1x2_f, // 7 +# u8x8_font_artossans8_r, // 8 +# u8x8_font_artosserif8_r, // 9 +# u8x8_font_torussansbold8_r, // 10 +# u8x8_font_victoriabold8_r, // 11 +# u8x8_font_victoriamedium8_r, // 12 +# u8x8_font_pressstart2p_f, // 13 +# u8x8_font_pcsenior_f, // 14 +# u8x8_font_pxplusibmcgathin_f, // 15 +# u8x8_font_pxplusibmcga_f, // 16 +# u8x8_font_pxplustandynewtv_f, // 17 +# +# for ILI9225, these fonts are available: +# Terminal6x8 // 0 +# Terminal11x16 // 1 +# Terminal12x16 // 2 +# FreeMono9pt7b, // 3 +# FreeMono12pt7b, // 4 +# FreeSans9pt7b, // 5 +# FreeSans12pt7b, // 6 +# Picopixel, // 7 +# +# color=rrggbb,rrggbb can be used to select color (foreground, background) +# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign) +# +# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels +# with scale=1,1 you can directly use pixel coordinates. (default: xscale=13,yscale=22 => 8 lines, 16 columns) +########### + +############ +# Scan display for large 2" TFT dispaly +@ScannerTFT +timer=-1,0,0 +key1action=D,#,F,W +key2action=D,#,#,# +timeaction=#,D,+ +0,0=XScan +0,5=S#: +0,9=T +3,0=F MHz +5,0,16=S +7,0=bVV +7,5=n + +############ +@Legacy +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +0,0=t +0,5=f MHz +1,0=is +#1,8=c +1,8=z +2,0=L +2,10=a +3,10=h +4,0=O +4,9=v +5,9=gC +5,13=gB +6,0=R +6,7=Q +7,6=gD +7,12=gI° + +############ +@Field +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@Field2 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +1,12=t +0,9=f +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@GPSDIST +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=Is +0,9=f +1,12=t +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +5,9=gC +5,13=gB +6,7=Q +7,0=gV +7,2=xd= +7,4=gD +7,12=gI° + +### Alternative display layouts based on https://gist.github.com/bazjo +# Scan display for large 2" TFT dispaly +@BatteryOLED +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xBat.Status: +0,12=bS +1,0=xBatt: +1,6=bVV +2,0=bCmA (charge) +3,0=bDmA (disch.) +4,0=xUSB: +4,5=bUV +5,5=bImA +6,0=xTemp: +6,5=bT C + +############ +@Meteo +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=Is +0,9=f +1,12=t +2,0=xSonde +3,0=xData +2,10=A +4,0=Mt°C +4,9=Mh%rH +6,0=MphPa +6,11=MbV + +################## +@GPS-Data +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xGPS-Data +1,0=xLAT : +1,6=gA +2,0=xLONG: +2,6=gO +3,0=xALT : +3,9=gH +4,0=xSonde +5,0=xAlt : +5,6=a +6,0=xDist: +6,6=gD + +################# +@TelemetryData +scale=22,13 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +fonts=5,6 +color=FFD700 +0,0,10.5=Is +color=0000FF +0,11,-5.5=f +1,0,4=t +1,10.5,-6=c +color=00ff00 +2,0,7=L +3,0,7=O +color=FFA500 +2,9.5,-7=a +2.8,9.5,-7=vm/s +color=AA5522 +3.6,9.5,-7=hkkm/h +color=FFFFFF +4.4,0=xTelemetry Data: +5.3,0=Mt C +5.3,9=Mh%rH +6.5,0=MphPa +6.5,11=MbV diff --git a/RX_FSK/data/screens5.txt b/RX_FSK/data/screens5.txt new file mode 100644 index 0000000..351a6fd --- /dev/null +++ b/RX_FSK/data/screens5.txt @@ -0,0 +1,276 @@ +## screens2.txt: TFT display (landscape) +# Definition of display content and action behaviour +# +# Timer: (view timer, rx timer, norx timer) +# - value -1: timer is disabled; value>=0: timer fires after (value) seconds +# - view timer: time since current view (display mode and sonde) was started +# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX) +# - norx timer: time since when no sonde data has been received continuously +# (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving +# anything for a 1s period) +# +# Actions: +# - W: activate WiFi scan +# - F: activate frequency spectrum display +# - 0: activate "Scan:" display (this is basically just display mode 0) +# - x: (1..N): activate display mode x [deprecated] +# - >: activate next display mode +# - D: activate default receiver display (display mode specified in config) +# - +: advance to next active sonde from QRG config +# - #: no action +# +# Display content (lower/upper case: small/large font) +# line,column=content +# for ILI9225 its also possible to indicate +# line,column,width=content for text within a box of width 'width' +# line,column,-width=content for right-justified text +# +# XText : Text +# F(suffix): frequency (with suffix, e.g., " MHz") +# L latitade +# O lOngitute +# A altitude +# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only) +# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only) +# Ix sonde ID (default/d: dxlaprs; s: short id, n: real serial number) +# RS41,RS92: all identical R1234567 +# DFMx: ID M12345678; short ID and serial 12345678 +# M10: ID ME95231F0; short ID: M95231F0; serial 9062104592 +# Q signal quality statistics bar +# T type string (RS41/DFM9/DFM6/RS92) +# C afC value +# N ip address (only tiny font) +# S scan list entry info: l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t +# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown +# format: K_4: h:mm k_6: h:mm:ss k_s: sssss, nothing shown for other sonde +# Mx telemetry value x (t temp p preassure h hyg b batt) +# Gx GPS-related data +# raw data from GPS: GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground +# relative to sonde: GD, GI, GB: Distance, dIrection (absolute), relative Bearing +# G0 GPS circle diagram e.g. 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff +# "N" (what is on top: N=north C=course) +# "C" (where does the arrow point to: C=course, S=sonde) +# "S" (what is shown by the bullet: C=course, S=sonde) +# 50: circle radius, followed by fg and bg color +# 5: bullet radius, followed by fg color +# 4: arrow width, followed by fg color +# R RSSI +# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current +# U=USB volt I=USB current T=IC temp +# +# fonts=x,y can be used to select font (x=small, y=large) for all items below +# for SSD1306, x and y can be used to select one of those fonts: +# (y should be a 1x2 font (1,5,6,7), x a small font) +# u8x8_font_chroma48medium8_r, // 0 ** default small +# u8x8_font_7x14_1x2_f, // 1 ** default large +# u8x8_font_amstrad_cpc_extended_f, // 2 +# u8x8_font_5x7_f, // 3 +# u8x8_font_5x8_f, // 4 +# u8x8_font_8x13_1x2_f, // 5 +# u8x8_font_8x13B_1x2_f, // 6 +# u8x8_font_7x14B_1x2_f, // 7 +# u8x8_font_artossans8_r, // 8 +# u8x8_font_artosserif8_r, // 9 +# u8x8_font_torussansbold8_r, // 10 +# u8x8_font_victoriabold8_r, // 11 +# u8x8_font_victoriamedium8_r, // 12 +# u8x8_font_pressstart2p_f, // 13 +# u8x8_font_pcsenior_f, // 14 +# u8x8_font_pxplusibmcgathin_f, // 15 +# u8x8_font_pxplusibmcga_f, // 16 +# u8x8_font_pxplustandynewtv_f, // 17 +# +# for ILI9225, these fonts are available: +# Terminal6x8 // 0 +# Terminal11x16 // 1 +# Terminal12x16 // 2 +# FreeMono9pt7b, // 3 +# FreeMono12pt7b, // 4 +# FreeSans9pt7b, // 5 +# FreeSans12pt7b, // 6 +# Picopixel, // 7 +# +# color=rrggbb,rrggbb can be used to select color (foreground, background) +# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign) +# +# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels +# with scale=1,1 you can directly use pixel coordinates. (default: xscale=13,yscale=22 => 8 lines, 16 columns) +########### + +############ +# Scan display for large 2" TFT dispaly +@ScannerTFT +timer=-1,0,0 +key1action=D,#,F,W +key2action=D,#,#,# +timeaction=#,D,+ +0,0=XScan +0,5=S#: +0,9=T +3,0=F MHz +5,0,16=S +7,0=bVV +7,5=n + +############ +@Legacy +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +0,0=t +0,5=f MHz +1,0=is +#1,8=c +1,8=z +2,0=L +2,10=a +3,10=h +4,0=O +4,9=v +5,9=gC +5,13=gB +6,0=R +6,7=Q +7,6=gD +7,12=gI° + +############ +@Field +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@Field2 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +2,0=L +4,0=O +1,12=t +0,9=f +3,10=h +4,9=v +0,0=Is +6,0=A +6,7=Q + +############ +@GPSDIST +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +0,0=Is +0,9=f +1,12=t +2,0=L +4,0=O +2,10=a +3,10=h +4,9=v +5,9=gC +5,13=gB +6,7=Q +7,0=gV +7,2=xd= +7,4=gD +7,12=gI° + +### Alternative display layouts based on https://gist.github.com/bazjo +# Scan display for large 2" TFT dispaly +@BatteryOLED +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xBat.Status: +0,12=bS +1,0=xBatt: +1,6=bVV +2,0=bCmA (charge) +3,0=bDmA (disch.) +4,0=xUSB: +4,5=bUV +5,5=bImA +6,0=xTemp: +6,5=bT C + +############ +@Meteo +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=Is +0,9=f +1,12=t +2,0=xSonde +3,0=xData +2,10=A +4,0=Mt°C +4,9=Mh%rH +6,0=MphPa +6,11=MbV + +################## +@GPS-Data +timer=-1,-1,-1 +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,# +fonts=0,1 +0,0=xGPS-Data +1,0=xLAT : +1,6=gA +2,0=xLONG: +2,6=gO +3,0=xALT : +3,9=gH +4,0=xSonde +5,0=xAlt : +5,6=a +6,0=xDist: +6,6=gD + +################# +@TelemetryData +scale=22,13 +timer=-1,-1,N +key1action=+,0,F,W +key2action=>,#,#,# +timeaction=#,#,0 +fonts=5,6 +color=FFD700 +0,0,10.5=Is +color=0000FF +0,11,-5.5=f +1,0,4=t +1,10.5,-6=c +color=00ff00 +2,0,7=L +3,0,7=O +color=FFA500 +2,9.5,-7=a +2.8,9.5,-7=vm/s +color=AA5522 +3.6,9.5,-7=hkkm/h +color=FFFFFF +4.4,0=xTelemetry Data: +5.3,0=Mt C +5.3,9=Mh%rH +6.5,0=MphPa +6.5,11=MbV diff --git a/RX_FSK/data/style.css b/RX_FSK/data/style.css new file mode 100755 index 0000000..d12fbe7 --- /dev/null +++ b/RX_FSK/data/style.css @@ -0,0 +1,659 @@ +body, html { + height: 100%; + margin: 0; + font-family: Arial; +} + +table, th, td { + border: 1px solid black; + border-collapse: collapse; + background-color: #ddd +} + +td#caption { + text-align: center; + background-color: #aaa; + font-weight: bold; +} + +td#sfreq { + background-color: #ccc; +} + +.tab { + overflow: hidden; + border: 1px solid #ccc; +} + +.tab button { + background-color: inherit; + float: left; + border: none; + outline: none; + cursor: pointer; + padding: 14px 16px; + transition: 0.3s; +} + +.tab button:hover { + background-color: #ddd; +} + +.tab button.active { + background-color: #ccc; +} + +.tabcontent { + display: none; + padding: 6px 12px; + border: 1px solid #ccc; + border-top: none; + height: 100%; + background-color: #FFFFFF; +} + +html { + font-family: Helvetica; + display: inline-block; + margin: 0px auto; + text-align: center; +} +h1{ + color: #0F3376; + padding: 2vh; +} +p{ + font-size: 1.5rem; +} +.button { + display: inline-block; + background-color: #008CBA; + border: none; + border-radius: 4px; + color: white; + padding: 16px 40px; + text-decoration: none; + font-size: 30px; + margin: 2px; + cursor: pointer; +} +.button2 { + background-color: #f44336; +} + +/*! + * Font Awesome 4.3.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:'FontAwesome'; +src:url('fontawesome-webfont.eot?v=4.3.0'); +src:url('fontawesome-webfont.eot?#iefix&v=4.3.0') format('embedded-opentype'),url('fontawesome-webfont.woff2?v=4.3.0') format('woff2'),url('fontawesome-webfont.woff?v=4.3.0') format('woff'),url('fontawesome-webfont.ttf?v=4.3.0') format('truetype'),url('fontawesome-webfont.svg?v=4.3.0#fontawesomeregular') format('svg'); +font-weight:normal; +font-style:normal}.fa{display:inline-block; +font:normal normal normal 14px/1 FontAwesome; +font-size:inherit; +text-rendering:auto; +-webkit-font-smoothing:antialiased; +-moz-osx-font-smoothing:grayscale; +transform:translate(0, 0)}.fa-lg{font-size:1.33333333em; +line-height:.75em; +vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571429em; +text-align:center}.fa-ul{padding-left:0; +margin-left:2.14285714em; +list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute; +left:-2.14285714em; +width:2.14285714em; +top:.14285714em; +text-align:center}.fa-li.fa-lg{left:-1.85714286em}.fa-border{padding:.2em .25em .15em; +border:solid .08em #eee; +border-radius:.1em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s infinite linear; +animation:fa-spin 2s infinite linear}.fa-pulse{-webkit-animation:fa-spin 1s infinite steps(8); +animation:fa-spin 1s infinite steps(8)}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg); +transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg); +transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg); +transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg); +transform:rotate(359deg)}}.fa-rotate-90{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=1); +-webkit-transform:rotate(90deg); +-ms-transform:rotate(90deg); +transform:rotate(90deg)}.fa-rotate-180{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2); +-webkit-transform:rotate(180deg); +-ms-transform:rotate(180deg); +transform:rotate(180deg)}.fa-rotate-270{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=3); +-webkit-transform:rotate(270deg); +-ms-transform:rotate(270deg); +transform:rotate(270deg)}.fa-flip-horizontal{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1); +-webkit-transform:scale(-1, 1); +-ms-transform:scale(-1, 1); +transform:scale(-1, 1)}.fa-flip-vertical{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1); +-webkit-transform:scale(1, -1); +-ms-transform:scale(1, -1); +transform:scale(1, -1)}:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270,:root .fa-flip-horizontal,:root .fa-flip-vertical{filter:none}.fa-stack{position:relative; +display:inline-block; +width:2em; +height:2em; +line-height:2em; +vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute; +left:0; +width:100%; +text-align:center} +.fa-stack-1x{line-height:inherit} +.fa-stack-2x{font-size:2em} +.fa-inverse{color:#fff} +.fa-glass:before{content:"\f000"} +.fa-music:before{content:"\f001"} +.fa-search:before{content:"\f002"} +.fa-envelope-o:before{content:"\f003"} +.fa-heart:before{content:"\f004"} +.fa-star:before{content:"\f005"} +.fa-star-o:before{content:"\f006"} +.fa-user:before{content:"\f007"} +.fa-film:before{content:"\f008"} +.fa-th-large:before{content:"\f009"} +.fa-th:before{content:"\f00a"} +.fa-th-list:before{content:"\f00b"} +.fa-check:before{content:"\f00c"} +.fa-remove:before,.fa-close:before,.fa-times:before{content:"\f00d"} +.fa-search-plus:before{content:"\f00e"} +.fa-search-minus:before{content:"\f010"} +.fa-power-off:before{content:"\f011"} +.fa-signal:before{content:"\f012"} +.fa-gear:before,.fa-cog:before{content:"\f013"} +.fa-trash-o:before{content:"\f014"} +.fa-home:before{content:"\f015"} +.fa-file-o:before{content:"\f016"} +.fa-clock-o:before{content:"\f017"} +.fa-road:before{content:"\f018"} +.fa-download:before{content:"\f019"} +.fa-arrow-circle-o-down:before{content:"\f01a"} +.fa-arrow-circle-o-up:before{content:"\f01b"} +.fa-inbox:before{content:"\f01c"} +.fa-play-circle-o:before{content:"\f01d"} +.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"} +.fa-refresh:before{content:"\f021"} +.fa-list-alt:before{content:"\f022"} +.fa-lock:before{content:"\f023"} +.fa-flag:before{content:"\f024"} +.fa-headphones:before{content:"\f025"} +.fa-volume-off:before{content:"\f026"} +.fa-volume-down:before{content:"\f027"} +.fa-volume-up:before{content:"\f028"} +.fa-qrcode:before{content:"\f029"} +.fa-barcode:before{content:"\f02a"} +.fa-tag:before{content:"\f02b"} +.fa-tags:before{content:"\f02c"} +.fa-book:before{content:"\f02d"} +.fa-bookmark:before{content:"\f02e"} +.fa-print:before{content:"\f02f"} +.fa-camera:before{content:"\f030"} +.fa-font:before{content:"\f031"} +.fa-bold:before{content:"\f032"} +.fa-italic:before{content:"\f033"} +.fa-text-height:before{content:"\f034"} +.fa-text-width:before{content:"\f035"} +.fa-align-left:before{content:"\f036"} +.fa-align-center:before{content:"\f037"} +.fa-align-right:before{content:"\f038"} +.fa-align-justify:before{content:"\f039"} +.fa-list:before{content:"\f03a"} +.fa-dedent:before,.fa-outdent:before{content:"\f03b"} +.fa-indent:before{content:"\f03c"} +.fa-video-camera:before{content:"\f03d"} +.fa-photo:before,.fa-image:before,.fa-picture-o:before{content:"\f03e"} +.fa-pencil:before{content:"\f040"} +.fa-map-marker:before{content:"\f041"} +.fa-adjust:before{content:"\f042"} +.fa-tint:before{content:"\f043"} +.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"} +.fa-share-square-o:before{content:"\f045"} +.fa-check-square-o:before{content:"\f046"} +.fa-arrows:before{content:"\f047"} +.fa-step-backward:before{content:"\f048"} +.fa-fast-backward:before{content:"\f049"} +.fa-backward:before{content:"\f04a"} +.fa-play:before{content:"\f04b"} +.fa-pause:before{content:"\f04c"} +.fa-stop:before{content:"\f04d"} +.fa-forward:before{content:"\f04e"} +.fa-fast-forward:before{content:"\f050"} +.fa-step-forward:before{content:"\f051"} +.fa-eject:before{content:"\f052"} +.fa-chevron-left:before{content:"\f053"} +.fa-chevron-right:before{content:"\f054"} +.fa-plus-circle:before{content:"\f055"} +.fa-minus-circle:before{content:"\f056"} +.fa-times-circle:before{content:"\f057"} +.fa-check-circle:before{content:"\f058"} +.fa-question-circle:before{content:"\f059"} +.fa-info-circle:before{content:"\f05a"} +.fa-crosshairs:before{content:"\f05b"} +.fa-times-circle-o:before{content:"\f05c"} +.fa-check-circle-o:before{content:"\f05d"} +.fa-ban:before{content:"\f05e"} +.fa-arrow-left:before{content:"\f060"} +.fa-arrow-right:before{content:"\f061"} +.fa-arrow-up:before{content:"\f062"} +.fa-arrow-down:before{content:"\f063"} +.fa-mail-forward:before,.fa-share:before{content:"\f064"} +.fa-expand:before{content:"\f065"} +.fa-compress:before{content:"\f066"} +.fa-plus:before{content:"\f067"} +.fa-minus:before{content:"\f068"} +.fa-asterisk:before{content:"\f069"} +.fa-exclamation-circle:before{content:"\f06a"} +.fa-gift:before{content:"\f06b"} +.fa-leaf:before{content:"\f06c"} +.fa-fire:before{content:"\f06d"} +.fa-eye:before{content:"\f06e"} +.fa-eye-slash:before{content:"\f070"} +.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"} +.fa-plane:before{content:"\f072"} +.fa-calendar:before{content:"\f073"} +.fa-random:before{content:"\f074"} +.fa-comment:before{content:"\f075"} +.fa-magnet:before{content:"\f076"} +.fa-chevron-up:before{content:"\f077"} +.fa-chevron-down:before{content:"\f078"} +.fa-retweet:before{content:"\f079"} +.fa-shopping-cart:before{content:"\f07a"} +.fa-folder:before{content:"\f07b"} +.fa-folder-open:before{content:"\f07c"} +.fa-arrows-v:before{content:"\f07d"} +.fa-arrows-h:before{content:"\f07e"} +.fa-bar-chart-o:before,.fa-bar-chart:before{content:"\f080"} +.fa-twitter-square:before{content:"\f081"} +.fa-facebook-square:before{content:"\f082"} +.fa-camera-retro:before{content:"\f083"} +.fa-key:before{content:"\f084"} +.fa-gears:before,.fa-cogs:before{content:"\f085"} +.fa-comments:before{content:"\f086"} +.fa-thumbs-o-up:before{content:"\f087"} +.fa-thumbs-o-down:before{content:"\f088"} +.fa-star-half:before{content:"\f089"} +.fa-heart-o:before{content:"\f08a"} +.fa-sign-out:before{content:"\f08b"} +.fa-linkedin-square:before{content:"\f08c"} +.fa-thumb-tack:before{content:"\f08d"} +.fa-external-link:before{content:"\f08e"} +.fa-sign-in:before{content:"\f090"} +.fa-trophy:before{content:"\f091"} +.fa-github-square:before{content:"\f092"} +.fa-upload:before{content:"\f093"} +.fa-lemon-o:before{content:"\f094"} +.fa-phone:before{content:"\f095"} +.fa-square-o:before{content:"\f096"} +.fa-bookmark-o:before{content:"\f097"} +.fa-phone-square:before{content:"\f098"} +.fa-twitter:before{content:"\f099"} +.fa-facebook-f:before,.fa-facebook:before{content:"\f09a"} +.fa-github:before{content:"\f09b"} +.fa-unlock:before{content:"\f09c"} +.fa-credit-card:before{content:"\f09d"} +.fa-rss:before{content:"\f09e"} +.fa-hdd-o:before{content:"\f0a0"} +.fa-bullhorn:before{content:"\f0a1"} +.fa-bell:before{content:"\f0f3"} +.fa-certificate:before{content:"\f0a3"} +.fa-hand-o-right:before{content:"\f0a4"} +.fa-hand-o-left:before{content:"\f0a5"} +.fa-hand-o-up:before{content:"\f0a6"} +.fa-hand-o-down:before{content:"\f0a7"} +.fa-arrow-circle-left:before{content:"\f0a8"} +.fa-arrow-circle-right:before{content:"\f0a9"} +.fa-arrow-circle-up:before{content:"\f0aa"} +.fa-arrow-circle-down:before{content:"\f0ab"} +.fa-globe:before{content:"\f0ac"} +.fa-wrench:before{content:"\f0ad"} +.fa-tasks:before{content:"\f0ae"} +.fa-filter:before{content:"\f0b0"} +.fa-briefcase:before{content:"\f0b1"} +.fa-arrows-alt:before{content:"\f0b2"} +.fa-group:before,.fa-users:before{content:"\f0c0"} +.fa-chain:before,.fa-link:before{content:"\f0c1"} +.fa-cloud:before{content:"\f0c2"} +.fa-flask:before{content:"\f0c3"} +.fa-cut:before,.fa-scissors:before{content:"\f0c4"} +.fa-copy:before,.fa-files-o:before{content:"\f0c5"} +.fa-paperclip:before{content:"\f0c6"} +.fa-save:before,.fa-floppy-o:before{content:"\f0c7"} +.fa-square:before{content:"\f0c8"} +.fa-navicon:before,.fa-reorder:before,.fa-bars:before{content:"\f0c9"} +.fa-list-ul:before{content:"\f0ca"} +.fa-list-ol:before{content:"\f0cb"} +.fa-strikethrough:before{content:"\f0cc"} +.fa-underline:before{content:"\f0cd"} +.fa-table:before{content:"\f0ce"} +.fa-magic:before{content:"\f0d0"} +.fa-truck:before{content:"\f0d1"} +.fa-pinterest:before{content:"\f0d2"} +.fa-pinterest-square:before{content:"\f0d3"} +.fa-google-plus-square:before{content:"\f0d4"} +.fa-google-plus:before{content:"\f0d5"} +.fa-money:before{content:"\f0d6"} +.fa-caret-down:before{content:"\f0d7"} +.fa-caret-up:before{content:"\f0d8"} +.fa-caret-left:before{content:"\f0d9"} +.fa-caret-right:before{content:"\f0da"} +.fa-columns:before{content:"\f0db"} +.fa-unsorted:before,.fa-sort:before{content:"\f0dc"} +.fa-sort-down:before,.fa-sort-desc:before{content:"\f0dd"} +.fa-sort-up:before,.fa-sort-asc:before{content:"\f0de"} +.fa-envelope:before{content:"\f0e0"} +.fa-linkedin:before{content:"\f0e1"} +.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"} +.fa-legal:before,.fa-gavel:before{content:"\f0e3"} +.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"} +.fa-comment-o:before{content:"\f0e5"} +.fa-comments-o:before{content:"\f0e6"} +.fa-flash:before,.fa-bolt:before{content:"\f0e7"} +.fa-sitemap:before{content:"\f0e8"} +.fa-umbrella:before{content:"\f0e9"} +.fa-paste:before,.fa-clipboard:before{content:"\f0ea"} +.fa-lightbulb-o:before{content:"\f0eb"} +.fa-exchange:before{content:"\f0ec"} +.fa-cloud-download:before{content:"\f0ed"} +.fa-cloud-upload:before{content:"\f0ee"} +.fa-user-md:before{content:"\f0f0"} +.fa-stethoscope:before{content:"\f0f1"} +.fa-suitcase:before{content:"\f0f2"} +.fa-bell-o:before{content:"\f0a2"} +.fa-coffee:before{content:"\f0f4"} +.fa-cutlery:before{content:"\f0f5"} +.fa-file-text-o:before{content:"\f0f6"} +.fa-building-o:before{content:"\f0f7"} +.fa-hospital-o:before{content:"\f0f8"} +.fa-ambulance:before{content:"\f0f9"} +.fa-medkit:before{content:"\f0fa"} +.fa-fighter-jet:before{content:"\f0fb"} +.fa-beer:before{content:"\f0fc"} +.fa-h-square:before{content:"\f0fd"} +.fa-plus-square:before{content:"\f0fe"} +.fa-angle-double-left:before{content:"\f100"} +.fa-angle-double-right:before{content:"\f101"} +.fa-angle-double-up:before{content:"\f102"} +.fa-angle-double-down:before{content:"\f103"} +.fa-angle-left:before{content:"\f104"} +.fa-angle-right:before{content:"\f105"} +.fa-angle-up:before{content:"\f106"} +.fa-angle-down:before{content:"\f107"} +.fa-desktop:before{content:"\f108"} +.fa-laptop:before{content:"\f109"} +.fa-tablet:before{content:"\f10a"} +.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"} +.fa-circle-o:before{content:"\f10c"} +.fa-quote-left:before{content:"\f10d"} +.fa-quote-right:before{content:"\f10e"} +.fa-spinner:before{content:"\f110"} +.fa-circle:before{content:"\f111"} +.fa-mail-reply:before,.fa-reply:before{content:"\f112"} +.fa-github-alt:before{content:"\f113"} +.fa-folder-o:before{content:"\f114"} +.fa-folder-open-o:before{content:"\f115"} +.fa-smile-o:before{content:"\f118"} +.fa-frown-o:before{content:"\f119"} +.fa-meh-o:before{content:"\f11a"} +.fa-gamepad:before{content:"\f11b"} +.fa-keyboard-o:before{content:"\f11c"} +.fa-flag-o:before{content:"\f11d"} +.fa-flag-checkered:before{content:"\f11e"} +.fa-terminal:before{content:"\f120"} +.fa-code:before{content:"\f121"} +.fa-mail-reply-all:before,.fa-reply-all:before{content:"\f122"} +.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"} +.fa-location-arrow:before{content:"\f124"} +.fa-crop:before{content:"\f125"} +.fa-code-fork:before{content:"\f126"} +.fa-unlink:before,.fa-chain-broken:before{content:"\f127"} +.fa-question:before{content:"\f128"} +.fa-info:before{content:"\f129"} +.fa-exclamation:before{content:"\f12a"} +.fa-superscript:before{content:"\f12b"} +.fa-subscript:before{content:"\f12c"} +.fa-eraser:before{content:"\f12d"} +.fa-puzzle-piece:before{content:"\f12e"} +.fa-microphone:before{content:"\f130"} +.fa-microphone-slash:before{content:"\f131"} +.fa-shield:before{content:"\f132"} +.fa-calendar-o:before{content:"\f133"} +.fa-fire-extinguisher:before{content:"\f134"} +.fa-rocket:before{content:"\f135"} +.fa-maxcdn:before{content:"\f136"} +.fa-chevron-circle-left:before{content:"\f137"} +.fa-chevron-circle-right:before{content:"\f138"} +.fa-chevron-circle-up:before{content:"\f139"} +.fa-chevron-circle-down:before{content:"\f13a"} +.fa-html5:before{content:"\f13b"} +.fa-css3:before{content:"\f13c"} +.fa-anchor:before{content:"\f13d"} +.fa-unlock-alt:before{content:"\f13e"} +.fa-bullseye:before{content:"\f140"} +.fa-ellipsis-h:before{content:"\f141"} +.fa-ellipsis-v:before{content:"\f142"} +.fa-rss-square:before{content:"\f143"} +.fa-play-circle:before{content:"\f144"} +.fa-ticket:before{content:"\f145"} +.fa-minus-square:before{content:"\f146"} +.fa-minus-square-o:before{content:"\f147"} +.fa-level-up:before{content:"\f148"} +.fa-level-down:before{content:"\f149"} +.fa-check-square:before{content:"\f14a"} +.fa-pencil-square:before{content:"\f14b"} +.fa-external-link-square:before{content:"\f14c"} +.fa-share-square:before{content:"\f14d"} +.fa-compass:before{content:"\f14e"} +.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"} +.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"} +.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"} +.fa-euro:before,.fa-eur:before{content:"\f153"} +.fa-gbp:before{content:"\f154"} +.fa-dollar:before,.fa-usd:before{content:"\f155"} +.fa-rupee:before,.fa-inr:before{content:"\f156"} +.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"} +.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"} +.fa-won:before,.fa-krw:before{content:"\f159"} +.fa-bitcoin:before,.fa-btc:before{content:"\f15a"} +.fa-file:before{content:"\f15b"} +.fa-file-text:before{content:"\f15c"} +.fa-sort-alpha-asc:before{content:"\f15d"} +.fa-sort-alpha-desc:before{content:"\f15e"} +.fa-sort-amount-asc:before{content:"\f160"} +.fa-sort-amount-desc:before{content:"\f161"} +.fa-sort-numeric-asc:before{content:"\f162"} +.fa-sort-numeric-desc:before{content:"\f163"} +.fa-thumbs-up:before{content:"\f164"} +.fa-thumbs-down:before{content:"\f165"} +.fa-youtube-square:before{content:"\f166"} +.fa-youtube:before{content:"\f167"} +.fa-xing:before{content:"\f168"} +.fa-xing-square:before{content:"\f169"} +.fa-youtube-play:before{content:"\f16a"} +.fa-dropbox:before{content:"\f16b"} +.fa-stack-overflow:before{content:"\f16c"} +.fa-instagram:before{content:"\f16d"} +.fa-flickr:before{content:"\f16e"} +.fa-adn:before{content:"\f170"} +.fa-bitbucket:before{content:"\f171"} +.fa-bitbucket-square:before{content:"\f172"} +.fa-tumblr:before{content:"\f173"} +.fa-tumblr-square:before{content:"\f174"} +.fa-long-arrow-down:before{content:"\f175"} +.fa-long-arrow-up:before{content:"\f176"} +.fa-long-arrow-left:before{content:"\f177"} +.fa-long-arrow-right:before{content:"\f178"} +.fa-apple:before{content:"\f179"} +.fa-windows:before{content:"\f17a"} +.fa-android:before{content:"\f17b"} +.fa-linux:before{content:"\f17c"} +.fa-dribbble:before{content:"\f17d"} +.fa-skype:before{content:"\f17e"} +.fa-foursquare:before{content:"\f180"} +.fa-trello:before{content:"\f181"} +.fa-female:before{content:"\f182"} +.fa-male:before{content:"\f183"} +.fa-gittip:before,.fa-gratipay:before{content:"\f184"} +.fa-sun-o:before{content:"\f185"} +.fa-moon-o:before{content:"\f186"} +.fa-archive:before{content:"\f187"} +.fa-bug:before{content:"\f188"} +.fa-vk:before{content:"\f189"} +.fa-weibo:before{content:"\f18a"} +.fa-renren:before{content:"\f18b"} +.fa-pagelines:before{content:"\f18c"} +.fa-stack-exchange:before{content:"\f18d"} +.fa-arrow-circle-o-right:before{content:"\f18e"} +.fa-arrow-circle-o-left:before{content:"\f190"} +.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"} +.fa-dot-circle-o:before{content:"\f192"} +.fa-wheelchair:before{content:"\f193"} +.fa-vimeo-square:before{content:"\f194"} +.fa-turkish-lira:before,.fa-try:before{content:"\f195"} +.fa-plus-square-o:before{content:"\f196"} +.fa-space-shuttle:before{content:"\f197"} +.fa-slack:before{content:"\f198"} +.fa-envelope-square:before{content:"\f199"} +.fa-wordpress:before{content:"\f19a"} +.fa-openid:before{content:"\f19b"} +.fa-institution:before,.fa-bank:before,.fa-university:before{content:"\f19c"} +.fa-mortar-board:before,.fa-graduation-cap:before{content:"\f19d"} +.fa-yahoo:before{content:"\f19e"} +.fa-google:before{content:"\f1a0"} +.fa-reddit:before{content:"\f1a1"} +.fa-reddit-square:before{content:"\f1a2"} +.fa-stumbleupon-circle:before{content:"\f1a3"} +.fa-stumbleupon:before{content:"\f1a4"} +.fa-delicious:before{content:"\f1a5"} +.fa-digg:before{content:"\f1a6"} +.fa-pied-piper:before{content:"\f1a7"} +.fa-pied-piper-alt:before{content:"\f1a8"} +.fa-drupal:before{content:"\f1a9"} +.fa-joomla:before{content:"\f1aa"} +.fa-language:before{content:"\f1ab"} +.fa-fax:before{content:"\f1ac"} +.fa-building:before{content:"\f1ad"} +.fa-child:before{content:"\f1ae"} +.fa-paw:before{content:"\f1b0"} +.fa-spoon:before{content:"\f1b1"} +.fa-cube:before{content:"\f1b2"} +.fa-cubes:before{content:"\f1b3"} +.fa-behance:before{content:"\f1b4"} +.fa-behance-square:before{content:"\f1b5"} +.fa-steam:before{content:"\f1b6"} +.fa-steam-square:before{content:"\f1b7"} +.fa-recycle:before{content:"\f1b8"} +.fa-automobile:before,.fa-car:before{content:"\f1b9"} +.fa-cab:before,.fa-taxi:before{content:"\f1ba"} +.fa-tree:before{content:"\f1bb"} +.fa-spotify:before{content:"\f1bc"} +.fa-deviantart:before{content:"\f1bd"} +.fa-soundcloud:before{content:"\f1be"} +.fa-database:before{content:"\f1c0"} +.fa-file-pdf-o:before{content:"\f1c1"} +.fa-file-word-o:before{content:"\f1c2"} +.fa-file-excel-o:before{content:"\f1c3"} +.fa-file-powerpoint-o:before{content:"\f1c4"} +.fa-file-photo-o:before,.fa-file-picture-o:before,.fa-file-image-o:before{content:"\f1c5"} +.fa-file-zip-o:before,.fa-file-archive-o:before{content:"\f1c6"} +.fa-file-sound-o:before,.fa-file-audio-o:before{content:"\f1c7"} +.fa-file-movie-o:before,.fa-file-video-o:before{content:"\f1c8"} +.fa-file-code-o:before{content:"\f1c9"} +.fa-vine:before{content:"\f1ca"} +.fa-codepen:before{content:"\f1cb"} +.fa-jsfiddle:before{content:"\f1cc"} +.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-saver:before,.fa-support:before,.fa-life-ring:before{content:"\f1cd"} +.fa-circle-o-notch:before{content:"\f1ce"} +.fa-ra:before,.fa-rebel:before{content:"\f1d0"} +.fa-ge:before,.fa-empire:before{content:"\f1d1"} +.fa-git-square:before{content:"\f1d2"} +.fa-git:before{content:"\f1d3"} +.fa-hacker-news:before{content:"\f1d4"} +.fa-tencent-weibo:before{content:"\f1d5"} +.fa-qq:before{content:"\f1d6"} +.fa-wechat:before,.fa-weixin:before{content:"\f1d7"} +.fa-send:before,.fa-paper-plane:before{content:"\f1d8"} +.fa-send-o:before,.fa-paper-plane-o:before{content:"\f1d9"} +.fa-history:before{content:"\f1da"} +.fa-genderless:before,.fa-circle-thin:before{content:"\f1db"} +.fa-header:before{content:"\f1dc"} +.fa-paragraph:before{content:"\f1dd"} +.fa-sliders:before{content:"\f1de"} +.fa-share-alt:before{content:"\f1e0"} +.fa-share-alt-square:before{content:"\f1e1"} +.fa-bomb:before{content:"\f1e2"} +.fa-soccer-ball-o:before,.fa-futbol-o:before{content:"\f1e3"} +.fa-tty:before{content:"\f1e4"} +.fa-binoculars:before{content:"\f1e5"} +.fa-plug:before{content:"\f1e6"} +.fa-slideshare:before{content:"\f1e7"} +.fa-twitch:before{content:"\f1e8"} +.fa-yelp:before{content:"\f1e9"} +.fa-newspaper-o:before{content:"\f1ea"} +.fa-wifi:before{content:"\f1eb"} +.fa-calculator:before{content:"\f1ec"} +.fa-paypal:before{content:"\f1ed"} +.fa-google-wallet:before{content:"\f1ee"} +.fa-cc-visa:before{content:"\f1f0"} +.fa-cc-mastercard:before{content:"\f1f1"} +.fa-cc-discover:before{content:"\f1f2"} +.fa-cc-amex:before{content:"\f1f3"} +.fa-cc-paypal:before{content:"\f1f4"} +.fa-cc-stripe:before{content:"\f1f5"} +.fa-bell-slash:before{content:"\f1f6"} +.fa-bell-slash-o:before{content:"\f1f7"} +.fa-trash:before{content:"\f1f8"} +.fa-copyright:before{content:"\f1f9"} +.fa-at:before{content:"\f1fa"} +.fa-eyedropper:before{content:"\f1fb"} +.fa-paint-brush:before{content:"\f1fc"} +.fa-birthday-cake:before{content:"\f1fd"} +.fa-area-chart:before{content:"\f1fe"} +.fa-pie-chart:before{content:"\f200"} +.fa-line-chart:before{content:"\f201"} +.fa-lastfm:before{content:"\f202"} +.fa-lastfm-square:before{content:"\f203"} +.fa-toggle-off:before{content:"\f204"} +.fa-toggle-on:before{content:"\f205"} +.fa-bicycle:before{content:"\f206"} +.fa-bus:before{content:"\f207"} +.fa-ioxhost:before{content:"\f208"} +.fa-angellist:before{content:"\f209"} +.fa-cc:before{content:"\f20a"} +.fa-shekel:before,.fa-sheqel:before,.fa-ils:before{content:"\f20b"} +.fa-meanpath:before{content:"\f20c"} +.fa-buysellads:before{content:"\f20d"} +.fa-connectdevelop:before{content:"\f20e"} +.fa-dashcube:before{content:"\f210"} +.fa-forumbee:before{content:"\f211"} +.fa-leanpub:before{content:"\f212"} +.fa-sellsy:before{content:"\f213"} +.fa-shirtsinbulk:before{content:"\f214"} +.fa-simplybuilt:before{content:"\f215"} +.fa-skyatlas:before{content:"\f216"} +.fa-cart-plus:before{content:"\f217"} +.fa-cart-arrow-down:before{content:"\f218"} +.fa-diamond:before{content:"\f219"} +.fa-ship:before{content:"\f21a"} +.fa-user-secret:before{content:"\f21b"} +.fa-motorcycle:before{content:"\f21c"} +.fa-street-view:before{content:"\f21d"} +.fa-heartbeat:before{content:"\f21e"} +.fa-venus:before{content:"\f221"} +.fa-mars:before{content:"\f222"} +.fa-mercury:before{content:"\f223"} +.fa-transgender:before{content:"\f224"} +.fa-transgender-alt:before{content:"\f225"} +.fa-venus-double:before{content:"\f226"} +.fa-mars-double:before{content:"\f227"} +.fa-venus-mars:before{content:"\f228"} +.fa-mars-stroke:before{content:"\f229"} +.fa-mars-stroke-v:before{content:"\f22a"} +.fa-mars-stroke-h:before{content:"\f22b"} +.fa-neuter:before{content:"\f22c"} +.fa-facebook-official:before{content:"\f230"} +.fa-pinterest-p:before{content:"\f231"} +.fa-whatsapp:before{content:"\f232"} +.fa-server:before{content:"\f233"} +.fa-user-plus:before{content:"\f234"} +.fa-user-times:before{content:"\f235"} +.fa-hotel:before,.fa-bed:before{content:"\f236"} +.fa-viacoin:before{content:"\f237"} +.fa-train:before{content:"\f238"} +.fa-subway:before{content:"\f239"} +.fa-medium:before{content:"\f23a"} diff --git a/RX_FSK/data/style_map.css b/RX_FSK/data/style_map.css new file mode 100755 index 0000000..c5d02b7 --- /dev/null +++ b/RX_FSK/data/style_map.css @@ -0,0 +1,392 @@ +body, html { + height: 100%; + margin: 0; + font-family: Arial; +} + +.active, .cfgheader:hover { + background-color: #ccc; +} +.cfgpanel { +} + +th.cfg { + padding:5pt +} +table.stat { + margin:0px 0px 5px 0px; +} + +.hamburger { + position: relative; + display: inline-block; + width: 1.25em; + height: 0.8em; + margin-right: 0.3em; + border-top: 0.2em solid #fff; + border-bottom: 0.2em solid #fff; +} + +.hamburger:before { + content: ""; + position: absolute; + top: 0.3em; + left: 0px; + width: 100%; + border-top: 0.2em solid #fff; +} + +.wrapper { + height: 100%; + display: flex; + flex-direction: column; + margin: 0; +} +.tci { + flex-grow: 1; border: none; margin: 0; padding: 0; +} +.footer { + background-color: #333; + display: flex; + justify-content: space-between; +} + +td.ch { + text-align: right; + padding: 0px 8px; +} +td.act { + text-align: center; +} +table, th, td { + border: 1px solid black; + border-collapse: collapse; + background-color: #ddd +} + +td#caption { + text-align: center; + background-color: #aaa; + font-weight: bold; +} + +td#sfreq { + background-color: #ccc; +} + +.content { + display: flex; + flex: 1; + flex-direction: column; + overflow: auto; + height: 100%; +} +.tabcontent { + display: none; + flex: 1; + border-top: none; + flex-direction: column; + overflow: auto; +} + +html { + font-family: Helvetica; + display: inline-block; + margin: 0px auto; + text-align: center; +} +h1{ + color: #0F3376; + font-size: 24px +} +p{ + font-size: 1.5rem; +} + +.button2 { + background-color: #f44336; +} +:disabled.save { + opacity: 0.5; +} +.save { + background-color: #CC1111; /* 0F33C6; */ + border: white; + border-width: 1; + color: white; + padding: 8px 30px; + text-align: center; + text-decoration: none; + display: block; + font-size: 14px; + margin: 0 +} + +.ttgoinfo { + color: white; + padding: 8px 10px; + display: block; + font-size: 14px; + margin: 0 +} +.ctlbtn { + background-color: #ccc; + border: black; + border-width: 1; + color: black; + padding: 4px 30px; + text-align: center; + text-decoration: none; + display: block; + margin: 2; + font-size: 4vh; +} +.update { + margin: 0; + display: block; +} + +#map { + height: 100%; +} + +.leaflet-popup-content table, .leaflet-popup-content table td { + border:0; + background-color: white; +} + +.leaflet-popup-content table td:nth-child(2),.leaflet-popup-content table td:nth-child(5) { + text-align: right; + padding-left: 3px; +} + +.leaflet-popup-content table td:nth-child(3),.leaflet-popup-content table td:nth-child(6) { + text-align: left; + padding-right: 10px; +} + +.leaflet-gps{animation:fading 1s infinite}@keyframes fading{0%{opacity:0.7}50%{opacity:1}100%{opacity:0.7}} + +.leaflet-gps::after { + content: '🔵'; +} +.leaflet-gps { + margin-left: -7px !important; + margin-top: -9px !important; +} + +.leaflet-burst::after { + content: '💥'; +} +.leaflet-burst { + margin-left: -20px !important; + margin-top: -22px !important; + font-weight: bold; + font-size: 30px; +} + +.leaflet-landing::after { + content: '×'; +} + +.leaflet-landing { + margin-left: -13px !important; + margin-top: -30px !important; + font-weight: bold; + font-size: 40px; +} + + +.leaflet-header { + text-align: center; + width: 250px; + box-shadow: 0 1px 5px rgba(0,0,0,0.65); + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + pointer-events: auto !important; +} + +.leaflet-header #settings { + display: none; +} + +.leaflet-header label { + display: block; + margin-top: 5px; +} +.leaflet-header input { + width: 80px; + margin: 0 auto; +} + +.leaflet-header #submit { + margin: 3px auto; +} + +.leaflet-footer { + display:none; + text-align: center; + width: 180px; + box-shadow: 0 1px 5px rgba(0,0,0,0.65); + border-top-left-radius: 4px; + border-top-right-radius: 4px; +} + +.leaflet-center { + left:0; + right:0; + margin: 0 auto; + padding: 5px; + background: #fff; + background: rgba(255, 255, 255, 0.8); +} + +.leaflet-header #sonde_detail { + display:none; +} + +@media screen and (max-width: 600px) { + .leaflet-control-attribution { + -moz-transform: rotate(-90deg) translateX(100%); + -ms-transform: rotate(-90deg) translateX(100%); + -o-transform: rotate(-90deg) translateX(100%);; + -webkit-transform: rotate(-90deg) translateX(100%); + transform: rotate(-90deg) translateX(100%); + -webkit-transform-origin: 100% 100%; + -moz-transform-origin: 100% 100%; + -ms-transform-origin: 100% 100%; + -o-transform-origin: 100% 100%; + transform-origin: 100% 100%; + } +} + +.ldot { + height: 15px; + width: 15px; + margin-top: 8px; + margin-left: -1px; + border-radius: 50%; + display: inline-block; +} + +.ybg { + background-color: orange; + background-image: -webkit-gradient(linear, left top, left bottom, from(yellow), to(orange)); + background-image: linear-gradient(top, yellow, orange); +} +.gbg { + background-color: green; + background-image: -webkit-gradient(linear, left top, left bottom, from(lime), to(green)); + background-image: linear-gradient(top, lime, green); +} +.rbg { + background-color: red; + background-image: -webkit-gradient(linear, left top, left bottom, from(orange), to(red)); + background-image: linear-gradient(top, orange, red); +} + +#sonde_statbar .ldot { + margin-right: 3px; +} + +/* Add a black background color to the top navigation */ +.topnav { + background-color: #333; + overflow: hidden; +} + +/* Style the links inside the navigation bar */ +.topnav a { + float: left; + display: block; + color: #f2f2f2; + text-align: center; + padding: 14px 16px; + text-decoration: none; + font-size: 17px; +} + +/* Change the color of links on hover */ +.topnav a:hover { + background-color: #ddd; + color: black; +} + +/* Add an active class to highlight the current page */ +.topnav a.active { + background-color: #04AA6D; + color: white; +} + +/* Hide the link that should open and close the topnav on small screens */ +.topnav .icon { + display: none; + padding-bottom: 12px; + padding-top: 11px; +} + +/* When the screen is less than 600 pixels wide, hide all links, except for the first one ("Home"). Show the link that contains should open and close the topnav (.icon) */ +@media screen and (max-width: 600px) { + .topnav a:not(.active) {display: none;} + .topnav a.icon { + float: right; + display: block; + } +} + +/* The "responsive" class is added to the topnav with JavaScript when the user clicks on the icon. This class makes the topnav look good on small screens (display the links vertically instead of horizontally) */ +@media screen and (max-width: 600px) { + .topnav.responsive {position: relative;} + .topnav.responsive a.icon { + position: absolute; + right: 0; + top: 0; + } + .topnav.responsive a { + float: none; + display: block; + text-align: left; + } +} +@media (prefers-color-scheme: dark) { + body { + background-color: #333; + } + h2{ + color: white; + } + table, th, td, .save, a.active { + color: white; + border: 1px solid grey; + border-collapse: collapse; + background-color: #333; + } + input, select, .tci, .warning { + color: white; + background-color: #333; + } + a:link, a:visited { + color: #D3D3D3; + } + .topnav, td#sfreq { + background-color: grey; + } + .topnav a:visited { + color: white; + } + .ctlbtn { + color: white; + background-color: grey; + } + .leaflet-center { + color: white; + background-color: grey; + } + .leaflet-bar a { + background-color: grey !important; + } + .leaflet-popup-content-wrapper, .leaflet-popup-tip { + color: white !important; + background: grey !important; + } +} diff --git a/RX_FSK/features.h b/RX_FSK/features.h new file mode 100644 index 0000000..eafc6d8 --- /dev/null +++ b/RX_FSK/features.h @@ -0,0 +1,24 @@ + +// Configuration flags for including/excluding fuctionality from the compiled binary +// set flag to 0 for exclude/1 for include + +/* data feed to sondehubv2 */ +/* needs about 4k4 code, 200b data, 200b stack, 200b heap */ +#define FEATURE_SONDEHUB 1 +#define FEATURE_CHASEMAPPER 1 +#define FEATURE_MQTT 0 + +#define FEATURE_RS92 1 + +/* Most recent version support fonts in a dedicated flash parition "fonts". + * This is incomabtible (in terms of code and flash layout) to previous versions. + * If LEGACY_FONTS_IN_CODEBIN is sets, fonts are also included in the bin image. + * This maintains compatibility for OTA with previous versions (in which case the + * bin image fonts will be used as before). + * The code automatically uses fonts in flash partition if that exists, otherwise + * fonts in code. + * The flash partition fonts support latin15 codeset (instead of 7bit ascii). + * Also, it is easier to use different fonts :) just flash the font partition w/ something else... + * This option will likely be removed post-master1.0 + */ +#define LEGACY_FONTS_IN_CODEBIN 1 diff --git a/RX_FSK/src/Chasemapper.cpp b/RX_FSK/src/Chasemapper.cpp new file mode 100644 index 0000000..166abaf --- /dev/null +++ b/RX_FSK/src/Chasemapper.cpp @@ -0,0 +1,43 @@ +#include "Chasemapper.h" + +extern const char *sondeTypeStrSH[]; + +int Chasemapper::send(WiFiUDP &udp, SondeInfo *si) { + char buf[1024]; + struct tm tim; + time_t t = si->d.time; + gmtime_r(&t, &tim); + uint8_t realtype = si->type; + if (TYPE_IS_METEO(realtype)) { + realtype = si->d.subtype == 1 ? STYPE_M10 : STYPE_M20; + } + sprintf(buf, "{ \"type\": \"PAYLOAD_SUMMARY\"," + "\"callsign\": \"%s\"," + "\"latitude\": %.5f," + "\"longitude\": %.5f," + "\"altitude\": %d," + "\"speed\": %d," + "\"heading\": %d," + "\"time\": \"%02d:%02d:%02d\"," + "\"model\": \"%s\"," + "\"freq\": \"%.3f MHz\"", + si->d.ser, + si->d.lat, + si->d.lon, + (int)si->d.alt, + (int)(si->d.hs * 1.9438445), // m/s into knots + (int)si->d.dir, + tim.tm_hour, tim.tm_min, tim.tm_sec, + sondeTypeStrSH[realtype], + si->freq); + if( !isnan(si->d.temperature) ) { + sprintf(buf + strlen(buf), ", \"temp\": %.1f", si->d.temperature); + } + strcat(buf, "}"); + Serial.printf("Sending chasemapper json: %s\n", buf); + udp.beginPacket(sonde.config.cm.host, sonde.config.cm.port); + udp.write((const uint8_t *)buf, strlen(buf)); + udp.endPacket(); + return 0; +} + diff --git a/RX_FSK/src/Chasemapper.h b/RX_FSK/src/Chasemapper.h new file mode 100644 index 0000000..4f537b9 --- /dev/null +++ b/RX_FSK/src/Chasemapper.h @@ -0,0 +1,13 @@ +#ifndef _CHASEMAPPER_H +#define _CHASEMAPPER_H + +#include "Sonde.h" +//#include +#include +#include +class Chasemapper { +public: + static int send(WiFiUDP &udb, SondeInfo *si); +}; + +#endif diff --git a/RX_FSK/src/DFM.cpp b/RX_FSK/src/DFM.cpp new file mode 100644 index 0000000..e93ab05 --- /dev/null +++ b/RX_FSK/src/DFM.cpp @@ -0,0 +1,693 @@ + +/* DFM decoder functions */ +#include "DFM.h" +#include "SX1278FSK.h" +#include "Sonde.h" + +#define DFM_DEBUG 0 + +#if DFM_DEBUG +#define DFM_DBG(x) x +#else +#define DFM_DBG(x) +#endif + +#define DFM_FRAMELEN 33 + +#define MAXIDAGE 1800 + +/* + * observed DAT patterns for DFM-9: + * A: 0+1; 2+3; 4+5; 6+7; 8+0 => keep frame in shadowFrame + * B: 1+2; 3+4; 5+6; 7+8 => all good => keep date in shadowDate + * C: 0+1; 2+3; 4+5; 6+7; 8+15 => all good => keep date in shadowDate + * D: 0+1; 2+3; 4+5; 6+7; 0+1 => use shadowDate + * not seen:5+6; 7+1 + * values: + * 0:packet counter; 1:utc-msec; 2:lat,vh; 3:lon,dir, 4:alt,vv, 8=utc-date(day-hh-mm) + */ + +// single data structure, search restarts after decoder change +static struct st_dfmstat { + int idcnt0; + int idcnt1; + int lastfrid; + int lastfrcnt; + uint8_t start[50]; + uint16_t dat[50*2]; + uint8_t cnt[50*2]; + uint16_t good; + uint32_t datesec; + uint8_t frame; + uint16_t msec; + uint8_t nameregok; + uint8_t nameregtop; + uint8_t lastdat; + uint8_t cycledone; // 0=no; 1=OK, 2=partially/with errors + float meas[5+2]; +} dfmstate; + +decoderSetupCfg DFMSetupCfg { + .bitrate = 2500, + // continuous mode + // Enable auto-AFC, auto-AGC, RX Trigger by preamble ???? + .rx_cfg = 0x1E, + .sync_cfg = 0x70, + .sync_len = 2, + .sync_data = (const uint8_t *)"\xAA\xAA", + .preamble_cfg = 0xA8, +}; + +int DFM::setup(float frequency, int type) +{ + stype = type; +#if DFM_DEBUG + Serial.printf("Setup sx1278 for DFM sonde (type=%d)\n", stype); +#endif + if(sx1278.ON()!=0) { + DFM_DBG(Serial.println("Setting SX1278 power on FAILED")); + return 1; + } + + if(DecoderBase::setup(DFMSetupCfg, sonde.config.dfm.agcbw, sonde.config.dfm.rxbw) != 0) { + return 1; + } +#if 0 + // This is now all done by the generic setup method in base class + if(sx1278.setFSK()!=0) { + DFM_DBG(Serial.println("Setting FSM mode FAILED")); + return 1; + } + if(sx1278.setBitrate(2500)!=0) { + DFM_DBG(Serial.println("Setting bitrate 2500bit/s FAILED")); + return 1; + } + if(sx1278.setAFCBandwidth(sonde.config.dfm.agcbw)!=0) { + DFM_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.dfm.agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.dfm.rxbw)!=0) { + DFM_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.dfm.rxbw)); + return 1; + } + { + if(sx1278.setRxConf(0x1E)!=0) { + DFM_DBG(Serial.println("Setting RX Config FAILED")); + return 1; + } + // working with continuous RX + const char *SYNC="\xAA\xAA"; + if(sx1278.setSyncConf(0x70, 2, (const uint8_t *)SYNC)!=0) { + DFM_DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + if(sx1278.setPreambleDetect(0xA8)!=0) { + //if(sx1278.setPreambleDetect(0x9F)!=0) { + DFM_DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } + } +#endif + if(sx1278.setPacketConfig(0x08, 0x40)!=0) { + DFM_DBG(Serial.println("Setting Packet config FAILED")); + return 1; + } + sx1278.setPayloadLength(0); // infinite for now... + Serial.print("DFM: setting RX frequency to "); + Serial.println(frequency); + + int retval = sx1278.setFrequency(frequency); + sx1278.clearIRQFlags(); + + // Do this only once in setup in continous mode + sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE); + + memset((void *)&dfmstate, 0, sizeof(dfmstate)); + DFM_DBG(Serial.println("Setting SX1278 config for DFM finished\n"); Serial.println()); + return retval; +} + + +#define bitpick(value,bitpos) (((value)>>(7-(bitpos)))&0x01) +// Input: str: packed data, MSB first +void DFM::deinterleave(uint8_t *str, int L, uint8_t *block) { + int i, j; + for (j = 0; j < B; j++) { // L = 7 (CFG), 13 (DAT1, DAT2) + for (i = 0; i < L; i++) { + block[B*i+j] = bitpick( str[(L*j+i)/8], (L*j+i)&7 )?0:1; + } + } +} + +uint32_t DFM::bits2val(const uint8_t *bits, int len) { + uint32_t val = 0; + for (int j = 0; j < len; j++) { + val |= (bits[j] << (len-1-j)); + } + return val; +} + +// Error correction for hamming code +// returns 0: ok >0: 1 error was corrected -1: uncorrectable error +int DFM::check(uint8_t code[8]) { + int i, j; + uint32_t synval = 0; + uint8_t syndrom[4]; + int ret=0; + + for (i = 0; i < 4; i++) { + syndrom[i] = 0; + for (j = 0; j < 8; j++) { + syndrom[i] ^= H[i][j] & code[j]; + } + } + synval = bits2val(syndrom, 4); + if (synval) { + ret = -1; + for (j = 0; j < 8; j++) { // 1-bit-error + if (synval == He[j]) { // reicht auf databits zu pruefen, d.h. + ret = j+1; // (systematischer Code) He[0..3] + break; + } + } + } + else ret = 0; + if (ret > 0) code[ret-1] ^= 0x1; + + return ret; +} + +// Extended (8,4) Hamming code +// Return number of corrected bits, -1 if uncorrectable error +int DFM::hamming(uint8_t *ham, int L, uint8_t *sym) { + int i, j; + int ret = 0; // DFM: length L = 7 or 13 + for (i = 0; i < L; i++) { // L bytes (4bit data, 4bit parity) + if (use_ecc) { + int res = check(ham+8*i); + if( res<0 ) ret = -1; + else if ( ret >= 0 && res > 0 ) ret++; + } + // systematic Hamming code: copy bits 0..3 + for (j = 0; j < 4; j++) { + sym[4*i+j] = ham[8*i+j]; + } + } + return ret; +} + +DFM::DFM() { +} + +void DFM::printRaw(const char *label, int len, int ret, const uint8_t *data) +{ + Serial.print(label); Serial.print("("); + Serial.print(ret); + Serial.print("):"); + int i; + for(i=0; i DFM6 + "PS15", // 07 => PS15 (untested) + "", "", + "DFM9", // 0A => DFM9 + "DF17", // 0B => DFM17? + "DF9P", // 0C => DFM9P or DFM17 test + "DF17", // 0D => DFM17 + "", "" +}; + +void DFM::killid() { + SondeData *sd = &(sonde.si()->d); + sd->validID = false; + *(sd->id) = 0; + *(sd->ser) = 0; + memset((void *)&dfmstate, 0, sizeof(dfmstate)); +} + +#define DFMIDTHRESHOLD 2 +/* inspired by oe5dxl's finddnmae in sondeudp.c of dxlaprs */ +void DFM::finddfname(uint8_t *b) +{ + uint8_t st; + uint32_t thres; + uint32_t i; + uint8_t ix; + uint16_t d; + SondeData *sd = &(sonde.si()->d); + + st = b[0]; /* frame start byte */ + ix = b[3]; /* hi/lo part of ser; (LSB due to our bitsToBytes...) */ + d = (b[1]<<8) + b[2]; /* data byte */ + /* find highest channel number single frame serial, + (2 frame serial will make a single serial too) */ + if(dfmstate.idcnt0 < DFMIDTHRESHOLD && dfmstate.idcnt1 < DFMIDTHRESHOLD) { + uint32_t v = (st<<20) | (d<<4) | ix; + if ( st > (dfmstate.lastfrid>>20) ) { + dfmstate.lastfrid = v; + Serial.print(" MAXCH:"); Serial.print(st); + dfmstate.lastfrcnt = 0; + } else if ( st == (dfmstate.lastfrid>>20) ) { + /* same id found */ + if (v == dfmstate.lastfrid) { + ++dfmstate.lastfrcnt; + thres = DFMIDTHRESHOLD * 2; + /* may be a 2 frame serial so increase safety level */ + if (ix <= 1) thres *= 2; + /* may be not a dfm6 so increase safety level */ + if ( (st>>4) != 6) thres *= 2; + if (dfmstate.lastfrcnt >= thres) { + /* id found */ + if (dfmstate.lastfrcnt == thres) { + uint32_t id = ((st&0x0F)<<20) | (d<<4) | ix; + uint32_t chkid = id; + int i; + /* check validity */ + for(i=0; i<6; i++) { + if((chkid&0x0f)>9) { break; /* not ok */ } + chkid >>= 4; + } + if(i==6) { + snprintf(sd->id, 10, "D%x ", id); + memcpy(sd->ser, sd->id+1, 9); + sd->validID = true; + sd->subtype = (st>>4)&0x0F; + strncpy(sd->typestr, typestr[ (st>>4)&0x0F ], 5); + return; + } + dfmstate.lastfrcnt = 0; + Serial.print(" NOT NUMERIC SERIAL"); + } + //anonym->idtime = osic_time(); + } else { + Serial.print(" MAXCHCNT/SECLVL:"); + Serial.print(dfmstate.lastfrcnt); + Serial.print("/"); + Serial.print(thres); + } + } else { + dfmstate.lastfrid = v; /* not stable ser */ + dfmstate.lastfrcnt = 0UL; + } + } + } /*find highest channel number single frame serial */ + + i = 0; + while (iid); + memcpy(sd->ser, sd->id+1, 9); + sd->validID = true; + sd->subtype = (st>>4)&0x0F; + strncpy(sd->typestr, typestr[ (st>>4)&0x0F ], 5); + } + if(dfmstate.nameregok==i) { + Serial.print(" ID OK"); + // idtime = .... /* TODO */ + } + } + } else { + /* data changed so not ser */ + dfmstate.cnt[2*i] = 0; + dfmstate.cnt[2*i+1] = 0; + if(dfmstate.nameregok == i) { /* found id wrong */ + dfmstate.idcnt0 = 0; + dfmstate.idcnt1 = 0; + } + } + } else if (ix<=1) { /* add new entry for possible ID */ + dfmstate.start[dfmstate.nameregtop] = st; + dfmstate.cnt[2*dfmstate.nameregtop] = 0; + dfmstate.cnt[2*dfmstate.nameregtop+1] = 0; + dfmstate.cnt[2*dfmstate.nameregtop+ix] = 1; + dfmstate.dat[2*dfmstate.nameregtop+ix] = d; + if(dfmstate.nameregtop<49) dfmstate.nameregtop++; + } +} + +static float get_Temp() { + SondeData *si = &(sonde.si()->d); + if(!si->validID) { // type not yet known, so don't try to decode + return NAN; + } + float f = dfmstate.meas[0], + f1 = dfmstate.meas[3], + f2 = dfmstate.meas[4]; + if(si->subtype >= 0x0C) { + f = dfmstate.meas[1]; + f1 = dfmstate.meas[5]; + f2 = dfmstate.meas[6]; + } + Serial.printf("Meas: %f %f %f\n", f, f1, f2); + // as in autorx / dfm + float BB0 = 3260.0; // B/Kelvin, fit -55C..+40C + float T0 = 25 + 273.15; // t0=25C + float R0 = 5.0e3; // R0=R25=5k + float Rf = 220e3; // Rf = 220k + float g = f2/Rf; + float R = (f-f1) / g; // meas[0,3,4] > 0 ? + float T = 0; // T/Kelvin + if (f*f1*f2 == 0) R = 0; + if (R > 0) T = 1/(1/T0 + 1/BB0 * log(R/R0)); + T = T - 273.15; // Celsius + if(T<-100 || T>50) { + Serial.printf("Temperature invalid: %f\n", T); + return NAN; + } + return T; +} + +void DFM::decodeCFG(uint8_t *cfg) +{ + SondeData *si = &(sonde.si()->d); + // new ID + finddfname(cfg); + // get meas + uint8_t conf_id = (*cfg)>>4; + if(conf_id<=6) { + uint32_t val = (cfg[1]<<12) | (cfg[2]<<4) | cfg[3]; + uint8_t exp = cfg[0] & 0xF; + dfmstate.meas[conf_id] = val / (float)(1<validID && si->subtype>=0x0A) { + // otherwise don't try, as we might not have the right type yet... + int cid = (si->subtype >= 0x0C) ? 0x7 : 0x5; + if(conf_id == cid) { + uint16_t val = cfg[1]<<8 | cfg[2]; + si->batteryVoltage = val / 1000.0; + Serial.printf("battery: %f\n", si->batteryVoltage); + } + } +} + +#if 0 +// not used any more +static int bitCount(int x) { + int m4 = 0x1 | (0x1<<8) | (0x1<<16) | (0x1<<24); + int m1 = 0xFF; + int s4 = (x&m4) + ((x>>1)&m4) + ((x>>2)&m4) + ((x>>3)&m4) + ((x>>4)&m4) + ((x>>5)&m4) + ((x>>6)&m4) + ((x>>7)&m4); + int s1 = (s4&m1) + ((s4>>8)&m1) + ((s4>>16)&m1) + ((s4>>24)&m1); + return s1; +} +#endif + +uint16_t MON[]={0,0,31,59,90,120,151,181,212,243,273,304,334}; + +void DFM::decodeDAT(uint8_t *dat) +{ + // TODO: Here we need to work on a shadow copy of SondeData in order to prevent concurrent changes while using data in main loop + SondeData *si = &(sonde.si()->d); + Serial.print(" DAT["); Serial.print(dat[6]); Serial.print("]: "); + + // We handle this case already here, because we need to update dfmstate.datesec before the cycle complete handling + if( dat[6]==8 ) { + int y = (dat[0]<<4) + (dat[1]>>4); + int m = dat[1]&0x0F; + int d = dat[2]>>3; + int h = ((dat[2]&0x07)<<2) + (dat[3]>>6); + int mi = (dat[3]&0x3F); + Serial.printf("Date: %04d-%02d-%02d %02d:%02dz ", y, m, d, h, mi); + si->sats = dat[4]; + si->validPos |= 0x40; + // convert to unix time + int tt = (y-1970)*365 + (y-1969)/4; // days since 1970 + if(m<=12) { tt += MON[m]; if((y%4)==0 && m>2) tt++; } + tt = (tt+d-1)*(60*60*24) + h*3600 + mi*60; + // If we get a time stamp much different to the previously received one, kill the ID. + // most likely, we have a new sonde now, so wait for the new ID. + if(tt-dfmstate.datesec > MAXIDAGE) killid(); + dfmstate.datesec = tt; + dfmstate.good |= 0x100; + } + else if( dat[6]>8 ) return; // we ignore those... + + /* Here we update data that should be updated only after receiving a "complete" frame (mainly for consistent SondeHub exports) + * We do this (a) when there is a DAT8 block and (b) when there is wrap from DAT7 to DAT0, for these fields: + * => frame + * => vframe (only used for SondeHub as virtual frame number) + * => time (calculated with using date and msec) + * [assuming that if there is no DAT8, then the date value did not change.] + */ + + if( dat[6]==8 || dat[6] < dfmstate.lastdat) { // After DAT8, or after a "warp around" + if( dfmstate.good&1 ) si->frame = dfmstate.frame; + if( (dfmstate.good&0x102)==0x102 ) { + si->time = dfmstate.datesec + dfmstate.msec/1000; + // Lets be consistent with autorx: the timestamp uses the msec value truncated to seconds, + // whereas the virtual frame number for DFM uses the msec value rounded to full seconds. + // Actually, tt is real UTC, and the transformation to GPS seconds lacks adjusting for leap seconds + si->vframe = dfmstate.datesec + (dfmstate.msec+500)/1000 - 315964800; + } + // All fields updated? 1=OK, 2=with errors + Serial.printf("Cycle done: good is %x\n", dfmstate.good); + si->temperature = get_Temp(); + Serial.printf("Temp: %f\n", si->temperature); + dfmstate.cycledone = ((dfmstate.good&0x11F)==0x11F) ? 1 : 2; + dfmstate.good = 0; + dfmstate.lastdat = 0; + } else { + dfmstate.lastdat = dat[6]; + } + dfmstate.good |= (1<sats = bitCount(tmp); + } + break; + case 2: + { + float lat, vh; + lat = (int32_t)(((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + ((uint32_t)dat[3])); + vh = ((uint16_t)dat[4]<<8) + dat[5]; + Serial.print("GPS-lat: "); Serial.print(lat*0.0000001); + Serial.print(", hor-V: "); Serial.print(vh*0.01); + lat = lat*0.0000001; + if( lat!=0 && si->lat!=0 && abs(lat-si->lat)>.25 ) killid(); + si->lat = lat; + si->hs = vh*0.01; + if(lat!=0 || vh!=0) si->validPos |= 0x11; else si->validPos &= ~0x11; + } + break; + case 3: + { + float lon, dir; + lon = (int32_t)(((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + (uint32_t)dat[3]); + dir = ((uint16_t)dat[4]<<8) + dat[5]; + lon = lon*0.0000001; + if( lon!=0 && si->lon!=0 && abs(lon-si->lon)>.25 ) killid(); + si->lon = lon; + si->dir = dir*0.01; + Serial.print("GPS-lon: "); Serial.print(si->lon); + Serial.print(", dir: "); Serial.print(si->dir); + if(lon != 0 || dir != 0) si->validPos |= 0x22; else si->validPos &= ~0x22; + } + break; + case 4: + { + float alt, vv; + alt = ((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + dat[3]; + vv = (int16_t)( ((int16_t)dat[4]<<8) | dat[5] ); + Serial.print("GPS-height: "); Serial.print(alt*0.01); + Serial.print(", vv: "); Serial.print(vv*0.01); + si->alt = alt*0.01; + si->vs = vv*0.01; + if(alt!=0 || vv != 0) si->validPos |= 0x0C; else si->validPos &= ~0x0C; + } + break; + case 8: + // handled above + break; + default: + Serial.print("(?)"); + break; + } +} + + +void DFM::bitsToBytes(uint8_t *bits, uint8_t *bytes, int len) +{ + int i; + for(i=0; i 01 or 10 => 1, otherweise => 0 + // not here: (10=>1, 01=>0)!!! rxbyte = rxbyte ^ d; + } + // + if(rxsearching) { + if( rxdata == 0x6566A5AA || rxdata == 0x9A995A55 ) { + rxsearching = false; + rxbitc = 0; + rxp = 0; + rxbyte = 0; + rssi=sx1278.getRSSI(); + fei=sx1278.getFEI(); + afc=sx1278.getAFC(); + sonde.si()->rssi = rssi; + sonde.si()->afc = afc; + invers = (rxdata == 0x6566A5AA)?1:0; + } + } else { + rxbitc = (rxbitc+1)%16; // 16; + if(rxbitc == 0) { // got 8 data bit + if(invers) rxbyte=~rxbyte; + data[rxp++] = rxbyte&0xff; // (rxbyte>>1)&0xff; + if(rxp>=DFM_FRAMELEN) { + rxsearching = true; + //Serial.println("Got a DFM frame!"); + Serial.print("[RSSI="); Serial.print(rssi); + Serial.print(" FEI="); Serial.print(fei); + Serial.print(" AFC="); Serial.print(afc); Serial.print("] "); + decodeFrameDFM(data); + haveNewFrame = 1; + } + } + } + } + return 0; +} + +int DFM::receive() { + int rxframes = 5; // UP TO 5 frames, stop at type 8 frame + + // tentative continuous RX version... + unsigned long t0 = millis(); + dfmstate.cycledone = 0; + while( ( millis() - t0 ) < 1300 ) { + uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2); + if ( bitRead(value, 7) ) { + Serial.println("FIFO full"); + } + if ( bitRead(value, 4) ) { + Serial.println("FIFO overflow"); + // new: (maybe clear only overflow??) TODO + sx1278.clearIRQFlags(); + } + if ( bitRead(value, 2) == 1 ) { + Serial.println("FIFO: payload ready()"); + // does not make much sence? (from m10): TODO + // ??????? sx1278.clearIRQFlags(); + } + if(bitRead(value, 6) == 0) { // while FIFO not empty + byte data = sx1278.readRegister(REG_FIFO); + processDFMdata(data); + value = sx1278.readRegister(REG_IRQ_FLAGS2); + } else { + if(haveNewFrame) { + //Serial.printf("DFM::receive(): new frame complete after %ldms\n", millis()-t0); + haveNewFrame = 0; + rxframes--; + // OK: All DAT frames (0/1/2/3/4/8) have been received in the last cycle + if(dfmstate.cycledone==1) return RX_OK; + if(dfmstate.cycledone>1 || rxframes==0) return RX_ERROR; + } + delay(2); + } + } + return rxframes == 5 ? RX_TIMEOUT : RX_ERROR; +} + +int DFM::decodeFrameDFM(uint8_t *data) { + deinterleave(data, 7, hamming_conf); + deinterleave(data+7, 13, hamming_dat1); + deinterleave(data+20, 13, hamming_dat2); + + int ret0 = hamming(hamming_conf, 7, block_conf); + int ret1 = hamming(hamming_dat1, 13, block_dat1); + int ret2 = hamming(hamming_dat2, 13, block_dat2); + //Serial.printf("Hamming returns %d %d %d -- %d\n", ret0, ret1, ret2, ret0|ret1|ret2); + + byte byte_conf[4], byte_dat1[7], byte_dat2[7]; + bitsToBytes(block_conf, byte_conf, 7); + bitsToBytes(block_dat1, byte_dat1, 13); + bitsToBytes(block_dat2, byte_dat2, 13); + + printRaw("CFG", 7, ret0, byte_conf); + printRaw("DAT", 13, ret1, byte_dat1); + printRaw("DAT", 13, ret2, byte_dat2); + if (ret0>=0) decodeCFG(byte_conf); + if (ret1>=0 && ret1<=4) decodeDAT(byte_dat1); + if (ret2>=0 && ret2<=4) decodeDAT(byte_dat2); + Serial.println(""); + // Consistent with autorx: If more than 4 corrected bit errors in DAT block, assume it is possibly corrupt and + // don't treat it as a correct frame (ttgo display shows data anyway, but it is not sent to external sites) + if(ret1>4 || ret2>4) return RX_ERROR; + return (ret0|ret1|ret2)>=0 ? RX_OK : RX_ERROR; +} + +// moved to a single function in Sonde(). This function can be used for additional +// processing here, that takes too long for doing in the RX task loop +int DFM::waitRXcomplete() { + return 0; +} + +DFM dfm = DFM(); diff --git a/RX_FSK/src/DFM.h b/RX_FSK/src/DFM.h new file mode 100644 index 0000000..0d690bb --- /dev/null +++ b/RX_FSK/src/DFM.h @@ -0,0 +1,74 @@ +/* + * DFM.h + * Functions for decoding DFM sondes with SX127x chips + * Copyright (C) 2019 Hansi Reiser, dl9rdz + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef DFM_h +#define DFM_h + +#include +#include +#include +#ifndef inttypes_h + #include +#endif +#include "DecoderBase.h" + +#define DFM_NORMAL 0 +#define DFM_INVERSE 1 + +/* Main class */ +class DFM : public DecoderBase +{ +private: + int stype; + char *stypename=NULL; + + void deinterleave(uint8_t *str, int L, uint8_t *block); + uint32_t bits2val(const uint8_t *bits, int len); + int check(uint8_t code[8]); + int hamming(uint8_t *ham, int L, uint8_t *sym); + void printRaw(const char *prefix, int len, int ret, const uint8_t* data); + void finddfname(uint8_t *cfg); + void decodeCFG(uint8_t *cfg); + void decodeDAT(uint8_t *dat); + void bitsToBytes(uint8_t *bits, uint8_t *bytes, int len); + int processDFMdata(uint8_t dt); + int decodeFrameDFM(uint8_t *data); + void killid(); + + +#define B 8 +#define S 4 + uint8_t hamming_conf[ 7*B]; // 7*8=56 + uint8_t hamming_dat1[13*B]; // 13*8=104 + uint8_t hamming_dat2[13*B]; + + uint8_t block_conf[ 7*S]; // 7*4=28 + uint8_t block_dat1[13*S]; // 13*4=52 + uint8_t block_dat2[13*S]; + + uint8_t H[4][8] = // extended Hamming(8,4) particy check matrix + {{ 0, 1, 1, 1, 1, 0, 0, 0}, + { 1, 0, 1, 1, 0, 1, 0, 0}, + { 1, 1, 0, 1, 0, 0, 1, 0}, + { 1, 1, 1, 0, 0, 0, 0, 1}}; + uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1}; // Spalten von H: + // 1-bit-error-Syndrome + +public: + DFM(); + // main decoder API + int setup(float frequency, int type); + int receive(); + int waitRXcomplete(); + + int use_ecc = 1; +}; + +extern DFM dfm; + +#endif diff --git a/RX_FSK/src/DecoderBase.cpp b/RX_FSK/src/DecoderBase.cpp new file mode 100644 index 0000000..86a4e00 --- /dev/null +++ b/RX_FSK/src/DecoderBase.cpp @@ -0,0 +1,51 @@ + +#include "DecoderBase.h" +#include "SX1278FSK.h" +#include "Sonde.h" + +#define DECODERBASE_DEBUG 1 + +#if DECODERBASE_DEBUG +#define DBG(x) x +#else +#define DBG(x) +#endif + + +int DecoderBase::setup(decoderSetupCfg &setupcfg, uint16_t agcbw, uint16_t rxbw) { + if(sx1278.setFSK()!=0) { + DBG(Serial.println("Setting FSK mode FAILED")); + return 1; + } + if(sx1278.setBitrate(setupcfg.bitrate)!=0) { + DBG(Serial.println("Setting bitrate FAILED")); + return 1; + } +#if DECODERBASE_DEBUG + float br = sx1278.getBitrate(); + Serial.print("Exact bitrate is "); + Serial.println(br); +#endif + if(sx1278.setAFCBandwidth(agcbw)!=0) { + DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(rxbw)!=0) { + DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", rxbw)); + return 1; + } + + if(sx1278.setRxConf(setupcfg.rx_cfg)!=0) { + DBG(Serial.println("Setting RX Config FAILED")); + return 1; + } + if(sx1278.setSyncConf(setupcfg.sync_cfg, setupcfg.sync_len, setupcfg.sync_data)!=0) { + DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + if(sx1278.setPreambleDetect(setupcfg.preamble_cfg)!=0) { + DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } + return 0; +} diff --git a/RX_FSK/src/DecoderBase.h b/RX_FSK/src/DecoderBase.h new file mode 100644 index 0000000..d1867ba --- /dev/null +++ b/RX_FSK/src/DecoderBase.h @@ -0,0 +1,38 @@ + +#ifndef DECODER_BASE_H +#define DECODER_BASE_H + +#include +#include +#include +#ifndef inttypes_h + #include +#endif +#include "Sonde.h" + +typedef struct _decoderSetupCfg { + uint16_t bitrate; + //uint16_t agcbw; + //uint16_t rxbw; + uint8_t rx_cfg; + uint8_t sync_cfg; + uint8_t sync_len; + const uint8_t *sync_data; + uint8_t preamble_cfg; +} decoderSetupCfg; + +/* Generic base class for all sonde decoders */ +class DecoderBase +{ +protected: + +public: + int setup(decoderSetupCfg &setupcfg, uint16_t agcbw, uint16_t rxbw); + virtual int setup(float frequency, int type=0) = 0; + + virtual int receive() = 0; + virtual int waitRXcomplete() = 0; +}; + + +#endif diff --git a/RX_FSK/src/DefaultFonts.c b/RX_FSK/src/DefaultFonts.c new file mode 100644 index 0000000..665c6ac --- /dev/null +++ b/RX_FSK/src/DefaultFonts.c @@ -0,0 +1,367 @@ +// SPDX-License-Identifier: GPL-3.0 +// original source: https://github.com/Nkawu/TFT_22_ILI9225 + + +#ifdef __AVR__ + #include +#elif defined(ESP8266) || defined(ESP32) + #include +#endif + +#if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_STM32F1) || defined(STM32F1) || defined(ESP32) + #define PROGMEM + #define fontdatatype const char +#else + #define fontdatatype const uint8_t +#endif + +//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0 +//MikroElektronika 2011 +//http://www.mikroe.com + +//GLCD FontName : Terminal6x8 +//GLCD FontSize : 6 x 8 + +fontdatatype Terminal6x8[] PROGMEM = { + 0x06, 0x08, 0x20, 0x60, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char + 0x05, 0x00, 0x00, 0x06, 0x5F, 0x06, 0x00, // Code for char ! + 0x06, 0x00, 0x07, 0x03, 0x00, 0x07, 0x03, // Code for char " + 0x06, 0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24, // Code for char # + 0x05, 0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00, // Code for char $ + 0x06, 0x00, 0x63, 0x13, 0x08, 0x64, 0x63, // Code for char % + 0x06, 0x00, 0x36, 0x49, 0x56, 0x20, 0x50, // Code for char & + 0x04, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, // Code for char ' + 0x04, 0x00, 0x00, 0x3E, 0x41, 0x00, 0x00, // Code for char ( + 0x04, 0x00, 0x00, 0x41, 0x3E, 0x00, 0x00, // Code for char ) + 0x06, 0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08, // Code for char * + 0x06, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, // Code for char + + 0x04, 0x00, 0x00, 0xE0, 0x60, 0x00, 0x00, // Code for char , + 0x06, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, // Code for char - + 0x04, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, // Code for char . + 0x06, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02, // Code for char / + 0x06, 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E, // Code for char 0 + 0x05, 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, // Code for char 1 + 0x06, 0x00, 0x62, 0x51, 0x49, 0x49, 0x46, // Code for char 2 + 0x06, 0x00, 0x22, 0x49, 0x49, 0x49, 0x36, // Code for char 3 + 0x06, 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10, // Code for char 4 + 0x06, 0x00, 0x2F, 0x49, 0x49, 0x49, 0x31, // Code for char 5 + 0x06, 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30, // Code for char 6 + 0x06, 0x00, 0x01, 0x71, 0x09, 0x05, 0x03, // Code for char 7 + 0x06, 0x00, 0x36, 0x49, 0x49, 0x49, 0x36, // Code for char 8 + 0x06, 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E, // Code for char 9 + 0x04, 0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00, // Code for char : + 0x04, 0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00, // Code for char ; + 0x05, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, // Code for char < + 0x06, 0x00, 0x24, 0x24, 0x24, 0x24, 0x24, // Code for char = + 0x06, 0x00, 0x00, 0x41, 0x22, 0x14, 0x08, // Code for char > + 0x06, 0x00, 0x02, 0x01, 0x59, 0x09, 0x06, // Code for char ? + 0x06, 0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E, // Code for char @ + 0x06, 0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E, // Code for char A + 0x06, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36, // Code for char B + 0x06, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22, // Code for char C + 0x06, 0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E, // Code for char D + 0x06, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41, // Code for char E + 0x06, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01, // Code for char F + 0x06, 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A, // Code for char G + 0x06, 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F, // Code for char H + 0x05, 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00, // Code for char I + 0x06, 0x00, 0x30, 0x40, 0x40, 0x40, 0x3F, // Code for char J + 0x06, 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41, // Code for char K + 0x06, 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40, // Code for char L + 0x06, 0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F, // Code for char M + 0x06, 0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F, // Code for char N + 0x06, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E, // Code for char O + 0x06, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06, // Code for char P + 0x06, 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E, // Code for char Q + 0x06, 0x00, 0x7F, 0x09, 0x09, 0x19, 0x66, // Code for char R + 0x06, 0x00, 0x26, 0x49, 0x49, 0x49, 0x32, // Code for char S + 0x06, 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01, // Code for char T + 0x06, 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F, // Code for char U + 0x06, 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F, // Code for char V + 0x06, 0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F, // Code for char W + 0x06, 0x00, 0x63, 0x14, 0x08, 0x14, 0x63, // Code for char X + 0x06, 0x00, 0x07, 0x08, 0x70, 0x08, 0x07, // Code for char Y + 0x05, 0x00, 0x71, 0x49, 0x45, 0x43, 0x00, // Code for char Z + 0x05, 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00, // Code for char [ + 0x06, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, // Code for char BackSlash + 0x05, 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00, // Code for char ] + 0x06, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04, // Code for char ^ + 0x06, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // Code for char _ + 0x04, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, // Code for char ` + 0x06, 0x00, 0x20, 0x54, 0x54, 0x54, 0x78, // Code for char a + 0x06, 0x00, 0x7F, 0x44, 0x44, 0x44, 0x38, // Code for char b + 0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0x28, // Code for char c + 0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0x7F, // Code for char d + 0x06, 0x00, 0x38, 0x54, 0x54, 0x54, 0x08, // Code for char e + 0x05, 0x00, 0x08, 0x7E, 0x09, 0x09, 0x00, // Code for char f + 0x06, 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C, // Code for char g + 0x05, 0x00, 0x7F, 0x04, 0x04, 0x78, 0x00, // Code for char h + 0x05, 0x00, 0x00, 0x00, 0x7D, 0x40, 0x00, // Code for char i + 0x05, 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00, // Code for char j + 0x05, 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00, // Code for char k + 0x05, 0x00, 0x00, 0x00, 0x7F, 0x40, 0x00, // Code for char l + 0x06, 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78, // Code for char m + 0x05, 0x00, 0x7C, 0x04, 0x04, 0x78, 0x00, // Code for char n + 0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, // Code for char o + 0x06, 0x00, 0xFC, 0x44, 0x44, 0x44, 0x38, // Code for char p + 0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0xFC, // Code for char q + 0x06, 0x00, 0x44, 0x78, 0x44, 0x04, 0x08, // Code for char r + 0x06, 0x00, 0x08, 0x54, 0x54, 0x54, 0x20, // Code for char s + 0x05, 0x00, 0x04, 0x3E, 0x44, 0x24, 0x00, // Code for char t + 0x05, 0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00, // Code for char u + 0x06, 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C, // Code for char v + 0x06, 0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C, // Code for char w + 0x05, 0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00, // Code for char x + 0x05, 0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00, // Code for char y + 0x05, 0x00, 0x64, 0x54, 0x54, 0x4C, 0x00, // Code for char z + 0x05, 0x00, 0x08, 0x3E, 0x41, 0x41, 0x00, // Code for char { + 0x04, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, // Code for char | + 0x06, 0x00, 0x00, 0x41, 0x41, 0x3E, 0x08, // Code for char } + 0x05, 0x00, 0x02, 0x01, 0x02, 0x01, 0x00, // Code for char ~ + 0x06, 0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C // Code for char + }; + + +//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0 +//MikroElektronika 2011 +//http://www.mikroe.com + +//GLCD FontName : Terminal11x16 +//GLCD FontSize : 11 x 16 + +fontdatatype Terminal11x16[] PROGMEM = { + 0x0B, 0x10, 0x20, 0x60, + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x00, 0xFF, 0x33, 0xFF, 0x33, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ! + 0x08, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char " + 0x0B, 0x00, 0x02, 0x10, 0x1E, 0x90, 0x1F, 0xF0, 0x03, 0x7E, 0x02, 0x1E, 0x1E, 0x90, 0x1F, 0xF0, 0x03, 0x7E, 0x02, 0x1E, 0x00, 0x10, 0x00, // Code for char # + 0x09, 0x00, 0x00, 0x78, 0x04, 0xFC, 0x0C, 0xCC, 0x0C, 0xFF, 0x3F, 0xFF, 0x3F, 0xCC, 0x0C, 0xCC, 0x0F, 0x88, 0x07, 0x00, 0x00, 0x00, 0x00, // Code for char $ + 0x0B, 0x00, 0x30, 0x38, 0x38, 0x38, 0x1C, 0x38, 0x0E, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x38, 0x70, 0x38, 0x38, 0x38, 0x1C, 0x00, // Code for char % + 0x0A, 0x00, 0x00, 0x00, 0x1F, 0xB8, 0x3F, 0xFC, 0x31, 0xC6, 0x21, 0xE2, 0x37, 0x3E, 0x1E, 0x1C, 0x1C, 0x00, 0x36, 0x00, 0x22, 0x00, 0x00, // Code for char & + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x3F, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ' + 0x08, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x07, 0x38, 0x01, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ( + 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x20, 0x07, 0x38, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ) + 0x09, 0x00, 0x00, 0x98, 0x0C, 0xB8, 0x0E, 0xE0, 0x03, 0xF8, 0x0F, 0xF8, 0x0F, 0xE0, 0x03, 0xB8, 0x0E, 0x98, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char * + 0x09, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xF0, 0x0F, 0xF0, 0x0F, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char + + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x00, 0xF8, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char , + 0x09, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char - + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char . + 0x0B, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00, // Code for char / + 0x0B, 0xF8, 0x07, 0xFE, 0x1F, 0x06, 0x1E, 0x03, 0x33, 0x83, 0x31, 0xC3, 0x30, 0x63, 0x30, 0x33, 0x30, 0x1E, 0x18, 0xFE, 0x1F, 0xF8, 0x07, // Code for char 0 + 0x0A, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x30, 0x0C, 0x30, 0x0E, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, // Code for char 1 + 0x0B, 0x1C, 0x30, 0x1E, 0x38, 0x07, 0x3C, 0x03, 0x3E, 0x03, 0x37, 0x83, 0x33, 0xC3, 0x31, 0xE3, 0x30, 0x77, 0x30, 0x3E, 0x30, 0x1C, 0x30, // Code for char 2 + 0x0B, 0x0C, 0x0C, 0x0E, 0x1C, 0x07, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x39, 0x7E, 0x1F, 0x3C, 0x0E, // Code for char 3 + 0x0B, 0xC0, 0x03, 0xE0, 0x03, 0x70, 0x03, 0x38, 0x03, 0x1C, 0x03, 0x0E, 0x03, 0x07, 0x03, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x03, 0x00, 0x03, // Code for char 4 + 0x0B, 0x3F, 0x0C, 0x7F, 0x1C, 0x63, 0x38, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0xE3, 0x38, 0xC3, 0x1F, 0x83, 0x0F, // Code for char 5 + 0x0B, 0xC0, 0x0F, 0xF0, 0x1F, 0xF8, 0x39, 0xDC, 0x30, 0xCE, 0x30, 0xC7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x39, 0x80, 0x1F, 0x00, 0x0F, // Code for char 6 + 0x0B, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x0F, 0xC3, 0x03, 0xF3, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x03, 0x00, // Code for char 7 + 0x0B, 0x00, 0x0F, 0xBC, 0x1F, 0xFE, 0x39, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFE, 0x39, 0xBC, 0x1F, 0x00, 0x0F, // Code for char 8 + 0x0B, 0x3C, 0x00, 0x7E, 0x00, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x38, 0xC3, 0x1C, 0xC3, 0x0E, 0xE7, 0x07, 0xFE, 0x03, 0xFC, 0x00, // Code for char 9 + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char : + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x9C, 0x70, 0xFC, 0x70, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ; + 0x09, 0x00, 0x00, 0xC0, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x38, 0x07, 0x1C, 0x0E, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char < + 0x0A, 0x00, 0x00, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x00, 0x00, // Code for char = + 0x09, 0x00, 0x00, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0x1C, 0x0E, 0x38, 0x07, 0xF0, 0x03, 0xE0, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char > + 0x0A, 0x1C, 0x00, 0x1E, 0x00, 0x07, 0x00, 0x03, 0x00, 0x83, 0x37, 0xC3, 0x37, 0xE3, 0x00, 0x77, 0x00, 0x3E, 0x00, 0x1C, 0x00, 0x00, 0x00, // Code for char ? + 0x0B, 0xF8, 0x0F, 0xFE, 0x1F, 0x07, 0x18, 0xF3, 0x33, 0xFB, 0x37, 0x1B, 0x36, 0xFB, 0x37, 0xFB, 0x37, 0x07, 0x36, 0xFE, 0x03, 0xF8, 0x01, // Code for char @ + 0x0A, 0x00, 0x38, 0x00, 0x3F, 0xE0, 0x07, 0xFC, 0x06, 0x1F, 0x06, 0x1F, 0x06, 0xFC, 0x06, 0xE0, 0x07, 0x00, 0x3F, 0x00, 0x38, 0x00, 0x00, // Code for char A + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFE, 0x39, 0xBC, 0x1F, 0x00, 0x0F, 0x00, 0x00, // Code for char B + 0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0x0C, 0x0C, 0x00, 0x00, // Code for char C + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, // Code for char D + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, // Code for char E + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, // Code for char F + 0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x3F, 0xC6, 0x3F, 0x00, 0x00, // Code for char G + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char H + 0x08, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I + 0x0A, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00, // Code for char J + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x38, 0x07, 0x1C, 0x0E, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00, // Code for char K + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, // Code for char L + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x1E, 0x00, 0x78, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0x78, 0x00, 0x1E, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char M + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x0E, 0x00, 0x38, 0x00, 0xF0, 0x00, 0xC0, 0x03, 0x00, 0x07, 0x00, 0x1C, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char N + 0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, // Code for char O + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0xC7, 0x01, 0xFE, 0x00, 0x7C, 0x00, 0x00, 0x00, // Code for char P + 0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x36, 0x07, 0x3E, 0x0E, 0x1C, 0xFC, 0x3F, 0xF0, 0x33, 0x00, 0x00, // Code for char Q + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x01, 0x83, 0x03, 0x83, 0x07, 0x83, 0x0F, 0xC7, 0x1D, 0xFE, 0x38, 0x7C, 0x30, 0x00, 0x00, // Code for char R + 0x0A, 0x3C, 0x0C, 0x7E, 0x1C, 0xE7, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x39, 0x8E, 0x1F, 0x0C, 0x0F, 0x00, 0x00, // Code for char S + 0x09, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T + 0x0A, 0xFF, 0x07, 0xFF, 0x1F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00, // Code for char U + 0x0A, 0x07, 0x00, 0x3F, 0x00, 0xF8, 0x01, 0xC0, 0x0F, 0x00, 0x3E, 0x00, 0x3E, 0xC0, 0x0F, 0xF8, 0x01, 0x3F, 0x00, 0x07, 0x00, 0x00, 0x00, // Code for char V + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x1C, 0x00, 0x06, 0x80, 0x03, 0x80, 0x03, 0x00, 0x06, 0x00, 0x1C, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char W + 0x0A, 0x03, 0x30, 0x0F, 0x3C, 0x1C, 0x0E, 0x30, 0x03, 0xE0, 0x01, 0xE0, 0x01, 0x30, 0x03, 0x1C, 0x0E, 0x0F, 0x3C, 0x03, 0x30, 0x00, 0x00, // Code for char X + 0x0A, 0x03, 0x00, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x00, 0xC0, 0x3F, 0xC0, 0x3F, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0x00, 0x00, 0x00, // Code for char Y + 0x0A, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x3E, 0x03, 0x33, 0xC3, 0x31, 0xE3, 0x30, 0x33, 0x30, 0x1F, 0x30, 0x0F, 0x30, 0x03, 0x30, 0x00, 0x00, // Code for char Z + 0x08, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [ + 0x0B, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x18, // Code for char BackSlash + 0x08, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ] + 0x0B, 0x60, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0x60, 0x00, // Code for char ^ + 0x0B, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, // Code for char _ + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x7E, 0x00, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ` + 0x0A, 0x00, 0x1C, 0x40, 0x3E, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xE0, 0x3F, 0xC0, 0x3F, 0x00, 0x00, // Code for char a + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00, // Code for char b + 0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xC0, 0x18, 0x80, 0x08, 0x00, 0x00, // Code for char c + 0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x30, 0xC0, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char d + 0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3B, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xC0, 0x13, 0x80, 0x01, 0x00, 0x00, // Code for char e + 0x08, 0xC0, 0x00, 0xC0, 0x00, 0xFC, 0x3F, 0xFE, 0x3F, 0xC7, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f + 0x0A, 0x80, 0x03, 0xC0, 0xC7, 0xE0, 0xCE, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xE6, 0xE0, 0x7F, 0xE0, 0x3F, 0x00, 0x00, // Code for char g + 0x09, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, // Code for char h + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0x30, 0xEC, 0x3F, 0xEC, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x60, 0xC0, 0xEC, 0xFF, 0xEC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j + 0x09, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x03, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1C, 0x60, 0x38, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char k + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l + 0x0A, 0xE0, 0x3F, 0xC0, 0x3F, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0xC0, 0x3F, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, // Code for char m + 0x0A, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, // Code for char n + 0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00, // Code for char o + 0x0A, 0xE0, 0xFF, 0xE0, 0xFF, 0x60, 0x0C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0xE0, 0x1C, 0xC0, 0x0F, 0x80, 0x07, 0x00, 0x00, // Code for char p + 0x0A, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x0C, 0xE0, 0xFF, 0xE0, 0xFF, 0x00, 0x00, // Code for char q + 0x0A, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0xC0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x00, // Code for char r + 0x08, 0xC0, 0x11, 0xE0, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x3F, 0x40, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s + 0x08, 0x60, 0x00, 0x60, 0x00, 0xFE, 0x1F, 0xFE, 0x3F, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t + 0x0A, 0xE0, 0x0F, 0xE0, 0x1F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x18, 0xE0, 0x3F, 0xE0, 0x3F, 0x00, 0x00, // Code for char u + 0x0A, 0x60, 0x00, 0xE0, 0x01, 0x80, 0x07, 0x00, 0x1E, 0x00, 0x38, 0x00, 0x38, 0x00, 0x1E, 0x80, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00, // Code for char v + 0x0A, 0xE0, 0x07, 0xE0, 0x1F, 0x00, 0x38, 0x00, 0x1C, 0xE0, 0x0F, 0xE0, 0x0F, 0x00, 0x1C, 0x00, 0x38, 0xE0, 0x1F, 0xE0, 0x07, 0x00, 0x00, // Code for char w + 0x09, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x1D, 0x80, 0x0F, 0x00, 0x07, 0x80, 0x0F, 0xC0, 0x1D, 0xE0, 0x38, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char x + 0x09, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x81, 0x80, 0xE7, 0x00, 0x7E, 0x00, 0x1E, 0x80, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y + 0x09, 0x60, 0x30, 0x60, 0x38, 0x60, 0x3C, 0x60, 0x36, 0x60, 0x33, 0xE0, 0x31, 0xE0, 0x30, 0x60, 0x30, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char z + 0x09, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xFC, 0x1F, 0x7E, 0x3F, 0x07, 0x70, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00, // Code for char { + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char | + 0x09, 0x00, 0x00, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x07, 0x70, 0x7E, 0x3F, 0xFC, 0x1F, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char } + 0x0A, 0x10, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x18, 0x00, 0x10, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char ~ + 0x0A, 0x00, 0x0F, 0x80, 0x0F, 0xC0, 0x0C, 0x60, 0x0C, 0x30, 0x0C, 0x30, 0x0C, 0x60, 0x0C, 0xC0, 0x0C, 0x80, 0x0F, 0x00, 0x0F, 0x00, 0x00 // Code for char + }; + + +//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0 +//MikroElektronika 2011 +//http://www.mikroe.com + +//GLCD FontName : Terminal12x16 +//GLCD FontSize : 12 x 16 + +fontdatatype Terminal12x16[] PROGMEM = { + 0x0C, 0x10, 0x20, 0x60, + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x00, 0xFF, 0x33, 0xFF, 0x33, 0xFF, 0x33, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ! + 0x09, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char " + 0x0C, 0x00, 0x02, 0x10, 0x1E, 0x90, 0x1F, 0xF0, 0x1F, 0xFE, 0x03, 0x7E, 0x1E, 0x9E, 0x1F, 0xF0, 0x1F, 0xFE, 0x03, 0x7E, 0x02, 0x1E, 0x00, 0x10, 0x00, // Code for char # + 0x0A, 0x00, 0x00, 0x78, 0x04, 0xFC, 0x0C, 0xFC, 0x0C, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xCC, 0x0F, 0xCC, 0x0F, 0x88, 0x07, 0x00, 0x00, 0x00, 0x00, // Code for char $ + 0x0C, 0x00, 0x30, 0x38, 0x38, 0x38, 0x3C, 0x38, 0x1E, 0x38, 0x0F, 0x80, 0x07, 0xC0, 0x03, 0xE0, 0x39, 0xF0, 0x38, 0x78, 0x38, 0x3C, 0x38, 0x1C, 0x00, // Code for char % + 0x0B, 0x00, 0x00, 0x00, 0x1F, 0xB8, 0x3F, 0xFC, 0x3F, 0xFE, 0x31, 0xE6, 0x37, 0xFE, 0x3F, 0x3E, 0x1E, 0x1C, 0x3E, 0x00, 0x36, 0x00, 0x22, 0x00, 0x00, // Code for char & + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ' + 0x09, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0x3F, 0x07, 0x38, 0x01, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ( + 0x09, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x20, 0x07, 0x38, 0xFF, 0x3F, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ) + 0x0A, 0x00, 0x00, 0x98, 0x0C, 0xB8, 0x0E, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xB8, 0x0E, 0x98, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char * + 0x0A, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char + + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char , + 0x0A, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char - + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char . + 0x0C, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x0F, 0x80, 0x07, 0xC0, 0x03, 0xE0, 0x01, 0xF0, 0x00, 0x78, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x0E, 0x00, // Code for char / + 0x0C, 0xF8, 0x07, 0xFE, 0x1F, 0xFE, 0x1F, 0x07, 0x3F, 0x83, 0x33, 0xC3, 0x31, 0xE3, 0x30, 0x73, 0x30, 0x3F, 0x38, 0xFE, 0x1F, 0xFE, 0x1F, 0xF8, 0x07, // Code for char 0 + 0x0B, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x30, 0x0C, 0x30, 0x0E, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, // Code for char 1 + 0x0C, 0x1C, 0x30, 0x1E, 0x38, 0x1F, 0x3C, 0x07, 0x3E, 0x03, 0x3F, 0x83, 0x37, 0xC3, 0x33, 0xE3, 0x31, 0xF7, 0x30, 0x7F, 0x30, 0x3E, 0x30, 0x1C, 0x30, // Code for char 2 + 0x0C, 0x0C, 0x0C, 0x0E, 0x1C, 0x0F, 0x3C, 0xC7, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x39, 0xFF, 0x3F, 0x7E, 0x1F, 0x3C, 0x0E, // Code for char 3 + 0x0C, 0xC0, 0x03, 0xE0, 0x03, 0xF0, 0x03, 0x78, 0x03, 0x3C, 0x03, 0x1E, 0x03, 0x0F, 0x03, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x03, 0x00, 0x03, // Code for char 4 + 0x0C, 0x3F, 0x0C, 0x7F, 0x1C, 0x7F, 0x3C, 0x63, 0x38, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0xE3, 0x38, 0xE3, 0x3F, 0xC3, 0x1F, 0x83, 0x0F, // Code for char 5 + 0x0C, 0xC0, 0x0F, 0xF0, 0x1F, 0xF8, 0x3F, 0xFC, 0x39, 0xDE, 0x30, 0xCF, 0x30, 0xC7, 0x30, 0xC3, 0x30, 0xC3, 0x39, 0xC3, 0x3F, 0x80, 0x1F, 0x00, 0x0F, // Code for char 6 + 0x0C, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x3F, 0xC3, 0x0F, 0xF3, 0x03, 0xFF, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x03, 0x00, // Code for char 7 + 0x0C, 0x00, 0x0F, 0xBC, 0x1F, 0xFE, 0x3F, 0xFF, 0x39, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFF, 0x39, 0xFE, 0x3F, 0xBC, 0x1F, 0x00, 0x0F, // Code for char 8 + 0x0C, 0x3C, 0x00, 0x7E, 0x00, 0xFF, 0x30, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x38, 0xC3, 0x3C, 0xC3, 0x1E, 0xE7, 0x0F, 0xFF, 0x07, 0xFE, 0x03, 0xFC, 0x00, // Code for char 9 + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char : + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x9C, 0x70, 0xFC, 0x70, 0xFC, 0x70, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ; + 0x0A, 0x00, 0x00, 0xC0, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0xF8, 0x07, 0x3C, 0x0F, 0x1E, 0x1E, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char < + 0x0B, 0x00, 0x00, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x00, 0x00, // Code for char = + 0x0A, 0x00, 0x00, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0x1E, 0x1E, 0x3C, 0x0F, 0xF8, 0x07, 0xF0, 0x03, 0xE0, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char > + 0x0B, 0x1C, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x07, 0x00, 0x83, 0x37, 0xC3, 0x37, 0xE3, 0x37, 0xF7, 0x00, 0x7F, 0x00, 0x3E, 0x00, 0x1C, 0x00, 0x00, 0x00, // Code for char ? + 0x0C, 0xF8, 0x0F, 0xFE, 0x1F, 0xFF, 0x1F, 0xF7, 0x3B, 0xFB, 0x37, 0xFB, 0x37, 0xFB, 0x37, 0xFB, 0x37, 0xFF, 0x37, 0xFF, 0x37, 0xFE, 0x03, 0xF8, 0x01, // Code for char @ + 0x0B, 0x00, 0x38, 0x00, 0x3F, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x06, 0x1F, 0x06, 0xFF, 0x06, 0xFC, 0x07, 0xE0, 0x3F, 0x00, 0x3F, 0x00, 0x38, 0x00, 0x00, // Code for char A + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFF, 0x39, 0xFE, 0x3F, 0xBC, 0x1F, 0x00, 0x0F, 0x00, 0x00, // Code for char B + 0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0x0E, 0x1C, 0x0C, 0x0C, 0x00, 0x00, // Code for char C + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, // Code for char D + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, // Code for char E + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, // Code for char F + 0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x3F, 0xC7, 0x3F, 0xC6, 0x3F, 0x00, 0x00, // Code for char G + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char H + 0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I + 0x0B, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x3E, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x3F, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00, // Code for char J + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xE0, 0x01, 0xF0, 0x03, 0xF8, 0x07, 0x3C, 0x0F, 0x1E, 0x1E, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00, // Code for char K + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, // Code for char L + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x7E, 0x00, 0xF8, 0x01, 0xE0, 0x01, 0xF8, 0x01, 0x7E, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char M + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x3E, 0x00, 0xF8, 0x00, 0xF0, 0x03, 0xC0, 0x07, 0x00, 0x1F, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char N + 0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, // Code for char O + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0xC7, 0x01, 0xFF, 0x01, 0xFE, 0x00, 0x7C, 0x00, 0x00, 0x00, // Code for char P + 0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x36, 0x07, 0x3E, 0x0F, 0x3E, 0xFE, 0x3F, 0xFC, 0x3F, 0xF0, 0x33, 0x00, 0x00, // Code for char Q + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x03, 0x83, 0x07, 0x83, 0x0F, 0xC7, 0x1F, 0xFF, 0x3D, 0xFE, 0x38, 0x7C, 0x30, 0x00, 0x00, // Code for char R + 0x0B, 0x3C, 0x0C, 0x7E, 0x1C, 0xFF, 0x3C, 0xE7, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x39, 0xCF, 0x3F, 0x8E, 0x1F, 0x0C, 0x0F, 0x00, 0x00, // Code for char S + 0x0A, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T + 0x0B, 0xFF, 0x07, 0xFF, 0x1F, 0xFF, 0x3F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x3F, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00, // Code for char U + 0x0B, 0x07, 0x00, 0x3F, 0x00, 0xFF, 0x01, 0xF8, 0x0F, 0xC0, 0x3F, 0x00, 0x3E, 0xC0, 0x3F, 0xF8, 0x0F, 0xFF, 0x01, 0x3F, 0x00, 0x07, 0x00, 0x00, 0x00, // Code for char V + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x1E, 0x80, 0x07, 0x80, 0x03, 0x80, 0x07, 0x00, 0x1E, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char W + 0x0B, 0x03, 0x30, 0x0F, 0x3C, 0x1F, 0x3E, 0x3C, 0x0F, 0xF0, 0x03, 0xE0, 0x01, 0xF0, 0x03, 0x3C, 0x0F, 0x1F, 0x3E, 0x0F, 0x3C, 0x03, 0x30, 0x00, 0x00, // Code for char X + 0x0B, 0x03, 0x00, 0x0F, 0x00, 0x3F, 0x00, 0xFC, 0x00, 0xF0, 0x3F, 0xC0, 0x3F, 0xF0, 0x3F, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x03, 0x00, 0x00, 0x00, // Code for char Y + 0x0B, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x3E, 0x03, 0x3F, 0xC3, 0x33, 0xE3, 0x31, 0xF3, 0x30, 0x3F, 0x30, 0x1F, 0x30, 0x0F, 0x30, 0x03, 0x30, 0x00, 0x00, // Code for char Z + 0x09, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [ + 0x0C, 0x0E, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x00, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x1C, 0x00, 0x18, // Code for char BackSlash + 0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ] + 0x0C, 0x60, 0x00, 0x70, 0x00, 0x78, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0x70, 0x00, 0x60, 0x00, // Code for char ^ + 0x0C, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, // Code for char _ + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ` + 0x0B, 0x00, 0x1C, 0x40, 0x3E, 0x60, 0x3F, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xE0, 0x3F, 0xE0, 0x3F, 0xC0, 0x3F, 0x00, 0x00, // Code for char a + 0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xE0, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xE0, 0x3F, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00, // Code for char b + 0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x18, 0x80, 0x08, 0x00, 0x00, // Code for char c + 0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x30, 0xE0, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, // Code for char d + 0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x3B, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xE0, 0x33, 0xC0, 0x13, 0x80, 0x01, 0x00, 0x00, // Code for char e + 0x09, 0xC0, 0x00, 0xC0, 0x00, 0xFC, 0x3F, 0xFE, 0x3F, 0xFF, 0x3F, 0xC7, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f + 0x0B, 0x80, 0x03, 0xC0, 0xC7, 0xE0, 0xCF, 0xE0, 0xCE, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xEE, 0xE0, 0xFF, 0xE0, 0x7F, 0xE0, 0x3F, 0x00, 0x00, // Code for char g + 0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xE0, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, // Code for char h + 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0x30, 0xEC, 0x3F, 0xEC, 0x3F, 0xEC, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i + 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x60, 0xC0, 0xEC, 0xFF, 0xEC, 0xFF, 0xEC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j + 0x0A, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1F, 0xE0, 0x3C, 0x60, 0x38, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char k + 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l + 0x0B, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0xE0, 0x3F, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, // Code for char m + 0x0B, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, // Code for char n + 0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xE0, 0x3F, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00, // Code for char o + 0x0B, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0x60, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0xE0, 0x1C, 0xE0, 0x1F, 0xC0, 0x0F, 0x80, 0x07, 0x00, 0x00, // Code for char p + 0x0B, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1F, 0xE0, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x1C, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0x00, 0x00, // Code for char q + 0x0B, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x00, // Code for char r + 0x09, 0xC0, 0x11, 0xE0, 0x33, 0xE0, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x3F, 0x60, 0x3F, 0x40, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s + 0x09, 0x60, 0x00, 0x60, 0x00, 0xFE, 0x1F, 0xFE, 0x3F, 0xFE, 0x3F, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t + 0x0B, 0xE0, 0x0F, 0xE0, 0x1F, 0xE0, 0x3F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0x00, 0x00, // Code for char u + 0x0B, 0x60, 0x00, 0xE0, 0x01, 0xE0, 0x07, 0x80, 0x1F, 0x00, 0x3E, 0x00, 0x38, 0x00, 0x3E, 0x80, 0x1F, 0xE0, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00, // Code for char v + 0x0B, 0xE0, 0x07, 0xE0, 0x1F, 0xE0, 0x3F, 0x00, 0x3C, 0xE0, 0x1F, 0xE0, 0x0F, 0xE0, 0x1F, 0x00, 0x3C, 0xE0, 0x3F, 0xE0, 0x1F, 0xE0, 0x07, 0x00, 0x00, // Code for char w + 0x0A, 0x60, 0x30, 0xE0, 0x38, 0xE0, 0x3D, 0xC0, 0x1F, 0x80, 0x0F, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3D, 0xE0, 0x38, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char x + 0x0A, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x81, 0xE0, 0xE7, 0x80, 0xFF, 0x00, 0x7E, 0x80, 0x1F, 0xE0, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y + 0x0A, 0x60, 0x30, 0x60, 0x38, 0x60, 0x3C, 0x60, 0x3E, 0x60, 0x37, 0xE0, 0x33, 0xE0, 0x31, 0xE0, 0x30, 0x60, 0x30, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char z + 0x0A, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xFC, 0x1F, 0xFE, 0x3F, 0x7F, 0x7F, 0x07, 0x70, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00, // Code for char { + 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char | + 0x0A, 0x00, 0x00, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x07, 0x70, 0x7F, 0x7F, 0xFE, 0x3F, 0xFC, 0x1F, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char } + 0x0B, 0x10, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char ~ + 0x0B, 0x00, 0x0F, 0x80, 0x0F, 0xC0, 0x0F, 0xE0, 0x0C, 0x70, 0x0C, 0x30, 0x0C, 0x70, 0x0C, 0xE0, 0x0C, 0xC0, 0x0F, 0x80, 0x0F, 0x00, 0x0F, 0x00, 0x00 // Code for char + }; + + +//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0 +//MikroElektronika 2011 +//http://www.mikroe.com + +//GLCD FontName : Trebuchet_MS16x21 +//GLCD FontSize : 16 x 21 + +fontdatatype Trebuchet_MS16x21[] PROGMEM = { + 0x10, 0x15, 0x2E, 0x0D, + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char . + 0x0C, 0x00, 0x00, 0x10, 0x00, 0x00, 0x1E, 0x00, 0xC0, 0x1F, 0x00, 0xF0, 0x1F, 0x00, 0xFE, 0x0F, 0x80, 0xFF, 0x03, 0xF0, 0x7F, 0x00, 0xFE, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0x7F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char / + 0x10, 0x00, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0xF0, 0xFF, 0x03, 0xFC, 0xFF, 0x07, 0xFE, 0xFF, 0x0F, 0x3E, 0x80, 0x0F, 0x0F, 0x00, 0x1E, 0x07, 0x00, 0x1C, 0x07, 0x00, 0x1C, 0x07, 0x00, 0x1C, 0x0F, 0x00, 0x1E, 0x1F, 0x80, 0x0F, 0xFE, 0xFF, 0x0F, 0xFC, 0xFF, 0x07, 0xF8, 0xFF, 0x01, 0xC0, 0x7F, 0x00, // Code for char 0 + 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x78, 0x00, 0x00, 0x38, 0x00, 0x00, 0x3C, 0x00, 0x00, 0xFE, 0xFF, 0x1F, 0xFE, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1 + 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x18, 0x1E, 0x00, 0x1C, 0x0E, 0x00, 0x1F, 0x0F, 0x80, 0x1F, 0x07, 0xC0, 0x1F, 0x07, 0xF0, 0x1F, 0x07, 0xF8, 0x1D, 0x07, 0xFE, 0x1C, 0x0F, 0x3F, 0x1C, 0xFE, 0x1F, 0x1C, 0xFE, 0x0F, 0x1C, 0xFC, 0x03, 0x1C, 0xF8, 0x00, 0x1C, 0x00, 0x00, 0x1C, // Code for char 2 + 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x0E, 0x0E, 0x00, 0x0F, 0x0F, 0x00, 0x1E, 0x07, 0x00, 0x1C, 0x07, 0x07, 0x1C, 0x07, 0x07, 0x1C, 0x07, 0x07, 0x1C, 0x8F, 0x0F, 0x1E, 0xFF, 0x1F, 0x1E, 0xFE, 0xFD, 0x0F, 0xFC, 0xFD, 0x0F, 0x78, 0xF8, 0x07, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, // Code for char 3 + 0x10, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xF8, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xEF, 0x00, 0x80, 0xE7, 0x00, 0xC0, 0xE3, 0x00, 0xF0, 0xE0, 0x00, 0x78, 0xE0, 0x00, 0xFC, 0xFF, 0x1F, 0xFE, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, // Code for char 4 + 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xFF, 0x03, 0x0F, 0xFF, 0x07, 0x0E, 0xFF, 0x03, 0x1C, 0xFF, 0x01, 0x1C, 0xC7, 0x01, 0x1C, 0xC7, 0x01, 0x1C, 0xC7, 0x01, 0x1E, 0xC7, 0x03, 0x1F, 0xC7, 0xFF, 0x0F, 0x87, 0xFF, 0x0F, 0x07, 0xFF, 0x07, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, // Code for char 5 + 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x80, 0xFF, 0x03, 0xE0, 0xFF, 0x07, 0xF0, 0xFF, 0x0F, 0xF8, 0x0F, 0x1E, 0x7C, 0x07, 0x1C, 0x3E, 0x07, 0x1C, 0x1E, 0x07, 0x1C, 0x0F, 0x07, 0x1C, 0x07, 0x0F, 0x1E, 0x02, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFC, 0x07, 0x00, 0xF0, 0x01, // Code for char 6 + 0x10, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x18, 0x07, 0x00, 0x1E, 0x07, 0xC0, 0x1F, 0x07, 0xF0, 0x1F, 0x07, 0xFC, 0x0F, 0x07, 0xFF, 0x01, 0xC7, 0x7F, 0x00, 0xF7, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0xFF, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x03, 0x00, 0x00, // Code for char 7 + 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x78, 0xF8, 0x07, 0xFC, 0xFD, 0x0F, 0xFE, 0xFF, 0x0F, 0xFF, 0x1F, 0x1E, 0x8F, 0x0F, 0x1C, 0x07, 0x07, 0x1C, 0x07, 0x0F, 0x1C, 0x8F, 0x0F, 0x1C, 0xFF, 0x3F, 0x1E, 0xFE, 0xFD, 0x0F, 0xFE, 0xFD, 0x0F, 0x78, 0xF0, 0x07, 0x00, 0xE0, 0x03, // Code for char 8 + 0x0F, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x08, 0x0F, 0x1E, 0x1C, 0x07, 0x1C, 0x1E, 0x07, 0x1C, 0x0F, 0x07, 0x9C, 0x0F, 0x07, 0xDC, 0x07, 0x0F, 0xFE, 0x03, 0xFE, 0xFF, 0x01, 0xFC, 0xFF, 0x00, 0xF8, 0x3F, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, // Code for char 9 + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x0C, 0xC0, 0x03, 0x1E, 0xC0, 0x03, 0x1E, 0x80, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Code for char : + }; + + + diff --git a/RX_FSK/src/Display.cpp b/RX_FSK/src/Display.cpp new file mode 100644 index 0000000..c076870 --- /dev/null +++ b/RX_FSK/src/Display.cpp @@ -0,0 +1,1616 @@ +#include "../features.h" +#include +#include +#include +#include +#include +#include "Display.h" +#include "Sonde.h" + +int readLine(Stream &stream, char *buffer, int maxlen); + +extern const char *version_name; +extern const char *version_id; + +#include "fonts/FreeMono9pt7b.h" +#include "fonts/FreeMono12pt7b.h" +#include "fonts/FreeSans9pt7b.h" +#include "fonts/FreeSans12pt7b.h" +#include "fonts/FreeSans18pt7b.h" +#include "fonts/Picopixel.h" +#include "fonts/Terminal11x16.h" + +extern Sonde sonde; + +extern AXP20X_Class axp; +extern bool axp192_found; +extern SemaphoreHandle_t axpSemaphore; + +extern xSemaphoreHandle globalLock; +#define SPI_MUTEX_LOCK() \ + do \ + { \ + } while (xSemaphoreTake(globalLock, portMAX_DELAY) != pdPASS) +#define SPI_MUTEX_UNLOCK() xSemaphoreGive(globalLock) + +struct GpsPos gpsPos; + +//SPIClass spiDisp(HSPI); + +byte myIP_tiles[8*11]; +static uint8_t ap_tile[8]={0x00,0x04,0x22,0x92, 0x92, 0x22, 0x04, 0x00}; + +static const uint8_t font[10][5]={ + 0x3E, 0x51, 0x49, 0x45, 0x3E, // 0 + 0x00, 0x42, 0x7F, 0x40, 0x00, // 1 + 0x42, 0x61, 0x51, 0x49, 0x46, // 2 + 0x21, 0x41, 0x45, 0x4B, 0x31, // 3 + 0x18, 0x14, 0x12, 0x7F, 0x10, // 4 + 0x27, 0x45, 0x45, 0x45, 0x39, // 5 + 0x3C, 0x4A, 0x49, 0x49, 0x30, // 6 + 0x01, 0x01, 0x79, 0x05, 0x03, // 7 + 0x36, 0x49, 0x49, 0x49, 0x36, // 8 + 0x06, 0x49, 0x39, 0x29, 0x1E }; // 9; .=0x40 + + +static unsigned char kmh_tiles[] U8X8_PROGMEM = { + 0x1F, 0x04, 0x0A, 0x11, 0x00, 0x1F, 0x02, 0x04, 0x42, 0x3F, 0x10, 0x08, 0xFC, 0x22, 0x20, 0xF8 + }; +static unsigned char ms_tiles[] U8X8_PROGMEM = { + 0x1F, 0x02, 0x04, 0x02, 0x1F, 0x40, 0x20, 0x10, 0x08, 0x04, 0x12, 0xA8, 0xA8, 0xA4, 0x40, 0x00 + }; +static unsigned char stattiles[5][4] = { + 0x00, 0x1F, 0x00, 0x00 , // | == ok + 0x00, 0x10, 0x10, 0x00 , // . == no header found + 0x1F, 0x15, 0x15, 0x00 , // E == decode error + 0x00, 0x00, 0x00, 0x00 , // ' ' == unknown/unassigned + 0x07, 0x05, 0x07, 0x00 }; // ° = rx ok, but no valid position +static unsigned char stattilesXL[5][5] = { + 0x00, 0x7F, 0x00, 0x00, 0x00, // | == ok + 0x00, 0x40, 0x40, 0x00, 0x00, // . == no header found + 0x7F, 0x49, 0x49, 0x49, 0x00, // E == decode error + 0x00, 0x00, 0x00, 0x00, 0x00, // ' ' == unknown/unassigned + 0x07, 0x05, 0x07, 0x00, 0x00 }; // ° = rx ok, but no valid position (not yet used?) + + +//static uint8_t halfdb_tile[8]={0x80, 0x27, 0x45, 0x45, 0x45, 0x39, 0x00, 0x00}; + +static uint8_t halfdb_tile1[8]={0x00, 0x38, 0x28, 0x28, 0x28, 0xC8, 0x00, 0x00}; +static uint8_t halfdb_tile2[8]={0x00, 0x11, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00}; + +//static uint8_t empty_tile[8]={0x80, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x00}; + +static uint8_t empty_tile1[8]={0x00, 0xF0, 0x88, 0x48, 0x28, 0xF0, 0x00, 0x00}; +static uint8_t empty_tile2[8]={0x00, 0x11, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00}; + +//static uint8_t gps_tile[8]={0x3E, 0x77, 0x63, 0x77, 0x3E, 0x1C, 0x08, 0x00}; +static uint8_t gps_tile[8]={0x00, 0x0E, 0x1F, 0x3B, 0x71, 0x3B, 0x1F, 0x0E}; +static uint8_t nogps_tile[8]={0x41, 0x22, 0x14, 0x08, 0x14, 0x22, 0x41, 0x00}; + +static uint8_t deg_tile[8]={0x00, 0x06,0x09, 0x09, 0x06, 0x00, 0x00, 0x00}; + + +/* Description of display layouts. + * for each display, the content is described by a DispEntry structure + * timeout values are in milliseconds, for view activ, rx signal present, no rx signal present + * for each displey, actions (switching to different sonde or different view) can be defined + * based on key presses or on expired timeouts + */ +DispEntry searchLayout[] = { + {0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawText, "Scan:"}, + {0, 8, FONT_LARGE, -1, 0xFFFF, 0, disp.drawType, NULL}, + {3, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawFreq, " MHz"}, + {5, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawSite, "l"}, + {7, 5, 0, -1, 0xFFFF, 0, disp.drawIP, NULL}, + {-1, -1, -1, 0, 0, 0, NULL, NULL}, +}; +int16_t searchTimeouts[] = { -1, 0, 0 }; +uint8_t searchActions[] = { + ACT_NONE, + ACT_DISPLAY_DEFAULT, ACT_NONE, ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI, + ACT_NONE, ACT_NONE, ACT_NONE, ACT_NONE, + ACT_NONE, ACT_DISPLAY_DEFAULT, ACT_NEXTSONDE}; +DispEntry legacyLayout[] = { + {0, 5, FONT_SMALL, -1, 0xFFFF, 0, disp.drawFreq, " MHz"}, + {1, 8, FONT_SMALL, -1, 0xFFFF, 0, disp.drawAFC, NULL}, + {0, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawType, NULL}, + {1, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawID, NULL}, + {2, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLat, NULL}, + {4, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLon, NULL}, + {2, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawAlt, NULL}, + {3, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawHS, NULL}, + {4, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVS, NULL}, + {6, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawRSSI, NULL}, + {6, 7, 0, -1, 0xFFFF, 0, disp.drawQS, NULL}, + {7, 5, 0, -1, 0xFFFF, 0, disp.drawIP, NULL}, + {-1, -1, -1, 0, 0, 0, NULL, NULL}, +}; +int16_t legacyTimeouts[] = { -1, -1, 20000 }; +uint8_t legacyActions[] = { + ACT_NONE, + ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI, + ACT_DISPLAY(2), ACT_NONE, ACT_NONE, ACT_NONE, + ACT_NONE, ACT_NONE, ACT_DISPLAY(0)}; +DispEntry fieldLayout[] = { + {2, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLat, NULL}, + {4, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLon, NULL}, + {3, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawHS, NULL}, + {4, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVS, NULL}, + {0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawID, NULL}, + {6, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawAlt, NULL}, + {6, 7, 0, -1, 0xFFFF, 0, disp.drawQS, NULL}, + {-1, -1, -1, 0, 0, 0, NULL, NULL}, +}; +int16_t fieldTimeouts[] = { -1, -1, -1 }; +uint8_t fieldActions[] = { + ACT_NONE, + ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI, + ACT_DISPLAY(4), ACT_NONE, ACT_NONE, ACT_NONE, + ACT_NONE, ACT_NONE, ACT_NONE}; +DispEntry field2Layout[] = { + {2, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLat, NULL}, + {4, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLon, NULL}, + {1, 12, FONT_SMALL, -1, 0xFFFF, 0, disp.drawType, NULL}, + {0, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawFreq, ""}, + {3, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawHS, NULL}, + {4, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVS, NULL}, + {0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawID, NULL}, + {6, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawAlt, NULL}, + {6, 7, 0, -1, 0xFFFF, 0, disp.drawQS, NULL}, + {-1, -1, -1, 0, 0, 0, NULL, NULL}, +}; +uint8_t field2Actions[] = { + ACT_NONE, + ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI, + ACT_DISPLAY(1), ACT_NONE, ACT_NONE, ACT_NONE, + ACT_NONE, ACT_NONE, ACT_NONE}; +DispEntry gpsLayout[] = { + {0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawID, NULL}, + {2, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawLat, NULL}, + {3, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawLon, NULL}, + {4, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawAlt, NULL}, + {6, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawGPS, "V"}, + //{6, 1, FONT_SMALL, disp.drawGPS, "A"}, + //{6, 8, FONT_SMALL, disp.drawGPS, "O"}, + {7, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawGPS, "D"}, + {7, 8, FONT_SMALL, -1, 0xFFFF, 0, disp.drawGPS, "I"}, + {-1, -1, -1, 0, 0, 0, NULL, NULL}, +}; +uint8_t gpsActions[] = { + ACT_NONE, + ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI, + ACT_DISPLAY(1), ACT_NONE, ACT_NONE, ACT_NONE, + ACT_NONE, ACT_NONE, ACT_NONE}; + +DispInfo staticLayouts[5] = { + { searchLayout, searchActions, searchTimeouts, "StaticSearch" }, + { legacyLayout, legacyActions, legacyTimeouts, "StaticLegacy" }, + { fieldLayout, fieldActions, fieldTimeouts, "StaticField1" }, + { field2Layout, field2Actions, fieldTimeouts, "StaticFiel2" }, + { gpsLayout, gpsActions, fieldTimeouts, "StaticGPS" } }; + + +/////////////// Wrapper code for various display + +static void utf2latin15(const char *src, char *dst, int dstlen) { + static uint8_t decoderState = 0; + static uint16_t decoderBuffer; + + while(uint8_t c = *src++) { + if( (c&0x80)==0 || c==0xB0) { // 7bit code point (or special case: old °sign) + decoderState = 0; + *dst++ = c; + continue; + } + if(decoderState==0) { + if((c&0xE0)==0xC0) { // 11bit code point + decoderBuffer = ((c&0x1F)<<6); // first 5 bit + decoderState = 1; + } else if ((c&0xF0)==0xE0) { // 16 bit code point + decoderBuffer = ((c&0x0f)<<12); // first 4 bit + decoderState = 2; + } + } else { + decoderState --; + if(decoderState == 1) + decoderBuffer |= ((c&0x3f)<<6); // next 6 bit of 16 bit code point + else if (decoderState==0) { + decoderBuffer |= (c&0x3f); // last 6 bit of code point$a + } + } + if(decoderState==0) { + // emit encoded byte if possible + switch(decoderBuffer) { + case 0x0152: decoderBuffer=0xbc; break; + case 0x0153: decoderBuffer=0xbd; break; + case 0x0160: decoderBuffer=0xa6; break; + case 0x0161: decoderBuffer=0xa8; break; + case 0x0178: decoderBuffer=0xbe; break; + case 0x017D: decoderBuffer=0xb4; break; + case 0x017E: decoderBuffer=0xb8; break; + case 0x20AC: decoderBuffer=0xa4; break; + } + + if(decoderBuffer>0xff) decoderBuffer=0x7f; + else if(decoderBuffer>0x7f) decoderBuffer-=0x20; + *dst++ = (uint8_t)decoderBuffer; + } + + } + *dst = 0; +} + + +// ALLFONTS requires 30k extra flash memory... for now there is still enough space :) +//#define ALLFONTS 1 +static const uint8_t *fl[] = { + u8x8_font_chroma48medium8_r, // 0 ** default small + u8x8_font_7x14_1x2_f, // 1 ** default large +#ifdef ALLFONTS + u8x8_font_amstrad_cpc_extended_f, // 2 + u8x8_font_5x7_f, // 3 + u8x8_font_5x8_f, // 4 + u8x8_font_8x13_1x2_f, // 5 + u8x8_font_8x13B_1x2_f, // 6 + u8x8_font_7x14B_1x2_f, // 7 + u8x8_font_artossans8_r, // 8 + u8x8_font_artosserif8_r, // 9 + u8x8_font_torussansbold8_r, // 10 + u8x8_font_victoriabold8_r, // 11 + u8x8_font_victoriamedium8_r, // 12 + u8x8_font_pressstart2p_f, // 13 + u8x8_font_pcsenior_f, // 14 + u8x8_font_pxplusibmcgathin_f, // 15 + u8x8_font_pxplusibmcga_f, // 16 + u8x8_font_pxplustandynewtv_f, // 17 +#endif +}; + + +void U8x8Display::begin() { + Serial.printf("Init SSD1306 display %d %d\n", sonde.config.oled_scl, sonde.config.oled_sda); + //u8x8 = new U8X8_SSD1306_128X64_NONAME_SW_I2C(/* clock=*/ sonde.config.oled_scl, /* data=*/ sonde.config.oled_sda, /* reset=*/ sonde.config.oled_rst); // Unbuffered, basic graphics, software I2C + if (_type==2) { + u8x8 = new U8X8_SH1106_128X64_NONAME_HW_I2C(/* reset=*/ sonde.config.oled_rst, /* clock=*/ sonde.config.oled_scl, /* data=*/ sonde.config.oled_sda); // Unbuffered, basic graphics, software I2C + } else { //__type==0 or anything else + u8x8 = new U8X8_SSD1306_128X64_NONAME_HW_I2C(/* reset=*/ sonde.config.oled_rst, /* clock=*/ sonde.config.oled_scl, /* data=*/ sonde.config.oled_sda); // Unbuffered, basic graphics, software I2C + } + u8x8->begin(); + if(sonde.config.oled_orient==3) u8x8->setFlipMode(true); + if(sonde.config.dispcontrast>=0) u8x8->setContrast(sonde.config.dispcontrast); + + fontlist = fl; + nfonts = sizeof(fl)/sizeof(uint8_t *); + Serial.printf("Size of font list is %d\n", nfonts); +} + +void U8x8Display::clear() { + u8x8->clear(); +} + +void U8x8Display::setContrast(uint8_t contrast) { + u8x8->setContrast(contrast); +} + + +// For u8x8 oled display: 0=small font, 1=large font 7x14 +void U8x8Display::setFont(uint8_t fontindex) { + if(fontindex>=nfonts) fontindex=0; // prevent overflow + u8x8->setFont( fontlist[fontindex] ); +} + +void U8x8Display::getDispSize(uint8_t *height, uint8_t *width, uint8_t *lineskip, uint8_t *colskip) { + // TODO: maybe we should decided depending on font size (single/double?) + if(height) *height = 8; + if(width) *width = 16; + if(lineskip) *lineskip = 1; + if(colskip) *colskip = 1; +} + +void U8x8Display::drawString(uint16_t x, uint16_t y, const char *s, int16_t width, uint16_t fg, uint16_t bg) { + char buf[50]; + utf2latin15(s, buf, 50); + if(width!=WIDTH_AUTO && width>0) { + for(int l = strlen(buf); ldrawString(x, y, buf); +} + +void U8x8Display::drawTile(uint16_t x, uint16_t y, uint8_t cnt, uint8_t *tile_ptr) { + u8x8->drawTile(x, y, cnt, tile_ptr); +} + +void U8x8Display::drawBitmap(uint16_t x1, uint16_t y1, const uint16_t* bitmap, int16_t w, int16_t h) { + // not supported +} +void U8x8Display::drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color, bool fill) { + // not supported (yet) +} + +void U8x8Display::welcome() { + u8x8->clear(); + setFont(FONT_LARGE); + drawString(8 - strlen(version_name) / 2, 0, version_name); + drawString(8 - strlen(version_id) / 2, 2, version_id); + setFont(FONT_SMALL); + drawString(0, 4, "RS41/92,DFM,M1&2"); + drawString(0, 6, " by Vigor & Xav "); +} + +static String previp; +void U8x8Display::drawIP(uint16_t x, uint16_t y, int16_t width, uint16_t fg, uint16_t bg) { + if(!previp.equals(sonde.ipaddr)) { + // ip address has changed + // create tiles + memset(myIP_tiles, 0, 11*8); + int len = sonde.ipaddr.length(); + const char *ip = sonde.ipaddr.c_str(); + int pix = (len-3)*6+6; + int tp = 80-pix+8; + if(sonde.isAP) memcpy(myIP_tiles+(tp<16?0:8), ap_tile, 8); + for(int i=0; idrawTile(x, y, 11, myIP_tiles); +} + +// len must be multiple of 2, size is fixed for u8x8 display +void U8x8Display::drawQS(uint16_t x, uint16_t y, uint8_t len, uint8_t /*size*/, uint8_t *stat, uint16_t fg, uint16_t bg) { + for(int i=0; isize, SPI_FLASH_MMAP_DATA, (const void **)&data, &handle); + if( err != ESP_OK ) { + Serial.println("mmap not OK\n"); + return; + } + Serial.println("font partition successfully mmaped"); + // do relocation stuff.... + const GFXfont **fptr = (const GFXfont **)data; + if((uint32_t)*fptr != 0x544E4F46) { // FONT + Serial.println("No font data in font partition"); + return; + } + int n=0; + for(const GFXfont **g=fptr; *g!=NULL; g++) n++; + Serial.printf("There a %d fonts in the font partition\n", n); + if(n>MAXFONT) n=MAXFONT; + GFXfont **newgfl = (GFXfont **)malloc( n*sizeof(GFXfont) + MAXFONT*sizeof(GFXfont *) ); + if(!newgfl) { + Serial.println("no memory for gfx fonts"); + return; + } + GFXfont *fonts = (GFXfont *)(((char *)newgfl) + MAXFONT*sizeof(GFXfont *)); + // create GFXfont list + for(int i=0; ibitmap = newgfl[i]->bitmap + (uint32_t)data; // relocate bitmap pointer to mmap partition + newgfl[i]->glyph = (GFXglyph *)( ((char *)newgfl[i]->glyph) + (uint32_t)data ); + Serial.printf("font i: gfl[i] is %p, gfl[i]->bitmap is %p, gfl[i]->glyph is %p\n", newgfl[i], newgfl[i]->bitmap, newgfl[i]->glyph); + } + gfl = (const GFXfont **)newgfl; + ngfx = n; + } +} + +struct gfxoffset_t { + uint8_t yofs, yclear; +}; +#if 0 +///// **** this is now calculated automatically +// +// obtained as max offset from font (last column) and maximum height (3rd column) in glyphs +// first value: offset: max offset from font glyphs (last column * (-1)) (check /, \, `, $)` +// yclear:max height: max of (height in 3rd column) + (yofs + 6th column) (check j) +const struct gfxoffset_t gfxoffsets[]={ + { 16, 18}, + { 16, 18}, + { 13, 18 }, // 17+13-12 "j" + { 17, 23 }, // 23+17-17 + { 4, 6}, // 6+4-4 + { 25, 34 }, // 34 25 -25 +}; +#endif + +struct gfxoffset_t gfxoffsets[MAXFONT]; + +void calc_gfx_offsets() { + for(int i=0; iglyph; + for(int j=0; j<=gfl[i]->last-gfl[i]->first; j++) { + if(g[j].yOffset < bofs) bofs = g[j].yOffset; // yOffset are negative values + } + gfxoffsets[i].yofs = -bofs; + // find max. height (yofs + yOffset + height) -- note that yOffset is negative + int hgt = 0; + for(int j=0; j<=gfl[i]->last-gfl[i]->first; j++) { + int h = gfxoffsets[i].yofs + g[j].yOffset + g[j].height; + if(h>hgt) hgt=h; + } + gfxoffsets[i].yclear = hgt; + printf("Font %d: yofs=%d, yclear=%d\n", i, gfxoffsets[i].yofs, gfxoffsets[i].yclear); + } +} + +#define TFT_LED 0 // 0 if wired to +5V directly +#define TFT_BRIGHTNESS 100 // Initial brightness of TFT backlight (optional) + +Arduino_DataBus *bus; + + + + + +#include +#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr)) + + +/////////////// + + +char Display::buf[17]; +char Display::lineBuf[Display::LINEBUFLEN]; + +RawDisplay *Display::rdis = NULL; + +//TODO: maybe merge with initFromFile later? +void Display::init() { + Serial.printf("disptype is %d\n",sonde.config.disptype); + if(sonde.config.disptype==0 || sonde.config.disptype==2) { + rdis = new U8x8Display(sonde.config.disptype); + } + Serial.println("Display created"); + rdis->begin(); + delay(100); + Serial.println("Display initialized"); + rdis->clear(); + dispstate = 1; // display active by default +} + + +Display::Display() { + layouts = staticLayouts; + setLayout(0); +} + +#define MAXSCREENS 20 +#define DISP_ACTIONS_N 12 +#define DISP_TIMEOUTS_N 3 + +void Display::replaceLayouts(DispInfo *newlayouts, int nnew) { + if(nnew<1) return; // no new layouts => ignore + + // remember old layouts + DispInfo *old = layouts; + + // assign new layouts and current layout + Serial.printf("replaceLayouts: idx=%d n(new)=%d\n", layoutIdx, nLayouts); + layouts = newlayouts; + nLayouts = nnew; + if(layoutIdx >= nLayouts) layoutIdx = 0; + layout = layouts+layoutIdx; + + // Make it unlikely that anyone else is still using previous layouts + delay(500); + + // and release memory not used any more + if(old==staticLayouts) return; + for(int i=0; ide = (DispEntry *)mem; + mem += (entries+1) * sizeof(DispEntry); + + d->actions = (uint8_t *)mem; + mem += DISP_ACTIONS_N * sizeof(uint8_t); + d->actions[0] = ACT_NONE; + + d->timeouts = (int16_t *)mem; + + d->label = label; + Serial.printf("%s: alloc %d bytes (%d entries) for %p (addr=%p)\n", label, totalsize, entries, d, d->de); + return 0; +} + +uint16_t encodeColor(uint32_t col) { + return (col>>19) << 11 | ((col>>10)&0x3F) << 5 | ((col>>3)&0x1F); +} +uint16_t encodeColor(char *colstr) { + uint32_t col; + int res=sscanf(colstr, "%" SCNx32, &col); + if(res!=1) return 0xffff; + return encodeColor(col); +} + +void Display::parseDispElement(char *text, DispEntry *de) +{ + char type = *text; + if(type>='A'&&type<='Z') { + type += 32; // lc + de->fmt = fontlar; + } else { + de->fmt = fontsma; + } + de->fg = colfg; + de->bg = colbg; + switch(type) { + case 'l': + de->func = disp.drawLat; break; + case 'o': + de->func = disp.drawLon; break; + case 'a': + de->func = disp.drawAlt; break; + case 'h': + de->func = disp.drawHS; + de->extra = text[1]?strdup(text+1):NULL; break; + case 'v': + de->func = disp.drawVS; + de->extra = text[1]?strdup(text+1):NULL; break; + case 'i': + de->func = disp.drawID; + de->extra = strdup(text+1); + break; + case 'q': + { + struct StatInfo *statinfo = (struct StatInfo *)malloc(sizeof(struct StatInfo)); + // maybe enable more flexible configuration? + statinfo->size=3; + statinfo->len=18; + if(text[1]=='4') statinfo->size = 4; + + de->extra = (const char *)statinfo; + de->func = disp.drawQS; + } + break; + case 't': + de->func = disp.drawType; break; + case 'c': + de->func = disp.drawAFC; break; + case 'f': + de->func = disp.drawFreq; + de->extra = strdup(text+1); + //Serial.printf("parsing 'f' entry: extra is '%s'\n", de->extra); + break; + case 'm': + de->func = disp.drawTelemetry; + de->extra = strdup(text+1); + break; + case 'n': + // IP address / small always uses tiny font on TFT for backward compatibility + // Large font can be used arbitrarily + if(de->fmt==fontsma) de->fmt=0; + de->func = disp.drawIP; + de->extra = strdup(text+1); + break; + case 's': + de->func = disp.drawSite; + de->extra = strdup(text+1); + break; + case 'k': + de->func = disp.drawKilltimer; + de->extra = strdup(text+1); + break; + case 'g': + de->func = disp.drawGPS; + if(text[1]=='0') { + // extended configuration for arrow... + struct CircleInfo *circinfo = (struct CircleInfo *)malloc(sizeof(struct CircleInfo)); +#if 1 + circinfo->type = '0'; + circinfo->top = text[2]; + circinfo->arr = text[3]; + circinfo->bul = text[4]; + char *ptr=text+5; + while(*ptr && *ptr!=',') ptr++; ptr++; + // next: radius + circinfo->radius = atoi(ptr); + while(*ptr && *ptr!=',') ptr++; ptr++; + circinfo->fgcol = encodeColor(ptr); + while(*ptr && *ptr!=',') ptr++; ptr++; + circinfo->bgcol = encodeColor(ptr); +#else + circinfo->type = '0'; + circinfo->top = 'N'; + circinfo->bul = 'S'; + circinfo->arr = 'C'; + circinfo->radius = 50; + circinfo->fgcol = 0xfe80; + circinfo->bgcol = 0x0033; +#endif + while(*ptr && *ptr!=',') ptr++; ptr++; + circinfo->awidth = atoi(ptr); + while(*ptr && *ptr!=',') ptr++; ptr++; + circinfo->acol = encodeColor(ptr); + while(*ptr && *ptr!=',') ptr++; ptr++; + circinfo->brad = atoi(ptr); + while(*ptr && *ptr!=',') ptr++; ptr++; + circinfo->bcol = encodeColor(ptr); + de->extra = (char *)circinfo; + } else { + de->extra = strdup(text+1); + //Serial.printf("parsing 'g' entry: extra is '%s'\n", de->extra); + } + break; + case 'r': + de->func = disp.drawRSSI; break; + case 'x': + de->func = disp.drawText; + de->extra = strdup(text+1); + break; + case 'b': + de->func = disp.drawBatt; + de->extra = strdup(text+1); + break; + default: + Serial.printf("Unknown element: %c\n", type); + break; + } +} + +static uint8_t ACTION(char c) { + switch(c) { + case 'D': + return ACT_DISPLAY_DEFAULT; + case 'F': + return ACT_DISPLAY_SPECTRUM; + case 'W': + return ACT_DISPLAY_WIFI; + case '+': + return ACT_NEXTSONDE; + case '#': + return ACT_NONE; + case '>': + return ACT_DISPLAY_NEXT; + default: + if(c>='0'&&c<='9') + return ACT_DISPLAY(c-'0'); + // Hack, will change later to better syntax + if(c>='a'&&c<='z') + return ACT_ADDFREQ(c-'a'+2); + } + return ACT_NONE; +} + + +int Display::countEntries(File f) { + int pos = f.position(); + int n = 0; + while(1) { + //String line = readLine(f); //f.readStringUntil('\n'); + //line.trim(); + //const char *c=line.c_str(); + readLine(f, lineBuf, LINEBUFLEN); + const char *c = trim(lineBuf); + if(*c=='#') continue; + if(*c>='0'&&*c<='9') n++; + if(strchr(c,'=')) continue; + break; + } + f.seek(pos, SeekSet); + //Serial.printf("Counted %d entries\n", n); + return n; +} + +int Display::getScreenIndex(int index) { + if(index!=0) return index; + switch(sonde.config.disptype) { + case 1: // ILI9225 + index = 2; // landscape mode (orient=1/3) + if( (sonde.config.oled_orient&0x01)==0 ) index++; // portrait mode (0/2) + break; + case 3: // ILI9341 + case 4: // ILI9342 + case 5: + index = 4; // landscape mode (orient=1/3) + if( (sonde.config.oled_orient&0x01)==0 ) index++; // portrait mode (0/2) + break; + case 0: case 2: // small OLED display (SD1306/SH1106) + default: + index = 1; break; + } + return index; +} +void Display::initFromFile(int index) { + File d; + char file[20]; + + index = getScreenIndex(index); // auto selection for index==0 + snprintf(file, 20, "/screens%d.txt", index); + Serial.printf("Reading %s\n", file); + d = SPIFFS.open(file, "r"); + if(!d || d.available()==0 ) { Serial.printf("%s not found\n", file); return; } + + DispInfo *newlayouts = (DispInfo *)malloc(MAXSCREENS * sizeof(DispInfo)); + if(!newlayouts) { + Serial.println("Init from file: FAILED, not updating layouts"); + return; + } + memset(newlayouts, 0, MAXSCREENS * sizeof(DispInfo)); + + // default values + xscale=13; + yscale=22; + fontsma=0; + fontlar=1; + // default color + colfg = 0xffff; // white; only used for ILI9225 + colbg = 0; // black; only used for ILI9225 + int idx = -1; + int what = -1; + int entrysize; + Serial.printf("Reading from screen config: available=%d\n",d.available()); + while(d.available()) { + //Serial.printf("Unused stack: %d\n", uxTaskGetStackHighWaterMark(0)); + const char *ptr; + readLine(d, lineBuf, LINEBUFLEN); + const char *s = trim(lineBuf); + // String line = readLine(d); + // line.trim(); + // const char *s = line.c_str(); + DebugPrintf(DEBUG_SPARSER, "Line: '%s'\n", s); + if(*s == '#') continue; // ignore comments + switch(what) { + case -1: // wait for start of screen (@) + { + if(*s != '@') { + if(*s==0 || *s==10 || *s==13) continue; + Serial.printf("Illegal start of screen: %s\n", s); + continue; + } + char *label = strdup(s+1); + entrysize = countEntries(d); + DebugPrintf(DEBUG_SPARSER,"Reading entry with %d elements\n", entrysize); + idx++; + int res = allocDispInfo(entrysize, &newlayouts[idx], label); + if(res<0) { + Serial.println("Error allocating memory for disp info"); + continue; + } + what = 0; + } + break; + default: // parse content... (additional data or line `what`) + if(strncmp(s,"timer=",6)==0) { // timer values + char t1[10],t2[10],t3[10]; + sscanf(s+6, "%5[0-9a-zA-Z-] , %5[0-9a-zA-Z-] , %5[0-9a-zA-Z-]", t1, t2, t3); + DebugPrintf(DEBUG_SPARSER,"timers are %s, %s, %s\n", t1, t2, t3); + newlayouts[idx].timeouts[0] = (*t1=='n'||*t1=='N')?sonde.config.norx_timeout:atoi(t1); + newlayouts[idx].timeouts[1] = (*t2=='n'||*t2=='N')?sonde.config.norx_timeout:atoi(t2); + newlayouts[idx].timeouts[2] = (*t3=='n'||*t3=='N')?sonde.config.norx_timeout:atoi(t3); + // Code later assumes milliseconds, but config.txt and screens.txt use values in seconds + if(newlayouts[idx].timeouts[0]>0) newlayouts[idx].timeouts[0]*=1000; + if(newlayouts[idx].timeouts[1]>0) newlayouts[idx].timeouts[1]*=1000; + if(newlayouts[idx].timeouts[2]>0) newlayouts[idx].timeouts[2]*=1000; + //sscanf(s+6, "%hd,%hd,%hd", newlayouts[idx].timeouts, newlayouts[idx].timeouts+1, newlayouts[idx].timeouts+2); + //Serial.printf("timer values: %d, %d, %d\n", newlayouts[idx].timeouts[0], newlayouts[idx].timeouts[1], newlayouts[idx].timeouts[2]); + } else if(strncmp(s, "key1action=",11)==0) { // key 1 actions + char c1,c2,c3,c4; + sscanf(s+11, "%c,%c,%c,%c", &c1, &c2, &c3, &c4); + newlayouts[idx].actions[1] = ACTION(c1); + newlayouts[idx].actions[2] = ACTION(c2); + newlayouts[idx].actions[3] = ACTION(c3); + newlayouts[idx].actions[4] = ACTION(c4); + } else if(strncmp(s, "key2action=",11)==0) { // key 2 actions + char c1,c2,c3,c4; + sscanf(s+11, "%c,%c,%c,%c", &c1, &c2, &c3, &c4); + newlayouts[idx].actions[5] = ACTION(c1); + newlayouts[idx].actions[6] = ACTION(c2); + newlayouts[idx].actions[7] = ACTION(c3); + newlayouts[idx].actions[8] = ACTION(c4); + //Serial.printf("parsing key2action: %c %c %c %c\n", c1, c2, c3, c4); + } else if(strncmp(s, "timeaction=",11)==0) { // timer actions + char c1,c2,c3; + sscanf(s+11, "%c,%c,%c", &c1, &c2, &c3); + newlayouts[idx].actions[9] = ACTION(c1); + newlayouts[idx].actions[10] = ACTION(c2); + newlayouts[idx].actions[11] = ACTION(c3); + } else if(strncmp(s, "fonts=",6)==0) { // change font + sscanf(s+6, "%d,%d", &fontsma, &fontlar); + } else if(strncmp(s, "scale=",6)==0) { // change line->pixel scaling for ILI9225 display + sscanf(s+6, "%d,%d", &yscale, &xscale); + } else if(strncmp(s, "color=",6)==0) { // + int res; + uint32_t fg,bg; + res=sscanf(s+6, "%" SCNx32 ",%" SCNx32, &fg, &bg); + colfg = (fg>>19) << 11 | ((fg>>10)&0x3F) << 5 | ((fg>>3)&0x1F); + if(res==2) { + colbg = (bg>>19) << 11 | ((bg>>10)&0x3F) << 5 | ((bg>>3)&0x1F); + } + } else if( (ptr=strchr(s, '=')) ) { // one line with some data... + float x,y,w; + int n; + char text[61]; + n=sscanf(s, "%f,%f,%f", &y, &x, &w); + sscanf(ptr+1, "%60[^\r\n]", text); + if(sonde.config.disptype!=0 && sonde.config.disptype!=2) { + x*=xscale; y*=yscale; w*=xscale; + } + newlayouts[idx].de[what].x = x; + newlayouts[idx].de[what].y = y; + newlayouts[idx].de[what].width = n>2 ? w : WIDTH_AUTO; + parseDispElement(text, newlayouts[idx].de+what); + DebugPrintf(DEBUG_SPARSER,"entry at %d,%d width=%d font %d, color=%x,%x\n", (int)x, (int)y, newlayouts[idx].de[what].width, newlayouts[idx].de[what].fmt, + newlayouts[idx].de[what].fg, newlayouts[idx].de[what].bg); + if(newlayouts[idx].de[what].func == disp.drawGPS) { + newlayouts[idx].usegps = GPSUSE_BASE|GPSUSE_DIST|GPSUSE_BEARING; // just all for now + } + what++; + newlayouts[idx].de[what].func = NULL; + } else { + what=-1; + } + break; + } + } + replaceLayouts(newlayouts, idx+1); +} + +void Display::circ(uint16_t *bm, int16_t size, int16_t x0, int16_t y0, int16_t r, uint16_t fg, boolean fill, uint16_t bg) { + // draw circle + int x = 0; + int y = r; + int ddF_x = 1; + int ddF_y = -2 * r; + int f = 1-r; + bm[x0 + (y0+r)*size] = fg; + bm[x0 + (y0-r)*size] = fg; + bm[x0+r + y0*size] = fg; + bm[x0-r + y0*size] = fg; + if(fill) { for(int yy=-y+1; yy=0) { y--; ddF_y += 2; f += ddF_y; newy = true; } + x++; ddF_x += 2; f += ddF_x; + bm[ (x0+x) + (y0+y)*size ] = fg; + bm[ (x0-x) + (y0+y)*size ] = fg; + bm[ (x0+x) + (y0-y)*size ] = fg; + bm[ (x0-x) + (y0-y)*size ] = fg; + bm[ (x0+y) + (y0+x)*size ] = fg; + bm[ (x0-y) + (y0+x)*size ] = fg; + bm[ (x0+y) + (y0-x)*size ] = fg; + bm[ (x0-y) + (y0-x)*size ] = fg; + if(fill) { + if(newy) { + for(int xx = -x+1; xx=nLayouts) newidx = 0; + layout = &layouts[newidx]; + layoutIdx = newidx; +} + +void Display::drawString(DispEntry *de, const char *str) { + rdis->drawString(de->x, de->y, str, de->width, de->fg, de->bg); +} + +void Display::drawLat(DispEntry *de) { + rdis->setFont(de->fmt); + if(!VALIDPOS(sonde.si()->d.validPos)) { + drawString(de," "); + return; + } + //Format Degres, minutes, secondes ou decimal 1=degres 0=decimal + if (sonde.config.degdec==1) + { + float decimal=sonde.si()->d.lat; + int degres=int(decimal); + float minutes=(decimal - degres)*60; + float secondes=(minutes-int(minutes))*60; + snprintf(buf, 16, "%2d %2.0f'%2.0f", degres, minutes, secondes); + drawString(de,buf); + rdis->drawTile(2, 2, 1, deg_tile); + } else + { + snprintf(buf, 16, "%2.5f", sonde.si()->d.lat); + drawString(de,buf); + } +} +void Display::drawLon(DispEntry *de) { + rdis->setFont(de->fmt); + if(!VALIDPOS(sonde.si()->d.validPos)) { + drawString(de," "); + return; + } + //Format Degres, minutes, secondes ou decimal 1=degres 0=decimal + if (sonde.config.degdec==1) + { + float decimal=sonde.si()->d.lon; + int degres=int(decimal); + float minutes=(decimal - degres)*60; + float secondes=(minutes-int(minutes))*60; + snprintf(buf, 16, "%2d %2.0f'%2.0f", degres, minutes, secondes); + drawString(de,buf); + rdis->drawTile(2, 4, 1, deg_tile); + } else + { + snprintf(buf, 16, "%2.5f", sonde.si()->d.lon); + drawString(de,buf); + } +} +void Display::drawAlt(DispEntry *de) { + rdis->setFont(de->fmt); + if(!VALIDALT(sonde.si()->d.validPos)) { + drawString(de," "); + return; + } + float alt = sonde.si()->d.alt; + //testing only.... alt += 30000-454; + snprintf(buf, 16, alt>=1000?" %5.0fm":" %3.1fm", alt); + drawString(de,buf+strlen(buf)-6); +} +void Display::drawHS(DispEntry *de) { + rdis->setFont(de->fmt); + if(!VALIDHS(sonde.si()->d.validPos)) { + drawString(de," "); + return; + } + boolean is_ms = (de->extra && de->extra[0]=='m')?true:false; // m/s or km/h + float hs = sonde.si()->d.hs; + if(!is_ms) hs = hs * 3.6; + boolean has_extra = (de->extra && de->extra[1]!=0)? true: false; + snprintf(buf, 16, hs>99?" %3.0f":" %2.1f", hs); + if(has_extra) { strcat(buf, de->extra+1); } + drawString(de,buf+strlen(buf)-4- (has_extra?strlen(de->extra+1):0) ); + if(!has_extra) rdis->drawTile(de->x+4,de->y,2,is_ms?ms_tiles:kmh_tiles); +} +void Display::drawVS(DispEntry *de) { + rdis->setFont(de->fmt); + if(!VALIDVS(sonde.si()->d.validPos)) { + drawString(de," "); + return; + } + snprintf(buf, 16, " %+2.1f", sonde.si()->d.vs); + DebugPrintf(DEBUG_DISPLAY, "drawVS: extra is %s width=%d\n", de->extra?de->extra:"", de->width); + if(de->extra) { strcat(buf, de->extra); } + drawString(de, buf+strlen(buf)-5- (de->extra?strlen(de->extra):0) ); + if(!de->extra) rdis->drawTile(de->x+5,de->y,2,ms_tiles); +} +void Display::drawID(DispEntry *de) { + rdis->setFont(de->fmt); + if(!sonde.si()->d.validID) { + drawString(de, "nnnnnnnn "); + return; + } + if(de->extra && de->extra[0]=='n') { + // real serial number, as printed on sonde, can be up to 11 digits long + drawString(de, sonde.si()->d.ser); + } else if (de->extra && de->extra[0]=='s') { + // short ID, max 8 digits (no initial "D" for DFM, "M" instead of "ME" for M10) + if( TYPE_IS_DFM(sonde.si()->type) ) { + drawString(de, sonde.si()->d.id+1); + } else if (TYPE_IS_METEO(sonde.si()->type)) { + char sid[9]; + sid[0]='M'; + memcpy(sid+1, sonde.si()->d.id+2, 8); + sid[8] = 0; + drawString(de, sid); + } else { + drawString(de, sonde.si()->d.id); + } + } else { + // dxlAPRS sonde number, max 9 digits, as used on aprs.fi and radiosondy.info + drawString(de, sonde.si()->d.id); + } +} +void Display::drawRSSI(DispEntry *de) { + rdis->setFont(de->fmt); + Serial.printf("\ndBSmetre %d\n",sonde.config.dbsmetre); + if (sonde.config.dbsmetre==0) { + if(sonde.config.disptype!=1) { + snprintf(buf, 16, "-%d ", sonde.si()->rssi/2); + int len=strlen(buf)-3; + Serial.printf("drawRSSI: %d %d %d (%d)[%d]\n", de->y, de->x, sonde.si()->rssi/2, sonde.currentSonde, len); + buf[5]=0; + drawString(de,buf); + rdis->drawTile(de->x+len, de->y, 1, (sonde.si()->rssi&1)?halfdb_tile1:empty_tile1); + rdis->drawTile(de->x+len, de->y+1, 1, (sonde.si()->rssi&1)?halfdb_tile2:empty_tile2); + } else { // special for 2" display + snprintf(buf, 16, "-%d.%c ", sonde.si()->rssi/2, (sonde.si()->rssi&1)?'5':'0'); + drawString(de,buf); + } + } else { + int dbmetre=sonde.si()->rssi/2; + Serial.printf("\nSmetre %d\n",sonde.si()->rssi/2); + //Ici tableau Smetre + //S1 <-121dB //S2 <-115dB //S3 <-109dB //S4 <-103dB //S5 <-97dB + //S6 <-91dB //S7 <-85dB //S8 <-79dB //S9 <-73dB //S9+10 <-63dB + //S9+20 <-53dB //S9+30 <-43db //S9+40 <- 33dB //S9+50dB <-23dB //S9+60 <-13dB + //S9+70 <-0dB + if (dbmetre>138) drawString(de,"S0"); + if ((dbmetre<137)&&(dbmetre>122)) drawString(de,"S1 "); + if ((dbmetre<121)&&(dbmetre>116)) drawString(de,"S2 "); + if ((dbmetre<115)&&(dbmetre>108)) drawString(de,"S3 "); + if ((dbmetre<109)&&(dbmetre>104)) drawString(de,"S4 "); + if ((dbmetre<103)&&(dbmetre>98)) drawString(de,"S5 "); + if ((dbmetre<97)&&(dbmetre>92)) drawString(de,"S6 "); + if ((dbmetre<91)&&(dbmetre>86)) drawString(de,"S7 "); + if ((dbmetre<85)&&(dbmetre>80)) drawString(de,"S8 "); + if ((dbmetre<79)&&(dbmetre>74)) drawString(de,"S9 "); + if ((dbmetre<73)&&(dbmetre>64)) drawString(de,"S9+10"); + if ((dbmetre<63)&&(dbmetre>54)) drawString(de,"S9+20"); + if ((dbmetre<53)&&(dbmetre>44)) drawString(de,"S9+30"); + if ((dbmetre<43)&&(dbmetre>34)) drawString(de,"S9+40"); + if ((dbmetre<33)&&(dbmetre>24)) drawString(de,"S9+50"); + if ((dbmetre<23)&&(dbmetre>14)) drawString(de,"S9+60"); + if ((dbmetre<13)&&(dbmetre>0)) drawString(de,"S9+70"); + } +} +void Display::drawQS(DispEntry *de) { + uint8_t *stat = sonde.si()->rxStat; + struct StatInfo *statinfo = (struct StatInfo *)de->extra; + rdis->drawQS(de->x, de->y, statinfo->len, statinfo->size, stat, de->fg, de->bg); +} + +void Display::drawType(DispEntry *de) { + rdis->setFont(de->fmt); + const char *typestr = sonde.si()->d.typestr; + if(*typestr==0) typestr = sondeTypeStr[sonde.si()->type]; + drawString(de, typestr); +} +void Display::drawFreq(DispEntry *de) { + rdis->setFont(de->fmt); + snprintf(buf, 16, "%3.3f%s", sonde.si()->freq, de->extra?de->extra:""); + drawString(de, buf); +} + +void Display::drawAFC(DispEntry *de) { + rdis->setFont(de->fmt); + { snprintf(buf, 15, " %+3.2fk", sonde.si()->afc*0.001); } + drawString(de, buf+strlen(buf)-8); +} +void Display::drawIP(DispEntry *de) { + rdis->setFont(de->fmt); + rdis->drawIP(de->x, de->y, de->width, de->fg, de->bg); +} +void Display::drawSite(DispEntry *de) { + rdis->setFont(de->fmt); + switch(de->extra[0]) { + case '#': + // currentSonde is index in array starting with 0; + // but we draw "1" for the first entry and so on... + snprintf(buf, 3, "%d ", sonde.currentSonde+1); + buf[2]=0; + break; + case 't': + snprintf(buf, 3, "%d", sonde.config.maxsonde); + buf[2]=0; + break; + case 'a': + { + uint8_t active = 0; + for(int i=0; ilaunchsite); + //drawString(de, sonde.si()->launchsite); + //return; + } + if(de->extra[0]) strcat(buf, de->extra+1); + drawString(de, buf); +} +void Display::drawTelemetry(DispEntry *de) { + rdis->setFont(de->fmt); + float value=0; + memset(buf, ' ', 16); + switch(de->extra[0]) { + case 't': + value = sonde.si()->d.temperature; + if(!isnan(value)) { + sprintf(buf, "%5.1f", value); + strcat(buf, de->extra+1); + } + buf[5+strlen(de->extra+1)] = 0; + break; + case 'p': + value = sonde.si()->d.pressure; + if(!isnan(value)) { + if(value>=1000) sprintf(buf, "%6.1f", value); + else sprintf(buf, "%6.2f", value); + strcat(buf, de->extra+1); + } + buf[6+strlen(de->extra+1)] = 0; + break; + case 'h': + value = sonde.si()->d.relativeHumidity; + if(!isnan(value)) { + sprintf(buf, "%4.1f", value); + strcat(buf, de->extra+1); + } + buf[4+strlen(de->extra+1)] = 0; + break; + case 'b': + value = sonde.si()->d.batteryVoltage; + if(!isnan(value)) { + snprintf(buf, 5, "%4.2f", value); + strcat(buf, de->extra+1); + } + buf[5+strlen(de->extra+1)] = 0; + break; + } + drawString(de,buf); +} + +void Display::drawKilltimer(DispEntry *de) { + rdis->setFont(de->fmt); + uint16_t value=0; + switch(de->extra[0]) { + case 'l': value = sonde.si()->d.launchKT; break; + case 'b': value = sonde.si()->d.burstKT; break; + case 'c': value = sonde.si()->d.countKT; break; + } + // format: 4=h:mm; 6=h:mm:ss; s=sssss + uint16_t h=value/3600; + uint16_t m=(value-h*3600)/60; + uint16_t s=value%60; + switch(de->extra[1]) { + case '4': + if(value!=0xffff) snprintf(buf, 5, "%d:%02d", h, m); + else strcpy(buf, " "); + break; + case '6': + if(value!=0xffff) snprintf(buf, 7, "%d:%02d:%02d", h, m, s); + else strcpy(buf, " "); + break; + default: + if(value!=0xffff) snprintf(buf, 6, "%5d", value); + else strcpy(buf, " "); + break; + } + if(de->extra[1]) + strcat(buf, de->extra+2); + drawString(de, buf); +} +#define EARTH_RADIUS (6371000.0F) +#ifndef PI +#define PI (3.1415926535897932384626433832795) +#endif +// defined by Arduino.h #define radians(x) ( (x)*180.0F/PI ) + +extern int lastCourse; // from RX_FSK.ino + + +float calcLatLonDist(float lat1, float lon1, float lat2, float lon2) { + float x = radians(lon1-lon2) * cos( radians((lat1+lat2)/2) ); + float y = radians(lat2-lat1); + float d = sqrt(x*x+y*y)*EARTH_RADIUS; + return d; +} + +void Display::calcGPS() { + float mylat = sonde.config.rxlat; + float mylon = sonde.config.rxlon; + bool valid = !(isnan(mylat)||isnan(mylon)); + if( gpsPos.valid) { + mylat = gpsPos.lat; + mylon = gpsPos.lon; + valid = true; + } + // distance + if( valid && VALIDPOS(sonde.si()->d.validPos) && (layout->usegps&GPSUSE_DIST)) { + gpsDist = (int)calcLatLonDist(mylat, mylon, sonde.si()->d.lat, sonde.si()->d.lon); + } else { + gpsDist = -1; + } + // bearing + if( valid && VALIDPOS(sonde.si()->d.validPos&0x03) && (layout->usegps&GPSUSE_BEARING)) { + float lat1 = radians(mylat); + float lat2 = radians(sonde.si()->d.lat); + float lon1 = radians(mylon); + float lon2 = radians(sonde.si()->d.lon); + float y = sin(lon2-lon1)*cos(lat2); + float x = cos(lat1)*sin(lat2) - sin(lat1)*cos(lat2)*cos(lon2-lon1); + float dir = atan2(y, x)/PI*180; + if(dir<0) dir+=360; + gpsDir = (int)dir; + gpsBear = gpsDir - gpsPos.course; + if(gpsBear < 0) gpsBear += 360; + if(gpsBear >= 360) gpsBear -= 360; + } else { + gpsDir = -1; + gpsBear = -1; + } + + DebugPrintf(DEBUG_DISPLAY, "GPS data: valid%d GPS at %f,%f (alt=%d,cog=%d); sonde at dist=%d, dir=%d rel.bear=%d\n",gpsPos.valid?1:0, + gpsPos.lat, gpsPos.lon, gpsPos.alt, gpsPos.course, gpsDist, gpsDir, gpsBear); +} + +void Display::drawGPS(DispEntry *de) { + // TODO: FIXME: ??? if(sonde.config.gps_rxd<0) return; + rdis->setFont(de->fmt); + switch(de->extra[0]) { + case 'V': + { + // show if GPS location is valid + uint8_t *tile = gpsPos.valid?gps_tile:nogps_tile; + rdis->drawTile(de->x, de->y, 1, tile); + } + break; + case 'O': + // GPS long + snprintf(buf, 16, "%2.5f", gpsPos.lon); + drawString(de,buf); + break; + case 'A': + // GPS lat + snprintf(buf, 16, "%2.5f", gpsPos.lat); + drawString(de,buf); + break; + case 'H': + // GPS alt + snprintf(buf, 16, "%4dm", gpsPos.alt); + drawString(de,buf); + break; + case 'C': + // GPS Course over ground + snprintf(buf, 4, "%3d", gpsPos.course); + drawString(de, buf); + break; + case 'D': + { + // distance + // equirectangular approximation is good enough + if( !VALIDPOS(sonde.si()->d.validPos) ) { + snprintf(buf, 16, "no pos "); + if(de->extra && *de->extra=='5') buf[5]=0; + } else if( disp.gpsDist < 0 ) { + snprintf(buf, 16, "no gps "); + if(de->extra && *de->extra=='5') buf[5]=0; + } else { + if(de->extra && *de->extra=='5') { // 5-character version: ****m / ***km / **e6m + if(disp.gpsDist>999999) snprintf(buf, 16, "%de6m ", (int)(disp.gpsDist/1000000)); + if(disp.gpsDist>9999) snprintf(buf, 16, "%dkm ", (int)(disp.gpsDist/1000)); + else snprintf(buf, 16, "%dm ", (int)disp.gpsDist); + buf[5]=0; + } else { // 6-character version: *****m / ****km) + if(disp.gpsDist>99999) snprintf(buf, 16, "%dkm ", (int)(disp.gpsDist/1000)); + else snprintf(buf, 16, "%dm ", (int)disp.gpsDist); + buf[6]=0; + } + } + drawString(de, buf); + } + break; + case 'I': + // dIrection + if( disp.gpsDir<0 ) { // 0..360 valid, -1 invalid + drawString(de, "---"); + break; + } + snprintf(buf, 16, "%3d", disp.gpsDir); + buf[3]=0; + drawString(de, buf); + if(de->extra[1]==(char)176) + rdis->drawTile(de->x+3, de->y, 1, deg_tile); + break; + case 'B': + // relative bearing + if( disp.gpsBear < 0 ) { // 0..360 valid, -1 invalid + drawString(de, "---"); + break; + } + snprintf(buf, 16, "%3d", disp.gpsBear); + buf[3]=0; + drawString(de, buf); + if(de->extra[1]==(char)176) + rdis->drawTile(de->x+3, de->y, 1, deg_tile); + break; + case '0': + // diagram + { + static int alpha = 0; + alpha = (alpha+5)%360; + struct CircleInfo *circinfo = (struct CircleInfo *)de->extra; + int border = circinfo->brad; + if(border<7) border=7; // space for "N" label + int size = 1 + 2*circinfo->radius + 2*border; + uint16_t *bitmap = (uint16_t *)malloc(sizeof(uint16_t) * size * size); + Serial.printf("Drawing circle with size %d at %d,%d\n",size,de->x, de->y); + for(int i=0; iradius, de->fg, true, de->bg); + // + bool rxgood = (sonde.si()->rxStat[0]==0); + int angN, angA, angB; // angle of north, array, bullet + int validA, validB; // 0: no, 1: yes, -1: old + if(circinfo->arr=='C') { angA=gpsPos.course; validA=disp.gpsCourseOld?-1:1; } + else { angA=disp.gpsDir; validA=sonde.si()->d.validPos?(rxgood?1:-1):0; } + if(circinfo->bul=='C') { angB=gpsPos.course; validB=disp.gpsCourseOld?-1:1; } + else { angB=disp.gpsDir; validB=sonde.si()->d.validPos?(rxgood?1:-1):0; } + if(circinfo->top=='N') { + angN = 0; + } else { + //if (circinfo->top=='C') { + angN = 360-gpsPos.course; + angA += angN; if(angA>=360) angA-=360; + angB += angN; if(angB>=360) angB-=360; + } + Serial.printf("GPS0: %c%c%c N=%d, A=%d, B=%d\n", circinfo->top, circinfo->arr, circinfo->bul, angN, angA, angB); + // "N" in direction angN +#if 1 + // TODO +#else + static_cast(rdis)->tft->drawGFXcharBM(x0 + circinfo->radius*sin(angN*PI/180)-6, y0 - circinfo->radius*cos(angN*PI/180)+7, 'N', 0xffff, bitmap, size, size); +#endif + + // small circle in direction angB + if(validB) { + circ(bitmap, size, x0+circinfo->radius*sin(angB*PI/180), y0-circinfo->radius*cos(angB*PI/180), circinfo->brad, + circinfo->bcol, true, validB==1?circinfo->bcol:0); + } + rdis->drawBitmap(de->x, de->y, bitmap, size, size); + // triangle in direction angA + uint16_t xa,ya,xb,yb,xc,yc; + float xf=sin(angA*PI/180); + float yf=cos(angA*PI/180); + xa = de->x + x0 + xf*circinfo->radius; + ya = de->y + y0 - yf*circinfo->radius; + xb = de->x + x0 + yf*circinfo->awidth; + yb = de->y + y0 + xf*circinfo->awidth; + xc = de->x + x0 - yf*circinfo->awidth; + yc = de->y + y0 - xf*circinfo->awidth; + Serial.printf("%d: %d,%d\n", alpha, xa, ya); + if(validA==-1) + rdis->drawTriangle(xa,ya,xb,yb,xc,yc,circinfo->acol, false); + else if(validA==1) + rdis->drawTriangle(xa,ya,xb,yb,xc,yc,circinfo->acol, true); + free(bitmap); + } + break; + case 'E': + // elevation + break; + } +} + +void Display::drawBatt(DispEntry *de) { + float val; + char buf[30]; + if (!axp192_found) { + if (sonde.config.batt_adc<0) return; + switch (de->extra[0]) + { + case 'V': + val = (float)(analogRead(sonde.config.batt_adc)) / 4095 * 2 * 3.3 * 1.1; + snprintf(buf, 30, "%.2f%s", val, de->extra + 1); + break; + default: + *buf = 0; + } + rdis->setFont(de->fmt); + drawString(de, buf); + } else { + xSemaphoreTake( axpSemaphore, portMAX_DELAY ); + switch(de->extra[0]) { + case 'S': + if(!axp.isBatteryConnect()) { + if(axp.isVBUSPlug()) { strcpy(buf, "U"); } + else { strcpy(buf, "N"); } // no battary + } + else if (axp.isChargeing()) { strcpy(buf, "C"); } // charging + else { strcpy(buf, "B"); } // battery, but not charging + break; + case 'V': + val = axp.getBattVoltage(); + snprintf(buf, 30, "%.2f%s", val/1000, de->extra+1); + break; + case 'C': + val = axp.getBattChargeCurrent(); + snprintf(buf, 30, "%.2f%s", val, de->extra+1); + break; + case 'D': + val = axp.getBattDischargeCurrent(); + snprintf(buf, 30, "%.2f%s", val, de->extra+1); + break; + case 'U': + if(sonde.config.type == TYPE_M5_CORE2) { + val = axp.getAcinVoltage(); + } else { + val = axp.getVbusVoltage(); + } + snprintf(buf, 30, "%.2f%s", val/1000, de->extra+1); + break; + case 'I': + if(sonde.config.type == TYPE_M5_CORE2) { + val = axp.getAcinCurrent(); + } else { + val = axp.getVbusCurrent(); + } + snprintf(buf, 30, "%.2f%s", val, de->extra+1); + break; + case 'T': + val = axp.getTemp(); // fixed in newer versions of libraray: -144.7 no longer needed here! + snprintf(buf, 30, "%.2f%s", val, de->extra+1); + break; + default: + *buf=0; + } + xSemaphoreGive( axpSemaphore ); + rdis->setFont(de->fmt); + drawString(de, buf); + } +} + +void Display::drawText(DispEntry *de) { + rdis->setFont(de->fmt); + drawString(de, de->extra); +} +extern void buzzerLed(int temps); +void Display::updateDisplayPos() { + if( dispstate == 0 ) return; // do not display anything + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawLat && di->func != disp.drawLon) continue; + di->func(di); + } +} +void Display::updateDisplayPos2() { + if( dispstate == 0 ) return; // do not display anything + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawAlt && di->func != disp.drawHS && di->func != disp.drawVS) continue; + di->func(di); + } +} +void Display::updateDisplayID() { + if( dispstate == 0 ) return; // do not display anything + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawID) continue; + di->func(di); + } +} +void Display::updateDisplayRSSI() { + if( dispstate == 0 ) return; // do not display anything + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawRSSI) continue; + di->func(di); + } +} +void Display::updateStat() { + if( dispstate == 0 ) return; // do not display anything + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawQS) continue; + di->func(di); + } +} + +void Display::updateDisplayRXConfig() { + if( dispstate == 0 ) return; // do not display anything + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawQS && di->func != disp.drawAFC) continue; + di->func(di); + } +} + +void Display::updateDisplayIP() { + for(DispEntry *di=layout->de; di->func != NULL; di++) { + if(di->func != disp.drawIP) continue; + Serial.printf("updateDisplayIP: %d %d\n",di->x, di->y); + di->func(di); + } +} + +void Display::updateDisplay() { + if( dispstate == 0 ) return; // do not display anything + calcGPS(); + for(DispEntry *di=layout->de; di->func != NULL; di++) { + di->func(di); + } +} + +// Called when key is pressed or new RX starts +void Display::dispsavectlON() { + // nothing to do to turn display on, may add power on code here later + dispstate = 1; +} + +// Should be called 1x / sec to update display +// parameter: rxactive (1=currently receiving something, 0=no rx) +void Display::dispsavectlOFF(int rxactive) { + if( sonde.config.dispsaver == 0 ) return; // screensaver disabled + if( dispstate == 0 ) return; // already OFF + if( rxactive && ((sonde.config.dispsaver%10)==2) ) return; // OFF only if no RX, but rxactive is 0 + dispstate++; + if( dispstate > (sonde.config.dispsaver/10) ) { + rdis->clear(); + dispstate = 0; + } +} + +void Display::setContrast() { + if(sonde.config.dispcontrast<0) return; + rdis->setContrast(sonde.config.dispcontrast); +} + +Display disp = Display(); diff --git a/RX_FSK/src/Display.h b/RX_FSK/src/Display.h new file mode 100644 index 0000000..f7f8728 --- /dev/null +++ b/RX_FSK/src/Display.h @@ -0,0 +1,185 @@ +#ifndef Display_h +#define Display_h + +#define FONT_LARGE 1 +#define FONT_SMALL 0 + +#include +#include +#include +#include + +struct GpsPos { + double lat; + double lon; + int alt; + int course; + float speed; + int sat; + int accuracy; + int hdop; + int valid; +}; +extern struct GpsPos gpsPos; + +#define WIDTH_AUTO 9999 +struct DispEntry { + int16_t y; + int16_t x; + int16_t fmt, width; + uint16_t fg,bg; + void (*func)(DispEntry *de); + const char *extra; +}; + +#define GPSUSE_BASE 1 +#define GPSUSE_DIST 2 +#define GPSUSE_BEARING 4 +struct DispInfo { + DispEntry *de; + uint8_t *actions; + int16_t *timeouts; + const char *label; + uint8_t usegps; +}; + +struct StatInfo { + uint8_t len; + uint8_t size; +}; + +struct CircleInfo { // 3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff + char type; + char top,bul,arr; // what to point to with top, bullet, array + uint16_t fgcol, bgcol; + uint8_t radius; + uint8_t brad; + uint16_t bcol; + uint8_t awidth; + uint16_t acol; +}; + +// Now starting towards supporting different Display types / libraries +class RawDisplay { +public: + virtual void begin() = 0; + virtual void clear() = 0; + virtual void setContrast(uint8_t contrast) = 0; + virtual void setFont(uint8_t fontindex) = 0; + virtual void getDispSize(uint8_t *height, uint8_t *width, uint8_t *lineskip, uint8_t *colskip) = 0; + virtual void drawString(uint16_t x, uint16_t y, const char *s, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0 ) = 0; + virtual void drawTile(uint16_t x, uint16_t y, uint8_t cnt, uint8_t *tile_ptr) = 0; + virtual void drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color, bool fill) = 0; + virtual void drawBitmap(uint16_t x1, uint16_t y1, const uint16_t* bitmap, int16_t w, int16_t h) = 0; + virtual void welcome() = 0; + virtual void drawIP(uint16_t x, uint16_t y, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0 ) = 0; + virtual void drawQS(uint16_t x, uint16_t y, uint8_t len, uint8_t size, uint8_t *stat, uint16_t fg=0xffff, uint16_t bg=0) = 0; +}; + +class U8x8Display : public RawDisplay { +private: + U8X8 *u8x8 = NULL; // initialize later after reading config file + uint8_t _type; + const uint8_t **fontlist; + int nfonts; + +public: + U8x8Display(uint8_t type = 0) { _type = type; } + void begin(); + void clear(); + void setContrast(uint8_t contrast); + void setFont(uint8_t fontindex); + void getDispSize(uint8_t *height, uint8_t *width, uint8_t *lineskip, uint8_t *colskip); + void drawString(uint16_t x, uint16_t y, const char *s, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0); + void drawTile(uint16_t x, uint16_t y, uint8_t cnt, uint8_t *tile_ptr); + void drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color, bool fill); + void drawBitmap(uint16_t x1, uint16_t y1, const uint16_t* bitmap, int16_t w, int16_t h); + void welcome(); + void drawIP(uint16_t x, uint16_t y, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0); + void drawQS(uint16_t x, uint16_t y, uint8_t len, uint8_t size, uint8_t *stat, uint16_t fg=0xffff, uint16_t bg=0); +}; + +typedef Arduino_GFX MY_ILI9225; + +class Display { +private: + void replaceLayouts(DispInfo *newlayout, int nnew); + int allocDispInfo(int entries, DispInfo *d, char *label); + void parseDispElement(char *text, DispEntry *de); + int xscale=13, yscale=22; + int fontsma=0, fontlar=1; + uint16_t colfg, colbg; + static void circ(uint16_t *bm, int16_t w, int16_t x0, int16_t y0, int16_t r, uint16_t fg, boolean fill, uint16_t bg); + static int countEntries(File f); + void calcGPS(); + int gpsDist; // -1: invalid + int gpsDir, gpsBear; // 0..360; -1: invalid + boolean gpsCourseOld; + static const int LINEBUFLEN{ 255 }; + static char lineBuf[LINEBUFLEN]; + static const char *trim(char *s) { + char *ret = s; + while(*ret && isspace(*ret)) { ret++; } + while(1) { + int lastidx; + lastidx = strlen(ret)-1; + if(lastidx>=0 && isspace(ret[lastidx])) + ret[lastidx] = 0; + else + break; + } + return ret; + } +public: + static int getScreenIndex(int index); + void initFromFile(int index); + + int layoutIdx; + DispInfo *layout; + + DispInfo *layouts; + int nLayouts; + static RawDisplay *rdis; + uint16_t dispstate; + + Display(); + void init(); + static char buf[17]; + static void drawLat(DispEntry *de); + static void drawLon(DispEntry *de); + static void drawAlt(DispEntry *de); + static void drawHS(DispEntry *de); + static void drawVS(DispEntry *de); + static void drawID(DispEntry *de); + static void drawRSSI(DispEntry *de); + static void drawQS(DispEntry *de); + static void drawType(DispEntry *de); + static void drawFreq(DispEntry *de); + static void drawAFC(DispEntry *de); + static void drawIP(DispEntry *de); + static void drawSite(DispEntry *de); + static void drawTelemetry(DispEntry *de); + static void drawKilltimer(DispEntry *de); + static void drawGPS(DispEntry *de); + static void drawText(DispEntry *de); + static void drawBatt(DispEntry *de); + static void drawString(DispEntry *de, const char *str); + void clearIP(); + void setIP(const char *ip, bool AP); + void updateDisplayPos(); + void updateDisplayPos2(); + void updateDisplayID(); + void updateDisplayRSSI(); + void updateStat(); + void updateDisplayRXConfig(); + void updateDisplayIP(); + void updateDisplay(); + void dispsavectlON(); + void dispsavectlOFF(int rxactive); + void setLayout(int layout); + void setContrast(); +}; + +extern Display disp; + +#endif diff --git a/RX_FSK/src/M10M20.cpp b/RX_FSK/src/M10M20.cpp new file mode 100644 index 0000000..bfaf0a8 --- /dev/null +++ b/RX_FSK/src/M10M20.cpp @@ -0,0 +1,652 @@ + +/* M10 and M20 decoder functions */ + +#include "M10M20.h" +#include "SX1278FSK.h" +#include "rsc.h" +#include "Sonde.h" +#include + +#define M10M20_DEBUG 1 + +#if M10M20_DEBUG +#define M10M20_DBG(x) x +#else +#define M10M20_DBG(x) +#endif + + +static byte data1[512]; +static byte *dataptr=data1; + +static uint8_t rxbitc; +static uint16_t rxbyte; +static int rxp=0; +static int haveNewFrame = 0; +//static int lastFrame = 0; +static int headerDetected = 0; + + +decoderSetupCfg m10m20SetupCfg = { + .bitrate = 9600, + //// Disable auto-AFC, auto-AGC, RX Trigger by preamble + .rx_cfg = 0x00, + .sync_cfg = 0x70, + .sync_len = 1, + .sync_data = (const uint8_t *)"\x66\x66", + // Preamble detection off (+ size 1 byte, maximum tolerance; should not matter for "off"?) + .preamble_cfg = 0x00 | 0x00 | 0x1F, +}; + +int M10M20::setup(float frequency, int /*type*/) +{ + M10M20_DBG(Serial.println("Setup sx1278 for M10/M20 sonde"));; + if(sx1278.ON()!=0) { + M10M20_DBG(Serial.println("Setting SX1278 power on FAILED")); + return 1; + } + // setFSK: switches to FSK standby mode + if(sx1278.setFSK()!=0) { + M10M20_DBG(Serial.println("Setting FSK mode FAILED")); + return 1; + } + Serial.print("M10/M20: setting RX frequency to "); + Serial.println(frequency); + int res = sx1278.setFrequency(frequency); + // Test: maybe fix issue after spectrum display? + sx1278.writeRegister(REG_PLL_HOP, 0); + + if(sx1278.setAFCBandwidth(sonde.config.m10m20.agcbw)!=0) { + M10M20_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.m10m20.agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.m10m20.rxbw)!=0) { + M10M20_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.m10m20.rxbw)); + return 1; + } + +/// TODO: Maybe do this conditionally? -- maybe skip if afc if agcbw set to 0 or -1? +//// Step 1: Tentative AFC mode + sx1278.clearIRQFlags(); + // preamble detector + AFC + AGC on + // wait for preamble interrupt within 2sec + sx1278.setBitrate(4800); + // DetectorOn=1, Preamble detector size 01, preamble tol 0x0A (10) + sx1278.setPreambleDetect(0x80 | 0x20 | 0x0A); + // Manual start RX, Enable Auto-AFC, Auto-AGC, RX Trigger (AGC+AFC)by preamble + sx1278.setRxConf(0x20 | 0x10 | 0x08 | 0x06); + // Packet config 1: fixed len, no mancecer, no crc, no address filter + // Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0) + if(sx1278.setPacketConfig(0x08, 0x40)!=0) { + M10M20_DBG(Serial.println("Setting Packet config FAILED")); + return 1; + } + // enable RX + sx1278.setPayloadLength(0); + sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE); + unsigned long t0 = millis(); + M10M20_DBG(Serial.printf("M10M20::setup() AFC preamble search start at %ld\n",t0)); + while( millis() - t0 < 1000 ) { + uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS1); + if(value & 2) { + int32_t afc = sx1278.getAFC(); + int16_t rssi = sx1278.getRSSI(); + Serial.printf("M10M20::setup: preamble: AFC is %d, RSSI is %.1f\n", afc, rssi/2.0); + sonde.sondeList[rxtask.currentSonde].rssi = rssi; + sonde.sondeList[rxtask.currentSonde].afc = afc; + break; + } + yield(); + } + if( millis() - t0 >= 1000) { + Serial.println("Preamble scan for AFC: TIMEOUT\n"); + return 1; // no preamble, so we may fail fast.... + } + +//// Step 2: Real reception + if( DecoderBase::setup(m10m20SetupCfg, sonde.config.m10m20.agcbw, sonde.config.m10m20.rxbw)!=0 ) { + return 1; + } +#if 0 + // Now all done in DecoderBase::setup + // FSK standby mode, seems like otherweise baudrate cannot be changed? + sx1278.setFSK(); + if(sx1278.setBitrate(9600)!=0) { + M10M20_DBG(Serial.println("Setting bitrate 9600bit/s FAILED")); + return 1; + } + M10M20_DBG(Serial.printf("Exact bitrate is %f\n", sx1278.getBitrate())); + // Probably not necessary, as this was set before + if(sx1278.setAFCBandwidth(sonde.config.m10m20.agcbw)!=0) { + M10M20_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.m10m20.agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.m10m20.rxbw)!=0) { + M10M20_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.m10m20.rxbw)); + return 1; + } + + ///// Enable auto-AFC, auto-AGC, RX Trigger by preamble + //if(sx1278.setRxConf(0x1E)!=0) { + // Disable auto-AFC, auto-AGC, RX Trigger by preamble + if(sx1278.setRxConf(0x00)!=0) { + M10M20_DBG(Serial.println("Setting RX Config FAILED")); + return 1; + } + // version 1, working with continuous RX + const char *SYNC="\x66\x66"; + if(sx1278.setSyncConf(0x70, 1, (const uint8_t *)SYNC)!=0) { + M10M20_DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + // Preamble detection off (+ size 1 byte, maximum tolerance; should not matter for "off"?) + if(sx1278.setPreambleDetect(0x00 | 0x00 | 0x1F)!=0) { + M10M20_DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } +#endif + + // Packet config 1: fixed len, no mancecer, no crc, no address filter + // Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0) + if(sx1278.setPacketConfig(0x08, 0x40)!=0) { + M10M20_DBG(Serial.println("Setting Packet config FAILED")); + return 1; + } + + // enable RX + sx1278.setPayloadLength(0); // infinite for now... + sx1278.setRxConf(0x20); + uint16_t afc = sx1278.getRawAFC(); + sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE); + delay(50); + sx1278.setRawAFC(afc); + delay(50); + Serial.printf("after RX_MODE: AFC is %d\n", sx1278.getAFC()); + +#if M10M20_DEBUG + M10M20_DBG(Serial.println("Setting SX1278 config for M10 finished\n"); Serial.println()); +#endif + return res; +} + + +M10M20::M10M20() { +} + +#define M10_FRAMELEN 101 +#define M10_CRCPOS 99 + +#define M20_FRAMELEN 88 +#define M20_CRCPOSB 22 + +void M10M20::printRaw(uint8_t *data, int len) +{ + char buf[3]; + int i; + for(i=0; i> 1) | ((b & 1) << 7); + b ^= (b >> 2) & 0xFF; + // A1 + t6 = ( c & 1) ^ ((c >> 2) & 1) ^ ((c >> 4) & 1); + t7 = ((c >> 1) & 1) ^ ((c >> 3) & 1) ^ ((c >> 5) & 1); + t = (c & 0x3F) | (t6 << 6) | (t7 << 7); + // A2 + s = (c >> 7) & 0xFF; + s ^= (s >> 2) & 0xFF; + c0 = b ^ t ^ s; + return ((c1 << 8) | c0) & 0xFFFF; +} +static uint16_t crc_M10M20(int len, uint8_t *msg) { + uint16_t cs = 0; + for (int i = 0; i < len; i++) { + cs = update_checkM10M20(cs, msg[i]); + } + return cs; +} +static bool checkM10M20crc(int crcpos, uint8_t *msg) { + uint16_t cs, cs1; + cs = crc_M10M20(crcpos, msg); + cs1 = (msg[crcpos] << 8) | msg[crcpos+1]; + return (cs1 == cs); +} + +typedef uint32_t SET256[8]; +static SET256 sondeudp_VARSET = {0x03BBBBF0UL,0x80600000UL,0x06A001A0UL, + 0x0000001CUL,0x00000000UL,0x00000000UL,0x00000000UL, + 0x00000000UL}; +// VARSET=SET256{4..9,11..13,15..17,19..21,23..25,53..54,63,69,71,72,85,87,89,90,98..100}; +static SET256 sondeudp_VARSETM20 = {0xF3E27F54UL,0x0000000FUL,0x00000030UL, + 0x00000000UL, 0x00444C39UL, 0x53445A00UL, 0x00000000UL, + 0x00000000UL}; +// VARSET=SET256{2,4,6,8..10,11..14,17,21..25,28..35,68,69}; (* known as variable *) + +static uint8_t fixcnt[M10_FRAMELEN]; +static uint8_t fixbytes[M10_FRAMELEN]; + +static int32_t getint32(uint8_t *data) { + return (int32_t)( data[3]|(data[2]<<8)|(data[1]<<16)|(data[0]<<24) ); +} + +static int32_t getint24(uint8_t *data) { + return (int32_t)(data[2]|(data[1]<<8)|(data[0]<<16) ); +} + +static int32_t getint24_r(uint8_t *data) { + return (int32_t)(data[0]|(data[1]<<8)|(data[2]<<16) ); +} + +static int16_t getint16(uint8_t *data) { + return (int16_t)(data[1]|((uint16_t)data[0]<<8)); +} + +static int16_t getint16_r(uint8_t *data) { + return (int16_t)(((uint16_t)data[1]<<8) |data[0]); +} + +static char dez(uint8_t nr) { + nr = nr%10; + return '0'+nr; +} +static char hex(uint8_t nr) { + nr = nr&0x0f; + if(nr<10) return '0'+nr; + else return 'A'+nr-10; +} +const static float DEGMUL = 1.0/0xB60B60; + +#define VMUL 0.005 +#define VMUL_M20 0.01 +#ifndef PI +#define PI (3.1415926535897932384626433832795) +#endif +#define RAD (PI/180) + + +// ret: 1=frame ok; 2=frame with errors; 0=ignored frame (m10dop-alternativ) +int M10M20::decodeframeM10(uint8_t *data) { + int repairstep = 16; + int repl = 0; + bool crcok; + // error correction, inspired by oe5dxl's sondeudp + do { + crcok = checkM10M20crc(M10_CRCPOS, data); + if(crcok || repairstep==0) break; + repl = 0; + for(int i=0; i=repairstep) ) { + repl++; + data[i] = fixbytes[i]; + } + } + repairstep >>= 1; + } while(true); + if(crcok) { + for(int i=0; id); + + // Its a M10 + // getid... + char ids[12]; + ids[0] = 'M'; + ids[1] = 'E'; + ids[2] = hex(data[95]/16); + ids[3] = hex(data[95]); + ids[4] = hex(data[93]); + uint32_t id = data[96] + data[97]*256; + ids[5] = hex(id/4096); + ids[6] = hex(id/256); + ids[7] = hex(id/16); + ids[8] = hex(id); + ids[9] = 0; + strncpy(si->id, ids, 10); + ids[0] = hex(data[95]/16); + ids[1] = dez((data[95]&0x0f)/10); + ids[2] = dez((data[95]&0x0f)); + ids[3] = '-'; + ids[4] = dez(data[93]); + ids[5] = '-'; + ids[6] = dez(id>>13); + id &= 0x1fff; + ids[7] = dez(id/1000); + ids[8] = dez((id/100)%10); + ids[9] = dez((id/10)%10); + ids[10] = dez(id%10); + ids[11] = 0; + strncpy(si->ser, ids, 12); + si->validID = true; + Serial.printf("ID is %s [%02x %02x %d]\n", ids, data[95], data[93], id); + // ID printed on sonde is ...-.-abbbb, with a=id>>13, bbbb=id&0x1fff in decimal + // position data + si->lat = getint32(data+14) * DEGMUL; + si->lon = getint32(data+18) * DEGMUL; + si->alt = getint32(data+22) * 0.001; + float ve = getint16(data+4)*VMUL; + float vn = getint16(data+6)*VMUL; + si->vs = getint16(data+8) * VMUL; + si->hs = sqrt(ve*ve+vn*vn); + si->sats = data[30]; + float dir = atan2(ve, vn)*(1.0/RAD); + if(dir<0) dir+=360; + si->dir = dir; + si->validPos = 0x3f; + // m10 temp + float T = NAN; + { + const float p0 = 1.07303516e-03, p1 = 2.41296733e-04, p2 = 2.26744154e-06, p3 = 6.52855181e-08; + const float Rs[3] = { 12.1e3 , 36.5e3 , 475.0e3 }; + const float Rp[3] = { 1e20 , 330.0e3 , 2000.0e3 }; + uint8_t sct = data[62]; + float rt = getint16_r(data+63) & (0xFFF); + if(rt!=0 && sct<3) { + rt = (4095-rt)/rt - (Rs[sct]/Rp[sct]); + if(rt>0) { + rt = Rs[sct] / rt; + if(rt>0) { + rt = log(rt); + rt = 1/( p0 + p1*rt + p2*rt*rt + p3*rt*rt*rt ) - 273.15; + if(rt>-99 && rt<50) { T = rt; } + } + } + } + si->temperature = T; + } + + // m10 battery + uint16_t batADC = (uint16_t)getint16_r(data+0x45); + si->batteryVoltage = 2.709 * batADC * 2.5/1023.0; + + // m10 humidity + { + float cRHc55 = ((float)(uint32_t)getint24_r(data+0x35)) / (uint32_t)getint24_r(data+0x32); + float TH = -273.15; + const float huRs = 22.1e3; + const float p0 = 4.42606809e-03, p1 = -6.58184309e-04, p2 = 8.95735557e-05, p3 = -2.84347503e-06; + float R = huRs / ( (4095.0/getint16_r(data+0x59)) - 1 ); + if(R>0) TH += 1/( p0 + p1*log(R) + p2*log(R)*log(R) + p3*log(R)*log(R)*log(R) ); + //float Tc = T; + float rh = (cRHc55-0.8955)/0.002; + const float T0=0.0, T1=-30.0; + //float T = Tc; + if(T100.0) rh=100.0; + si->relativeHumidity = rh; + } + Serial.printf("hum: %.2f batt: %.2f\n", si->relativeHumidity, si->batteryVoltage); + + uint32_t gpstime = getint32(data+10); + uint16_t gpsweek = getint16(data+32); + // UTC is GPSTIME - 18s (24*60*60-18 = 86382) + // one week = 7*24*60*60 = 604800 seconds + // unix epoch starts jan 1st 1970 0:00 + // gps time starts jan 6, 1980 0:00. thats 315964800 epoch seconds. + // subtracting 86400 yields 315878400UL + si->time = (gpstime/1000) + 86382 + gpsweek*604800 + 315878400UL; + // consistent with autorx, vframe is based on GPS time without the -18 seconds adjustment + // for the GPS time / UTC time difference (included in 86382 above) + si->vframe = si->time - 315964800 + 18; + si->validTime = true; + } else { + Serial.printf("data is %02x %02x %02x\n", data[0], data[1], data[2]); + return 0; + } + return 1; +} + +static uint32_t rxdata; +static bool rxsearching=true; +static bool isM20=false; + +// search for +// //101001100110011010011010011001100110100110101010100110101001 +// //1010011001100110100110100110 0110.0110 1001.1010 1010.1001 1010.1001 => 0x669AA9A9 +void M10M20::processM10data(uint8_t dt) +{ + for(int i=0; i<8; i++) { + uint8_t d = (dt&0x80)?1:0; + dt <<= 1; + rxdata = (rxdata<<1) | d; + if( (rxbitc&1)==0 ) { + // "bit1" + rxbyte = (rxbyte<<1) | d; + } else { + // "bit2" ==> 01 or 10 => 1, otherweise => 0 + rxbyte = rxbyte ^ d; + } + // + if(rxsearching) { + if( rxdata == 0xcccca64c || rxdata == 0x333359b3 ) { + rxsearching = false; + rxbitc = 0; + rxp = 0; + isM20 = false; + headerDetected = 1; +#if 1 + int rssi=sx1278.getRSSI(); + int fei=sx1278.getFEI(); + int afc=sx1278.getAFC(); + Serial.print("SYNC!!! Test: RSSI="); Serial.print(rssi); + Serial.print(" FEI="); Serial.print(fei); + Serial.print(" AFC="); Serial.println(afc); + sonde.si()->rssi = rssi; + sonde.si()->afc = afc; +#endif + } + } else { + rxbitc = (rxbitc+1)%16; // 16; + if(rxbitc == 0) { // got 8 data bit + //Serial.printf("%03x ",rxbyte); + dataptr[rxp++] = rxbyte&0xff; // (rxbyte>>1)&0xff; + // detect type of sonde: + // 64 9F 20 => M10 + // 64 49 0x => M10 (?) -- not used here + // 45 20 7x => M20 + if(rxp==2 && dataptr[0]==0x45 && dataptr[1]==0x20) { isM20 = true; } + if(isM20) { + memcpy(sonde.si()->d.typestr, "M20 ", 5); + sonde.si()->d.subtype = 2; + if(rxp>=M20_FRAMELEN) { + rxsearching = true; + haveNewFrame = decodeframeM20(dataptr); + } + } else { + memcpy(sonde.si()->d.typestr, "M10 ", 5); + sonde.si()->d.subtype = 1; + if(rxp>=M10_FRAMELEN) { + rxsearching = true; + haveNewFrame = decodeframeM10(dataptr); + } + } + } + } + } +} + +int M10M20::receive() { + unsigned long t0 = millis(); + Serial.printf("M10M20::receive() start at %ld\n",t0); + while( millis() - t0 < 1100 ) { + uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2); + if ( bitRead(value, 7) ) { + Serial.println("FIFO full"); + } + if ( bitRead(value, 4) ) { + Serial.println("FIFO overflow"); + } + if ( bitRead(value, 2) == 1 ) { + Serial.println("FIFO: ready()"); + sx1278.clearIRQFlags(); + } + if(bitRead(value, 6) == 0) { // while FIFO not empty + byte data = sx1278.readRegister(REG_FIFO); + //Serial.printf("%02x:",data); + processM10data(data); + value = sx1278.readRegister(REG_IRQ_FLAGS2); + } else { + if(headerDetected) { + t0 = millis(); // restart timer... don't time out if header detected... + headerDetected = 0; + } + if(haveNewFrame) { + Serial.printf("M10M20::receive(): new frame complete after %ldms\n", millis()-t0); + printRaw(dataptr, M10_FRAMELEN); + int retval = haveNewFrame==1 ? RX_OK: RX_ERROR; + haveNewFrame = 0; + return retval; + } + delay(2); + } + } + int32_t afc = sx1278.getAFC(); + int16_t rssi = sx1278.getRSSI(); + Serial.printf("receive: AFC is %d, RSSI is %.1f\n", afc, rssi/2.0); + Serial.printf("M10M20::receive() timed out\n"); + return RX_TIMEOUT; // TODO RX_OK; +} + +#define M10MAXLEN (240) + +int M10M20::waitRXcomplete() { + return 0; +} + + + +// ret: 1=frame ok; 2=frame with errors; 0=ignored frame (m20dop-alternativ) +int M10M20::decodeframeM20(uint8_t *data) { + int repairstep = 16; + int frl; + int repl = 0; + bool crcok = false; + bool crcbok = false; + //SondeInfo *si = sonde.si(); + SondeData *si = &(sonde.si()->d); + // error correction, inspired by oe5dxl's sondeudp + // check first block + uint8_t s[200]; + s[0] = 0x16; + for(int i=1; i<=M20_CRCPOSB-1; i++) { s[i] = data[i+1]; } + crcbok = (crc_M10M20(M20_CRCPOSB-1, s) == + ((data[M20_CRCPOSB] << 8) | data[M20_CRCPOSB+1])); + + frl = data[0] + 1; // frame len? (0x45+1 => 70) + if(frl>M20_FRAMELEN) { frl = M20_FRAMELEN; } + do { + crcok = checkM10M20crc(frl-2, data); + if(crcok || repairstep == 0) break; + repl = 0; + for(int i=crcbok?M20_CRCPOSB+2:0; i=repairstep) ) { + repl++; + data[i] = fixbytes[i]; + } + } + repairstep >>= 1; + } while(true); + if(crcbok) { + int oklen = crcok ? frl-2 : 21; + for(int i=0; iid, ids, 10); + // Serial: AAB-C-DDEEE + char *ser = si->ser; + uint8_t tmp = data[18] & 0x7F; + ser[0] = (tmp/12) + '0'; + ser[1] = ((tmp%12 + 1) / 10 ) + '0'; + ser[2] = ((tmp%12 + 1) % 10 ) + '0'; + ser[3] = '-'; + ser[4] = ((data[19]&0x03)<<1) + (data[18]/128) + 1 + '0'; + ser[5] = '-'; + ser[6] = ids[4]; + ser[7] = ids[5]; + ser[8] = ids[6]; + ser[9] = ids[7]; + ser[10] = ids[8]; + ser[11] = 0; + + // TODO + if(crcok) { + si->validID = true; + //Serial.printf("ID is %s [%02x %02x %d]\n", ids, data[95], data[93], id); + // ID printed on sonde is ...-.-abbbb, with a=id>>13, bbbb=id&0x1fff in decimal + // position data + // 0x1C 4 byte + si->lat = getint32(data+28) * 1e-6; + //0x20 4 byte + si->lon = getint32(data+32) * 1e-6; + //0x08 3 byte + si->alt = getint24(data+8) * VMUL_M20; + //0x0B 2 byte + //VMUL_M20 specific + float ve = getint16(data+11)*VMUL_M20; + //0x0D 2 byte + float vn = getint16(data+13)*VMUL_M20; + //0x18 2 byte + si->vs = getint16(data+24) * VMUL_M20; + si->hs = sqrt(ve*ve+vn*vn); + float dir = atan2(ve, vn)*(1.0/RAD); + if(dir<0) dir+=360; + si->dir = dir; + si->validPos = 0x3f; + + //0x0F 3 byte + uint32_t tow = getint24(data+15); + uint16_t week = getint16(data+26); + si->time = (tow+week*604800+315964800)-18; + si->vframe =si->time - 315964800; + + si->validTime = true; + } + return crcok?1:2; +} + + +M10M20 m10m20 = M10M20(); diff --git a/RX_FSK/src/M10M20.h b/RX_FSK/src/M10M20.h new file mode 100644 index 0000000..9585b90 --- /dev/null +++ b/RX_FSK/src/M10M20.h @@ -0,0 +1,66 @@ +/* + * M10M20.h + * Functions for decoding Meteomodem M10M20 sondes with SX127x chips + * Copyright (C) 2019 Hansi Reiser, dl9rdz + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef M10M20_h +#define M10M20_h + +#include +#include +#include +#ifndef inttypes_h + #include +#endif +#include "DecoderBase.h" + +/* Main class */ +class M10M20 : public DecoderBase +{ +private: + void printRaw(uint8_t *data, int len); + void processM10data(uint8_t data); + int decodeframeM10(uint8_t *data); + int decodeframeM20(uint8_t *data); +#if 0 + void stobyte92(uint8_t byte); + void dogps(const uint8_t *sf, int sf_len, + struct CONTEXTR9 * cont, uint32_t * timems, + uint32_t * gpstime); + uint32_t bits2val(const uint8_t *bits, int len); + int bitsToBytes(uint8_t *bits, uint8_t *bytes, int len); + int decode92(byte *data, int maxlen); + + uint8_t hamming_conf[ 7*8]; // 7*8=56 + uint8_t hamming_dat1[13*8]; // 13*8=104 + uint8_t hamming_dat2[13*8]; + + uint8_t block_conf[ 7*4]; // 7*4=28 + uint8_t block_dat1[13*4]; // 13*4=52 + uint8_t block_dat2[13*4]; + + uint8_t H[4][8] = // extended Hamming(8,4) particy check matrix + {{ 0, 1, 1, 1, 1, 0, 0, 0}, + { 1, 0, 1, 1, 0, 1, 0, 0}, + { 1, 1, 0, 1, 0, 0, 1, 0}, + { 1, 1, 1, 0, 0, 0, 0, 1}}; + uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1}; // Spalten von H: + // 1-bit-error-Syndrome + boolean initialized = false; +#endif + +public: + M10M20(); + int setup(float frequency, int type = 0); + int receive(); + int waitRXcomplete(); + + //int use_ecc = 1; +}; + +extern M10M20 m10m20; + +#endif diff --git a/RX_FSK/src/MP3H.cpp b/RX_FSK/src/MP3H.cpp new file mode 100644 index 0000000..43458a5 --- /dev/null +++ b/RX_FSK/src/MP3H.cpp @@ -0,0 +1,559 @@ + +/* MP3H decoder functions */ + +#include "MP3H.h" +#include "SX1278FSK.h" +#include "rsc.h" +#include "Sonde.h" +#include + +#define MP3H_DEBUG 1 + +#if MP3H_DEBUG +#define MP3H_DBG(x) x +#else +#define MP3H_DBG(x) +#endif + +static struct st_mp3hstate { + uint32_t id1, id2; + uint8_t idok; + uint32_t gpsdate; + uint32_t gpsdatetime; + bool dateok; +} mp3hstate; + +static byte data1[512]; +static byte *dataptr=data1; + +static uint8_t rxbitc; +static uint16_t rxbyte; +static int rxp=0; +static int haveNewFrame = 0; +//static int lastFrame = 0; +static int headerDetected = 0; + +extern uint16_t MON[]; + +decoderSetupCfg mp3hSetupCfg = { + .bitrate = 2400, + .rx_cfg = 0x00, + .sync_cfg = 0x70, + .sync_len = 1, + .sync_data = (const uint8_t *)"\x66\x66", + .preamble_cfg = 0x00 | 0x00 | 0x1F +}; + +int MP3H::setup(float frequency, int /*type*/) +{ + MP3H_DBG(Serial.println("Setup sx1278 for MP3H sonde"));; + if(sx1278.ON()!=0) { + MP3H_DBG(Serial.println("Setting SX1278 power on FAILED")); + return 1; + } + // setFSK: switches to FSK standby mode + if(sx1278.setFSK()!=0) { + MP3H_DBG(Serial.println("Setting FSK mode FAILED")); + return 1; + } + Serial.print("MP3H: setting RX frequency to "); + Serial.println(frequency); + int res = sx1278.setFrequency(frequency); + // Test: maybe fix issue after spectrum display? + sx1278.writeRegister(REG_PLL_HOP, 0); + + if(sx1278.setAFCBandwidth(sonde.config.mp3h.agcbw)!=0) { + MP3H_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.mp3h.agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.mp3h.rxbw)!=0) { + MP3H_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.mp3h.rxbw)); + return 1; + } + +//// Step 2: Real reception + if(DecoderBase::setup(mp3hSetupCfg, sonde.config.mp3h.agcbw, sonde.config.mp3h.rxbw)!=0) { + return 1; + } +#if 0 + // Now all done in Decoderbase + // FSK standby mode, seems like otherweise baudrate cannot be changed? + sx1278.setFSK(); + if(sx1278.setBitrate(2400)!=0) { + MP3H_DBG(Serial.println("Setting bitrate 2400bit/s FAILED")); + return 1; + } + MP3H_DBG(Serial.printf("Exact bitrate is %f\n", sx1278.getBitrate())); + // Probably not necessary, as this was set before + if(sx1278.setAFCBandwidth(sonde.config.mp3h.agcbw)!=0) { + MP3H_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.mp3h.agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.mp3h.rxbw)!=0) { + MP3H_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.mp3h.rxbw)); + return 1; + } + + ///// Enable auto-AFC, auto-AGC, RX Trigger by preamble + //if(sx1278.setRxConf(0x1E)!=0) { + // Disable auto-AFC, auto-AGC, RX Trigger by preamble + if(sx1278.setRxConf(0x00)!=0) { + MP3H_DBG(Serial.println("Setting RX Config FAILED")); + return 1; + } + // version 1, working with continuous RX + const char *SYNC="\x66\x66"; + if(sx1278.setSyncConf(0x70, 1, (const uint8_t *)SYNC)!=0) { + MP3H_DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + // Preamble detection off (+ size 1 byte, maximum tolerance; should not matter for "off"?) + if(sx1278.setPreambleDetect(0x00 | 0x00 | 0x1F)!=0) { + MP3H_DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } +#endif + + // Packet config 1: fixed len, no mancecer, no crc, no address filter + // Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0) + if(sx1278.setPacketConfig(0x08, 0x40)!=0) { + MP3H_DBG(Serial.println("Setting Packet config FAILED")); + return 1; + } + + // enable RX + sx1278.setPayloadLength(0); // infinite for now... + //sx1278.setRxConf(0x20); + uint16_t afc = sx1278.getRawAFC(); + sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE); + delay(50); + sx1278.setRawAFC(afc); + delay(50); + Serial.printf("after RX_MODE: AFC is %d\n", sx1278.getAFC()); + + memset((void *)&mp3hstate, 0, sizeof(mp3hstate)); +#if MP3H_DEBUG + MP3H_DBG(Serial.println("Setting SX1278 config for MP3H finished\n"); Serial.println()); +#endif + return res; +} + + +MP3H::MP3H() { +} + +#define MP3H_FRAMELEN 49 + +// offsets from zilog +// https://github.com/rs1729/RS/blob/master/demod/mod/mp3h1mod.c +#define OFS -3 +#define pos_CNT1 (OFS+ 3) // 1 nibble (0x80..0x8F ?) +#define pos_TIME (OFS+ 4) // 3*1 byte +#define pos_GPSecefX (OFS+ 8) // 4 byte +#define pos_GPSecefY (OFS+12) // 4 byte +#define pos_GPSecefZ (OFS+16) // 4 byte +#define pos_GPSecefV (OFS+20) // 3*2 byte +#define pos_GPSnSats (OFS+26) // 1 byte (num Sats ?) +#define pos_PTU1 (OFS+35) // 4 byte +#define pos_PTU2 (OFS+39) // 4 byte +#define pos_CNT2 (OFS+43) // 1 byte (0x01..0x10 ?) +#define pos_CFG (OFS+44) // 2/4 byte +#define pos_CRC (OFS+48) // 2 byte + + +#define crc16poly 0xA001 +static bool checkMP3CRC(uint8_t *data) +{ + int start = pos_CNT1; + int len = 45; + uint16_t rem = 0xffff; + for(int i=0; i>1) ^ crc16poly; + else rem = rem>>1; + } + } + uint16_t crcdat = data[pos_CRC] | (data[pos_CRC+1]<<8); + return rem == crcdat ? true : false; +} + +void MP3H::printRaw(uint8_t *data, int len) +{ + char buf[3]; + int i; + for(i=0; id); + double wx = i4(buf+pos_GPSecefX) * 0.01; + double wy = i4(buf+pos_GPSecefY) * 0.01; + double wz = i4(buf+pos_GPSecefZ) * 0.01; + double vx = i2(buf+pos_GPSecefV) * 0.01; + double vy = i2(buf+pos_GPSecefV+2) * 0.01; + double vz = i2(buf+pos_GPSecefV+4) * 0.01; + if(wx==0 && wy==0 && wz==0) { if(si->validPos&0x7f) { si->validPos |= 0x80; } return; } + // wgs84r + double lat, lng, alt; + wgs84r(wx, wy, wz, &lat, &lng, &alt); + if(alt<-1000 || alt>80000) { if(si->validPos&0x7f) { si->validPos |= 0x80; } return; } + si->lat = (float)(lat*DEG); + si->lon = (float)(lng*DEG); + si->alt = alt; + // speeddir + double sinlat = sin(lat); + double coslat = cos(lat); + double sinlng = sin(lng); + double coslng = cos(lng); + double vn = -vx*sinlat*coslng - vy*sinlat*sinlng + vz*coslat; + double ve = -vx*sinlng + vy*coslng; + double clb = vx*coslat*coslng + vy*coslat*sinlng + vz*sinlat; + double dir = atang2(vn, ve)/RAD; + if(dir<0.0) dir+=360.0; + si->dir = dir; + si->vs = clb; + si->hs = sqrt(vn*vn + ve*ve); + si->sats = buf[pos_GPSnSats]; + + Serial.printf("Pos: %f %f alt %f dir %f vs %f hs %f sats %d\n", si->lat, si->lon, si->alt, si->dir, si->vs, si->hs, si->sats); + si->validPos = 0x7f; +} +static uint32_t getgpstime(uint8_t *buf) { + return buf[pos_TIME] * 60*60 + buf[pos_TIME+1] * 60 + buf[pos_TIME+2]; +} +// unix time stamp from date and time info in frame. +static void getmp3htime(uint8_t *buf) { + //SondeInfo *si = sonde.si(); + SondeData *si =&(sonde.si()->d); + + // gpsdate from CFG frame 15 (0 if not yet received) + uint32_t gpsdate = mp3hstate.gpsdate; + uint32_t gpstime = getgpstime(buf); + int tt = 0; + if(gpsdate) { + uint16_t year = (gpsdate%100)+2000; + gpsdate /= 100; + uint8_t month = gpsdate%100; + gpsdate /= 100; + uint8_t day = gpsdate % 100; + // year-month-day to unix time + tt = (year-1970)*365 + (year-1969)/4; // days since 1970 + if(month<=12) { tt += MON[month]; if((year%4)==0 && month>2) tt++; } + tt = (tt+day-1)*(60*60*24); + if(gpstime < mp3hstate.gpsdatetime) tt += 60*60*24; // time wrapped since last date tx + Serial.printf("date: %04d-%02d-%02d t%d ", year, month, day, gpstime); + } + tt += gpstime; + si->time = tt; + si->vframe = tt - 315964800; + Serial.printf(" mp3h TIMESTAMP: %d\n", tt); +} + +static uint8_t hex(uint32_t n) { + n = n % 16; + return (n<10) ? (n+'0') : (n-10+'A'); +} + +static void resetmp3h() { + mp3hstate.id1 = mp3hstate.id2 = 0; + mp3hstate.idok = 0; + mp3hstate.gpsdate = 0; + mp3hstate.dateok = 0; +} + +// ret: 1=frame ok; 2=frame with errors; 0=ignored frame (m10dop-alternativ) +int MP3H::decodeframeMP3H(uint8_t *data) { + printRaw(data, MP3H_FRAMELEN); + + // + if(!checkMP3CRC(data)) { + // maybe add repairing frames later... + return 2; + } + + // data is a frame with correct CRC + //SondeInfo *si = sonde.si(); + SondeData *si =&(sonde.si()->d); + uint8_t cnt = data[pos_CNT1] & 0x0F; + uint32_t cfg = u4(data+pos_CFG); + if(cnt==15) { + // date + mp3hstate.gpsdate = cfg; + mp3hstate.gpsdatetime = getgpstime(data); + mp3hstate.dateok = true; + } else if(cnt==13) { + // id2 + if(mp3hstate.id2 > 0 && mp3hstate.id2 != cfg) { resetmp3h(); } + mp3hstate.id2 = cfg; + mp3hstate.idok |= 2; + } else if(cnt==12) { + // id1 + if(mp3hstate.id1 > 0 && mp3hstate.id1 != cfg) { resetmp3h(); } + mp3hstate.id1 = cfg; + mp3hstate.idok |= 1; + } + // get id + if((mp3hstate.idok&3) == 3) { + //... + //si->type = STYPE_MP3H; + uint32_t n = mp3hstate.id1*100000 + mp3hstate.id2; + si->id[0] = 'M'; + si->id[1] = 'R'; + si->id[2] = 'Z'; + si->id[3] = hex(n/0x100000); + si->id[4] = hex(n/0x10000); + si->id[5] = hex(n/0x1000); + si->id[6] = hex(n/0x100); + si->id[7] = hex(n/0x10); + si->id[8] = hex(n); + si->id[9] = 0; + snprintf(si->ser, 12, "%u-%u", mp3hstate.id1, mp3hstate.id2); + si->validID = true; + } + + // position + calcgps(data); + // time + getmp3htime(data); + return 1; +#if 0 + int repairstep = 16; + int repl = 0; + bool crcok; + // error correction, inspired by oe5dxl's sondeudp + do { + crcok = checkMP3Hcrc(M10_CRCPOS, data); + if(crcok || repairstep==0) break; + repl = 0; + for(int i=0; i=repairstep) ) { + repl++; + data[i] = fixbytes[i]; + } + } + repairstep >>= 1; + } while(true); + if(crcok) { + for(int i=0; iid, ids, 10); + ids[0] = hex(data[95]/16); + ids[1] = dez((data[95]&0x0f)/10); + ids[2] = dez((data[95]&0x0f)); + ids[3] = dez(data[93]); + ids[4] = dez(id>>13); + id &= 0x1fff; + ids[5] = dez(id/1000); + ids[6] = dez((id/100)%10); + ids[7] = dez((id/10)%10); + ids[8] = dez(id%10); + strncpy(sonde.si()->ser, ids, 10); + sonde.si()->validID = true; + Serial.printf("ID is %s [%02x %02x %d]\n", ids, data[95], data[93], id); + // ID printed on sonde is ...-.-abbbb, with a=id>>13, bbbb=id&0x1fff in decimal + // position data + sonde.si()->lat = getint32(data+14) * DEGMUL; + sonde.si()->lon = getint32(data+18) * DEGMUL; + sonde.si()->alt = getint32(data+22) * 0.001; + float ve = getint16(data+4)*VMUL; + float vn = getint16(data+6)*VMUL; + sonde.si()->vs = getint16(data+8) * VMUL; + sonde.si()->hs = sqrt(ve*ve+vn*vn); + float dir = atan2(vn, ve)*(1.0/RAD); + if(dir<0) dir+=360; + sonde.si()->dir = dir; + sonde.si()->validPos = 0x3f; + + uint32_t gpstime = getint32(data+10); + uint16_t gpsweek = getint16(data+32); + // UTC is GPSTIME - 18s (24*60*60-18 = 86382) + // one week = 7*24*60*60 = 604800 seconds + // unix epoch starts jan 1st 1970 0:00 + // gps time starts jan 6, 1980 0:00. thats 315964800 epoch seconds. + // subtracting 86400 yields 315878400UL + sonde.si()->time = (gpstime/1000) + 86382 + gpsweek*604800 + 315878400UL; + sonde.si()->validTime = true; + } else { + Serial.printf("data is %02x %02x %02x\n", data[0], data[1], data[2]); + return 0; + } + return crcok?1:2; +#endif + return 0; +} + +static uint32_t rxdata; +static bool rxsearching=true; + +// search for +// 0xBF3H (or inverse) +void MP3H::processMP3Hdata(uint8_t dt) +{ + for(int i=0; i<8; i++) { + uint8_t d = (dt&0x80)?1:0; + dt <<= 1; + rxdata = (rxdata<<1) | d; + if( (rxbitc&1)==0 ) { + // "bit1" + rxbyte = (rxbyte<<1) | d; + } else { + // "bit2" ==> 01 or 10 => 1, otherweise => 0 + // rxbyte = rxbyte ^ d; + } + // BF3H => 1011 1111 0011 0101 => 10011010 10101010 01011010 01100110 => 9AAA5A66 // 6555a599 + if(rxsearching) { + if( rxdata == 0x9AAA5A66 || rxdata == 0x6555a599 ) { + rxsearching = false; + rxbitc = 0; + rxp = 0; + headerDetected = 1; + Serial.print("SYNC\n"); + int rssi=sx1278.getRSSI(); + int fei=sx1278.getFEI(); + int afc=sx1278.getAFC(); + Serial.print("SYNC!!! Test: RSSI="); Serial.print(rssi); + Serial.print(" FEI="); Serial.print(fei); + Serial.print(" AFC="); Serial.println(afc); + sonde.si()->rssi = rssi; + sonde.si()->afc = afc; + } + } else { + rxbitc = (rxbitc+1)%16; // 16; + if(rxbitc == 0) { // got 8 data bit + dataptr[rxp++] = rxbyte&0xff; // (rxbyte>>1)&0xff; + //if(rxp==2 && dataptr[0]==0x45 && dataptr[1]==0x20) { isM20 = true; } + if(rxp>=MP3H_FRAMELEN) { + rxsearching = true; + haveNewFrame = decodeframeMP3H(dataptr); + } + } + } + } +} + +#define MAXFRAMES 6 +int MP3H::receive() { + // we wait for at most 6 frames or until a new seq nr. + uint8_t nFrames = MAXFRAMES; // MP3H sends every frame 6x + static uint32_t lastFrame = 0; + uint8_t retval = RX_TIMEOUT; + + unsigned long t0 = millis(); + Serial.printf("MP3H::receive() start at %ld\n",t0); + while( millis() - t0 < 1100 + (retval!=RX_TIMEOUT)?1000:0 ) { + uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2); + if ( bitRead(value, 7) ) { + Serial.println("FIFO full"); + } + if ( bitRead(value, 4) ) { + Serial.println("FIFO overflow"); + } + if ( bitRead(value, 2) == 1 ) { + Serial.println("FIFO: ready()"); + sx1278.clearIRQFlags(); + } + if(bitRead(value, 6) == 0) { // while FIFO not empty + byte data = sx1278.readRegister(REG_FIFO); + Serial.printf("%02x:",data); + processMP3Hdata(data); + value = sx1278.readRegister(REG_IRQ_FLAGS2); + } else { + if(headerDetected) { + t0 = millis(); // restart timer... don't time out if header detected... + headerDetected = 0; + } + if(haveNewFrame) { + Serial.printf("MP3H::receive(): new frame complete after %ldms\n", millis()-t0); + printRaw(dataptr, MP3H_FRAMELEN); + nFrames--; + // frame with CRC error: just skip and retry (unless we have waited for 6 frames alred) + if(haveNewFrame != 1) { + Serial.printf("hNF: %d (ERROR)\n", haveNewFrame); + retval = RX_ERROR; + } else if (sonde.si()->d.time == lastFrame) { // same frame number as seen before => skip + Serial.printf("Skipping frame with frame# %d\n", lastFrame); + // nothing, wait for next, "new" frame + } else { // good and new frame, return it. + Serial.println("Good frame"); + haveNewFrame = 0; + lastFrame = sonde.si()->d.time; + return RX_OK; + } + haveNewFrame = 0; +#if 0 + if(nFrames <= 0) { + // up to 6 old or erronous frames received => break out + Serial.printf("nFrames is %di, giving up\n", nFrames); + break; + } +#endif + } + delay(2); + } + } + int32_t afc = sx1278.getAFC(); + int16_t rssi = sx1278.getRSSI(); + Serial.printf("receive: AFC is %d, RSSI is %.1f\n", afc, rssi/2.0); + Serial.printf("MP3H::receive() timed out\n"); + return retval; +} + +int MP3H::waitRXcomplete() { + return 0; +} + + +MP3H mp3h = MP3H(); + diff --git a/RX_FSK/src/MP3H.h b/RX_FSK/src/MP3H.h new file mode 100644 index 0000000..7967f22 --- /dev/null +++ b/RX_FSK/src/MP3H.h @@ -0,0 +1,36 @@ +/* + * MP3H.h + * Functions for decoding MP3H radiosonde + * Copyright (C) 2021 Hansi Reiser, dl9rdz + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef MP3H_h +#define MP3H_h + +#include +#include +#include +#ifndef inttypes_h + #include +#endif +#include "DecoderBase.h" + +/* Main class */ +class MP3H : public DecoderBase +{ +private: + void printRaw(uint8_t *data, int len); + void processMP3Hdata(uint8_t data); + int decodeframeMP3H(uint8_t *data); +public: + MP3H(); + int setup(float frequency, int type = 0); + int receive(); + int waitRXcomplete(); +}; + +extern MP3H mp3h; + +#endif diff --git a/RX_FSK/src/RS41.cpp b/RX_FSK/src/RS41.cpp new file mode 100644 index 0000000..ef6fbf4 --- /dev/null +++ b/RX_FSK/src/RS41.cpp @@ -0,0 +1,934 @@ + +/* RS41 decoder functions */ +#include "RS41.h" +#include "SX1278FSK.h" +#include "rsc.h" +#include "Sonde.h" + +#define RS41_DEBUG 1 + +#if RS41_DEBUG +#define RS41_DBG(x) x +#else +#define RS41_DBG(x) +#endif + +#define RS41MAXLEN (320) +static byte data[800]; +static int dpos = 0; + + +// whole 51 row frame as C structure +// taken from https://github.com/einergehtnochrein/ra-firmware +struct subframeBuffer { + uint64_t valid; // bitmask for subframe valid; lsb=frame 0, etc. + union { + byte rawData[51*16]; + struct __attribute__((__packed__)) { + uint16_t crc16; /* CRC16 CCITT Checksum over range 0x002...0x31F */ + uint16_t frequency; /* 0x002: TX is on 400 MHz + (frequency / 64) * 10 kHz */ + uint8_t startupTxPower; /* 0x004: TX power level at startup (1...7) */ + uint8_t reserved005; + uint8_t reserved006; + uint16_t reserved007; /* 0x007: ?? (some bitfield) [0],[1],[2],[3]. Init value = 0xE */ + uint16_t reserved009; /* 0x009: ? */ + uint8_t reserved00B; + uint8_t reserved00C; + uint8_t serial[8]; /* 0x00D: Sonde ID, 8 char, not terminated */ + uint16_t firmwareVersion; /* 0x015: 10000*major + 100*minor + patch*/ + uint16_t reserved017; + uint16_t minHeight4Flight; /* 0x019: Height (meter above ground) where flight mode begins */ + uint8_t lowBatteryThreshold100mV; /* 0x01B: (Default=18) Shutdown if battery voltage below this + threshold for some time (10s ?) + */ + uint8_t nfcDetectorThreshold; /* 0x01C: NFC detector threshold [25mV] (Default: 0x05 = 125mV) */ + uint8_t reserved01D; /* 0x01D: ?? (Init value = 0xB4) */ + uint8_t reserved01E; /* 0x01E: ?? (Init value = 0x3C) */ + uint16_t reserved01F; + int8_t refTemperatureThreshold; /* 0x021: Reference temperature threshold [°C] */ + uint8_t reserved022; + uint16_t reserved023; + uint16_t reserved025; + int16_t flightKillFrames; /* 0x027: Number of frames in flight until kill (-1 = disabled) */ + uint16_t reserved029; /* 0x029: ? (Init value = 0) */ + uint8_t burstKill; /* 0x02B: Burst kill (0=disabled, 1=enabled) */ + uint8_t reserved02C; + uint8_t reserved02D; + uint16_t reserved02E; + uint16_t reserved030; + uint8_t reserved032; + uint16_t reserved033; + uint16_t reserved035; + uint16_t reserved037; + uint16_t reserved039; /* 0x039: */ + uint8_t reserved03B; /* 0x03B: */ + uint8_t reserved03C; /* 0x03C: */ + float refResistorLow; /* 0x03D: Reference resistor low (750 Ohms) */ + float refResistorHigh; /* 0x041: Reference resistor high (1100 Ohms) */ + float refCapLow; /* 0x045: Reference capacitance low (0) */ + float refCapHigh; /* 0x049: Reference capacitance high (47 pF) */ + float taylorT[3]; /* 0x04D: Tayor coefficients for main temperature calculation */ + float calT; /* 0x059: Calibration factor for main sensor */ + float polyT[6]; /* 0x05D: */ + float calibU[2]; /* 0x075: Calibration coefficients for humidity sensor */ + + float matrixU[7][6]; /* 0x07D: Matrix for humidity sensor RH calculation */ + float taylorTU[3]; /* 0x125: Coefficients for U sensor temperature calculation */ + float calTU; /* 0x131: Calibration factor for U temperature sensor */ + float polyTrh[6]; /* 0x135: */ + + uint8_t reserved14D; /* 0x14D: */ + uint32_t reserved14E; /* 0x14E: */ + + float f152; + uint8_t u156; + float f157; /* 0x157: ?? (Initialized by same value as calibU[0]) */ + uint8_t reserved15B; /* 0x15B: */ + uint32_t reserved15C; /* 0x15C: */ + float f160[35]; + uint8_t startIWDG; /* 0x1EC: If ==1 or ==2: Watchdog IWDG will not be started */ + uint8_t parameterSetupDone; /* 0x1ED: Set (!=0) if parameter setup was done */ + uint8_t enableTestMode; /* 0x1EE: Test mode (service menu) (0=disabled, 1=enabled) */ + uint8_t enableTX; /* 0x1EF: 0=TX disabled, 1=TX enabled (maybe this is autostart?) */ + float f1F0[8]; + float pressureLaunchSite[2]; /* 0x210: Pressure [hPa] at launch site */ + struct __attribute__((__packed__)){ + char variant[10]; /* 0x218: Sonde variant (e.g. "RS41-SG") */ + uint8_t mainboard[10]; /* 0x222: Name of mainboard (e.g. "RSM412") */ + } names; + struct __attribute__((__packed__)){ + uint8_t mainboard[9]; /* 0x22C: Serial number of mainboard (e.g. "L1123553") */ + uint8_t text235[12]; /* 0x235: "0000000000" */ + uint16_t reserved241; /* 0x241: */ + uint8_t pressureSensor[8]; /* 0x243: Serial number of pressure sensor (e.g. "N1310487") */ + uint16_t reserved24B; /* 0x24B: */ + } serials; + uint16_t reserved24D; /* 0x24D: */ + uint16_t reserved24F; /* 0x24F: */ + uint16_t reserved251; /* 0x251: (Init value = 0x21A = 538) */ + uint8_t xdataUartBaud; /* 0x253: 1=9k6, 2=19k2, 3=38k4, 4=57k6, 5=115k2 */ + uint8_t reserved254; + float cpuTempSensorVoltageAt25deg; /* 0x255: CPU temperature sensor voltage at 25°C */ + uint8_t reserved259; + uint8_t reserved25A[0x25E -0x25A]; + float matrixP[18]; /* 0x25E: Coefficients for pressure sensor polynomial */ + float vectorBp[3]; /* 0x2A6: */ + uint8_t reserved2B2[8]; /* 0x2B2: */ + float matrixBt[12]; /* 0x2BA: */ + uint8_t reserved2EA[0x2FA-0x2EA]; + uint16_t halfword2FA[9]; + float reserved30C; + float reserved310; /* 0x310: */ + uint8_t reserved314; /* 0x314: */ + uint8_t reserved315; /* 0x315: */ + int16_t burstKillFrames; /* 0x316: Number of active frames after burst kill */ + uint8_t reserved318[0x320-0x318]; + + /* This is fragment 50. It only uses 14 valid bytes! */ + int16_t killCountdown; /* 0x320: Counts frames remaining until kill (-1 = inactive) */ + uint8_t reserved322[6]; + int8_t intTemperatureCpu; /* 0x328: Temperature [°C] of CPU */ + int8_t intTemperatureRadio; /* 0x329: Temperature [°C] of radio chip */ + int8_t reserved32A; /* 0x32A: */ + uint8_t reserved32B; /* 0x32B: */ + uint8_t reserved32C; /* 0x32C: ? (the sum of two slow 8-bit counters) */ + uint8_t reserved32D; /* 0x32D: ? (the sum of two slow 8-bit counters) */ + } value; + }; +}; +// moved global variable "calibration" to sondeInfo->extra + +static uint16_t CRCTAB[256]; + +#define X2C_DIVR(a, b) ((b) != 0.0f ? (a)/(b) : (a)) +#define X2C_DIVL(a, b) ((a)/(b)) +static uint32_t X2C_LSH(uint32_t a, int32_t length, int32_t n) +{ + uint32_t m; + + m = 0; + m = (length == 32) ? 0xFFFFFFFFl : (1 << length) - 1; + if (n > 0) { + if (n >= (int32_t)length) + return 0; + return (a << n) & m; + } + + if (n <= (int32_t)-length) + return 0; + return (a >> -n) & m; +} + +double atang2(double x, double y) +{ + double w; + if (fabs(x)>fabs(y)) { + w = (double)atan(X2C_DIVL(y,x)); + if (x<0.0) { + if (y>0.0) w = 3.1415926535898+w; + else w = w-3.1415926535898; + } + } + else if (y!=0.0) { + w = (double)(1.5707963267949f-atan(X2C_DIVL(x, y))); + if (y<0.0) w = w-3.1415926535898; + } + else w = 0.0; + return w; +} /* end atang2() */ + + +static void Gencrctab(void) +{ + uint16_t j; + uint16_t i; + uint16_t crc; + for (i = 0U; i<=255U; i++) { + crc = (uint16_t)(i*256U); + for (j = 0U; j<=7U; j++) { + if ((0x8000U & crc)) crc = X2C_LSH(crc,16,1)^0x1021U; + else crc = X2C_LSH(crc,16,1); + } /* end for */ + CRCTAB[i] = X2C_LSH(crc,16,-8)|X2C_LSH(crc,16,8); + } /* end for */ +} /* end Gencrctab() */ + +decoderSetupCfg rs41SetupCfg = { + .bitrate = 4800, + .rx_cfg = 0x1E, // Enable auto-AFC, auto-AGC, RX Trigger by preamble + .sync_cfg = 0x57, // Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte + .sync_len = 8, + .sync_data = (const uint8_t *)"\x08\x6D\x53\x88\x44\x69\x48\x1F", + .preamble_cfg = 0xA8, +}; + + +int RS41::setup(float frequency, int /*type*/) +{ + if(!initialized) { + Gencrctab(); + initrsc(); + initialized = true; + } + + if(sx1278.ON()!=0) { + RS41_DBG(Serial.println("Setting SX1278 power on FAILED")); + return 1; + } + if(DecoderBase::setup(rs41SetupCfg, sonde.config.rs41.agcbw, sonde.config.rs41.rxbw)!=0 ) { + return 1; + } +#if 0 + // all moved to DecoderBase now + if(sx1278.setFSK()!=0) { + RS41_DBG(Serial.println("Setting FSK mode FAILED")); + return 1; + } + if(sx1278.setBitrate(4800)!=0) { + RS41_DBG(Serial.println("Setting bitrate 4800bit/s FAILED")); + return 1; + } + + if(sx1278.setAFCBandwidth(sonde.config.rs41.agcbw)!=0) { + RS41_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.rs41.agcbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.rs41.rxbw)!=0) { + RS41_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.rs41.rxbw)); + return 1; + } + // Enable auto-AFC, auto-AGC, RX Trigger by preamble + if(sx1278.setRxConf(0x1E)!=0) { + RS41_DBG(Serial.println("Setting RX Config FAILED")); + return 1; + } + // Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte + //char header[] = "0110.0101 0110.0110 1010.0101 1010.1010"; + + //const char *SYNC="\x10\xB6\xCA\x11\x22\x96\x12\xF8"; + const char *SYNC="\x08\x6D\x53\x88\x44\x69\x48\x1F"; + if(sx1278.setSyncConf(0x57, 8, (const uint8_t *)SYNC)!=0) { + RS41_DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + if(sx1278.setPreambleDetect(0xA8)!=0) { + RS41_DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } +#endif + + // Packet config 1: fixed len, no mancecer, no crc, no address filter + // Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0) + if(sx1278.setPacketConfig(0x08, 0x40)!=0) { + RS41_DBG(Serial.println("Setting Packet config FAILED")); + return 1; + } + int retval = sx1278.setFrequency(frequency); + dpos = 0; + + sx1278.clearIRQFlags(); + + return retval; +} + +uint32_t RS41::bits2val(const uint8_t *bits, int len) { + uint32_t val = 0; + for (int j = 0; j < len; j++) { + val |= (bits[j] << (len-1-j)); + } + return val; +} + +RS41::RS41() { +} + +/* RS41 reed solomon decoder, from dxlAPRS + */ +static int32_t reedsolomon41(byte buf[], uint32_t buf_len, uint32_t len2) +{ + uint32_t i; + int32_t res1; + /*tb1, */ + int32_t res; + char b1[256]; + char b[256]; + uint32_t eraspos[24]; + uint32_t tmp; + for (i = 0UL; i<=255UL; i++) { + b[i] = 0; + b1[i] = 0; + } /* end for */ + tmp = len2; + i = 0UL; + if (i<=tmp) for (;; i++) { + b[230UL-i] = buf[i*2UL+56UL]; + b1[230UL-i] = buf[i*2UL+57UL]; + if (i==tmp) break; + } /* end for */ + for (i = 0UL; i<=23UL; i++) { + b[254UL-i] = buf[i+8UL]; + b1[254UL-i] = buf[i+32UL]; + } /* end for */ + res = decodersc(b, eraspos, 0); + res1 = decodersc(b1, eraspos, 0); + if (res>0L && res<=12L) { + tmp = len2; + i = 0UL; + if (i<=tmp) for (;; i++) { + buf[i*2UL+56UL] = b[230UL-i]; + if (i==tmp) break; + } /* end for */ + for (i = 0UL; i<=23UL; i++) { + buf[i+8UL] = b[254UL-i]; + } /* end for */ + } + if (res1>0L && res1<=12L) { + tmp = len2; + i = 0UL; + if (i<=tmp) for (;; i++) { + buf[i*2UL+57UL] = b1[230UL-i]; + if (i==tmp) break; + } /* end for */ + for (i = 0UL; i<=23UL; i++) { + buf[i+32UL] = b1[254UL-i]; + } /* end for */ + } + if (res<0L || res1<0L) return -1L; + else return res+res1; + return 0; +} /* end reedsolomon41() */ + + + + +static char crcrs(const byte frame[], uint32_t frame_len, + int32_t from, int32_t to) +{ + uint16_t crc; + int32_t i; + int32_t tmp; + crc = 0xFFFFU; + tmp = to-3L; + i = from; + if (i<=tmp) for (;; i++) { + crc = X2C_LSH(crc,16,-8)^CRCTAB[(uint32_t)((crc^(uint16_t)(uint8_t)frame[i])&0xFFU)]; + if (i==tmp) break; + } /* end for */ + return frame[to-1L]==(char)crc && frame[to-2L]==(char)X2C_LSH(crc, + 16,-8); +} /* end crcrs() */ + +static int32_t getint32(const byte frame[], uint32_t frame_len, + uint32_t p) +{ + uint32_t n; + uint32_t i; + n = 0UL; + for (i = 3UL;; i--) { + n = n*256UL+(uint32_t)(uint8_t)frame[p+i]; + if (i==0UL) break; + } /* end for */ + return (int32_t)n; +} /* end getint32() */ + +static uint32_t getint24(const byte frame[], uint32_t frame_len, uint32_t p) { // 24bit unsigned int + uint32_t val24 = 0; + val24 = frame[p] | (frame[p+1]<<8) | (frame[p+2]<<16); + return val24; +} + +static uint32_t getcard16(const byte frame[], uint32_t frame_len, + uint32_t p) +{ + return (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t) + frame[p+1UL]; +} /* end getcard16() */ + + +static int32_t getint16(const byte frame[], uint32_t frame_len, + uint32_t p) +{ + uint32_t n; + n = (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t) + frame[p+1UL]; + if (n>=32768UL) return (int32_t)(n-65536UL); + return (int32_t)n; +} /* end getint16() */ + +// also used by MP3H.cpp +void wgs84r(double x, double y, double z, + double * lat, double * long0, + double * heig) +{ + double sl; + double ct; + double st; + double t; + double rh; + double xh; + double h; + h = x*x+y*y; + if (h>0.0) { + rh = sqrt(h); + xh = x+rh; + *long0 = atang2(xh, y)*2.0; + if (*long0>3.1415926535898) *long0 = *long0-6.2831853071796; + t = atan(X2C_DIVL(z*1.003364089821, rh)); + st = sin(t); + ct = cos(t); + *lat = atan((X2C_DIVL(z+4.2841311513312E+4*st*st*st, + rh-4.269767270718E+4*ct*ct*ct))); + sl = sin(*lat); + *heig = X2C_DIVL(rh,cos(*lat))-(X2C_DIVR(6.378137E+6f, + sqrt((1.0-6.6943799901413E-3*sl*sl)))); + } + else { + *lat = 0.0; + *long0 = 0.0; + *heig = 0.0; + } +/* lat:=atan(z/(rh*(1.0 - E2))); */ +/* heig:=sqrt(h + z*z) - EARTHA; */ +} /* end wgs84r() */ + +// returns: 0=ok, -1=error +static void posrs41(const byte b[], uint32_t b_len, uint32_t p) +{ + double dir; + double vu; + double ve; + double vn; + double vz; + double vy; + double vx; + double heig; + double long0; + double lat; + double z; + double y; + double x; + SondeData *si = &(sonde.si()->d); + x = (double)getint32(b, b_len, p)*0.01; + y = (double)getint32(b, b_len, p+4UL)*0.01; + z = (double)getint32(b, b_len, p+8UL)*0.01; + uint8_t sats = getcard16(b, b_len, p+18UL)&255UL; + Serial.printf("x:%g, y:%g, z:%g sats:%d\n", x, y, z, sats); + if( sats<4 || (x==0 && y==0 && z==0) ) { + // RS41 sometimes sends frame with all 0 + // or, if sats<4, data is simply garbage. do not use. + if(si->validPos) si->validPos |= 0x80; // flag as old + return; + } + si->sats = sats; + wgs84r(x, y, z, &lat, &long0, &heig); + Serial.print(" "); + si->lat = (float)(X2C_DIVL(lat,1.7453292519943E-2)); + Serial.print(si->lat); + Serial.print(" "); + si->lon = (float)(X2C_DIVL(long0,1.7453292519943E-2)); + Serial.print(si->lon); + if (heig<1.E+5 && heig>(-1.E+5)) { + Serial.print(" "); + Serial.print((uint32_t)heig); + Serial.print("m"); + } + /*speed */ + vx = (double)getint16(b, b_len, p+12UL)*0.01; + vy = (double)getint16(b, b_len, p+14UL)*0.01; + vz = (double)getint16(b, b_len, p+16UL)*0.01; + vn = (-(vx*sin(lat)*cos(long0))-vy*sin(lat)*sin(long0))+vz*cos(lat); + ve = -(vx*sin(long0))+vy*cos(long0); + vu = vx*cos(lat)*cos(long0)+vy*cos(lat)*sin(long0)+vz*sin(lat); + dir = X2C_DIVL(atang2(vn, ve),1.7453292519943E-2); + if (dir<0.0) dir = 360.0+dir; + si->dir = dir; + Serial.print(" "); + si->hs = sqrt(vn*vn+ve*ve); + Serial.print(si->hs*3.6); + Serial.print("km/h "); + Serial.print(dir); + Serial.print("deg "); + Serial.print((float)vu); + si->vs = vu; + Serial.print("m/s "); + si->alt = heig; + if( 0==(int)(lat*10000) && 0==(int)(long0*10000) ) { + if(si->validPos) { + // we have an old position, so keep previous position and mark it as old + si->validPos |= 0x80; + } + } + else + si->validPos = 0x7f; +} /* end posrs41() */ + +void ProcessSubframe( byte *subframeBytes, int subframeNumber ) { + // the total subframe consists of 51 rows, each row 16 bytes + // based on https://github.com/bazjo/RS41_Decoding/tree/master/RS41-SGP#Subframe + struct subframeBuffer *s = (struct subframeBuffer *)sonde.si()->extra; + // Allocate on demand + if(!s) { + s = (struct subframeBuffer *)malloc( sizeof(struct subframeBuffer) ); + if(!s) { Serial.println("ProcessSubframe: out of memory"); return; } + sonde.si()->extra = s; + s->valid = 0; + } + memcpy( s->rawData+16*subframeNumber, subframeBytes, 16); + s->valid |= (1ULL << subframeNumber); + Serial.printf("subframe %d; valid: %x%08x\n", subframeNumber, (uint32_t)(s->valid>>32), (uint32_t)s->valid); + for(int i=0; i<16; i++) { Serial.printf("%02x[%c]", subframeBytes[i],( subframeBytes[i]>20 && subframeBytes[i]<127)? subframeBytes[i] : '.'); } + Serial.println(""); + // subframeReceived[subframeNumber] = true; // mark this row of the total subframe as complete + + #if 0 + Serial.printf("subframe number: 0x%02X\n", subframeNumber ); + Serial.print("subframe values: "); + for ( int i = 0; i < 16; i++ ) { + Serial.printf( "%02X ", subframeBytes[i] ); + } + Serial.println(); + + Serial.println("Full subframe"); + for ( int j = 0; j<51; j++ ) { + Serial.printf("%03X ", j*16); + for ( int i = 0; i < 16; i++ ) { + Serial.printf( "%02X ", s.rawData[j*16+i] ); + } + Serial.println(); + } + Serial.println(); + #endif +} + +/* Find the water vapor saturation pressure for a given temperature. + * Uses the Hyland and Wexler equation with coefficients for T < 0°C. + */ +// taken from https://github.com/einergehtnochrein/ra-firmware +static float _RS41_waterVaporSaturationPressure (float Tcelsius) +{ + /* Convert to Kelvin */ + float T = Tcelsius + 273.15f; + + /* Apply some correction magic */ + T = 0 + - 0.4931358f + + (1.0f + 4.61e-3f) * T + - 1.3746454e-5f * T * T + + 1.2743214e-8f * T * T * T + ; + + /* Plug into H+W equation */ + float p = expf(-5800.2206f / T + + 1.3914993f + + 6.5459673f * logf(T) + - 4.8640239e-2f * T + + 4.1764768e-5f * T * T + - 1.4452093e-8f * T * T * T + ); + + /* Scale result to hPa */ + return p / 100.0f; +} + +#define PM(x) calibration->value.matrixP[x] +// CALIB_P: matrixP (frames 0x25..0x2A) and type (frame 0x21) +#define CALIB_P ((0x3Fll<<0x25)|(1ll<<0x21)) +float GetRAP( uint32_t m, uint32_t m1, uint32_t m2, int16_t ptraw) { + struct subframeBuffer *calibration = (struct subframeBuffer *)sonde.si()->extra; + float pt = (float)ptraw*0.01; + float pw[6]; + pw[0] = PM(0) + pt*PM(7) + pt*pt*PM(11) + pt*pt*pt*PM(15); + pw[1] = PM(1) + pt*PM(8) + pt*pt*PM(12) + pt*pt*pt*PM(16); + pw[2] = PM(2) + pt*PM(9) + pt*pt*PM(13) + pt*pt*pt*PM(17); + pw[3] = PM(3) + pt*PM(10)+ pt*pt*PM(14); + pw[4] = PM(4); + pw[5] = PM(5); + float f = (float)m; //meas[9]; + float f1 = (float)m1; //meas[10]; + float f2 = (float)m2; //meas[11]; + float r = f-f1; + if(r!=0.0) { + r = (f2-f1) * PM(6) / r; + float xx = 1.0; + float p = 0.0; + for(int i=0; i<=5; i++) { + p += pw[i] * xx; + xx = xx * r; + } + return p; + } + return NAN; +} + +// taken from https://github.com/einergehtnochrein/ra-firmware +float GetRATemp( uint32_t measuredCurrent, uint32_t refMin, uint32_t refMax, float calT, float taylorT[3], float polyT[6] ) { + struct subframeBuffer *calibration = (struct subframeBuffer *)sonde.si()->extra; + /* Reference values for temperature are two known resistors. + * From that we can derive the resistance of the sensor. + */ + float current = ( float(measuredCurrent) - float(refMin) ) / float(refMax - refMin); + float res = calibration->value.refResistorLow + + (calibration->value.refResistorHigh - calibration->value.refResistorLow) * current; + float x = res * calT; + + float Tuncal = 0 + + taylorT[0] + + taylorT[1] * x + + taylorT[2] * x * x; + + /* Apply calibration polynomial */ + float temperature = + Tuncal + polyT[0] + + polyT[1] * Tuncal + + polyT[2] * Tuncal * Tuncal + + polyT[3] * Tuncal * Tuncal * Tuncal + + polyT[4] * Tuncal * Tuncal * Tuncal * Tuncal + + polyT[5] * Tuncal * Tuncal * Tuncal * Tuncal * Tuncal; + + return temperature; +} + +// taken from https://github.com/einergehtnochrein/ra-firmware +float GetRAHumidity( uint32_t humCurrent, uint32_t humMin, uint32_t humMax, float sensorTemp, float externalTemp, float pressure ) { + struct subframeBuffer *calibration = (struct subframeBuffer *)sonde.si()->extra; + float current = float( humCurrent - humMin) / float( humMax - humMin ); + /* Compute absolute capacitance from the known references */ + float C = calibration->value.refCapLow + + (calibration->value.refCapHigh - calibration->value.refCapLow) * current; + + /* Apply calibration */ + float Cp = ( C / calibration->value.calibU[0] - 1.0f) * calibration->value.calibU[1]; + + /* Compensation for low temperature and pressure at altitude */ + if(isnan(pressure)) { + // if no pressure is available (non-SGP), estimate based on altitude + pressure = 1013.25f * expf(-1.18575919e-4f * sonde.si()->d.alt ); + } + + float Tp = (sensorTemp - 20.0f) / 180.0f; + float sum = 0; + float powc = 1.0f; + float p = pressure / 1000.0f; + for ( int i = 0; i < 3; i++) { + float l = 0; + float powt = 1.0f; + for ( int j = 0; j < 4; j++) { + l += calibration->value.matrixBt[4*i+j] * powt; + powt *= Tp; + } + float x = calibration->value.vectorBp[i]; + sum += l * (x * p / (1.0f + x * p) - x * powc / (1.0f + x)); + powc *= Cp; + } + Cp -= sum; + + float xj = 1.0f; + for ( int j = 0; j < 7; j++) { + float yk = 1.0f; + for ( int k = 0; k < 6; k++) { + sum += xj * yk * calibration->value.matrixU[j][k]; + yk *= Tp; + } + xj *= Cp; + } + + /* Since there is always a small difference between the temperature readings for + * the atmospheric (main) tempoerature sensor and the temperature sensor inside + * the humidity sensor device, transform the humidity value to the atmospheric conditions + * with its different water vapor saturation pressure. + */ + float RH = sum + * _RS41_waterVaporSaturationPressure(sensorTemp) + / _RS41_waterVaporSaturationPressure(externalTemp); + + return RH; +} + +// returns: 0: ok, -1: rs or crc error +int RS41::decode41(byte *data, int maxlen) +{ + char buf[128]; + int crcok = 1; + SondeData *si = &(sonde.si()->d); + + int32_t corr = reedsolomon41(data, 560, 131); // try short frame first + if(corr<0) { + corr = reedsolomon41(data, 560, 230); // try long frame + } +#if 0 + Serial.print("RS result:"); + Serial.print(corr); + Serial.println(); +#endif + int p = 57; // 8 byte header, 48 byte RS + while(pmaxlen) break; + +#if 0 + // DEBUG OUTPUT + Serial.print("@"); + Serial.print(p-2); + Serial.print(": ID:"); + Serial.print(typ, HEX); + Serial.print(", len="); + Serial.print(len); + Serial.print(": "); + for(int i=0; iid, (const char *)(data+p+2), 8)) { + // ID changed, i.e. new sonde on same frequency. clear calibration and all other data + sonde.clearAllData(sonde.si()); + struct subframeBuffer *sub = (struct subframeBuffer *)sonde.si()->extra; + if(sub) { sub->valid = 0; } + } + Serial.print("#"); + uint16_t fnr = data[p]+(data[p+1]<<8); + Serial.print(fnr); + si->vframe = si->frame = fnr; + Serial.print("; RS41 ID "); + snprintf(buf, 10, "%.8s ", data+p+2); + Serial.print(buf); + si->batteryVoltage = data[p+10] / 10.0f; + // not needed, if we end up here, the type has to be RS41.... si->type=STYPE_RS41; + strncpy(si->id, (const char *)(data+p+2), 8); + si->id[8]=0; + strncpy(si->ser, (const char *)(data+p+2), 8); + si->ser[8]=0; + si->validID=true; + int calnr = data[p+23]; + // not sure about this + if(calnr==0x31) { + uint16_t bt = data[p+30] + 256*data[p+31]; + si->burstKT = bt; + } + // this should be right... + if(calnr==0x02) { + uint16_t kt = data[p+31] + 256*data[p+32]; + si->launchKT = kt; + } + // and this seems fine as well... + if(calnr==0x32) { + uint16_t cntdown = data[p+24] + (data[p+25]<<8); + uint16_t min = cntdown - (cntdown/3600)*3600; + Serial.printf("Countdown value: %d\n [%2d:%02d:%02d]", cntdown, cntdown/3600, min/60, min-(min/60)*60); + si->countKT = cntdown; + si->crefKT = fnr; + } + ProcessSubframe( data+p+24, calnr ); + + } + // TODO: some more data + break; + case '|': // date + { + uint32_t gpstime = getint32(data, 560, p+2); + uint16_t gpsweek = getint16(data, 560, p); + // UTC is GPSTIME - 18s (24*60*60-18 = 86382) + // one week = 7*24*60*60 = 604800 seconds + // unix epoch starts jan 1st 1970 0:00 + // gps time starts jan 6, 1980 0:00. thats 315964800 epoch seconds. + // subtracting 86400 yields 315878400UL + si->time = (gpstime/1000) + 86382 + gpsweek*604800 + 315878400UL; + si->validTime = true; + } + break; + case '{': // pos + posrs41(data+p, len, 0); + break; + case 'z': // 0x7a is character z - 7A-MEAS temperature and humidity frame + { + uint32_t tempMeasMain = getint24(data, 560, p+0); + uint32_t tempMeasRef1 = getint24(data, 560, p+3); + uint32_t tempMeasRef2 = getint24(data, 560, p+6); + uint32_t humidityMain = getint24(data, 560, p+9); + uint32_t humidityRef1 = getint24(data, 560, p+12); + uint32_t humidityRef2 = getint24(data, 560, p+15); + uint32_t tempHumiMain = getint24(data, 560, p+18); + uint32_t tempHumiRef1 = getint24(data, 560, p+21); + uint32_t tempHumiRef2 = getint24(data, 560, p+24); + uint32_t pressureMain = getint24(data, 560, p+27); + uint32_t pressureRef1 = getint24(data, 560, p+30); + uint32_t pressureRef2 = getint24(data, 560, p+33); + int16_t ptraw = getint16(data, 560, p+38); + #if 0 + Serial.printf( "External temp: tempMeasMain = %ld, tempMeasRef1 = %ld, tempMeasRef2 = %ld\n", tempMeasMain, tempMeasRef1, tempMeasRef2 ); + Serial.printf( "Rel Humidity: humidityMain = %ld, humidityRef1 = %ld, humidityRef2 = %ld\n", humidityMain, humidityRef1, humidityRef2 ); + Serial.printf( "Humid sensor: tempHumiMain = %ld, tempHumiRef1 = %ld, tempHumiRef2 = %ld\n", tempHumiMain, tempHumiRef1, tempHumiRef2 ); + Serial.printf( "Pressure sens: pressureMain = %ld, pressureRef1 = %ld, pressureRef2 = %ld\n", pressureMain, pressureRef1, pressureRef2 ); + #endif + struct subframeBuffer *calibration = (struct subframeBuffer *)(sonde.si()->extra); + // temp: 0xF8==bits 3..7 : we need refResistorlow/high, taylorT, polyT + bool validExternalTemperature = calibration!=NULL && (calibration->valid & 0xF8) == 0xF8; + + // humidity: bits 3..20 and 37..46. and bit 33 (variant) + bool validHumidity = calibration!=NULL && (calibration->valid & 0x7FE2001FFFF8) == 0x7FE2001FFFF8; + + // pressure: bits 33 and 37..42 (variant; x25..x2a: matrixP) /// CALIB_P is 0x7E200000000) + bool validPressure = calibration!=NULL && (calibration->valid & CALIB_P)==CALIB_P && calibration->value.names.variant[7]=='P'; + + if ( validPressure ) { + si->pressure = GetRAP( pressureMain, pressureRef1, pressureRef2, ptraw ); + Serial.printf("Pressure sensor = %f\n", si->pressure); + } + + if ( validExternalTemperature ) { + si->temperature = GetRATemp( tempMeasMain, tempMeasRef1, tempMeasRef2, + calibration->value.calT, calibration->value.taylorT, calibration->value.polyT ); + Serial.printf("External temperature = %f\n", si->temperature ); + } + + if ( validHumidity && validExternalTemperature ) { + si->tempRHSensor = GetRATemp( tempHumiMain, tempHumiRef1, tempHumiRef2, + calibration->value.calTU, calibration->value.taylorTU, calibration->value.polyTrh ); + Serial.printf("Humidity Sensor temperature = %f\n", si->tempRHSensor ); + si->relativeHumidity = GetRAHumidity( humidityMain, humidityRef1, humidityRef2, si->tempRHSensor, si->temperature, si->pressure ); + Serial.printf("Relative humidity = %f\n", si->relativeHumidity ); + } + } + break; + + + + default: + break; + }} + p += len; + Serial.println(); + } + return crcok ? 0 : RX_ERROR; +} +void RS41::printRaw(uint8_t *data, int len) +{ + char buf[3]; + int i; + for(i=0; i>4]; +} + + +static uint8_t scramble[64] = {150U,131U,62U,81U,177U,73U,8U,152U,50U,5U,89U, + 14U,249U,68U,198U,38U,33U,96U,194U,234U,121U,93U,109U,161U, + 84U,105U,71U,12U,220U,232U,92U,241U,247U,118U,130U,127U,7U, + 153U,162U,44U,147U,124U,48U,99U,245U,16U,46U,97U,208U,188U, + 180U,182U,6U,170U,244U,35U,120U,110U,59U,174U,191U,123U,76U, + 193U}; + + +int RS41::receive() { + sx1278.setPayloadLength(RS41MAXLEN-8); + int e = sx1278.receivePacketTimeout(1000, data+8); +#if 1 + if(e) { /*Serial.println("TIMEOUT");*/ return RX_TIMEOUT; } + + for(int i=0; ilat = 48; + si->lon = -100; + si->alt = 30000; + si->vs = 3.4; + si->validPos = 0x7f; + si->validID = 1; + strcpy(si->id, "A1234"); + return 0; +#endif +} + +int RS41::waitRXcomplete() { + // Currently not used. can be used for additinoal post-processing + // (required for RS92 to avoid FIFO overrun in rx task) + return 0; +} + +// copy variant string to buf (max buflen chars; buflen should be 11 +// return 0 if subtype is available, -1 if not +int RS41::getSubtype(char *buf, int buflen, SondeInfo *si) { + struct subframeBuffer *sf = (struct subframeBuffer *)si->extra; + if(!sf) return -1; + if( ( (sf->valid>>0x21) &3) != 3 ) return -1; // or 1 instead of 3 for the first 8 chars only, as in autorx? + if(buflen>11) buflen=11; // then buflen should be capped at 9 (8+trailing \0) + strncpy(buf, sf->value.names.variant, buflen); + buf[buflen-1]=0; + if(*buf==0) return -1; + Serial.printf("subframe valid: %x%08x; subtype=%s\n", (uint32_t)(sf->valid>>32), (uint32_t)sf->valid, buf); + return 0; +} + +RS41 rs41 = RS41(); diff --git a/RX_FSK/src/RS41.h b/RX_FSK/src/RS41.h new file mode 100644 index 0000000..149a672 --- /dev/null +++ b/RX_FSK/src/RS41.h @@ -0,0 +1,73 @@ +/* + * RS41.h + * Functions for decoding RS41 sondes with SX127x chips + * Copyright (C) 2019 Hansi Reiser, dl9rdz + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef RS41_h +#define RS41_h + +#include +#include +#include +#ifndef inttypes_h + #include +#endif +#include "Sonde.h" +#include "DecoderBase.h" + +/* Main class */ +class RS41 : public DecoderBase +{ +private: + uint32_t bits2val(const uint8_t *bits, int len); + void printRaw(uint8_t *data, int len); + void bitsToBytes(uint8_t *bits, uint8_t *bytes, int len); + int decode41(byte *data, int maxlen); + +#if 0 +#define B 8 +#define S 4 + uint8_t hamming_conf[ 7*B]; // 7*8=56 + uint8_t hamming_dat1[13*B]; // 13*8=104 + uint8_t hamming_dat2[13*B]; + + uint8_t block_conf[ 7*S]; // 7*4=28 + uint8_t block_dat1[13*S]; // 13*4=52 + uint8_t block_dat2[13*S]; + + uint8_t H[4][8] = // extended Hamming(8,4) particy check matrix + {{ 0, 1, 1, 1, 1, 0, 0, 0}, + { 1, 0, 1, 1, 0, 1, 0, 0}, + { 1, 1, 0, 1, 0, 0, 1, 0}, + { 1, 1, 1, 0, 0, 0, 0, 1}}; + uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1}; // Spalten von H: +#endif + // 1-bit-error-Syndrome + boolean initialized = false; + +public: + RS41(); + // New interface: + // setup() is called when channel is activated (sets mode and frequency and activates receiver) + int setup(float frequency, int type = 0); + // processRXbyte is called by background task for each received byte + // should be fast enough to not cause sx127x fifo buffer overflow + // void processRXbyte(uint8_t data); + // is called approx. 1x per second, may do some post-processing of received data + // and update information in sonde data structure + // returns infomration about sucess/error (for timers and for quality bar in display) + int receive(); + int waitRXcomplete(); + //int receiveFrame(); + + static int getSubtype(char *buf, int buflen, SondeInfo *si); + + int use_ecc = 1; +}; + +extern RS41 rs41; + +#endif diff --git a/RX_FSK/src/RS92.cpp b/RX_FSK/src/RS92.cpp new file mode 100644 index 0000000..f9f6e52 --- /dev/null +++ b/RX_FSK/src/RS92.cpp @@ -0,0 +1,589 @@ + +/* RS92 decoder functions */ +#include "RS92.h" +#include "SX1278FSK.h" +#include "rsc.h" +#include "Sonde.h" +#include + +// well... +#include "rs92gps.h" + +#define RS92_DEBUG 1 + +#if RS92_DEBUG +#define RS92_DBG(x) x +#else +#define RS92_DBG(x) +#endif + +uint16_t *CRCTAB = NULL; + +#define X2C_DIVR(a, b) ((b) != 0.0f ? (a)/(b) : (a)) +#define X2C_DIVL(a, b) ((a)/(b)) +static uint32_t X2C_LSH(uint32_t a, int32_t length, int32_t n) +{ + uint32_t m; + + m = 0; + m = (length == 32) ? 0xFFFFFFFFl : (1 << length) - 1; + if (n > 0) { + if (n >= (int32_t)length) + return 0; + return (a << n) & m; + } + + if (n <= (int32_t)-length) + return 0; + return (a >> -n) & m; +} + +static void Gencrctab(void) +{ + uint16_t j; + uint16_t i; + uint16_t crc; + if(!CRCTAB) { CRCTAB=(uint16_t *)malloc(256*sizeof(uint16_t)); } + for (i = 0U; i<=255U; i++) { + crc = (uint16_t)(i*256U); + for (j = 0U; j<=7U; j++) { + if ((0x8000U & crc)) crc = X2C_LSH(crc,16,1)^0x1021U; + else crc = X2C_LSH(crc,16,1); + } /* end for */ + CRCTAB[i] = X2C_LSH(crc,16,-8)|X2C_LSH(crc,16,8); + } /* end for */ +} /* end Gencrctab() */ + + +static byte data1[512]={0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x10}; +static byte data2[512]={0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x10}; +static byte *dataptr=data1; + +static uint8_t rxbitc; +static int32_t asynst[10]={0}; +static uint16_t rxbyte; +int rxp=0; + +static int haveNewFrame = 0; +static int lastFrame = 0; +static int headerDetected = 0; + +decoderSetupCfg rs92SetupCfg = { + .bitrate = 4800, + .rx_cfg = 0x1E, + .sync_cfg = 0x70, + .sync_len = 2, + .sync_data = (const uint8_t *)"\x66\x65", + .preamble_cfg = 0xA8, +}; + +int RS92::setup(float frequency, int /*type*/) +{ +#if RS92_DEBUG + Serial.println("Setup sx1278 for RS92 sonde"); +#endif + if(!initialized) { + Gencrctab(); + initrsc(); + // not here for now.... get_eph("/brdc.19n"); + initialized = true; + } + + if(sx1278.ON()!=0) { + RS92_DBG(Serial.println("Setting SX1278 power on FAILED")); + return 1; + } + if(DecoderBase::setup(rs92SetupCfg, sonde.config.rs92.rxbw, sonde.config.rs92.rxbw)!=0) { + return 1; + } +#if 0 + if(sx1278.setFSK()!=0) { + RS92_DBG(Serial.println("Setting FSJ mode FAILED")); + return 1; + } + if(sx1278.setBitrate(4800)!=0) { + RS92_DBG(Serial.println("Setting bitrate 4800bit/s FAILED")); + return 1; + } +#if RS92_DEBUG + float br = sx1278.getBitrate(); + Serial.print("Exact bitrate is "); + Serial.println(br); +#endif + if(sx1278.setAFCBandwidth(sonde.config.rs92.rxbw)!=0) { + RS92_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.rs92.rxbw)); + return 1; + } + if(sx1278.setRxBandwidth(sonde.config.rs92.rxbw)!=0) { + RS92_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.rs92.rxbw)); + return 1; + } + + // Enable auto-AFC, auto-AGC, RX Trigger by preamble + if(sx1278.setRxConf(0x1E)!=0) { + RS92_DBG(Serial.println("Setting RX Config FAILED")); + return 1; + } + // Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte + //char header[] = "0110.0101 0110.0110 1010.0101 1010.1010"; + + //const char *SYNC="\x10\xB6\xCA\x11\x22\x96\x12\xF8"; + //const char *SYNC="\x08\x6D\x53\x88\x44\x69\x48\x1F"; + // was 0x57 + //const char *SYNC="\x99\x9A"; + // version 1, working with continuous RX + const char *SYNC="\x66\x65"; + if(sx1278.setSyncConf(0x70, 2, (const uint8_t *)SYNC)!=0) { + RS92_DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + if(sx1278.setPreambleDetect(0xA8)!=0) { + RS92_DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } +#endif + +#if 0 + // version 2, with per-packet rx start, untested + // header is 2a 10 65, i.e. with lsb first + // 0 0101 0100 1 0 0000 1000 1 0 1010 0110 1 + // 10 10011001 10011010 01 10 10101010 01101010 01 10 01100110 10010110 01 + // preamble 0x6A 0x66 0x6A + // i.e. preamble detector on (0x80), preamble detector size 1 (0x00), preample chip errors??? (0x0A) + // after 2a2a2a2a2a1065 + if(sx1278.setPreambleDetect(0xA8)!=0) { + RS92_DBG(Serial.println("Setting PreambleDetect FAILED")); + return 1; + } + // sync config: ato restart (01), preamble polarity AA (0), sync on (1), resevered (0), syncsize 2+1 (010) => 0x52 + const char *SYNC="\x6A\x66\x69"; + if(sx1278.setSyncConf(0x52, 3, (const uint8_t *)SYNC)!=0) { + RS92_DBG(Serial.println("Setting SYNC Config FAILED")); + return 1; + } + // payload length is ((240 - 7)*10 +6)/8 = 292 +#endif + + // Packet config 1: fixed len, no mancecer, no crc, no address filter + // Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0) + if(sx1278.setPacketConfig(0x08, 0x40)!=0) { + RS92_DBG(Serial.println("Setting Packet config FAILED")); + return 1; + } + + Serial.print("RS92: setting RX frequency to "); + Serial.println(frequency); + int res = sx1278.setFrequency(frequency); + sx1278.clearIRQFlags(); + + // enable RX + sx1278.setPayloadLength(0); // infinite for now... + //sx1278.setPayloadLength(292); + sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE); + +#if RS92_DEBUG + RS92_DBG(Serial.println("Setting SX1278 config for RS92 finished\n"); Serial.println()); +#endif + return res; +} + +uint32_t RS92::bits2val(const uint8_t *bits, int len) { + uint32_t val = 0; + for (int j = 0; j < len; j++) { + val |= (bits[j] << (len-1-j)); + } + return val; +} + +RS92::RS92() { +} + +/* RS92 reed solomon decoder, from dxlAPRS + */ + + +#if 0 +static char crcrs(const byte frame[], uint32_t frame_len, + int32_t from, int32_t to) +{ + uint16_t crc; + int32_t i; + int32_t tmp; + crc = 0xFFFFU; + tmp = to-3L; + i = from; + if (i<=tmp) for (;; i++) { + crc = X2C_LSH(crc,16,-8)^CRCTAB[(uint32_t)((crc^(uint16_t)(uint8_t)frame[i])&0xFFU)]; + if (i==tmp) break; + } /* end for */ + return frame[to-1L]==(char)crc && frame[to-2L]==(char)X2C_LSH(crc, + 16,-8); +} /* end crcrs() */ + +static int32_t getint32(const byte frame[], uint32_t frame_len, + uint32_t p) +{ + uint32_t n; + uint32_t i; + n = 0UL; + for (i = 3UL;; i--) { + n = n*256UL+(uint32_t)(uint8_t)frame[p+i]; + if (i==0UL) break; + } /* end for */ + return (int32_t)n; +} /* end getint32() */ + + +static uint32_t getcard16(const byte frame[], uint32_t frame_len, + uint32_t p) +{ + return (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t) + frame[p+1UL]; +} /* end getcard16() */ + + +static int32_t getint16(const byte frame[], uint32_t frame_len, + uint32_t p) +{ + uint32_t n; + n = (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t) + frame[p+1UL]; + if (n>=32768UL) return (int32_t)(n-65536UL); + return (int32_t)n; +} /* end getint16() */ + +static void wgs84r(double x, double y, double z, + double * lat, double * long0, + double * heig) +{ + double sl; + double ct; + double st; + double t; + double rh; + double xh; + double h; + h = x*x+y*y; + if (h>0.0) { + rh = (double)sqrt((float)h); + xh = x+rh; + *long0 = atang2(xh, y)*2.0; + if (*long0>3.1415926535898) *long0 = *long0-6.2831853071796; + t = (double)atan((float)(X2C_DIVL(z*1.003364089821, + rh))); + st = (double)sin((float)t); + ct = (double)cos((float)t); + *lat = (double)atan((float) + (X2C_DIVL(z+4.2841311513312E+4*st*st*st, + rh-4.269767270718E+4*ct*ct*ct))); + sl = (double)sin((float)*lat); + *heig = X2C_DIVL(rh,(double)cos((float)*lat))-(double)(X2C_DIVR(6.378137E+6f, + sqrt((float)(1.0-6.6943799901413E-3*sl*sl)))); + } + else { + *lat = 0.0; + *long0 = 0.0; + *heig = 0.0; + } +/* lat:=atan(z/(rh*(1.0 - E2))); */ +/* heig:=sqrt(h + z*z) - EARTHA; */ +} /* end wgs84r() */ +#endif + + +static int32_t reedsolomon92(uint8_t *buf, uint32_t buf_len) +{ + uint32_t i; + int32_t res; + uint8_t b[256]; + uint32_t eraspos[24]; + for (i = 0UL; i<=255UL; i++) { + b[i] = 0; + } /* end for */ + for (i = 0UL; i<=209UL; i++) { + b[230UL-i] = buf[i+6UL]; + } /* end for */ + for (i = 0UL; i<=23UL; i++) { + b[254UL-i] = buf[i+216UL]; + } /* end for */ + res = decodersc((char *)b, eraspos, 0L); + if (res>0L && res<=12L) { + for (i = 0UL; i<=209UL; i++) { + buf[i+6UL] = b[230UL-i]; + } /* end for */ + for (i = 0UL; i<=23UL; i++) { + buf[i+216UL] = b[254UL-i]; + } /* end for */ + } + return res; +} /* end reedsolomon92() */ + +void printRaw(uint8_t *data, int len) +{ + char buf[3]; + int i; + for(i=0; i240) { + Serial.print("RS92 frame too long: "); + Serial.println(len); + break; + } + ++p; + j=0; + uint16_t crc = 0xFFFF; + while(j240) { + Serial.println("eof"); + return; + } + } + if ( (((uint8_t)(crc&0xff)) != data[p-2]) || (((uint8_t)(crc>>8)) != data[p-1])) { + Serial.printf("************ crc error: expected %04x\n",crc); + continue; + } + switch(typ) { + case 'e': + Serial.println("cal "); + //docalib(sf, 256, objname, 9, &contextr9, &mhz, &frameno); + // ... + break; + case 'i': + if(calok && calibok==0xffffffff) { + //domes(sf, 256, &hp, &hyg, &temp) + mesok = 1; + } + break; + case 'g': + Serial.println("gps "); + if(1||calok) { + //dogps(data+p-len, 256, &contextr9, &contextr9.timems, &gpstime); + } + break; + case 'h': + Serial.println("data "); break; + if(data[p+2]!=3) Serial.println("aux "); + // .. + break; + } + } +#endif +} /* end decodeframe92() */ + + + + + +void RS92::printRaw(uint8_t *data, int len) +{ + char buf[3]; + int i; + for(i=0; i=5 || b=='*') rxp++; else rxp=0; + if(rxp==6) { // header detected + headerDetected = 1; + } + if(rxp>=240) { // frame complete... (240 byte) + rxp=0; + //printRaw(data, 240); + decodeframe92(dataptr); + haveNewFrame = 1; + } +} /* end stobyte92() */ + + +uint32_t rxdata; +bool rxsearching=true; + +// search for +// 101001100110011010011010011001100110100110101010100110101001 +// 1010011001100110100110100110 0110.0110 1001.1010 1010.1001 1010.1001 => 0x669AA9A9 +void RS92::process8N1data(uint8_t dt) +{ + for(int i=0; i<8; i++) { + uint8_t d = (dt&0x80)?1:0; + rxdata = (rxdata<<1) | d; + if((rxbitc&1)==1) { rxbyte = (rxbyte>>1) + (d<<9); } // mancester decoded data + dt <<= 1; + // + if(rxsearching) { + if(rxdata == 0x669AA9A9) { + rxsearching = false; + rxbitc = 0; + rxp = 6; + int rssi=sx1278.getRSSI(); + int fei=sx1278.getFEI(); + int afc=sx1278.getAFC(); + Serial.print("Test: RSSI="); Serial.print(rssi); + Serial.print(" FEI="); Serial.print(fei); + Serial.print(" AFC="); Serial.println(afc); + sonde.si()->rssi = rssi; + sonde.si()->afc = afc; + } + } else { + rxbitc = (rxbitc+1)%20; + if(rxbitc == 0) { // got startbit, 8 data bit, stop bit + //Serial.printf("%03x ",rxbyte); + dataptr[rxp++] = (rxbyte>>1)&0xff; + if(rxp==7 && dataptr[6] != 0x65) { + Serial.printf("wrong start: %02x\n",dataptr[6]); + rxsearching = true; + } + if(rxp>=240) { + rxsearching = true; + decodeframe92(dataptr); + haveNewFrame = 1; + } + } + } + } +} + +void process8N1dataOrig(uint8_t data) +{ + // data contains 8 bits (after mancester encoding; 4 real bit), big endian + for(int i=0; i<4; i++) { + uint8_t d = (data&0x80)?1:0; + data = data << 2; + rxbyte = (rxbyte>>1) + (d<<8); + int maxk = 0; + int max0 = 0; + for(int k = 0; k< 10; k++) { + int n = asynst[k] - asynst[(k+1)%10]; + if(abs(n)>abs(max0)) { + max0 = n; + maxk = k; + } + } + //Serial.printf("<%d,%d,%d>",max0,maxk,rxbitc); + if(rxbitc == maxk) { + if(max0<0) { rxbyte = rxbyte ^ 0xFF; } + /////TODO stobyte92( rxbyte&0xff ); + } + //Serial.printf("%d:",asynst[rxbitc]); + if(d) { + asynst[rxbitc] += (32767-asynst[rxbitc])/16; + } else { + asynst[rxbitc] -= (32767+asynst[rxbitc])/16; + } + //Serial.printf("%d ",asynst[rxbitc]); + rxbitc = (rxbitc+1) % 10; + } +} + +int RS92::receive() { + unsigned long t0 = millis(); + Serial.printf("RS92::receive() start at %ld\n",t0); + while( millis() - t0 < 1000 ) { + uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2); + if ( bitRead(value, 7) ) { + Serial.println("FIFO full"); + } + if ( bitRead(value, 4) ) { + Serial.println("FIFO overflow"); + } + if ( bitRead(value, 2) == 1 ) { + Serial.println("FIFO: ready()"); + sx1278.clearIRQFlags(); + } + if(bitRead(value, 6) == 0) { // while FIFO not empty + byte data = sx1278.readRegister(REG_FIFO); + //Serial.printf("%02x",data); + process8N1data(data); + value = sx1278.readRegister(REG_IRQ_FLAGS2); + } else { + if(headerDetected) { + t0 = millis(); // restart timer... don't time out if header detected... + headerDetected = 0; + } + if(haveNewFrame) { + Serial.printf("RS92::receive(): new frame complete after %ldms\n", millis()-t0); + haveNewFrame = 0; + return RX_OK; + } + delay(2); + } + } + Serial.printf("RS92::receive() timed out\n"); + return RX_TIMEOUT; // TODO RX_OK; +} + +#define RS92MAXLEN (240) +int RS92::waitRXcomplete() { + // called after complete... + Serial.printf("decoding frame %d\n", lastFrame); + print_frame(lastFrame==1?data1:data2, 240); + + SondeData *si = &( (sonde.sondeList+rxtask.receiveSonde)->d ); + si->lat = gpx.lat; + si->lon = gpx.lon; + si->alt = gpx.alt; + si->vs = gpx.vU; + si->hs = gpx.vH; + si->dir = gpx.vD; + si->validPos = 0x3f; + memcpy(si->id, gpx.id, 9); + memcpy(si->ser, gpx.id, 9); + si->validID = true; + si->vframe = si->frame = gpx.frnr; + si->sats = gpx.k; + si->time = (gpx.gpssec/1000) + 86382 + gpx.week*604800 + 315878400UL; + si->validTime = true; + + return 0; +} + + + +RS92 rs92 = RS92(); diff --git a/RX_FSK/src/RS92.h b/RX_FSK/src/RS92.h new file mode 100644 index 0000000..8c88add --- /dev/null +++ b/RX_FSK/src/RS92.h @@ -0,0 +1,92 @@ +/* + * RS92.h + * Functions for decoding RS92 sondes with SX127x chips + * Copyright (C) 2019 Hansi Reiser, dl9rdz + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef RS92_h +#define RS92_h + +#include +#include +#include +#ifndef inttypes_h + #include +#endif +#include "DecoderBase.h" + + +struct CONTEXTR9 { + char calibdata[512]; + uint32_t calibok; + char mesok; + char posok; + char framesent; + double lat; + double lon; + double heig; + double speed; + double dir; + double climb; + double lastlat; + double laslong; + double lastalt; + double lastspeed; + double lastdir; + double lastclb; + float hrmsc; + float vrmsc; + double hp; + double hyg; + double temp; + double ozontemp; + double ozon; + uint32_t goodsats; + uint32_t timems; + uint32_t framenum; +}; + + +/* Main class */ +class RS92 : public DecoderBase +{ +private: + void process8N1data(uint8_t data); + void stobyte92(uint8_t byte); + void decodeframe92(uint8_t *data); + uint32_t bits2val(const uint8_t *bits, int len); + void printRaw(uint8_t *data, int len); + int bitsToBytes(uint8_t *bits, uint8_t *bytes, int len); + int decode92(byte *data, int maxlen); + + uint8_t hamming_conf[ 7*8]; // 7*8=56 + uint8_t hamming_dat1[13*8]; // 13*8=104 + uint8_t hamming_dat2[13*8]; + + uint8_t block_conf[ 7*4]; // 7*4=28 + uint8_t block_dat1[13*4]; // 13*4=52 + uint8_t block_dat2[13*4]; + + uint8_t H[4][8] = // extended Hamming(8,4) particy check matrix + {{ 0, 1, 1, 1, 1, 0, 0, 0}, + { 1, 0, 1, 1, 0, 1, 0, 0}, + { 1, 1, 0, 1, 0, 0, 1, 0}, + { 1, 1, 1, 0, 0, 0, 0, 1}}; + uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1}; // Spalten von H: + // 1-bit-error-Syndrome + boolean initialized = false; + +public: + RS92(); + int setup(float frequency, int type = 0); + int receive(); + int waitRXcomplete(); + + int use_ecc = 1; +}; + +extern RS92 rs92; + +#endif diff --git a/RX_FSK/src/SX1278FSK.cpp b/RX_FSK/src/SX1278FSK.cpp new file mode 100644 index 0000000..f61e0ce --- /dev/null +++ b/RX_FSK/src/SX1278FSK.cpp @@ -0,0 +1,886 @@ +/* + * Functions for using SX127x in FSK mode (mainly receive) + * Copyright (C) 2019 Hansi Reiser, dl9rdz + * + * Partially based on the SX1278 libraray for managing Semtech modules + * Copyright (C) 2015 Wireless Open Source + * http://wirelessopensource.com + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#include "SX1278FSK.h" +#include "SPI.h" +#include "Sonde.h" +#include "Display.h" + + +#define SPI_MUTEX_LOCK() \ + do \ + { \ + } while (xSemaphoreTake(_lock, portMAX_DELAY) != pdPASS) +#define SPI_MUTEX_UNLOCK() xSemaphoreGive(_lock) + +SX1278FSK::SX1278FSK() {} + +void SX1278FSK::setup(xSemaphoreHandle lock) +{ + _lock = lock; + Serial.println("Setup sx1278"); + if(_lock) SPI_MUTEX_LOCK(); + digitalWrite(sonde.config.sx1278_ss, HIGH); + pinMode(sonde.config.sx1278_ss, OUTPUT); + Serial.printf("Configuing SX1278FSK SPI with miso=%d, mosi=%d, sck=%d, ss=%d\n", sonde.config.sx1278_miso, + sonde.config.sx1278_mosi, sonde.config.sx1278_sck, sonde.config.sx1278_ss); + SPI.begin(sonde.config.sx1278_sck, sonde.config.sx1278_miso, sonde.config.sx1278_mosi, -1); // no hardware CS + // was: SPI.begin(); + + //Set most significant bit first + SPI.setBitOrder(MSBFIRST); + //Divide the clock frequency + SPI.setClockDivider(SPI_CLOCK_DIV2); + //Set data mode + SPI.setDataMode(SPI_MODE0); + if(_lock) SPI_MUTEX_UNLOCK(); +}; + + +static SPISettings spiset = SPISettings(10000000L, MSBFIRST, SPI_MODE0); + +/* +Function: Turns the module ON. +Returns: 0 on success, 1 otherwise +*/ +uint8_t SX1278FSK::ON() +{ + uint8_t state = 2; +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'ON'")); +#endif + + // Set Maximum Over Current Protection + state = setMaxCurrent(0x1B); + if( state == 0 ) + { +#if (SX1278FSK_debug_mode > 1) + Serial.println(F("## Setting ON with maximum current supply ##")); + Serial.println(); +#endif + } + else + { + return 1; + } + // set FSK mode + state = setFSK(); + return state; +} + +/* +Function: Turn the module OFF. +Returns: Nothing +*/ +void SX1278FSK::OFF() +{ +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'OFF'")); +#endif + + //SPI.end(); +#if 0 + // Powering the module + pinMode(SX1278_SS,OUTPUT); + digitalWrite(SX1278_SS,LOW); +#endif + +#if (SX1278FSK_debug_mode > 1) + Serial.println(F("## Setting OFF ##")); + Serial.println(); +#endif +} + +/* +Function: Reads the indicated register. +Returns: The content of the register +Parameters: + address: address register to read from +*/ +byte SX1278FSK::readRegister(byte address) +{ + byte value = 0x00; + + if(_lock) SPI_MUTEX_LOCK(); + digitalWrite(sonde.config.sx1278_ss,LOW); + SPI.beginTransaction(spiset); + + //delay(1); + bitClear(address, 7); // Bit 7 cleared to write in registers + SPI.transfer(address); + value = SPI.transfer(0x00); + SPI.endTransaction(); + digitalWrite(sonde.config.sx1278_ss,HIGH); + +#if (SX1278FSK_debug_mode > 1) + if(address!=0x3F) { + Serial.print(F("## Reading: ##\t")); + Serial.print(F("Register ")); + Serial.print(address, HEX); + Serial.print(F(": ")); + Serial.print(value, HEX); + Serial.println(); + } +#endif + if(_lock) SPI_MUTEX_UNLOCK(); + return value; +} + +/* +Function: Writes on the indicated register. +Returns: Nothing +Parameters: + address: address register to write in + data: value to write in the register +*/ +void SX1278FSK::writeRegister(byte address, byte data) +{ + if(_lock) SPI_MUTEX_LOCK(); + digitalWrite(sonde.config.sx1278_ss,LOW); + SPI.beginTransaction(spiset); + + //delay(1); + bitSet(address, 7); // Bit 7 set to read from registers + SPI.transfer(address); + SPI.transfer(data); + SPI.endTransaction(); + digitalWrite(sonde.config.sx1278_ss,HIGH); + +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("## Writing: ##\t")); + Serial.print(F("Register ")); + bitClear(address, 7); + Serial.print(address, HEX); + Serial.print(F(": ")); + Serial.print(data, HEX); + Serial.println(); +#endif + if(_lock) SPI_MUTEX_UNLOCK(); +} + +/* + * Function: Clears the IRQ flags + * + * Configuration registers are accessed through the SPI interface. + * Registers are readable in all device mode including Sleep. However, they + * should be written only in Sleep and Stand-by modes. + * + * Returns: Nothing + */ +void SX1278FSK::clearIRQFlags() +{ +#if 0 + byte st0; + // Save the previous status + st0 = readRegister(REG_OP_MODE); + // Stdby mode to write in registers + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); +#endif + // FSK mode flags1 register + writeRegister(REG_IRQ_FLAGS1, 0xFF); + // FSK mode flags2 register + writeRegister(REG_IRQ_FLAGS2, 0xFF); +#if 0 + // Getting back to previous status + if(st0 != FSK_STANDBY_MODE) { + writeRegister(REG_OP_MODE, st0); + } +#endif +#if (SX1278FSK_debug_mode > 1) + Serial.println(F("## FSK flags cleared ##")); +#endif +} + +/* +Function: Sets the module in FSK mode. +Returns: Integer that determines if there has been any error + state = 2 --> The command has not been executed + state = 1 --> There has been an error while executing the command + state = 0 --> The command has been executed with no errors +*/ +uint8_t SX1278FSK::setFSK() +{ + uint8_t state = 2; + byte st0; + //byte config1; + +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'setFSK'")); +#endif + + writeRegister(REG_OP_MODE, FSK_SLEEP_MODE); // Sleep mode (mandatory to change mode) + // If we are in LORA mode, above line activate Sleep mode, but does not change mode to FSK + // as mode change is only allowed in sleep mode. Next line changes to FSK + writeRegister(REG_OP_MODE, FSK_SLEEP_MODE); + + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // FSK standby mode + + //writeRegister(REG_FIFO_THRESH, 0x80); // condition to start packet tx + //config1 = readRegister(REG_SYNC_CONFIG); + //config1 = config1 & B00111111; + //writeRegister(REG_SYNC_CONFIG,config1); + + delay(100); + + st0 = readRegister(REG_OP_MODE); // Reading config mode + if( st0 == FSK_STANDBY_MODE ) + { // FSK mode + state = 0; +#if (SX1278FSK_debug_mode > 1) + Serial.println(F("## FSK set with success ##")); + Serial.println(); +#endif + } else { // LoRa mode + state = 1; + Serial.println( st0 ); +#if (SX1278FSK_debug_mode > 1) + Serial.println(F("** There has been an error while setting FSK **")); + Serial.println(); +#endif + } + return state; +} + + +/* Function: Sets FSK bitrate + * Returns: 0 for success, >0 in case of error + * Parameters: bps: requested bitrate + * (raw data rate, for Mancester encoding, the effective bitrate is bps/2) +*/ + +uint8_t SX1278FSK::setBitrate(float bps) +{ + // TODO: Check if FSK mode is active + + // check if bitrate is allowed allowed bitrate + if((bps < 1200) || (bps > 300000)) { + return 1; + } + + // set mode to FSK STANDBY + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); + + // set bit rate + uint16_t bitRate = (SX127X_CRYSTAL_FREQ * 1.0) / bps; + writeRegister(REG_BITRATE_MSB, (bitRate & 0xFF00) >> 8); + writeRegister(REG_BITRATE_LSB, (bitRate & 0x00FF)); + + // also set fractional part + uint16_t fracRate = (SX127X_CRYSTAL_FREQ * 16.0) / bps - bitRate * 16 + 0.5; + writeRegister(REG_BIT_RATE_FRAC, fracRate&0x0F); + return 0; +} +/* Function: Gets configured bitrate + * Returns bitrate in bit/second + */ +float SX1278FSK::getBitrate() +{ + uint8_t fmsb = readRegister(REG_BITRATE_MSB); + uint8_t flsb = readRegister(REG_BITRATE_LSB); + uint8_t ffrac = readRegister(REG_BIT_RATE_FRAC) & 0x0F; + return SX127X_CRYSTAL_FREQ / ( (fmsb<<8) + flsb + ffrac / 16.0 ); +} + +//typedef struct rxbwset { float bw; uint8_t mant; uint8_t rxp; } st_rxbwsettings; + +uint8_t SX1278FSK::setRxBandwidth(float bw) +{ + // TODO: Check if in FSK mode + // + if(bw<2600 || bw>250000) { return 1; /* invalid */ } + + uint8_t rxbwexp = 1; + bw = SX127X_CRYSTAL_FREQ / bw / 8; + while(bw>31) { rxbwexp++; bw/=2.0; } + uint8_t rxbwmant = bw<17?0 : bw<21? 1:2; + + // set mode to FSK STANDBY + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); + + writeRegister(REG_RX_BW, rxbwexp | (rxbwmant<<3)); + return 0; +} + +float SX1278FSK::getRxBandwidth() +{ + uint8_t rxbw = readRegister(REG_RX_BW); + uint8_t rxbwexp = rxbw&0x07; + uint8_t rxbwmant = (rxbw>>3)&0x03; + rxbwmant = 16 + 4*rxbwmant; + return SX127X_CRYSTAL_FREQ / ( rxbwmant << (rxbwexp+2)); +} + +uint8_t SX1278FSK::setAFCBandwidth(float bw) +{ + // TODO: Check if in FSK mode + // + if(bw<2600 || bw>250000) { return 1; /* invalid */ } + + uint8_t rxbwexp = 1; + bw = SX127X_CRYSTAL_FREQ / bw / 8; + while(bw>31) { rxbwexp++; bw/=2.0; } + uint8_t rxbwmant = bw<17?0 : bw<21? 1:2; + + // set mode to FSK STANDBY + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); + + writeRegister(REG_AFC_BW, rxbwexp | (rxbwmant<<3)); + return 0; +} + +float SX1278FSK::getAFCBandwidth() +{ + uint8_t rxbw = readRegister(REG_AFC_BW); + uint8_t rxbwexp = rxbw&0x07; + uint8_t rxbwmant = (rxbw>>3)&0x03; + rxbwmant = 16 + 4*rxbwmant; + return SX127X_CRYSTAL_FREQ / ( rxbwmant << (rxbwexp+2)); +} + + +uint8_t SX1278FSK::setFrequency(float freq) { + + // set mode to FSK STANDBY + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); + freq += sonde.config.freqofs; // manual frequency correction + + uint32_t frf = freq * 1.0 * (1<<19) / SX127X_CRYSTAL_FREQ; + writeRegister(REG_FRF_MSB, (frf&0xff0000)>>16); + writeRegister(REG_FRF_MID, (frf&0x00ff00)>>8); + writeRegister(REG_FRF_LSB, (frf&0x0000ff)); + return 0; +} + +float SX1278FSK::getFrequency() { + uint8_t fmsb = readRegister(REG_FRF_MSB); + uint8_t fmid = readRegister(REG_FRF_MID); + uint8_t flsb = readRegister(REG_FRF_LSB); + return ((fmsb<<16)|(fmid<<8)|flsb) * 1.0 / (1<<19) * SX127X_CRYSTAL_FREQ; +} + + +static int gaintab[]={-999,0,-6,-12,-24,-36,-48,-999}; +int SX1278FSK::getLNAGain() { + int gain = (readRegister(REG_LNA)>>5)&0x07; + return gaintab[gain]; +} +uint8_t SX1278FSK::setLNAGain(int gain) { + uint8_t g=1; + while(gain8) return 1; + for(int i=0; i 1) + Serial.println(); + Serial.println(F("Starting 'getPreambleLength'")); +#endif + + p_length = readRegister(REG_PREAMBLE_MSB_FSK); + p_length = (p_length<<8) | readRegister(REG_PREAMBLE_LSB_FSK); +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("## Preamble length configured is ")); + Serial.print(p_length, HEX); + Serial.print(F(" ##")); + Serial.println(); +#endif + return p_length; +} + +/* +Function: Sets the preamble length in the module +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +Parameters: +l: length value to set as preamble length. +*/ +uint8_t SX1278FSK::setPreambleLength(uint16_t l) +{ + byte st0; + int8_t state = 2; + +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'setPreambleLength'")); +#endif + + st0 = readRegister(REG_OP_MODE); // Save the previous status + + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Set Standby mode to write in registers + // Storing MSB preamble length in FSK mode + writeRegister(REG_PREAMBLE_MSB_FSK, l>>8); + writeRegister(REG_PREAMBLE_LSB_FSK, l&0xFF); + + state = 0; +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("## Preamble length ")); + Serial.print(l, HEX); + Serial.println(F(" has been successfully set ##")); + Serial.println(); +#endif + + if(st0 != FSK_STANDBY_MODE) { + writeRegister(REG_OP_MODE, st0); // Getting back to previous status + } + return state; +} + +/* +Function: Gets the payload length from the module. +Returns: configured length; -1 on error +*/ +int SX1278FSK::getPayloadLength() +{ + int length; +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'getPayloadLength'")); +#endif + length = readRegister(REG_PAYLOAD_LENGTH_FSK); + +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("## Payload length configured is ")); + Serial.print(length); + Serial.println(F(" ##")); +#endif + return length; +} + +/* +Function: Sets the payload length from the module. +Returns: 0 for ok, otherwise error +// TODO: Larger than 255 bytes? +*/ +uint8_t SX1278FSK::setPayloadLength(int len) +{ +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("Starting 'setPayloadLength'")); + Serial.println(len); +#endif + uint8_t conf2 = readRegister(REG_PACKET_CONFIG2); + conf2 = (conf2 & 0xF8) | ( (len>>8)&0x7 ); + writeRegister(REG_PACKET_CONFIG2, conf2); + writeRegister(REG_PAYLOAD_LENGTH_FSK, len&0xFF); + return 0; +} + +/* +Function: Gets the current value of RSSI. +Returns: RSSI value +*/ +int16_t SX1278FSK::getRSSI() +{ + int16_t RSSI; + //int rssi_mean = 0; + int total = 1; + + /// FSK mode + // get mean value of RSSI + for(int i = 0; i < total; i++) + { + RSSI = readRegister(REG_RSSI_VALUE_FSK); + //rssi_mean += _RSSI; + } + //rssi_mean = rssi_mean / total; + //RSSI = rssi_mean; + +#if (SX1278FSK_debug_mode > 0) + Serial.print(F("## RSSI value is ")); + Serial.print(RSSI); + Serial.println(F(" ##")); +#endif + return RSSI; +} + +/* +Function: Gets the current value of FEI (frequency error indication) +Returns: FEI value in Hz +*/ +int32_t SX1278FSK::getFEI() +{ + int32_t FEI; + int16_t regval = (readRegister(REG_FEI_MSB)<<8) | readRegister(REG_FEI_LSB); + //Serial.printf("feireg: %04x\n", regval); + FEI = (int32_t)(regval * SX127X_FSTEP); + return FEI; +} +/* +Function: Gets the current value of AFC (automated frequency correction) +Returns: AFC value in Hz +*/ +int32_t SX1278FSK::getAFC() +{ + int32_t AFC; + int16_t regval = (readRegister(REG_AFC_MSB)<<8) | readRegister(REG_AFC_LSB); + //Serial.printf("afcreg: %04x\n", regval); + AFC = (int32_t)(regval * SX127X_FSTEP); + return AFC; +} +uint16_t SX1278FSK::getRawAFC() { + return (readRegister(REG_AFC_MSB)<<8) | readRegister(REG_AFC_LSB); +} +void SX1278FSK::setRawAFC(uint16_t afc) { + writeRegister(REG_AFC_MSB, afc>>8); + writeRegister(REG_AFC_LSB, afc&0xFF); +} + +/* +Function: Gets the current supply limit of the power amplifier, protecting battery chemistries. +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +Parameters: +rate: value to compute the maximum current supply. Maximum current is 45+5*'rate' [mA] +*/ +int SX1278FSK::getMaxCurrent() +{ + int value; + +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'getMaxCurrent'")); +#endif + + value = readRegister(REG_OCP); + + // extract only the OcpTrim value from the OCP register + value &= B00011111; + + if( value <= 15 ) { + value = (45 + (5 * value)); + } else if( value <= 27 ) { + value = (-30 + (10 * value)); + } else { + value = 240; + } +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("## Maximum current supply configured is ")); + Serial.print(value, DEC); + Serial.println(F(" mA ##")); + Serial.println(); +#endif + return value; +} + +/* +Function: Limits the current supply of the power amplifier, protecting battery chemistries. +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +state = -1 --> Forbidden parameter value for this function +Parameters: +rate: value to compute the maximum current supply. Range: 0x00 to 0x1B. The +Maximum current is: +Imax = 45+5*OcpTrim [mA] if OcpTrim <= 15 (120 mA) / +Imax = -30+10*OcpTrim [mA] if 15 < OcpTrim <= 27 (130 to 240 mA) +Imax = 240mA for higher settings +*/ +int8_t SX1278FSK::setMaxCurrent(uint8_t rate) +{ + int8_t state = 2; + byte st0; + +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'setMaxCurrent'")); +#endif + + // Maximum rate value = 0x1B, because maximum current supply = 240 mA + if (rate > 0x1B) + { + state = -1; +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("** Maximum current supply is 240 mA, ")); + Serial.println(F("so maximum parameter value must be 27 (DEC) or 0x1B (HEX) **")); + Serial.println(); +#endif + } + else + { + // Enable Over Current Protection + rate |= B00100000; + + //state = 1; + st0 = readRegister(REG_OP_MODE); // Save the previous status + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Set FSK Standby mode to write in registers + writeRegister(REG_OCP, rate); // Modifying maximum current supply + if(st0 != FSK_STANDBY_MODE) { + writeRegister(REG_OP_MODE, st0); // Getting back to previous status + } + state = 0; + } + return state; +} + + +/* +Function: Configures the module to receive information. +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +*/ +uint8_t SX1278FSK::receive() +{ + uint8_t state = 1; +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'receive'")); +#endif + // TODO: Is there anything else to be done? + // + writeRegister(REG_OP_MODE, FSK_RX_MODE); + state = 0; +#if (SX1278FSK_debug_mode > 1) + Serial.println(F("## Receiving FSK mode activated with success ##")); +#endif + return state; +} + +/* +Function: Configures the module to receive a packet +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +Parameters: + wait: timeout in ms + data: memory where to place received data +*/ +uint8_t SX1278FSK::receivePacketTimeout(uint32_t wait, byte *data) +{ + int di=0; + uint8_t state = 2; + unsigned long previous; + byte value = 0x00; +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'receivePacketTimeout'")); +#endif + // set RX mode + state = receive(); + if(state != 0) { return state; } + +#if (SX1278FSK_debug_mode > 0) + Serial.println(F("RX mode sucessfully activated")); +#endif + previous = millis(); + /// FSK mode + value = readRegister(REG_IRQ_FLAGS2); + byte ready=0; + // while not yet done or FIFO not yet empty + while( (!ready || bitRead(value,6)==0) && (millis() - previous < wait) ) + { + if( bitRead(value,2)==1 ) ready=1; + if( bitRead(value, 6) == 0 ) { // FIFO not empty + data[di++] = readRegister(REG_FIFO); + // It's a bit of a hack.... get RSSI and AFC (a) at beginning of packet and + // for RS41 after about 0.5 sec. It might be more logical to put this decoder-specific + // code into RS41.cpp instead of this file... (maybe TODO?) + if(di==1 || di==290 ) { + int rssi=getRSSI(); + int afc=getAFC(); +#if 0 + Serial.printf("Test(%d): RSSI=%d", rxtask.currentSonde, rssi/2); + Serial.print("Test: AFC="); Serial.println(afc); +#endif + sonde.sondeList[rxtask.currentSonde].rssi = rssi; + sonde.sondeList[rxtask.currentSonde].afc = afc; + if(rxtask.receiveResult==0xFFFF) + rxtask.receiveResult = RX_UPDATERSSI; + //sonde.si()->rssi = rssi; + //sonde.si()->afc = afc; + } + if(di>520) { + // TODO + Serial.println("TOO MUCH DATA"); + break; + } + previous = millis(); // reset timeout after receiving data + } else { + delay(10); + } + value = readRegister(REG_IRQ_FLAGS2); + } + if( !ready || bitRead(value, 6)==0) { +#if 1&&(SX1278FSK_debug_mode > 0) + Serial.println(F("** The timeout has expired **")); + Serial.println(); +#endif + sonde.si()->rssi = getRSSI(); + writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); // Setting standby FSK mode + return 1; // TIMEOUT + } + +#if (SX1278FSK_debug_mode > 0) + Serial.println(F("## Packet received:")); + for(unsigned int i = 0; i < di; i++) + { + Serial.print(data[i], HEX); // Printing payload + Serial.print("|"); + } + Serial.println(F(" ##")); +#endif + state = 0; + // Initializing flags + clearIRQFlags(); + + return state; +} + + +#if 0 +/* +Function: It gets the temperature from the measurement block module. +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +*/ +uint8_t SX1278FSK::getTemp() +{ + byte st0; + uint8_t state = 2; + +#if (SX1278FSK_debug_mode > 1) + Serial.println(); + Serial.println(F("Starting 'getTemp'")); +#endif + + st0 = readRegister(REG_OP_MODE); // Save the previous status + + if( _modem == LORA ) + { // Allowing access to FSK registers while in LoRa standby mode + writeRegister(REG_OP_MODE, LORA_STANDBY_FSK_REGS_MODE); + } + + state = 1; + // Saving temperature value + _temp = readRegister(REG_TEMP); + if( _temp & 0x80 ) // The SNR sign bit is 1 + { + // Invert and divide by 4 + _temp = ( ( ~_temp + 1 ) & 0xFF ); + } + else + { + // Divide by 4 + _temp = ( _temp & 0xFF ); + } + + +#if (SX1278FSK_debug_mode > 1) + Serial.print(F("## Temperature is: ")); + Serial.print(_temp); + Serial.println(F(" ##")); + Serial.println(); +#endif + + if( _modem == LORA ) + { + writeRegister(REG_OP_MODE, st0); // Getting back to previous status + } + + state = 0; + return state; +} + +/* +Function: It prints the registers related to RX +Returns: Integer that determines if there has been any error +state = 2 --> The command has not been executed +state = 1 --> There has been an error while executing the command +state = 0 --> The command has been executed with no errors +*/ +void SX1278FSK::showRxRegisters() +{ + Serial.println(F("\n--- Show RX register ---")); + + // variable + byte reg; + + for(int i = 0x00; i < 0x80; i++) + { + reg = readRegister(i); + Serial.print(F("Reg 0x")); + Serial.print(i, HEX); + Serial.print(F(":")); + Serial.print(reg, HEX); + Serial.println(); + delay(100); + } + + Serial.println(F("------------------------")); + +} +#endif + +xSemaphoreHandle globalLock =xSemaphoreCreateMutex(); +SX1278FSK sx1278 = SX1278FSK(); diff --git a/RX_FSK/src/SX1278FSK.h b/RX_FSK/src/SX1278FSK.h new file mode 100644 index 0000000..ea95b69 --- /dev/null +++ b/RX_FSK/src/SX1278FSK.h @@ -0,0 +1,280 @@ +/* + * Functions for using SX127x in FSK mode (mainly receive) + * Copyright (C) 2019 Hansi Reiser, dl9rdz + * + * Partially based on the SX1278 libraray for managing Semtech modules + * Copyright (C) 2015 Wireless Open Source + * http://wirelessopensource.com + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef SX1278FSK_h +#define SX1278FSK_h + +/****************************************************************************** + * Includes + ******************************************************************************/ + +#include +#include +#include +#include + +#ifndef inttypes_h + #include +#endif + + +/****************************************************************************** + * Definitions & Declarations + *****************************************************************************/ + +#define SX127X_CRYSTAL_FREQ 32000000 +#define SX127X_FSTEP (SX127X_CRYSTAL_FREQ*1.0/(1<<19)) + +#define SX1278FSK_debug_mode 0 + +//! MACROS // +#define bitRead(value, bit) (((value) >> (bit)) & 0x01) // read a bit +#define bitSet(value, bit) ((value) |= (1UL << (bit))) // set bit to '1' +#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) // set bit to '0' + + +//! REGISTERS // +// FSK Commun LORA +#define REG_FIFO 0x00 +#define REG_OP_MODE 0x01 +#define REG_BITRATE_MSB 0x02 +#define REG_BITRATE_LSB 0x03 +#define REG_FDEV_MSB 0x04 +#define REG_FDEV_LSB 0x05 +#define REG_FRF_MSB 0x06 +#define REG_FRF_MID 0x07 +#define REG_FRF_LSB 0x08 +#define REG_PA_CONFIG 0x09 +#define REG_PA_RAMP 0x0A +#define REG_OCP 0x0B +#define REG_LNA 0x0C +#define REG_RX_CONFIG 0x0D +#define REG_FIFO_ADDR_PTR 0x0D +#define REG_RSSI_CONFIG 0x0E +#define REG_FIFO_TX_BASE_ADDR 0x0E +#define REG_RSSI_COLLISION 0x0F +#define REG_FIFO_RX_BASE_ADDR 0x0F +#define REG_RSSI_THRESH 0x10 +#define REG_FIFO_RX_CURRENT_ADDR 0x10 +#define REG_RSSI_VALUE_FSK 0x11 +#define REG_IRQ_FLAGS_MASK 0x11 +#define REG_RX_BW 0x12 +#define REG_IRQ_FLAGS 0x12 +#define REG_AFC_BW 0x13 +#define REG_RX_NB_BYTES 0x13 +#define REG_OOK_PEAK 0x14 +#define REG_RX_HEADER_CNT_VALUE_MSB 0x14 +#define REG_OOK_FIX 0x15 +#define REG_RX_HEADER_CNT_VALUE_LSB 0x15 +#define REG_OOK_AVG 0x16 +#define REG_RX_PACKET_CNT_VALUE_MSB 0x16 +#define REG_RX_PACKET_CNT_VALUE_LSB 0x17 +#define REG_MODEM_STAT 0x18 +#define REG_PKT_SNR_VALUE 0x19 +#define REG_AFC_FEI 0x1A +#define REG_PKT_RSSI_VALUE 0x1A +#define REG_AFC_MSB 0x1B +#define REG_RSSI_VALUE_LORA 0x1B +#define REG_AFC_LSB 0x1C +#define REG_HOP_CHANNEL 0x1C +#define REG_FEI_MSB 0x1D +#define REG_MODEM_CONFIG1 0x1D +#define REG_FEI_LSB 0x1E +#define REG_MODEM_CONFIG2 0x1E +#define REG_PREAMBLE_DETECT 0x1F +#define REG_SYMB_TIMEOUT_LSB 0x1F +#define REG_RX_TIMEOUT1 0x20 +#define REG_PREAMBLE_MSB_LORA 0x20 +#define REG_RX_TIMEOUT2 0x21 +#define REG_PREAMBLE_LSB_LORA 0x21 +#define REG_RX_TIMEOUT3 0x22 +#define REG_PAYLOAD_LENGTH_LORA 0x22 +#define REG_RX_DELAY 0x23 +#define REG_MAX_PAYLOAD_LENGTH 0x23 +#define REG_OSC 0x24 +#define REG_HOP_PERIOD 0x24 +#define REG_PREAMBLE_MSB_FSK 0x25 +#define REG_FIFO_RX_BYTE_ADDR 0x25 +#define REG_PREAMBLE_LSB_FSK 0x26 +#define REG_MODEM_CONFIG3 0x26 +#define REG_SYNC_CONFIG 0x27 +#define REG_SYNC_VALUE1 0x28 +#define REG_LORA_FEI_MSB 0x28 +#define REG_SYNC_VALUE2 0x29 +#define REG_LORA_FEI_MID 0x29 +#define REG_SYNC_VALUE3 0x2A +#define REG_LORA_FEI_LSB 0x2A +#define REG_SYNC_VALUE4 0x2B +#define REG_SYNC_VALUE5 0x2C +#define REG_RSSI_WIDEBAND 0x2C +#define REG_SYNC_VALUE6 0x2D +#define REG_SYNC_VALUE7 0x2E +#define REG_SYNC_VALUE8 0x2F +#define REG_PACKET_CONFIG1 0x30 +#define REG_PACKET_CONFIG2 0x31 +#define REG_DETECT_OPTIMIZE 0x31 +#define REG_PAYLOAD_LENGTH_FSK 0x32 +#define REG_NODE_ADRS 0x33 +#define REG_INVERT_IQ 0x33 +#define REG_BROADCAST_ADRS 0x34 +#define REG_FIFO_THRESH 0x35 +#define REG_SEQ_CONFIG1 0x36 +#define REG_SEQ_CONFIG2 0x37 +#define REG_DETECTION_THRESHOLD 0x37 +#define REG_TIMER_RESOL 0x38 +#define REG_TIMER1_COEF 0x39 +#define REG_SYNC_WORD 0x39 +#define REG_TIMER2_COEF 0x3A +#define REG_IMAGE_CAL 0x3B +#define REG_TEMP 0x3C +#define REG_LOW_BAT 0x3D +#define REG_IRQ_FLAGS1 0x3E +#define REG_IRQ_FLAGS2 0x3F +#define REG_DIO_MAPPING1 0x40 +#define REG_DIO_MAPPING2 0x41 +#define REG_VERSION 0x42 +#define REG_PLL_HOP 0x44 +#define REG_TCXO 0x4B +#define REG_PA_DAC 0x4D +#define REG_FORMER_TEMP 0x5B +#define REG_BIT_RATE_FRAC 0x5D +#define REG_AGC_REF 0x61 +#define REG_AGC_THRESH1 0x62 +#define REG_AGC_THRESH2 0x63 +#define REG_AGC_THRESH3 0x64 +#define REG_PLL 0x70 + + +//FSK MODES: +const uint8_t FSK_SLEEP_MODE = 0x00; +const uint8_t FSK_STANDBY_MODE = 0x01; +const uint8_t FSK_TX_MODE = 0x03; +const uint8_t FSK_RX_MODE = 0x05; + + +/****************************************************************************** + * SX1278FSK Class + * Functions and variables for managing SX127x transceiver chips in FSK mode, + * mainly for receiving radiosonde transmissions + ******************************************************************************/ +class SX1278FSK +{ +public: + // class constructor + SX1278FSK(); + + void setup(xSemaphoreHandle lock); + + // Turn on SX1278 module (return 0 on sucess, 1 otherwise) + uint8_t ON(); + + // Turn off SX1278 module + void OFF(); + + // Read internal register + byte readRegister(byte address); + + // Write internal register + void writeRegister(byte address, byte data); + + // Clear IRQ flags + void clearIRQFlags(); + + // Activate FSK mode (return 0 on success, 1 otherwise) + uint8_t setFSK(); + + // Configures bitrate register (closest approximation to requested bitrate) + uint8_t setBitrate(float bps); + float getBitrate(); + + // Configures RX bandwidth (next largest supported bandwith if exact value not possible) + uint8_t setRxBandwidth(float bps); + float getRxBandwidth(); + + // Configures AFC bandwidth (next largest supported bandwith if exact value not possible) + uint8_t setAFCBandwidth(float bps); + float getAFCBandwidth(); + + // Configures RX frequency (closest approximation to requested frequency) + uint8_t setFrequency(float freq); + float getFrequency(); + + int getLNAGain(); + uint8_t setLNAGain(int gain); + + uint8_t getRxConf(); + uint8_t setRxConf(uint8_t conf); + + uint8_t setSyncConf(uint8_t conf, int len, const uint8_t *syncpattern); + uint8_t getSyncConf(); + + uint8_t setPreambleDetect(uint8_t conf); + uint8_t getPreambleDetect(); + + uint8_t setPacketConfig(uint8_t conf1, uint8_t conf2); + uint16_t getPacketConfig(); + + // Get configured preamble length (used for TX only?) + uint16_t getPreambleLength(); + + // Sets the preamble length. + uint8_t setPreambleLength(uint16_t l); + + // Gets the payload length (expected length for receive) + int getPayloadLength(); + uint8_t setPayloadLength(int len); + + // Get current RSSI value + int16_t getRSSI(); + + // Get current FEI (frequency error indication) value + int32_t getFEI(); + + // Get current AFC value + int32_t getAFC(); + uint16_t getRawAFC(); + void setRawAFC(uint16_t afc); + + // Get the maximum current supply by the module. + int getMaxCurrent(); + + // Set the maximum current supply by the module. + int8_t setMaxCurrent(uint8_t rate); + + // Put the module in reception mode. + //return '0' on success, '1' otherwise + uint8_t receive(); + + // Receive a packet + uint8_t receivePacketTimeout(uint32_t wait, byte *data); + + xSemaphoreHandle _lock = NULL; + +#if 0 + //! It gets the internal temperature of the module. + /*! + It stores in global '_temp' variable the module temperature. + \return '0' on success, '1' otherwise + */ + uint8_t getTemp(); + + //! It prints the registers related to RX via USB + /*! + * \return void + */ + void showRxRegisters(); +#endif + +}; + +extern SX1278FSK sx1278; + +#endif diff --git a/RX_FSK/src/Scanner.cpp b/RX_FSK/src/Scanner.cpp new file mode 100644 index 0000000..64039f9 --- /dev/null +++ b/RX_FSK/src/Scanner.cpp @@ -0,0 +1,207 @@ +#include "Scanner.h" + +#include + +#include "SX1278FSK.h" +#include "Sonde.h" +#include "Display.h" + + +double STARTF; + + +struct scancfg { + int PLOT_W; // Width of plot, in pixel + int PLOT_H8; // Height of plot, in 8 pixel units + int TICK1; // Pixel per MHz marker + int TICK2; // Pixel per sub-Mhz marker (250k or 200k) + double CHANSTEP; // Scanner frequenz steps + int SMPL_PIX; // Frequency steps per pixel + int NCHAN; // number of channels to scan, PLOT_W * SMPL_PIX + int SMOOTH; + int ADDWAIT; + int VSCALE; +}; + +//struct scancfg scanLCD={ 121, 7, 120/6, 120/6/4, 6000.0/120.0/20.0, 20, 120*20, 1 }; +struct scancfg scanLCD={ 121, 7, 120/6, 120/6/4, 6000.0/120.0/10.0, 10, 120*10, 2, 40, 1 }; +struct scancfg scanTFT={ 210, 16, 210/6, 210/6/5, 6000.0/210.0/10.0, 10, 210*10, 1, 0, 1 }; +struct scancfg scan934x={ 300, 22, 300/6, 300/6/5, 6000.0/300.0/7.0, 7, 300*5, 1, 10, 2 }; + +struct scancfg &scanconfig = scanTFT; + +#define CHANBW 12500 +//#define PIXSAMPL (50/CHANBW) +//#define STARTF 401000000 + +// max of 120*5 and 210*3 +//#define MAXN 210*10 +//#define MAXN 120*20 +#define MAXN 300*10 + +// max of 120 and 210 (ceil(210/8)*8)) -- now ceil(300/8)*8 +//#define MAXDISP 216 +#define MAXDISP 304 + +int scanresult[MAXN]; +int scandisp[MAXDISP]; +double peakf=0; + +//#define PLOT_MIN -250 +#define PLOT_MIN (sonde.config.noisefloor*2) +#define PLOT_SCALE(x) (x=8) { row[8*y]=255; continue; } + row[8*y] = tilepatterns[nbits]; + } +} +/* LCD: + * There are 16*8 columns to plot, NPLOT must be lower than that + * currently, we use 128 * 50kHz channels + * There are 8*8 values to plot; MIN is bottom end, + * TFT: + * There are 210 columns to plot + * Currently we use 210 * (6000/120)kHz channels, i.e. 28.5714kHz + */ +///// unused???? uint8_t tiles[16] = { 0x0f,0x0f,0x0f,0x0f,0xf0,0xf0,0xf0,0xf0, 1, 3, 7, 15, 31, 63, 127, 255}; + +// type 0: lcd, 1: tft(ILI9225), 2: lcd(sh1106) 3:TFT(ili9341), 4: TFT(ili9342) +#define ISTFT (sonde.config.disptype!=0 && sonde.config.disptype!=2) +void Scanner::plotResult() +{ + int yofs = 0; + char buf[30]; + if(ISTFT) { + yofs = 2; + if (sonde.config.marker != 0) { + itoa((sonde.config.startfreq), buf, 10); + disp.rdis->drawString(0, 1, buf); + disp.rdis->drawString(scanconfig.PLOT_W/2-10, 1, "MHz"); + itoa((sonde.config.startfreq + 6), buf, 10); + disp.rdis->drawString(scanconfig.PLOT_W-15, 1, buf); + } + } + else { + if (sonde.config.marker != 0) { + itoa((sonde.config.startfreq), buf, 10); + disp.rdis->drawString(0, 1, buf); + disp.rdis->drawString(7, 1, "MHz"); + itoa((sonde.config.startfreq + 6), buf, 10); + disp.rdis->drawString(13, 1, buf); + } + } + uint8_t row[scanconfig.PLOT_H8*8]; + for(int i=0; i=scanconfig.PLOT_W ) { for(int y=0; y=7*8&&i<10*8) || i>=13*8) continue; + } + disp.rdis->drawTile(i/8, y+yofs, 1, row+8*y); + } + } + if(ISTFT) { // large TFT + sprintf(buf, "Peak: %03.3f MHz", peakf*0.000001); + disp.rdis->drawString(0, (yofs+scanconfig.PLOT_H8+1)*8, buf); + } else { + sprintf(buf, "Peak: %03.3fMHz", peakf*0.000001); + disp.rdis->drawString(0, 7, buf); + } +} + +void Scanner::scan() +{ + if(!ISTFT) { // LCD small + scanconfig = scanLCD; + } else if (sonde.config.disptype==1) { + scanconfig = scanTFT; + } else { + scanconfig = scan934x; + } + // Configure + STARTF = (sonde.config.startfreq * 1000000); + sx1278.writeRegister(REG_PLL_HOP, 0x80); // FastHopOn + sx1278.setRxBandwidth((int)(scanconfig.CHANSTEP*1000)); + double bw = sx1278.getRxBandwidth(); + Serial.print("RX Bandwith for scan: "); Serial.println(bw); + sx1278.writeRegister(REG_RSSI_CONFIG, scanconfig.SMOOTH&0x07); + sx1278.setFrequency(STARTF); + Serial.print("Start freq = "); Serial.println(STARTF); + sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE); + + unsigned long start = millis(); + uint32_t lastfrf= STARTF * (1<<19) / SX127X_CRYSTAL_FREQ; + float freq = STARTF; + int wait = scanconfig.ADDWAIT + 20 + 1000*(1<<(scanconfig.SMOOTH+1))/4/(0.001*CHANBW); + Serial.print("wait time (us) is: "); Serial.println(wait); + for(int iter=0; iter<3; iter++) { // three interations, to catch all RS41 transmissions + delayMicroseconds(20000); yield(); + for(int i=0; i>16)!=(frf>>16) ) { + sx1278.writeRegister(REG_FRF_MSB, (frf&0xff0000)>>16); + } + if( ((lastfrf&0x00ff00)>>8) != ((frf&0x00ff00)>>8) ) { + sx1278.writeRegister(REG_FRF_MID, (frf&0x00ff00)>>8); + } + sx1278.writeRegister(REG_FRF_LSB, (frf&0x0000ff)); + lastfrf = frf; + // Wait TS_HOP (20us) + TS_RSSI ( 2^(scacconfig.SMOOTH+1) / 4 / CHANBW us) + delayMicroseconds(wait); + int rssi = -(int)sx1278.readRegister(REG_RSSI_VALUE_FSK); + if(iter==0) { scanresult[i] = rssi; } else { + if(rssi>scanresult[i]) scanresult[i]=rssi; + } + } + } + yield(); + unsigned long duration = millis()-start; + Serial.print("wait: "); + Serial.println(wait); + Serial.print("Scan time: "); + Serial.println(duration); + Serial.print("Final freq: "); + Serial.println(freq); + int peakidx=-1; + int peakres=-9999; + for(int i=0; ipeakres+1) { peakres=r; peakidx=i*scanconfig.SMPL_PIX; } + scandisp[i] = r; + for(int j=1; jpeakres+1) { peakres=r; peakidx=i*scanconfig.SMPL_PIX+j; } + } + //for(int j=1; jscandisp[i/PIXSAMPL]) scandisp[i/PIXSAMPL] = scanresult[i+j]; } + Serial.print(scanresult[i]); Serial.print(", "); + } + peakidx--; + double newpeakf = STARTF + scanconfig.CHANSTEP*1000.0*peakidx; + if(newpeakfpeakf+20000) peakf=newpeakf; // different frequency + else if (newpeakf < peakf) peakf = 0.75*newpeakf + 0.25*peakf; // averaging on frequency, some bias towards lower... + else peakf = 0.25*newpeakf + 0.75*peakf; + Serial.println("\n"); + for(int i=0; i +#include +#include +#ifndef inttypes_h + #include +#endif +class Scanner +{ +private: + void fillTiles(uint8_t *row, int value); + +public: + void plotResult(); + void scan(void); +}; + +extern Scanner scanner; +#endif diff --git a/RX_FSK/src/ShFreqImport.cpp b/RX_FSK/src/ShFreqImport.cpp new file mode 100644 index 0000000..407b7aa --- /dev/null +++ b/RX_FSK/src/ShFreqImport.cpp @@ -0,0 +1,247 @@ +#include +#include +#include +#include +#include +#include + +#include "ShFreqImport.h" +#include "Sonde.h" + +static int ppos; +static int quotes; +static char id[20]; +static int idpos; +static float lat, lon, freq; +static char type[20]; + +static uint8_t inuse[1+99/8]; // MAXSONDE is 99 + +static char keyword[40]; +static int keywordpos; +static char value[40]; +static int valuepos; + +static int importState; +static float homelat, homelon; + + +// Map SondeHub type string to Stype. -1 for not supported types. +int ShFreqImport::stringToStype(const char *type) { + if(type[2]=='4') return STYPE_RS41; + if(type[2]=='9') return STYPE_RS92; + if(type[1]=='1') return STYPE_M10M20; + if(type[1]=='2') return STYPE_M10M20; + if(type[0]=='D') return STYPE_DFM; + if(type[2]=='3') return STYPE_MP3H; // TODO: check if '3' is correct + return -1; // iMet is not supported +} + +// in Display.cpp +extern float calcLatLonDist(float lat1, float lon1, float lat2, float lon2); + +void ShFreqImport::setLabel(int idx, char *id, float lat, float lon) { + snprintf(sonde.sondeList[idx].launchsite, 18, "@%s/%d", id, (int)(calcLatLonDist(homelat, homelon, lat, lon)/1000)); + sonde.sondeList[idx].launchsite[17] = 0; +} + +void ShFreqImport::usekeyvalue() { + if(strcmp(keyword,"lat")==0) lat = atof(value); + if(strcmp(keyword,"lon")==0) lon = atof(value); + if(strcmp(keyword,"frequency")==0) { if(isnan(freq)) freq = atof(value); } // prefer tx_frequency if available + if(strcmp(keyword,"tx_frequency")==0) freq = atof(value); + if(strcmp(keyword,"type")==0) strcpy(type, value); +} + +/* populate qrg.txt with frequency of near sonde */ +void ShFreqImport::populate(char *id, float lat, float lon, float freq, const char *type) +{ + //printf(" ID %s: %.5f, %.5f f=%.3f, type=%s \n", id, lat, lon, freq, type); + // Skip if freq already exists + int stype = stringToStype(type); + if(stype<0) return; // unsupported type + + // check if frequency exists already + // don't do anything if its a static entry + // update label if its a dynamic SH entry + int i; + for(i=0; i= sonde.config.maxsonde) { + Serial.println("populate: out of free slots"); + return; + } // no more free slots + + sonde.clearAllData(&sonde.sondeList[ppos]); + sonde.sondeList[ppos].active = 1; + sonde.sondeList[ppos].freq = freq; + sonde.sondeList[ppos].type = (SondeType)stype; + setLabel(ppos, id, lat, lon); + inuse[ppos/8] |= (1<<(ppos&7)); + ppos++; +} + +// clears all remaining automatically filled slots (no longer in SH data) +void ShFreqImport::cleanup() { + //Serial.println("Cleanup called ********"); + for(int i=0; i>(i&7))&1) == 0) && *sonde.sondeList[i].launchsite=='@' ) { + // Don't remove the currently active entry + if(i==sonde.currentSonde) continue; + Serial.printf("removing #%d\n", i); + sonde.sondeList[i].launchsite[0] = 0; + sonde.sondeList[i].active = 0; + sonde.sondeList[i].freq = 400; + } + } +} + +#define BUFLEN 128 +#define VALLEN 20 +int ShFreqImport::handleChar(char c) { + Serial.print(c); + switch(importState) { + case START: + // wait for initial '{' + if(c=='{') { + Serial.println("{ found"); + importState++; + } + break; + case BEFOREID: + // what for first '"' in { "A1234567" : { ... } }; or detect end + if(c=='"') { idpos = 0; lat = NAN; lon = NAN; freq = NAN; *type = 0; importState++; } + if(c=='}') { + importState = ENDREACHED; + cleanup(); + return 1; + } + break; + case COPYID: + // copy ID "A1234567" until second '"' is earched + if(c=='"') { id[idpos] = 0; importState++; } + else id[idpos++] = c; + break; + case AFTERID: + // wait for '{' in '"A1234567": { ...' + if(c=='{') importState++; + break; + case BEFOREKEY: + if(c=='"') { keywordpos = 0; importState++; } + break; + case COPYKEY: + if(c=='"') { importState++; keyword[keywordpos] = 0; /* printf("Key: >%s<\n", keyword);*/ } + else keyword[keywordpos++] = c; + break; + case AFTERKEY: + if(c==':') { + valuepos = 0; + quotes = 0; + if(strcmp(keyword,"lat")==0 || strcmp(keyword, "lon")==0 || strcmp(keyword, "frequency")==0 || strcmp(keyword, "tx_frequency")==0) + importState = BEFORENUMVAL; + else { + if (strcmp(keyword, "type")==0) + importState = BEFORESTRINGVAL; + else + importState = SKIPVAL; + } + } + break; + case BEFORENUMVAL: + if( (c>='0'&&c<='9') || c=='-') { value[0] = c; valuepos=1; importState++; } + break; + case COPYNUMVAL: + if( !(c>='0'&&c<='9') && c!='-' && c!='.' ) { + value[valuepos]=0; importState=SKIPVAL; usekeyvalue(); + if(c!=',' && c!='}') break; + } + else { value[valuepos++] = c; break; } + // intenionall fall-through + case SKIPVAL: + // This is rather fragile, we *should* handle more escaping and so on but do not do so so far, only simple quotes + if(c=='"') quotes = !quotes; + if(quotes) break; + if(c==',') importState = BEFOREKEY; + if(c=='}') { + // we have an ID and all key/value pairs, check if its good.... + if( !isnan(lat) && !isnan(lon) && !isnan(freq) && type[0] ) { + printf("SondeHub import: populate %s %f %f %f %s\n", id, lat, lon, freq, type); + populate(id, lat, lon, freq, type); + } else { + printf("Skipping incomplete %s\n", id); + } + importState = ENDORNEXT; + } + break; + case BEFORESTRINGVAL: + if(c=='"') importState++; + break; + case COPYSTRINGVAL: + if(c=='"') { importState=SKIPVAL; value[valuepos]=0; usekeyvalue(); } + else value[valuepos++] = c; + break; + case ENDORNEXT: + // next we have to see either a final "}', or a comma before the next id + if(c==',') importState = BEFOREID; + else if (c=='}') { importState = ENDREACHED; cleanup(); return 1; } + break; + case ENDREACHED: + Serial.println("REPLY: END REACHED"); + return 1; + } + return 0; +} + +// lat lon in deg, dist in km, time in minutes +int ShFreqImport::shImportSendRequest(WiFiClient *client, float lat, float lon, int dist, int time) { + if(!client->connected()) { + if(!client->connect(sonde.config.sondehub.host, 80)) { + Serial.println("Connection FAILED"); + return 1; + } + } + Serial.println("Sending SondeHub import request"); + char req[300]; + snprintf(req, 200, "GET /sondes?lat=%f&lon=%f&distance=%d&last=%d HTTP/1.1\r\n" + "Host: %s\r\n" + "Accept: application/json\r\n" + "Cache-Control: no-cache\r\n\r\n", + lat, lon, dist*1000, time*60, sonde.config.sondehub.host); + client->print(req); + Serial.print(req); + importState = START; + homelat = lat; + homelon = lon; + memset(inuse, 0, sizeof(inuse)); + ppos = 0; + return 0; +} + +// return 0 if more data should be read (later), 1 if finished (close connection...) +int ShFreqImport::shImportHandleReply(WiFiClient *client) { + if(!client->connected()) return 1; + while(client->available()) { + int res = handleChar(client->read()); + if(res) return res; + } + return 0; +} diff --git a/RX_FSK/src/ShFreqImport.h b/RX_FSK/src/ShFreqImport.h new file mode 100644 index 0000000..7e6927a --- /dev/null +++ b/RX_FSK/src/ShFreqImport.h @@ -0,0 +1,30 @@ +#ifndef SH_FREQ_IMPORT_ +#define SH_FREQ_IMPORT_H +// Automated frequency import from SondeHub + +#include + +enum ImportState { START, BEFOREID, COPYID, AFTERID, BEFOREKEY, COPYKEY, AFTERKEY, SKIPVAL, BEFORENUMVAL, COPYNUMVAL, BEFORESTRINGVAL, COPYSTRINGVAL, AFTERPAYLOAD, ENDORNEXT, ENDREACHED }; + +class ShFreqImport { +public: + // Fetch data from sondehub and populate qrg.txt with result + // return: 0: ok; 1: failure + static int shImportSendRequest(WiFiClient *client, float lat, float lon, int dist, int time); + + // return 0: ok, need more data; 1: finished/failure, close connection + // Asynchronous I/O. Handle data if available + static int shImportHandleReply(WiFiClient *client); + +private: + static int stringToStype(const char *type); + static void setLabel(int idx, char *id, float lat, float lon); + static void usekeyvalue(); + static int handleChar(char c); + + // add one entry on available slot at or after ppos + static void populate(char *id, float lat, float lon, float freq, const char *type); + static void cleanup(); +}; + +#endif diff --git a/RX_FSK/src/Sonde.cpp b/RX_FSK/src/Sonde.cpp new file mode 100644 index 0000000..7b7a3be --- /dev/null +++ b/RX_FSK/src/Sonde.cpp @@ -0,0 +1,736 @@ +#include +#include + +#include "Sonde.h" +#include "RS41.h" +#include "RS92.h" +#include "DFM.h" +#include "M10M20.h" +#include "MP3H.h" +#include "SX1278FSK.h" +#include "Display.h" +#include + +uint8_t debug = 255-8-16; + +RXTask rxtask = { -1, -1, -1, 0xFFFF, 0 }; + +const char *evstring[]={"NONE", "KEY1S", "KEY1D", "KEY1M", "KEY1L", "KEY2S", "KEY2D", "KEY2M", "KEY2L", + "VIEWTO", "RXTO", "NORXTO", "(max)"}; + +const char *RXstr[]={"RX_OK", "RX_TIMEOUT", "RX_ERROR", "RX_UNKNOWN"}; + +// Dependency to enum SondeType +const char *sondeTypeStr[NSondeTypes] = { "DFM ", "RS41", "RS92", "Mxx ", "M10 ", "M20 ", "MP3H" }; +const char *sondeTypeLongStr[NSondeTypes] = { "DFM (all)", "RS41", "RS92", "M10/M20", "M10 ", "M20 ", "MP3-H1" }; +const char sondeTypeChar[NSondeTypes] = { 'D', '4', 'R', 'M', 'M', '2', '3' }; +const char *manufacturer_string[]={"Graw", "Vaisala", "Vaisala", "Meteomodem", "Meteomodem", "Meteomodem", "Meteo-Radiy"}; + +int fingerprintValue[]={ 17, 31, 64, 4, 55, 48, 23, 128+23, 119, 128+119, -1 }; +const char *fingerprintText[]={ + "TTGO T-Beam (new version 1.0), I2C not working after powerup, assuming 0.9\" OLED@21,22", + "TTGO LORA32 v2.1_1.6 (0.9\" OLED@21,22)", + "TTGO LORA v1.0 (0.9\" OLED@4,15)", + "Heltec v1/v2 (0.9\"OLED@4,15)", + "TTGO T-Beam (V0.7), 0.9\" OLED@21,22", + "TTGO T-Beam (V0.7), SPI TFT@4,21,22", + "TTGO T-Beam (V1.0), 0.9\" OLED@21,22", + "TTGO T-Beam (V1.0), SPI TFT@4,13,14", + "TTGO T-Beam (V1.1), 0.9\" OLED@21,22", + "TTGO T-Beam (V1.1), SPI TFT@4,13,14", +}; + +/* global variables from RX_FSK.ino */ +int getKeyPressEvent(); +int handlePMUirq(); +extern uint8_t pmu_irq; +extern SX1278FSK sx1278; + +/* Task model: + * There is a background task for all SX1278 interaction. + * - On startup and on each mode/frequency change (requested by setting requestNextSonde + * to an sonde index >=0) it calls Sonde::setup(), which will call the new decoder's + * setup function. Setup will update the value currentSonde. + * - Periodically it calls Sonde::receive(), which calls the current decoder's receive() + * function. It should return control to the SX1278 main loop at least once per second. + * It will also set the internal variable receiveResult. The decoder's receive function + * must make sure that there are no FIFO overflows in the SX1278. + * - the Arduino main loop will call the waitRXcomplete function, which should return as + * soon as there is some new data to display, or no later than after 1s, returning the + * value of receiveResult (or timeout, if receiveResult was not set within 1s). It + * should also return immediately if there is some keyboard input. + */ +int initlevels[40]; + +Sonde::Sonde() { + for (int i = 0; i < 39; i++) { + initlevels[i] = gpio_get_level((gpio_num_t)i); + } +} + +void Sonde::defaultConfig() { + fingerprint = initlevels[4]; + fingerprint = (fingerprint<<1) | initlevels[12]; + fingerprint = (fingerprint<<1) | initlevels[16]; + fingerprint = (fingerprint<<1) | initlevels[17]; + fingerprint = (fingerprint<<1) | initlevels[21]; + fingerprint = (fingerprint<<1) | initlevels[22]; + fingerprint = (fingerprint<<1) | initlevels[23]; + Serial.printf("Board fingerprint is %d\n", fingerprint); + + sondeList = (SondeInfo *)malloc((MAXSONDE+1)*sizeof(SondeInfo)); + // addSonde should initialize everything anyway, so this should not strictly be necessary, but does no harm either + memset(sondeList, 0, (MAXSONDE+1)*sizeof(SondeInfo)); + for(int i=0; i<(MAXSONDE+1); i++) { + sondeList[i].freq=400; + sondeList[i].type=STYPE_RS41; + clearAllData(&sondeList[i]); + } + config.touch_thresh = 70; + config.led_pout = -1; + config.power_pout = -1; + config.spectrum=10; + // Try autodetecting board type + config.type = TYPE_TTGO; + // Seems like on startup, GPIO4 is 1 on v1 boards, 0 on v2.1 boards? + config.gps_rxd = -1; + config.gps_txd = -1; + config.batt_adc = -1; + config.sx1278_ss = SS; // default SS pin, on all TTGOs + config.sx1278_miso = MISO; + config.sx1278_mosi = MOSI; + config.sx1278_sck = SCK; + config.oled_rst = 16; + config.disptype = 0; + config.dispcontrast = -1; + config.oled_orient = 1; + config.button2_axp = 0; + config.norx_timeout = 20; + config.screenfile = 1; + + if(initlevels[16]==0) { + config.oled_sda = 4; + config.oled_scl = 15; + config.button_pin = 0; + config.button2_pin = T4 + 128; // T4 == GPIO13 + config.power_pout = 21; // for Heltec v2 + config.led_pout = 2; + Serial.println("Autoconfig: looks like TTGO v1 / Heltec v1/V2 board"); + } else { + config.oled_sda = 21; + config.oled_scl = 22; + if(initlevels[17]==0) { // T-Beam or M5Stack Core2? + int tbeam=7; + if(initlevels[12]==0) { + tbeam = 10; + Serial.println("Autoconfig: looks like T-Beam 1.0 or M5Stack Core2 board"); + } else if ( initlevels[4]==1 && initlevels[12]==1 ) { + tbeam = 11; + Serial.println("Autoconfig: looks like T-Beam 1.1 board"); + } + if(tbeam == 10 || tbeam == 11) { // T-Beam v1.0 or T-Beam v1.1 + Wire.begin(21, 22); +#define BM8563_ADDRESS 0x51 + Wire.beginTransmission(BM8563_ADDRESS); + byte err = Wire.endTransmission(); + if(err) { // try again + delay(400); + Wire.beginTransmission(BM8563_ADDRESS); + err = Wire.endTransmission(); + } + if(err==0) { + Serial.println("M5stack Core2 board detected\n"); + config.type = TYPE_M5_CORE2; + config.button_pin = 255; + config.button2_pin = 255; + config.button2_axp = 1; + config.disptype = 4; // ILI9342 + config.oled_sda = 23; + config.oled_scl = 18; + config.oled_rst = -1; + config.screenfile = 4; + config.gps_rxd = 13; + config.gps_txd = -1; // 14 + config.sx1278_ss = 33; + config.sx1278_miso = 38; + config.sx1278_mosi = 23; //MOSI; + config.sx1278_sck = 18; // SCK; + } else { // some t-beam... + config.button_pin = 38; + config.button2_pin = 15 + 128; //T4 + 128; // T4 = GPIO13 + // Maybe in future use as default only PWR as button2? + //config.button2_pin = 255; + config.button2_axp = 1; + config.gps_rxd = 34; + config.gps_txd = 12; + // Check for I2C-Display@21,22 +#define SSD1306_ADDRESS 0x3c + Wire.beginTransmission(SSD1306_ADDRESS); + err = Wire.endTransmission(); + delay(100); // otherwise its too fast?! + Wire.beginTransmission(SSD1306_ADDRESS); + err = Wire.endTransmission(); + if(err!=0 && fingerprint!=17) { // hmm. 17 after powerup with oled commected and no i2c answer!?!? + fingerprint |= 128; + Serial.println("no I2C display found, assuming large TFT display\n"); + // CS=0, RST=14, RS=2, SDA=4, CLK=13 + Serial.println("... with large TFT display\n"); + config.disptype = 1; + config.oled_sda = 4; + config.oled_scl = 13; + config.oled_rst = 14; + + config.spectrum = -1; // no spectrum for now on large display + config.screenfile = 2; + } else { + // OLED display, pins 21,22 ok... + config.disptype = 0; + Serial.println("... with small OLED display\n"); + } + } + } else { + Serial.println("Autoconfig: looks like T-Beam v0.7 board"); + config.button_pin = 39; + config.button2_pin = T4 + 128; // T4 == GPIO13 + config.gps_rxd = 12; + // Check if we possibly have a large display + if(initlevels[21]==0) { + Serial.println("Autoconfig: looks like T-Beam v0.7 board with large TFT display"); + config.disptype = 1; + config.oled_sda = 4; + config.oled_scl = 21; + config.oled_rst = 22; + + config.spectrum = -1; // no spectrum for now on large display + config.screenfile = 2; + } + } + } else { + // Likely a TTGO V2.1_1.6 + config.button_pin = 2 + 128; // GPIO2 / T2 + config.button2_pin = 14 + 128; // GPIO14 / T6 + config.led_pout = 25; + config.batt_adc = 35; + } + } + // + config.noisefloor = -125; + strcpy(config.call,"NOCALL"); + config.passcode = -1; + strcpy(config.mdnsname, "radiosonde"); + config.maxsonde=15; + config.debug=0; + config.wifi=1; + config.buzzerOn=0; + config.buzzerFreq=700; + config.buzzerPort=12; + config.dbsmetre=0; + config.degdec=0; + config.display[0]=0; + config.display[1]=1; + config.display[2]=-1; + config.startfreq=400; + config.channelbw=10; + config.marker=0; + config.freqofs=0; + config.rs41.agcbw=12500; + config.rs41.rxbw=6300; + config.rs92.rxbw=12500; + config.rs92.alt2d=480; + config.dfm.agcbw=20800; + config.dfm.rxbw=10400; + config.m10m20.agcbw=20800; + config.m10m20.rxbw=12500; + config.mp3h.agcbw=12500; + config.mp3h.rxbw=12500; + config.udpfeed.active = 1; + config.udpfeed.type = 0; + strcpy(config.udpfeed.host, "192.168.42.20"); + strcpy(config.udpfeed.symbol, "/O"); + config.udpfeed.port = 9002; + config.udpfeed.highrate = 1; + config.tcpfeed.active = 0; + config.tcpfeed.type = 1; + strcpy(config.tcpfeed.host, "radiosondy.info"); + strcpy(config.tcpfeed.symbol, "/O"); + config.tcpfeed.port = 12345; + config.tcpfeed.highrate = 10; + config.kisstnc.active = 0; + strcpy(config.ephftp,"igs.bkg.bund.de/IGS/BRDC/"); + + config.mqtt.active = 0; + strcpy(config.mqtt.id, "rdz_sonde_server"); + config.mqtt.port = 1883; + strcpy(config.mqtt.username, "/0"); + strcpy(config.mqtt.password, "/0"); + strcpy(config.mqtt.prefix, "rdz_sonde_server/"); +} + +extern struct st_configitems config_list[]; +extern const int N_CONFIG; + +void Sonde::checkConfig() { + if(config.maxsonde > MAXSONDE) config.maxsonde = MAXSONDE; + if(config.sondehub.fiinterval<5) config.sondehub.fiinterval = 5; + if(config.sondehub.fimaxdist>700) config.sondehub.fimaxdist = 700; + if(config.sondehub.fimaxage>48) config.sondehub.fimaxage = 48; + if(config.sondehub.fimaxdist==0) config.sondehub.fimaxdist = 150; + if(config.sondehub.fimaxage==0) config.sondehub.fimaxage = 2; +} +void Sonde::setConfig(const char *cfg) { + while(*cfg==' '||*cfg=='\t') cfg++; + if(*cfg=='#') return; + char *s = strchr(cfg,'='); + if(!s) return; + char *val = s+1; + *s=0; s--; + while(s>cfg && (*s==' '||*s=='\t')) { *s=0; s--; } + Serial.printf("configuration option '%s'=%s \n", cfg, val); + + // new code: use config_list to find config entry... + int i; + for(i=0; i0) { // string with that length + strlcpy((char *)config_list[i].data, val, config_list[i].type+1); + break; + } + switch(config_list[i].type) { + case 0: // integer + case -4: // integer (with "touch button" checkbox in web form) + case -3: // integer (boolean on/off swith in web form) + case -2: // integer (ID type) + *(int *)config_list[i].data = atoi(val); + break; + case -7: // double + { + double d = atof(val); + if(*val == 0 || d==0) d = NAN; + *(double *)config_list[i].data = d; + break; + } + case -6: // display list + { + int idx = 0; + char *ptr; + while(val) { + ptr = strchr(val,','); + if(ptr) *ptr = 0; + config.display[idx++] = atoi(val); + val = ptr?ptr+1:NULL; + Serial.printf("appending value %d next is %s\n", config.display[idx-1], val?val:""); + } + config.display[idx] = -1; + break; + } + default: + // skipping non-supported types + break; + } + + break; + } + if(i==N_CONFIG) { + Serial.printf("Invalid config option '%s'=%s \n", cfg, val); + } +} + +void Sonde::setIP(String ip, bool AP) { + ipaddr = ip; + isAP = AP; +} + +void Sonde::clearSonde() { + nSonde = 0; +} +void Sonde::addSonde(float frequency, SondeType type, int active, char *launchsite) { + if(nSonde>=config.maxsonde) { + Serial.println("Cannot add another sonde, MAXSONDE reached"); + return; + } + Serial.printf("Adding %f - %d - %d - %s\n", frequency, type, active, launchsite); + // reset all data if type or frequency has changed + if(type != sondeList[nSonde].type || frequency != sondeList[nSonde].freq) { + //TODO: Check for potential race condition with decoders + // do not clear extra while decoder is potentiall still accessing it! + if(sondeList[nSonde].extra) free(sondeList[nSonde].extra); + memset(&sondeList[nSonde], 0, sizeof(SondeInfo)); + sondeList[nSonde].type = type; + sondeList[nSonde].d.typestr[0] = 0; + sondeList[nSonde].freq = frequency; + memcpy(sondeList[nSonde].rxStat, "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3", 18); // unknown/undefined + clearAllData(sondeList+nSonde); + } + sondeList[nSonde].active = active; + strncpy(sondeList[nSonde].launchsite, launchsite, 17); + nSonde++; +} + +// called by updateState (only) +void Sonde::nextConfig() { + currentSonde++; + if(currentSonde>=config.maxsonde) { + currentSonde=0; + } + // Skip non-active entries (but don't loop forever if there are no active ones) + for(int i=0; i=config.maxsonde) currentSonde=0; + } + } +} +void Sonde::nextRxSonde() { + rxtask.currentSonde++; + if(rxtask.currentSonde>=config.maxsonde) { + rxtask.currentSonde=0; + } + for(int i=0; i=config.maxsonde) rxtask.currentSonde=0; + } + } + //Serial.printf("nextRxSonde: %d\n", rxtask.currentSonde); +} +void Sonde::nextRxFreq(int addkhz) { + // last entry is for the variable frequency + rxtask.currentSonde = nSonde - 1; + sondeList[rxtask.currentSonde].active = 1; + sondeList[rxtask.currentSonde].freq += addkhz*0.001; + if(sondeList[rxtask.currentSonde].freq>406) + sondeList[rxtask.currentSonde].freq = 400; + Serial.printf("nextRxFreq: %d\n", rxtask.currentSonde); +} +SondeInfo *Sonde::si() { + return &sondeList[currentSonde]; +} + +void Sonde::setup() { + if(rxtask.currentSonde<0 || rxtask.currentSonde>=config.maxsonde) { + Serial.print("Invalid rxtask.currentSonde: "); + Serial.println(rxtask.currentSonde); + rxtask.currentSonde = 0; + for(int i=0; i=config.maxsonde) rxtask.currentSonde=0; + } + } + sonde.currentSonde = rxtask.currentSonde; + } + + // update receiver config + Serial.print("Sonde::setup() start on index "); + Serial.println(rxtask.currentSonde); + switch(sondeList[rxtask.currentSonde].type) { + case STYPE_RS41: + rs41.setup(sondeList[rxtask.currentSonde].freq * 1000000); + break; + case STYPE_DFM: + dfm.setup( sondeList[rxtask.currentSonde].freq * 1000000, sondeList[rxtask.currentSonde].type ); + break; + case STYPE_RS92: + rs92.setup( sondeList[rxtask.currentSonde].freq * 1000000); + break; + case STYPE_M10: + case STYPE_M20: + case STYPE_M10M20: + m10m20.setup( sondeList[rxtask.currentSonde].freq * 1000000); + break; + case STYPE_MP3H: + mp3h.setup( sondeList[rxtask.currentSonde].freq * 1000000); + break; + } + // debug + int freq = (int)sx1278.getFrequency(); + int afcbw = (int)sx1278.getAFCBandwidth(); + int rxbw = (int)sx1278.getRxBandwidth(); + Serial.printf("Sonde::setup() done: Type %s Freq %f, AFC BW: %d, RX BW: %d\n", sondeTypeStr[sondeList[rxtask.currentSonde].type], 0.000001*freq, afcbw, rxbw); + + // reset rxtimer / norxtimer state + sonde.sondeList[sonde.currentSonde].lastState = -1; +} + +extern void flashLed(int ms); +extern void buzzerLed(int temps); + +void Sonde::receive() { + uint16_t res = 0; + SondeInfo *si = &sondeList[rxtask.currentSonde]; + switch(si->type) { + case STYPE_RS41: + res = rs41.receive(); + break; + case STYPE_RS92: + res = rs92.receive(); + break; + case STYPE_M10: + case STYPE_M20: + case STYPE_M10M20: + res = m10m20.receive(); + break; + case STYPE_DFM: + res = dfm.receive(); + break; + case STYPE_MP3H: + res = mp3h.receive(); + break; + } + + // state information for RX_TIMER / NORX_TIMER events + if(res==RX_OK || res==RX_ERROR) { // something was received... + + flashLed(700); + if(sonde.config.buzzerOn==1) { + buzzerLed(500); + } + if(si->lastState != 1) { + si->rxStart = millis(); + si->lastState = 1; + sonde.dispsavectlON(); + } + } else { // RX Timeout + flashLed( (res==RX_OK)?700:100); + ledcWriteTone(0, 0); + //Serial.printf("Sonde::receive(): result %d (%s), laststate was %d\n", res, (res<=3)?RXstr[res]:"?", si->lastState); + if(si->lastState != 0) { + si->norxStart = millis(); + si->lastState = 0; + } + } + // Serial.printf("debug: res was %d, now lastState is %d\n", res, si->lastState); + + + // we should handle timer events here, because after returning from receive, + // we'll directly enter setup + rxtask.receiveSonde = rxtask.currentSonde; // pass info about decoded sonde to main loop + + int event = getKeyPressEvent(); + if (!event) event = timeoutEvent(si); + else sonde.dispsavectlON(); + int action = (event==EVT_NONE) ? ACT_NONE : disp.layout->actions[event]; + //if(action!=ACT_NONE) { Serial.printf("event %x: action is %x\n", event, action); } + // If action is to move to a different sonde index, we do update things here, set activate + // to force the sx1278 task to call sonde.setup(), and pass information about sonde to + // main loop (display update...) + if(action == ACT_DISPLAY_SCANNER || action == ACT_NEXTSONDE || action==ACT_PREVSONDE || (action>64&&action<128) ) { + // handled here... + if(action==ACT_DISPLAY_SCANNER) { + // nothing to do here, be re-call setup() for M10/M20 for repeating AFC + } + else { + if(action==ACT_NEXTSONDE||action==ACT_PREVSONDE) + nextRxSonde(); + else + nextRxFreq( action-64 ); + action = ACT_SONDE(rxtask.currentSonde); + } + if(rxtask.activate==-1) { + // race condition here. maybe better use mutex. TODO + rxtask.activate = ACT_SONDE(rxtask.currentSonde); + } + } + Serial.printf("Sonde:receive(): result %d (%s), event %02x => action %02x\n", res, (res<=3)?RXstr[res]:"?", event, action); + res = (action<<8) | (res&0xff); + // let waitRXcomplete resume... + rxtask.receiveResult = res; +} + +// return (action<<8) | (rxresult) +uint16_t Sonde::waitRXcomplete() { + uint16_t res=0; + uint32_t t0 = millis(); +rxloop: + while( (pmu_irq!=1) && rxtask.receiveResult==0xFFFF && millis()-t0 < 3000) { delay(50); } + if( pmu_irq ) { + handlePMUirq(); + if(pmu_irq!=2) goto rxloop; + } + if( rxtask.receiveResult == RX_UPDATERSSI ) { + rxtask.receiveResult = 0xFFFF; + Serial.printf("RSSI update: %d/2\n", sonde.si()->rssi); + disp.updateDisplayRSSI(); + goto rxloop; + } + + if( rxtask.receiveResult==0xFFFF) { + Serial.println("TIMEOUT in waitRXcomplete. Should never happen!\n"); + res = RX_TIMEOUT; + } else { + res = rxtask.receiveResult; + } + rxtask.receiveResult = 0xFFFF; + /// TODO: THis has caused an exception when swithcing back to spectrumm... + Serial.printf("waitRXcomplete returning %04x (%s)\n", res, (res&0xff)<4?RXstr[res&0xff]:""); + // currently used only by RS92 + switch(sondeList[rxtask.receiveSonde].type) { + case STYPE_RS41: + rs41.waitRXcomplete(); + break; + case STYPE_RS92: + rs92.waitRXcomplete(); + break; + case STYPE_M10: + case STYPE_M20: + case STYPE_M10M20: + m10m20.waitRXcomplete(); + break; + case STYPE_DFM: + dfm.waitRXcomplete(); + break; + case STYPE_MP3H: + mp3h.waitRXcomplete(); + break; + } + memmove(sonde.si()->rxStat+1, sonde.si()->rxStat, 17); + sonde.si()->rxStat[0] = res; + return res; +} + +uint8_t Sonde::timeoutEvent(SondeInfo *si) { + uint32_t now = millis(); +#if 0 + Serial.printf("Timeout check: %d - %d vs %d; %d - %d vs %d; %d - %d vs %d; lastState: %d\n", + now, si->viewStart, disp.layout->timeouts[0], + now, si->rxStart, disp.layout->timeouts[1], + now, si->norxStart, disp.layout->timeouts[2], si->lastState); +#endif + if(disp.layout->timeouts[0]>=0 && now - si->viewStart >= disp.layout->timeouts[0]) { + Serial.println("Sonde::timeoutEvent: View"); + return EVT_VIEWTO; + } + if(si->lastState==1 && disp.layout->timeouts[1]>=0 && now - si->rxStart >= disp.layout->timeouts[1]) { + Serial.println("Sonde::timeoutEvent: RX"); + return EVT_RXTO; + } + if(si->lastState==0 && disp.layout->timeouts[2]>=0 && now - si->norxStart >= disp.layout->timeouts[2]) { + Serial.println("Sonde::timeoutEvent: NORX"); + return EVT_NORXTO; + } + return 0; +} + +uint8_t Sonde::updateState(uint8_t event) { + //Serial.printf("Sonde::updateState for event %02x\n", event); + // No change + if(event==ACT_NONE) return 0xFF; + + // In all cases (new display mode, new sonde) we reset the mode change timers + sonde.sondeList[sonde.currentSonde].viewStart = millis(); + sonde.sondeList[sonde.currentSonde].lastState = -1; + + // Moving to a different display mode + if (event==ACT_DISPLAY_SPECTRUM || event==ACT_DISPLAY_WIFI) { + // main loop will call setMode() and disable sx1278 background task + return event; + } + int n = event; + if(event==ACT_DISPLAY_DEFAULT) { + n = config.display[1]; + } else if(event==ACT_DISPLAY_SCANNER) { + n= config.display[0]; + } else if(event==ACT_DISPLAY_NEXT) { + int i; + for(i=0; config.display[i]!=-1; i++) { + if(config.display[i] == disp.layoutIdx) break; + } + if(config.display[i]==-1 || config.display[i+1]==-1) { + //unknown index, or end of list => loop to start + n = config.display[1]; + } else { + n = config.display[i+1]; + } + } + if(n>=0 && n=disp.nLayouts) { + Serial.println("WARNNG: next layout out of range"); + n = config.display[1]; + } + Serial.printf("Setting display mode %d\n", n); + disp.setLayout(n); + sonde.clearDisplay(); + return 0xFF; + } + + // Moving to a different value for currentSonde + // TODO: THis should be done in sx1278 task, not in main loop!!!!! + if(event==ACT_NEXTSONDE) { + sonde.nextConfig(); + Serial.printf("advancing to next sonde %d\n", sonde.currentSonde); + return event; + } + if (event==ACT_PREVSONDE) { + // TODO + Serial.printf("previous not supported, advancing to next sonde\n"); + sonde.nextConfig(); + return ACT_NEXTSONDE; + } + if(event&0x80) { + sonde.currentSonde = (event&0x7F); + return ACT_NEXTSONDE; + } + return 0xFF; +} + +void Sonde::clearAllData(SondeInfo *si) { + // set everything to 0 + memset(&(si->d), 0, sizeof(SondeData)); + // set floats to NaN + si->d.lat = si->d.lon = si->d.alt = si->d.vs = si->d.hs = si->d.dir = NAN; + si->d.temperature = si->d.tempRHSensor = si->d.relativeHumidity = si->d.pressure = si->d.batteryVoltage = NAN; +} + +void Sonde::updateDisplayPos() { + disp.updateDisplayPos(); +} + +void Sonde::updateDisplayPos2() { + disp.updateDisplayPos2(); +} + +void Sonde::updateDisplayID() { + disp.updateDisplayID(); +} + +void Sonde::updateDisplayRSSI() { + disp.updateDisplayRSSI(); +} + +void Sonde::updateStat() { + disp.updateStat(); +} + +void Sonde::updateDisplayRXConfig() { + disp.updateDisplayRXConfig(); +} + +void Sonde::updateDisplayIP() { + disp.updateDisplayIP(); +} + +void Sonde::updateDisplay() +{ + disp.updateDisplay(); +} + +void Sonde::clearDisplay() { + disp.rdis->clear(); +} + +void Sonde::dispsavectlON() { + disp.dispsavectlON(); +} + +void Sonde::dispsavectlOFF(int rxactive) { + disp.dispsavectlOFF(rxactive); +} + + +SondeType Sonde::realType(SondeInfo *si) { + if(TYPE_IS_METEO(si->type) && si->d.subtype>0 ) { return si->d.subtype==1 ? STYPE_M10:STYPE_M20; } + else return si->type; +} + +Sonde sonde = Sonde(); diff --git a/RX_FSK/src/Sonde.h b/RX_FSK/src/Sonde.h new file mode 100644 index 0000000..9c628e8 --- /dev/null +++ b/RX_FSK/src/Sonde.h @@ -0,0 +1,377 @@ + +#ifndef Sonde_h +#define Sonde_h + +#include +#include + +enum DbgLevel { DEBUG_OFF=0, DEBUG_INFO=1, DEBUG_SPARSER=16, DEBUG_DISPLAY=8 }; // to be extended for configuring serial debug output +extern uint8_t debug; + +#define DebugPrint(l,x) if(debug&l) { Serial.print(x); } +#define DebugPrintln(l,x) if(debug&l) { Serial.println(x); } +#define DebugPrintf(l,...) if(debug&l) { Serial.printf(__VA_ARGS__); } + +// RX_TIMEOUT: no header detected +// RX_ERROR: header detected, but data not decoded (crc error, etc.) +// RX_PARTIAL: header detected, some data ok, some with errors +// For RS41: Some blocks with CRC error, some blocks ok in a single frame +// For DFM: In +- 1s, some but not all DAT-subframes 1,2,3,4,5,6,7,8 received +// For RS92 ??? unclear +// For M10/M20 its always all or nothing, no PARTIAL data +// For MP3H its alway all or nothing, no PARTIAL data +// RX_OK: header and all data ok +enum RxResult { RX_OK, RX_TIMEOUT, RX_ERROR, RX_UNKNOWN, RX_NOPOS }; +#define RX_UPDATERSSI 0xFFFE + +// Events that change what is displayed (mode, sondenr) +// Keys: +// 1 Button (short) or Touch (short) +// 2 Button (double) or Touch (double) +// 3 Button (mid) or Touch (mid) +// 4 Button (long) or Touch (long) +// 5 Touch1/2 (short) +// 6 Touch1/2 (double) +// 7 Touch1/2 (mid) +// 8 Touch1/2 (long) + +/* Keypress => Sonde++ / Sonde-- / Display:=N*/ +enum Events { EVT_NONE, EVT_KEY1SHORT, EVT_KEY1DOUBLE, EVT_KEY1MID, EVT_KEY1LONG, + EVT_KEY2SHORT, EVT_KEY2DOUBLE, EVT_KEY2MID, EVT_KEY2LONG, + EVT_VIEWTO, EVT_RXTO, EVT_NORXTO, + EVT_MAX }; +extern const char *evstring[]; +extern const char *RXstr[]; +#define EVENTNAME(s) evstring[s] + +//int8_t actions[EVT_MAX]; +#define ACT_NONE 255 +#define ACT_DISPLAY(n) (n) +#define ACT_MAXDISPLAY 50 +#define ACT_DISPLAY_SCANNER 0 +#define ACT_DISPLAY_NEXT 64 +#define ACT_DISPLAY_DEFAULT 63 +#define ACT_DISPLAY_SPECTRUM 62 +#define ACT_DISPLAY_WIFI 61 +#define ACT_NEXTSONDE 65 +#define ACT_PREVSONDE 66 +#define ACT_ADDFREQ(n) ((n)+64) +#define ACT_SONDE(n) ((n)+128) + +// 0000nnnn => goto display nnnn +// 01000000 => goto sonde -1 +// 01000001 => goto sonde +1 + +#define NSondeTypes 7 +enum SondeType { STYPE_DFM, STYPE_RS41, STYPE_RS92, STYPE_M10M20, STYPE_M10, STYPE_M20, STYPE_MP3H }; +extern const char *sondeTypeStr[NSondeTypes]; +extern const char *sondeTypeLongStr[NSondeTypes]; +extern const char sondeTypeChar[NSondeTypes]; +extern const char *manufacturer_string[NSondeTypes]; + +#define ISOLED(cfg) ((cfg).disptype==0 || (cfg).disptype==2) + +#define TYPE_IS_DFM(t) ( (t)==STYPE_DFM ) +#define TYPE_IS_METEO(t) ( (t)==STYPE_M10M20 || (t)==STYPE_M10 || (t)==STYPE_M20 ) + +#define VALIDPOS(x) (((x)&0x03)==0x03) +#define VALIDALT(x) ((x)&0x04) +#define VALIDVS(x) ((x)&0x08) +#define VALIDHS(x) ((x)&0x10) +#define VALIDDIR(x) ((x)&0x20) +#define VALIDSATS(x) ((x)&0x40) + +typedef struct st_sondedata { + // decoded ID + char id[10]; + char ser[12]; + bool validID; + char typestr[5]; // decoded type (use type if *typestr==0) + int8_t subtype; /* 0 for none/unknown, hex type for dfm, 1/2 for M10/M20 */ + // decoded position + float lat; // latitude + float lon; // longitude + float alt; // altitude + float vs; // vertical speed in m/s + float hs; // horizontal speed in m/s + float dir; // 0..360 + uint8_t sats; // number of sats + uint8_t validPos; // bit pattern for validity of above 7 fields; 0x80: position is old + // decoded GPS time + uint32_t time; + uint32_t frame; + uint32_t vframe; // vframe==frame if frame is unique/continous, otherweise vframe is derived from gps time + bool validTime; + // shut down timers, currently only for RS41; -1=disabled + uint16_t launchKT, burstKT, countKT; + uint16_t crefKT; // frame number in which countKT was last sent + // sonde specific extra data, NULL if unused or not yet initialized, currently used for RS41 subframe data (calibration) + float temperature; // platinum resistor temperature + float tempRHSensor; // temperature of relative humidity sensor + float relativeHumidity; // relative humidity + float pressure; + float batteryVoltage = -1; +} SondeData; + +typedef struct st_sondeinfo { + // First part: static configuration, not decoded data. + // receiver configuration + bool active; + SondeType type; + float freq; + char launchsite[18]; + + // Second part: internal decoder state. no need to clear this on new sonde + // RSSI from receiver + int rssi; // signal strength + int32_t afc; // afc correction value + // statistics + uint8_t rxStat[20]; + uint32_t rxStart; // millis() timestamp of continuous rx start + uint32_t norxStart; // millis() timestamp of continuous no rx start + uint32_t viewStart; // millis() timestamp of viewinf this sonde with current display + int8_t lastState; // -1: disabled; 0: norx; 1: rx + // Third part: decoded data. Clear if reception of a new sonde has started + SondeData d; + + // Decoder-specific data, dynamically allocated (for RS41: calibration data) + void *extra; +} SondeInfo; +// rxStat: 3=undef[empty] 1=timeout[.] 2=errro[E] 0=ok[|] 4=no valid position[°] + +// Used for interacting with the RX background task +typedef struct st_RXTask { + // Variables set by Arduino main loop to value >=0 for requesting + // mode change to sonde reception for sonde now handled in JS + int type; // 0: numeric; i>0 string of length i; -1: separator; -2: type selector + void *data; +}; + +// defined in RX_FSK.ino +extern struct st_configitems config_list[]; +extern const int N_CONFIG; + + +#define MAXSONDE 50 + +extern int fingerprintValue[]; +extern const char *fingerprintText[]; + +class Sonde +{ +private: +public: + RDZConfig config; + int fingerprint = 0; + int currentSonde = 0; + int nSonde; + String ipaddr; + bool isAP; + // moved to heap, saving space in .bss + //SondeInfo sondeList[MAXSONDE+1]; + SondeInfo *sondeList; + // helper function for type string + static SondeType realType(SondeInfo *si); + + Sonde(); + void defaultConfig(); + void checkConfig(); + void setConfig(const char *str); + + void clearSonde(); + void addSonde(float frequency, SondeType type, int active, char *launchsite); + void nextConfig(); + void nextRxSonde(); + void nextRxFreq(int addkhz); + + /* new interface */ + void setup(); + void receive(); + uint16_t waitRXcomplete(); + + SondeInfo *si(); + void clearAllData(SondeInfo *si); + + uint8_t timeoutEvent(SondeInfo *si); + uint8_t updateState(uint8_t event); + + void updateDisplayPos(); + void updateDisplayPos2(); + void updateDisplayID(); + void updateDisplayRSSI(); + void updateDisplayRXConfig(); + void updateStat(); + void updateDisplayIP(); + void updateDisplay(); + void clearDisplay(); + void dispsavectlON(); + void dispsavectlOFF(int rxactive); + + void setIP(String ip, bool isAP); +}; + +extern Sonde sonde; + +#endif + diff --git a/RX_FSK/src/aprs.cpp b/RX_FSK/src/aprs.cpp new file mode 100644 index 0000000..ea6cfdb --- /dev/null +++ b/RX_FSK/src/aprs.cpp @@ -0,0 +1,391 @@ +/* Copyright (C) Hansi Reiser, dl9rdz + * + * partially based on dxlAPRS toolchain + * + * Copyright (C) Christian Rabler + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include +#include +#include +//#include +//#include +#include +#include +#include +#include "aprs.h" + +extern const char *version_name; +extern const char *version_id; +#if 0 +int openudp(const char *ip, int port, struct sockaddr_in *si) { + int fd; + if((fd=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1) return -1; + memset((char *)&si, 0, sizeof(si)); + si->sin_family = AF_INET; + si->sin_port = htons(port); + if(inet_aton(ip, &(si->sin_addr))==0) { + return -1; + } + return fd; +} + +int sendudp(int fd, struct sockaddr_in *si, char *frame, int framelen) +{ + if(sendto(fd, frame, framelen, 0, (struct sockaddr *)si, sizeof(struct sockaddr_in))==-1) { + return -1; + } + return 0; +} +#endif + + + +void aprsstr_append(char *b, const char *data) +{ + int blen=strlen(b); + int len=strlen(data); + if(blen+len>APRS_MAXLEN) len=APRS_MAXLEN-blen; + strncat(b, data, len); +} + +uint32_t realcard(float x) { + if(x<0) return 0; + else return (uint32_t)x; +} + + +/* CRC for AXUDP frames */ + +#define APRSCRC_POLY 0x8408 +static uint8_t CRCL[256]; +static uint8_t CRCH[256]; + +void aprs_gencrctab(void) +{ + uint32_t c; + uint32_t crc; + uint32_t i; + for (c = 0UL; c<=255UL; c++) { + crc = 255UL-c; + for (i = 0UL; i<=7UL; i++) { + if ((crc&1)) crc = (uint32_t)((uint32_t)(crc>>1)^APRSCRC_POLY); + else crc = crc>>1; + } /* end for */ + CRCL[c] = (uint8_t)crc; + CRCH[c] = (uint8_t)(255UL-(crc>>8)); + } /* end for */ +} /* end Gencrctab() */ + +static void aprsstr_appcrc(char frame[], uint32_t frame_len, int32_t size) +{ + uint8_t h; + uint8_t l; + uint8_t b; + int32_t i; + int32_t tmp; + l = 0U; + h = 0U; + tmp = size-1L; + i = 0L; + if (i<=tmp) for (;; i++) { + b = (uint8_t)((uint8_t)(uint8_t)frame[i]^l); + l = CRCL[b]^h; + h = CRCH[b]; + if (i==tmp) break; + } /* end for */ + frame[size] = (char)l; + frame[size+1L] = (char)h; +} /* end aprsstr_appcrc() */ + + +static int mkaprscall(int32_t * p, char raw[], + uint32_t * i, const char mon[], + char sep1, char sep2, char sep3, + uint32_t sbase) +{ + uint32_t s; + uint32_t l; + l = 0UL; + while ((((mon[*i] && mon[*i]!=sep1) && mon[*i]!=sep2) && mon[*i]!=sep3) + && mon[*i]!='-') { + s = (uint32_t)(uint8_t)mon[*i]*2UL&255UL; + if (s<=64UL) return 0; + raw[*p] = (char)s; + ++*p; + ++*i; + ++l; + if (l>=7UL) return 0; + } + while (l<6UL) { + raw[*p] = '@'; + ++*p; + ++l; + } + s = 0UL; + if (mon[*i]=='-') { + ++*i; + while ((uint8_t)mon[*i]>='0' && (uint8_t)mon[*i]<='9') { + s = (s*10UL+(uint32_t)(uint8_t)mon[*i])-48UL; + ++*i; + } + if (s>15UL) return 0; + } + raw[*p] = (char)((s+sbase)*2UL); + ++*p; + return 1; +} /* end call() */ + + + +// returns raw len, 0 in case of error +extern int aprsstr_mon2raw(const char *mon, char raw[], int raw_len) +{ + uint32_t r; + uint32_t n; + uint32_t i; + uint32_t tmp; + int p = 7L; + i = 0UL; + fprintf(stderr,"mon2raw for %s\n", mon); + if (!mkaprscall(&p, raw, &i, mon, '>', 0, 0, 48UL)) { + return 0; + } + p = 0L; + if (mon[i]!='>') return 0; + /* ">" */ + ++i; + if (!mkaprscall(&p, raw, &i, mon, ':', ',', 0, 112UL)) { + return 0; + } + p = 14L; + n = 0UL; + while (mon[i]==',') { + ++i; + if (!mkaprscall(&p, raw, &i, mon, ':', ',', '*', 48UL)) { + return 0; + } + ++n; + if (n>8UL) { + return 0; + } + if (mon[i]=='*') { + /* "*" has repeatet sign */ + ++i; + r = (uint32_t)p; + if (r>=21UL) for (tmp = (uint32_t)(r-21UL)/7UL;;) { + raw[r-1UL] = (char)((uint32_t)(uint8_t)raw[r-1UL]+128UL); + /* set "has repeated" flags */ + if (!tmp) break; + --tmp; + r -= 7UL; + } /* end for */ + } + } + if (p==0L || mon[i]!=':') { + return 0; + } + raw[p-1L] = (char)((uint32_t)(uint8_t)raw[p-1L]+1UL); + /* end address field mark */ + raw[p] = '\003'; + ++p; + raw[p] = '\360'; + ++p; + ++i; + n = 256UL; + while (mon[i]) { + /* copy info part */ + if (p>=(int32_t)(raw_len-1)-2L || n==0UL) { + return 0; + } + raw[p] = mon[i]; + ++p; + ++i; + --n; + } + aprsstr_appcrc(raw, raw_len, p); + //fprintf(stderr,"results in %s\n",raw); + return p+2; +} /* end mon2raw() */ + +extern int aprsstr_mon2kiss(const char *mon, char raw[], int raw_len) +{ + char tmp[201]; + int len = aprsstr_mon2raw(mon, tmp, 201); + if(len==0) return 0; + int idx=0; + raw[idx++] = '\xC0'; + raw[idx++] = 0; // channel 0 + for(int i=0; i=raw_len) + return 0; + } + return idx; +} + +#define FEET (1.0/0.3048) +#define KNOTS (1.851984) + +static uint32_t truncc(double r) +{ + if (r<=0.0) return 0UL; + else if (r>=2.E+9) return 2000000000UL; + else return (uint32_t)r; + return 0; +} /* end truncc() */ + + + +static uint32_t dao91(double x) +/* radix91(xx/1.1) of dddmm.mmxx */ +{ + double a; + a = fabs(x); + return ((truncc((a-(double)(float)truncc(a))*6.E+5)%100UL) + *20UL+11UL)/22UL; +} /* end dao91() */ + + +char b[251]; +//char raw[201]; +const char *destcall="APRRDZ"; + +char *aprs_send_beacon(const char *usercall, float lat, float lon, const char *sym, const char *comment) { + *b = 0; + aprsstr_append(b, usercall); + aprsstr_append(b, ">"); + aprsstr_append(b, destcall); +#if 0 + aprsstr_append(b, ":/"); // / is report with timestamp + int i = strlen(b); + int sec = 0; // TODO: NOW!!! + snprintf(b+i, APRS_MAXLEN, "%02d%02d%02dh", sec/(60*60), (sec%(60*60))/60, sec%60); +#else + // report without timestamp + aprsstr_append(b, ":!"); // ! is report w/p timestamp +#endif + // lat + int i = strlen(b); + int lati = abs((int)lat); + int latm = (fabs(lat)-lati)*6000; + snprintf(b+i, APRS_MAXLEN-i, "%02d%02d.%02d%c%c", lati, latm/100, latm%100, lat<0?'S':'N', sym[0]); + // lon + i = strlen(b); + int loni = abs((int)lon); + int lonm = (fabs(lon)-loni)*6000; + snprintf(b+i, APRS_MAXLEN-i, "%03d%02d.%02d%c%c", loni, lonm/100, lonm%100, lon<0?'W':'E', sym[1]); + // maybe add alt + // maybe add DAO? + i = strlen(b); + snprintf(b+i, APRS_MAXLEN-i, "%s", comment); + + i = strlen(b); + snprintf(b+i, APRS_MAXLEN-i, " %s-%s", version_name, version_id); + //sprintf(b + strlen(b), "%s", version_name); + return b; +} + +char *aprs_senddata(SondeInfo *si, const char *usercall, const char *objcall, const char *sym) { + SondeData *s = &(si->d); + *b=0; + aprsstr_append(b, *objcall ? objcall : usercall); + aprsstr_append(b, ">"); +// const char *destcall="APRARX,SONDEGATE,TCPIP,qAR,oh3bsg"; + aprsstr_append(b, destcall); +// if(*objcall) { aprsstr_append(b, ","); aprsstr_append(b, usercall); } + // uncompressed + aprsstr_append(b, ":;"); + char tmp[10]; + snprintf(tmp,10,"%s ",s->id); + aprsstr_append(b, tmp); + aprsstr_append(b, "*"); + // time + int i = strlen(b); + int sec = s->time % 86400; + snprintf(b+i, APRS_MAXLEN-1, "%02d%02d%02dh", sec/(60*60), (sec%(60*60))/60, sec%60); + i = strlen(b); + //aprsstr_append_data(time, ds); + int lati = abs((int)s->lat); + int latm = (fabs(s->lat)-lati)*6000; + snprintf(b+i, APRS_MAXLEN-i, "%02d%02d.%02d%c%c", lati, latm/100, latm%100, s->lat<0?'S':'N', sym[0]); + i = strlen(b); + int loni = abs((int)s->lon); + int lonm = (fabs(s->lon)-loni)*6000; + snprintf(b+i, APRS_MAXLEN-i, "%03d%02d.%02d%c%c", loni, lonm/100, lonm%100, s->lon<0?'W':'E', sym[1]); + if(s->hs>0.5) { + i=strlen(b); + snprintf(b+i, APRS_MAXLEN-i, "%03d/%03d", realcard(s->dir+1.5), realcard(s->hs*3.6/KNOTS+0.5)); + } + if(s->alt>0.5) { + i=strlen(b); + snprintf(b+i, APRS_MAXLEN-i, "/A=%06d", realcard(s->alt*FEET+0.5)); + } + // always use DAO + i=strlen(b); + snprintf(b+i, APRS_MAXLEN-i, "!w%c%c!", 33+dao91(s->lat), 33+dao91(s->lon)); + + // ??? strcat(b, "&"); + i=strlen(b); + i += snprintf(b+i, APRS_MAXLEN-i, "Clb=%.1fm/s ", s->vs ); + if( !isnan(s->pressure) ) { + sprintf(b+strlen(b), "p=%.1fhPa ", s->pressure); + } + if( !isnan(s->temperature) ) { + sprintf(b+strlen(b), "t=%.1fC ", s->temperature); + } + if( !isnan(s->relativeHumidity) ) { + sprintf(b+strlen(b), "h=%.1f%% ", s->relativeHumidity); + } + char type[12]; + if ( si->type == STYPE_RS41 && RS41::getSubtype(type, 11, si) == 0 ) { + // type was copied to type + } else { + strncpy(type, sondeTypeStr[sonde.realType(si)], 11); type[11]=0; + } + + sprintf(b+strlen(b), "%.3fMHz Type=%s ", si->freq, type /* sondeTypeStr[sonde.realType(si)] */ ); + if( s->countKT != 0xffff && s->vframe - s->crefKT < 51 ) { + sprintf(b+strlen(b), "TxOff=%dh%dm ", s->countKT/3600, (s->countKT-s->countKT/3600*3600)/60); + } + if( TYPE_IS_DFM(si->type) || TYPE_IS_METEO(si->type) ) { + sprintf(b + strlen(b), "ser=%s ", s->ser); + } + sprintf(b + strlen(b), "%s", version_name); + return b; +} + + +#if 0 +int main(int argc, char *argv[]) +{ + Gencrctab(); + + struct sockaddr_in si; + int fd = openudp("127.0.0.1",9002,&si); + if(fd<0) { fprintf(stderr,"open failed\n"); return 1; } + + float lat=48, lon=10; + while(1) { + const char *str = aprs_senddata(lat, lon, 543, 5, 180, 1.5, "RS41", "TE0ST", "TE1ST", "EO"); + int rawlen = aprsstr_mon2raw(str, raw, APRS_MAXLEN); + sendudp(fd, raw, rawlen); + + str = "OE3XKC>APMI06,qAR,OE3XLR:;ER-341109*111111z4803.61NE01532.39E0145.650MHz R15k OE3XPA"; + rawlen = aprsstr_mon2raw(str, raw, APRS_MAXLEN); + sendudp(fd, &si, raw, rawlen); + lat += 0.002; lon += 0.01; + sleep(5); + } +} +#endif diff --git a/RX_FSK/src/aprs.h b/RX_FSK/src/aprs.h new file mode 100644 index 0000000..d2e50c5 --- /dev/null +++ b/RX_FSK/src/aprs.h @@ -0,0 +1,16 @@ + +#ifndef _aprs_h +#define _aprs_h +#include "Sonde.h" +#include "RS41.h" + + +#define APRS_MAXLEN 201 +void aprs_gencrctab(void); +int aprsstr_mon2raw(const char *mon, char raw[], int raw_len); +int aprsstr_mon2kiss(const char *mon, char raw[], int raw_len); +char *aprs_send_beacon(const char *call, float lat, float lon, const char *sym, const char *comment); +char *aprs_senddata(SondeInfo *s, const char *usercall, const char *objcall, const char *sym); + + +#endif diff --git a/RX_FSK/src/autodetect-infos b/RX_FSK/src/autodetect-infos new file mode 100644 index 0000000..d93da7f --- /dev/null +++ b/RX_FSK/src/autodetect-infos @@ -0,0 +1,87 @@ +Heltec board v1 => fingerprint 0000100 => 4 +(sda,scl: 4,15) (same as LORA v1.0) +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:0 17:0 18:0 19:0 20:0 21:1 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 + +Heltec board v2 +(sda,scl: 4,15) (similar to v1.0, but GPIO21 switches 3V3) => fingerprint 4 +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:0 17:0 18:0 19:0 20:0 21:1 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:1 1:1 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:0 17:0 18:0 19:0 20:0 21:1 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup + +TTGO LORA32 v2.1_1.6 (button1: touch gpio 2 => 130; button2: touch gpio14 => 142) fingerprint 0011111 => 31 +(sda,scl: 21,22) +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:1 17:1 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:0 13:0 14:4 15:4 16:4 17:4 18:0 19:0 20:0 21:4 22:4 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (in Sonde()) + +TTGO LORA v1.0 => fingerprint 1000000 => 64 +(sda,scl: 4,15) (button1: 0) (button2: touch gpio13 = 141) +0:1 1:0 2:0 3:1 4:1 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:0 17:0 18:0 19:0 20:0 21:0 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:4 1:4 2:0 3:4 4:4 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:0 13:0 14:4 15:4 16:0 17:0 18:0 19:0 20:0 21:0 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (in Sonde()) + +TTGO T-Beam => fingerprint 0110111 => 55 +(sda,scl: 21,22) (button1: 39) (button2: touch gpio13 = 141) (gps rx: 12) +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:1 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:4 13:0 14:4 15:4 16:4 17:0 18:0 19:0 20:0 21:4 22:4 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup) + +TTGO T-Beam with extern 2" ILI9225 Display => fingerprint 0110000 => 48 +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:1 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:0 22:0 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:4 13:0 14:4 15:4 16:4 17:0 18:0 19:0 20:0 21:0 22:0 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup) + +TTGO T-Beam 1.0 with OLED display => fingerprint 0010111 => 23 +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:0 13:0 14:4 15:4 16:4 17:0 18:0 19:0 20:0 21:4 22:4 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup) + +TTGO T-Team 1.0 with IL9225 TFT => fingerprint 23 +0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:1 1:1 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup) + +M5Stack Core2 +0:1 1:0 2:0 3:1 4:1 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:1 14:1 15:1 16:1 17:0 18:1 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:1 1:1 2:0 3:1 4:1 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:1 14:1 15:1 16:1 17:0 18:1 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup) +Board fingerprint is 87 (nach power on) +0:1 1:0 2:0 3:1 4:0 5:0 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 +0:1 1:1 2:0 3:1 4:0 5:0 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 (before setup) +Board fingerprint is 22 (nach reset) +Autoconfig: looks like T-Beam 1.0 board + + + vs 0010111 +T-Beam 1.1 seems to be different: 1110111 +GPIO4 = 1 (additional pullup) => +64 +GPIO12 = 1 (maybe additional pullup) => +32 + +1 + +Fingerprint GPIOs: 4, 12, 16, 17, 21, 22, 23, + +Current autodetect strategy: +RST always set to 16 + +GPIO16=0 (GPio22,23 would also work): + ==Heltec or TTGO LORA v1.0== + SDA,SCL set to (4,15) + Button 1 set to GPIO 0 + Button 2 set to Touch in GPIO 13 (141) + + +otherwise + ==LORA32 v2.1 or T-Beam== + GPIO17=0: + == T-BEAM = + GPIO12==0: v1 (or check PMU via I2C?) + GPS RX set to 34 + Button 1 set to GPIO28 + BUtton 2 set to Touch GPIO13 + else: + GPS RX set to 12 + Button 1 set to GPIO39 + Button 2 set to Touch GPIO13 (141) + GPIO21=0: + large display connected (use ILI9225 contig: SDA4 CLK21 RS2 RST22 CS0) + else: + small display connected, set SDA,SCL to (21,22) + otherweise: + SDA,SCL set to (21,22) + GPS disabled + Button 1 set to Touch GPIO2 (130) + Button 2 set to Touch GPIO14 (142) + diff --git a/RX_FSK/src/fonts/FreeMono12pt7b.h b/RX_FSK/src/fonts/FreeMono12pt7b.h new file mode 100644 index 0000000..94ecb88 --- /dev/null +++ b/RX_FSK/src/fonts/FreeMono12pt7b.h @@ -0,0 +1,227 @@ +const uint8_t FreeMono12pt7bBitmaps[] PROGMEM = { + 0x49, 0x24, 0x92, 0x48, 0x01, 0xF8, 0xE7, 0xE7, 0x67, 0x42, 0x42, 0x42, + 0x42, 0x09, 0x02, 0x41, 0x10, 0x44, 0x11, 0x1F, 0xF1, 0x10, 0x4C, 0x12, + 0x3F, 0xE1, 0x20, 0x48, 0x12, 0x04, 0x81, 0x20, 0x48, 0x04, 0x07, 0xA2, + 0x19, 0x02, 0x40, 0x10, 0x03, 0x00, 0x3C, 0x00, 0x80, 0x10, 0x06, 0x01, + 0xE0, 0xA7, 0xC0, 0x40, 0x10, 0x04, 0x00, 0x3C, 0x19, 0x84, 0x21, 0x08, + 0x66, 0x0F, 0x00, 0x0C, 0x1C, 0x78, 0x01, 0xE0, 0xCC, 0x21, 0x08, 0x43, + 0x30, 0x78, 0x3E, 0x30, 0x10, 0x08, 0x02, 0x03, 0x03, 0x47, 0x14, 0x8A, + 0x43, 0x11, 0x8F, 0x60, 0xFD, 0xA4, 0x90, 0x05, 0x25, 0x24, 0x92, 0x48, + 0x92, 0x24, 0x11, 0x24, 0x89, 0x24, 0x92, 0x92, 0x90, 0x00, 0x04, 0x02, + 0x11, 0x07, 0xF0, 0xC0, 0x50, 0x48, 0x42, 0x00, 0x08, 0x04, 0x02, 0x01, + 0x00, 0x87, 0xFC, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x3B, 0x9C, 0xCE, + 0x62, 0x00, 0xFF, 0xE0, 0xFF, 0x80, 0x00, 0x80, 0xC0, 0x40, 0x20, 0x20, + 0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x02, 0x02, 0x01, 0x01, 0x00, 0x80, + 0x80, 0x40, 0x00, 0x1C, 0x31, 0x90, 0x58, 0x38, 0x0C, 0x06, 0x03, 0x01, + 0x80, 0xC0, 0x60, 0x30, 0x34, 0x13, 0x18, 0x70, 0x30, 0xE1, 0x44, 0x81, + 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81, 0x1F, 0xC0, 0x1E, 0x10, 0x90, + 0x68, 0x10, 0x08, 0x0C, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x0E, + 0x07, 0xFE, 0x3E, 0x10, 0x40, 0x08, 0x02, 0x00, 0x80, 0x40, 0xE0, 0x04, + 0x00, 0x80, 0x10, 0x04, 0x01, 0x00, 0xD8, 0x63, 0xE0, 0x06, 0x0A, 0x0A, + 0x12, 0x22, 0x22, 0x42, 0x42, 0x82, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x0F, + 0x7F, 0x20, 0x10, 0x08, 0x04, 0x02, 0xF1, 0x8C, 0x03, 0x00, 0x80, 0x40, + 0x20, 0x18, 0x16, 0x18, 0xF0, 0x0F, 0x8C, 0x08, 0x08, 0x04, 0x04, 0x02, + 0x79, 0x46, 0xC1, 0xE0, 0x60, 0x28, 0x14, 0x19, 0x08, 0x78, 0xFF, 0x81, + 0x81, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08, + 0x08, 0x3E, 0x31, 0xB0, 0x70, 0x18, 0x0C, 0x05, 0x8C, 0x38, 0x63, 0x40, + 0x60, 0x30, 0x18, 0x1B, 0x18, 0xF8, 0x3C, 0x31, 0x30, 0x50, 0x28, 0x0C, + 0x0F, 0x06, 0x85, 0x3C, 0x80, 0x40, 0x40, 0x20, 0x20, 0x63, 0xE0, 0xFF, + 0x80, 0x07, 0xFC, 0x39, 0xCE, 0x00, 0x00, 0x06, 0x33, 0x98, 0xC4, 0x00, + 0x00, 0xC0, 0x60, 0x18, 0x0C, 0x06, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x03, + 0x00, 0x30, 0x01, 0x00, 0xFF, 0xF0, 0x00, 0x00, 0x0F, 0xFF, 0xC0, 0x06, + 0x00, 0x30, 0x01, 0x80, 0x18, 0x01, 0x80, 0xC0, 0x30, 0x18, 0x0C, 0x02, + 0x00, 0x00, 0x3E, 0x60, 0xA0, 0x20, 0x10, 0x08, 0x08, 0x18, 0x10, 0x08, + 0x00, 0x00, 0x00, 0x01, 0xC0, 0xE0, 0x1C, 0x31, 0x10, 0x50, 0x28, 0x14, + 0x3A, 0x25, 0x22, 0x91, 0x4C, 0xA3, 0xF0, 0x08, 0x02, 0x01, 0x80, 0x7C, + 0x3F, 0x00, 0x0C, 0x00, 0x48, 0x01, 0x20, 0x04, 0x40, 0x21, 0x00, 0x84, + 0x04, 0x08, 0x1F, 0xE0, 0x40, 0x82, 0x01, 0x08, 0x04, 0x20, 0x13, 0xE1, + 0xF0, 0xFF, 0x08, 0x11, 0x01, 0x20, 0x24, 0x04, 0x81, 0x1F, 0xC2, 0x06, + 0x40, 0x68, 0x05, 0x00, 0xA0, 0x14, 0x05, 0xFF, 0x00, 0x1E, 0x48, 0x74, + 0x05, 0x01, 0x80, 0x20, 0x08, 0x02, 0x00, 0x80, 0x20, 0x04, 0x01, 0x01, + 0x30, 0x87, 0xC0, 0xFE, 0x10, 0x44, 0x09, 0x02, 0x40, 0x50, 0x14, 0x05, + 0x01, 0x40, 0x50, 0x14, 0x0D, 0x02, 0x41, 0x3F, 0x80, 0xFF, 0xC8, 0x09, + 0x01, 0x20, 0x04, 0x00, 0x88, 0x1F, 0x02, 0x20, 0x40, 0x08, 0x01, 0x00, + 0xA0, 0x14, 0x03, 0xFF, 0xC0, 0xFF, 0xE8, 0x05, 0x00, 0xA0, 0x04, 0x00, + 0x88, 0x1F, 0x02, 0x20, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x01, 0xF0, + 0x00, 0x1F, 0x46, 0x19, 0x01, 0x60, 0x28, 0x01, 0x00, 0x20, 0x04, 0x00, + 0x83, 0xF0, 0x0B, 0x01, 0x20, 0x23, 0x0C, 0x3E, 0x00, 0xE1, 0xD0, 0x24, + 0x09, 0x02, 0x40, 0x90, 0x27, 0xF9, 0x02, 0x40, 0x90, 0x24, 0x09, 0x02, + 0x40, 0xB8, 0x70, 0xFE, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x20, + 0x40, 0x81, 0x1F, 0xC0, 0x0F, 0xE0, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01, + 0x00, 0x20, 0x04, 0x80, 0x90, 0x12, 0x02, 0x40, 0xC6, 0x30, 0x7C, 0x00, + 0xF1, 0xE4, 0x0C, 0x41, 0x04, 0x20, 0x44, 0x04, 0x80, 0x5C, 0x06, 0x60, + 0x43, 0x04, 0x10, 0x40, 0x84, 0x08, 0x40, 0xCF, 0x07, 0xF8, 0x04, 0x00, + 0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x04, 0x80, + 0x90, 0x12, 0x03, 0xFF, 0xC0, 0xE0, 0x3B, 0x01, 0x94, 0x14, 0xA0, 0xA4, + 0x89, 0x24, 0x49, 0x14, 0x48, 0xA2, 0x45, 0x12, 0x10, 0x90, 0x04, 0x80, + 0x24, 0x01, 0x78, 0x3C, 0xE0, 0xF6, 0x02, 0x50, 0x25, 0x02, 0x48, 0x24, + 0xC2, 0x44, 0x24, 0x22, 0x43, 0x24, 0x12, 0x40, 0xA4, 0x0A, 0x40, 0x6F, + 0x06, 0x0F, 0x03, 0x0C, 0x60, 0x64, 0x02, 0x80, 0x18, 0x01, 0x80, 0x18, + 0x01, 0x80, 0x18, 0x01, 0x40, 0x26, 0x06, 0x30, 0xC0, 0xF0, 0xFF, 0x10, + 0x64, 0x05, 0x01, 0x40, 0x50, 0x34, 0x19, 0xFC, 0x40, 0x10, 0x04, 0x01, + 0x00, 0x40, 0x3E, 0x00, 0x0F, 0x03, 0x0C, 0x60, 0x64, 0x02, 0x80, 0x18, + 0x01, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0x40, 0x26, 0x06, 0x30, 0xC1, + 0xF0, 0x0C, 0x01, 0xF1, 0x30, 0xE0, 0xFF, 0x04, 0x18, 0x40, 0xC4, 0x04, + 0x40, 0x44, 0x0C, 0x41, 0x87, 0xE0, 0x43, 0x04, 0x10, 0x40, 0x84, 0x04, + 0x40, 0x4F, 0x03, 0x1F, 0x48, 0x34, 0x05, 0x01, 0x40, 0x08, 0x01, 0xC0, + 0x0E, 0x00, 0x40, 0x18, 0x06, 0x01, 0xE1, 0xA7, 0xC0, 0xFF, 0xF0, 0x86, + 0x10, 0x82, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, + 0x02, 0x00, 0x40, 0x7F, 0x00, 0xF0, 0xF4, 0x02, 0x40, 0x24, 0x02, 0x40, + 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x22, 0x04, 0x30, + 0xC0, 0xF0, 0xF8, 0x7C, 0x80, 0x22, 0x01, 0x04, 0x04, 0x10, 0x20, 0x40, + 0x80, 0x82, 0x02, 0x10, 0x08, 0x40, 0x11, 0x00, 0x48, 0x01, 0xA0, 0x03, + 0x00, 0x0C, 0x00, 0xF8, 0x7C, 0x80, 0x22, 0x00, 0x88, 0xC2, 0x23, 0x10, + 0x8E, 0x42, 0x29, 0x09, 0x24, 0x24, 0x90, 0x91, 0x41, 0x85, 0x06, 0x14, + 0x18, 0x70, 0x60, 0x80, 0xF0, 0xF2, 0x06, 0x30, 0x41, 0x08, 0x09, 0x80, + 0x50, 0x06, 0x00, 0x60, 0x0D, 0x00, 0x88, 0x10, 0xC2, 0x04, 0x60, 0x2F, + 0x0F, 0xF0, 0xF2, 0x02, 0x10, 0x41, 0x04, 0x08, 0x80, 0x50, 0x05, 0x00, + 0x20, 0x02, 0x00, 0x20, 0x02, 0x00, 0x20, 0x02, 0x01, 0xFC, 0xFF, 0x40, + 0xA0, 0x90, 0x40, 0x40, 0x40, 0x20, 0x20, 0x20, 0x10, 0x50, 0x30, 0x18, + 0x0F, 0xFC, 0xF2, 0x49, 0x24, 0x92, 0x49, 0x24, 0x9C, 0x80, 0x60, 0x10, + 0x08, 0x02, 0x01, 0x00, 0x40, 0x20, 0x08, 0x04, 0x01, 0x00, 0x80, 0x20, + 0x10, 0x04, 0x02, 0x00, 0x80, 0x40, 0xE4, 0x92, 0x49, 0x24, 0x92, 0x49, + 0x3C, 0x08, 0x0C, 0x09, 0x0C, 0x4C, 0x14, 0x04, 0xFF, 0xFC, 0x84, 0x21, + 0x3E, 0x00, 0x60, 0x08, 0x02, 0x3F, 0x98, 0x28, 0x0A, 0x02, 0xC3, 0x9F, + 0x30, 0xE0, 0x01, 0x00, 0x08, 0x00, 0x40, 0x02, 0x00, 0x13, 0xE0, 0xA0, + 0x86, 0x02, 0x20, 0x09, 0x00, 0x48, 0x02, 0x40, 0x13, 0x01, 0x14, 0x1B, + 0x9F, 0x00, 0x1F, 0x4C, 0x19, 0x01, 0x40, 0x28, 0x01, 0x00, 0x20, 0x02, + 0x00, 0x60, 0x43, 0xF0, 0x00, 0xC0, 0x08, 0x01, 0x00, 0x20, 0x04, 0x3C, + 0x98, 0x52, 0x06, 0x80, 0x50, 0x0A, 0x01, 0x40, 0x24, 0x0C, 0xC2, 0x87, + 0x98, 0x3F, 0x18, 0x68, 0x06, 0x01, 0xFF, 0xE0, 0x08, 0x03, 0x00, 0x60, + 0xC7, 0xC0, 0x0F, 0x98, 0x08, 0x04, 0x02, 0x07, 0xF8, 0x80, 0x40, 0x20, + 0x10, 0x08, 0x04, 0x02, 0x01, 0x03, 0xF8, 0x1E, 0x6C, 0x39, 0x03, 0x40, + 0x28, 0x05, 0x00, 0xA0, 0x12, 0x06, 0x61, 0x43, 0xC8, 0x01, 0x00, 0x20, + 0x08, 0x3E, 0x00, 0xC0, 0x10, 0x04, 0x01, 0x00, 0x40, 0x13, 0x87, 0x11, + 0x82, 0x40, 0x90, 0x24, 0x09, 0x02, 0x40, 0x90, 0x2E, 0x1C, 0x08, 0x04, + 0x02, 0x00, 0x00, 0x03, 0xC0, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, + 0x80, 0x43, 0xFE, 0x04, 0x08, 0x10, 0x00, 0x1F, 0xC0, 0x81, 0x02, 0x04, + 0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x0B, 0xE0, 0xE0, 0x02, 0x00, 0x20, + 0x02, 0x00, 0x20, 0x02, 0x3C, 0x21, 0x02, 0x60, 0x2C, 0x03, 0x80, 0x24, + 0x02, 0x20, 0x21, 0x02, 0x08, 0xE1, 0xF0, 0x78, 0x04, 0x02, 0x01, 0x00, + 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x43, 0xFE, + 0xDC, 0xE3, 0x19, 0x90, 0x84, 0x84, 0x24, 0x21, 0x21, 0x09, 0x08, 0x48, + 0x42, 0x42, 0x17, 0x18, 0xC0, 0x67, 0x83, 0x84, 0x20, 0x22, 0x02, 0x20, + 0x22, 0x02, 0x20, 0x22, 0x02, 0x20, 0x2F, 0x07, 0x1F, 0x04, 0x11, 0x01, + 0x40, 0x18, 0x03, 0x00, 0x60, 0x0A, 0x02, 0x20, 0x83, 0xE0, 0xCF, 0x85, + 0x06, 0x60, 0x24, 0x01, 0x40, 0x14, 0x01, 0x40, 0x16, 0x02, 0x50, 0x44, + 0xF8, 0x40, 0x04, 0x00, 0x40, 0x0F, 0x00, 0x1E, 0x6C, 0x3B, 0x03, 0x40, + 0x28, 0x05, 0x00, 0xA0, 0x12, 0x06, 0x61, 0x43, 0xC8, 0x01, 0x00, 0x20, + 0x04, 0x03, 0xC0, 0xE3, 0x8B, 0x13, 0x80, 0x80, 0x20, 0x08, 0x02, 0x00, + 0x80, 0x20, 0x3F, 0x80, 0x1F, 0x58, 0x34, 0x05, 0x80, 0x1E, 0x00, 0x60, + 0x06, 0x01, 0xC0, 0xAF, 0xC0, 0x20, 0x04, 0x00, 0x80, 0x10, 0x0F, 0xF0, + 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x03, 0x04, 0x3F, + 0x00, 0xC1, 0xC8, 0x09, 0x01, 0x20, 0x24, 0x04, 0x80, 0x90, 0x12, 0x02, + 0x61, 0xC7, 0xCC, 0xF8, 0xF9, 0x01, 0x08, 0x10, 0x60, 0x81, 0x08, 0x08, + 0x40, 0x22, 0x01, 0x20, 0x05, 0x00, 0x30, 0x00, 0xF0, 0x7A, 0x01, 0x10, + 0x08, 0x8C, 0x42, 0x62, 0x12, 0x90, 0xA5, 0x05, 0x18, 0x28, 0xC0, 0x86, + 0x00, 0x78, 0xF3, 0x04, 0x18, 0x80, 0xD0, 0x06, 0x00, 0x70, 0x09, 0x81, + 0x0C, 0x20, 0x6F, 0x8F, 0xF0, 0xF2, 0x02, 0x20, 0x41, 0x04, 0x10, 0x80, + 0x88, 0x09, 0x00, 0x50, 0x06, 0x00, 0x20, 0x04, 0x00, 0x40, 0x08, 0x0F, + 0xE0, 0xFF, 0x41, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0xBF, + 0xC0, 0x19, 0x08, 0x42, 0x10, 0x84, 0x64, 0x18, 0x42, 0x10, 0x84, 0x20, + 0xC0, 0xFF, 0xFF, 0xC0, 0xC1, 0x08, 0x42, 0x10, 0x84, 0x10, 0x4C, 0x42, + 0x10, 0x84, 0x26, 0x00, 0x38, 0x13, 0x38, 0x38 }; + +const GFXglyph FreeMono12pt7bGlyphs[] PROGMEM = { + { 0, 0, 0, 14, 0, 1 }, // 0x20 ' ' + { 0, 3, 15, 14, 6, -14 }, // 0x21 '!' + { 6, 8, 7, 14, 3, -14 }, // 0x22 '"' + { 13, 10, 16, 14, 2, -14 }, // 0x23 '#' + { 33, 10, 17, 14, 2, -14 }, // 0x24 '$' + { 55, 10, 15, 14, 2, -14 }, // 0x25 '%' + { 74, 9, 12, 14, 3, -11 }, // 0x26 '&' + { 88, 3, 7, 14, 5, -14 }, // 0x27 ''' + { 91, 3, 18, 14, 7, -14 }, // 0x28 '(' + { 98, 3, 18, 14, 4, -14 }, // 0x29 ')' + { 105, 9, 9, 14, 3, -14 }, // 0x2A '*' + { 116, 9, 11, 14, 3, -11 }, // 0x2B '+' + { 129, 5, 7, 14, 3, -3 }, // 0x2C ',' + { 134, 11, 1, 14, 2, -6 }, // 0x2D '-' + { 136, 3, 3, 14, 5, -2 }, // 0x2E '.' + { 138, 9, 18, 14, 3, -15 }, // 0x2F '/' + { 159, 9, 15, 14, 3, -14 }, // 0x30 '0' + { 176, 7, 14, 14, 4, -13 }, // 0x31 '1' + { 189, 9, 15, 14, 2, -14 }, // 0x32 '2' + { 206, 10, 15, 14, 2, -14 }, // 0x33 '3' + { 225, 8, 15, 14, 3, -14 }, // 0x34 '4' + { 240, 9, 15, 14, 3, -14 }, // 0x35 '5' + { 257, 9, 15, 14, 3, -14 }, // 0x36 '6' + { 274, 8, 15, 14, 3, -14 }, // 0x37 '7' + { 289, 9, 15, 14, 3, -14 }, // 0x38 '8' + { 306, 9, 15, 14, 3, -14 }, // 0x39 '9' + { 323, 3, 10, 14, 5, -9 }, // 0x3A ':' + { 327, 5, 13, 14, 3, -9 }, // 0x3B ';' + { 336, 11, 11, 14, 2, -11 }, // 0x3C '<' + { 352, 12, 4, 14, 1, -8 }, // 0x3D '=' + { 358, 11, 11, 14, 2, -11 }, // 0x3E '>' + { 374, 9, 14, 14, 3, -13 }, // 0x3F '?' + { 390, 9, 16, 14, 3, -14 }, // 0x40 '@' + { 408, 14, 14, 14, 0, -13 }, // 0x41 'A' + { 433, 11, 14, 14, 2, -13 }, // 0x42 'B' + { 453, 10, 14, 14, 2, -13 }, // 0x43 'C' + { 471, 10, 14, 14, 2, -13 }, // 0x44 'D' + { 489, 11, 14, 14, 2, -13 }, // 0x45 'E' + { 509, 11, 14, 14, 2, -13 }, // 0x46 'F' + { 529, 11, 14, 14, 2, -13 }, // 0x47 'G' + { 549, 10, 14, 14, 2, -13 }, // 0x48 'H' + { 567, 7, 14, 14, 4, -13 }, // 0x49 'I' + { 580, 11, 14, 14, 2, -13 }, // 0x4A 'J' + { 600, 12, 14, 14, 2, -13 }, // 0x4B 'K' + { 621, 11, 14, 14, 2, -13 }, // 0x4C 'L' + { 641, 13, 14, 14, 1, -13 }, // 0x4D 'M' + { 664, 12, 14, 14, 1, -13 }, // 0x4E 'N' + { 685, 12, 14, 14, 1, -13 }, // 0x4F 'O' + { 706, 10, 14, 14, 2, -13 }, // 0x50 'P' + { 724, 12, 17, 14, 1, -13 }, // 0x51 'Q' + { 750, 12, 14, 14, 2, -13 }, // 0x52 'R' + { 771, 10, 14, 14, 2, -13 }, // 0x53 'S' + { 789, 11, 14, 14, 2, -13 }, // 0x54 'T' + { 809, 12, 14, 14, 1, -13 }, // 0x55 'U' + { 830, 14, 14, 14, 0, -13 }, // 0x56 'V' + { 855, 14, 14, 14, 0, -13 }, // 0x57 'W' + { 880, 12, 14, 14, 1, -13 }, // 0x58 'X' + { 901, 12, 14, 14, 1, -13 }, // 0x59 'Y' + { 922, 9, 14, 14, 3, -13 }, // 0x5A 'Z' + { 938, 3, 18, 14, 7, -14 }, // 0x5B '[' + { 945, 9, 18, 14, 3, -15 }, // 0x5C '\' + { 966, 3, 18, 14, 5, -14 }, // 0x5D ']' + { 973, 9, 6, 14, 3, -14 }, // 0x5E '^' + { 980, 14, 1, 14, 0, 3 }, // 0x5F '_' + { 982, 4, 4, 14, 4, -15 }, // 0x60 '`' + { 984, 10, 10, 14, 2, -9 }, // 0x61 'a' + { 997, 13, 15, 14, 0, -14 }, // 0x62 'b' + { 1022, 11, 10, 14, 2, -9 }, // 0x63 'c' + { 1036, 11, 15, 14, 2, -14 }, // 0x64 'd' + { 1057, 10, 10, 14, 2, -9 }, // 0x65 'e' + { 1070, 9, 15, 14, 4, -14 }, // 0x66 'f' + { 1087, 11, 14, 14, 2, -9 }, // 0x67 'g' + { 1107, 10, 15, 14, 2, -14 }, // 0x68 'h' + { 1126, 9, 15, 14, 3, -14 }, // 0x69 'i' + { 1143, 7, 19, 14, 3, -14 }, // 0x6A 'j' + { 1160, 12, 15, 14, 1, -14 }, // 0x6B 'k' + { 1183, 9, 15, 14, 3, -14 }, // 0x6C 'l' + { 1200, 13, 10, 14, 1, -9 }, // 0x6D 'm' + { 1217, 12, 10, 14, 1, -9 }, // 0x6E 'n' + { 1232, 11, 10, 14, 2, -9 }, // 0x6F 'o' + { 1246, 12, 14, 14, 1, -9 }, // 0x70 'p' + { 1267, 11, 14, 14, 2, -9 }, // 0x71 'q' + { 1287, 10, 10, 14, 3, -9 }, // 0x72 'r' + { 1300, 10, 10, 14, 2, -9 }, // 0x73 's' + { 1313, 11, 14, 14, 1, -13 }, // 0x74 't' + { 1333, 11, 10, 14, 2, -9 }, // 0x75 'u' + { 1347, 13, 10, 14, 1, -9 }, // 0x76 'v' + { 1364, 13, 10, 14, 1, -9 }, // 0x77 'w' + { 1381, 12, 10, 14, 1, -9 }, // 0x78 'x' + { 1396, 12, 14, 14, 1, -9 }, // 0x79 'y' + { 1417, 9, 10, 14, 3, -9 }, // 0x7A 'z' + { 1429, 5, 18, 14, 5, -14 }, // 0x7B '{' + { 1441, 1, 18, 14, 7, -14 }, // 0x7C '|' + { 1444, 5, 18, 14, 5, -14 }, // 0x7D '}' + { 1456, 10, 3, 14, 2, -7 } }; // 0x7E '~' + +const GFXfont FreeMono12pt7b PROGMEM = { + (uint8_t *)FreeMono12pt7bBitmaps, + (GFXglyph *)FreeMono12pt7bGlyphs, + 0x20, 0x7E, 24 }; + +// Approx. 2132 bytes diff --git a/RX_FSK/src/fonts/FreeMono12pt8b.h b/RX_FSK/src/fonts/FreeMono12pt8b.h new file mode 100644 index 0000000..0703e63 --- /dev/null +++ b/RX_FSK/src/fonts/FreeMono12pt8b.h @@ -0,0 +1,495 @@ +const uint8_t FreeMono12pt8bBitmaps[] PROGMEM = { + 0x00, 0xDB, 0x6D, 0x92, 0x48, 0x01, 0xB8, 0xF7, 0x67, 0x67, 0x67, 0x66, + 0x66, 0x62, 0x00, 0x02, 0x40, 0x90, 0x44, 0x11, 0x04, 0x87, 0xFC, 0x48, + 0x12, 0x04, 0x87, 0xF8, 0x48, 0x12, 0x04, 0x81, 0x20, 0x48, 0x12, 0x00, + 0x08, 0x04, 0x0F, 0x0C, 0x6C, 0x14, 0x02, 0x00, 0xC0, 0x1E, 0x00, 0x80, + 0x30, 0x18, 0x17, 0x18, 0x70, 0x10, 0x08, 0x04, 0x00, 0x18, 0x19, 0x04, + 0x21, 0x08, 0x44, 0x0F, 0x00, 0x0C, 0x1C, 0x78, 0x20, 0xC0, 0xC8, 0x22, + 0x08, 0x42, 0x20, 0x78, 0x3E, 0x40, 0x40, 0x40, 0x20, 0x60, 0x91, 0x8A, + 0x8A, 0x86, 0x86, 0x7B, 0xFF, 0x6D, 0xB0, 0x01, 0x26, 0x44, 0xCC, 0xCC, + 0xCC, 0x44, 0x62, 0x31, 0x13, 0x24, 0xC9, 0x24, 0x92, 0xD6, 0x90, 0x00, + 0x04, 0x02, 0x11, 0x17, 0xF0, 0xC0, 0x50, 0x4C, 0x42, 0x00, 0x04, 0x00, + 0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0x3F, 0xF8, 0x20, 0x04, 0x00, 0x80, + 0x10, 0x02, 0x00, 0x3B, 0x9C, 0xC4, 0x60, 0xFF, 0xE0, 0x6F, 0x70, 0x00, + 0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x06, + 0x02, 0x01, 0x01, 0x00, 0x80, 0x80, 0x40, 0x00, 0x1C, 0x33, 0x10, 0x50, + 0x28, 0x14, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x2C, 0x12, 0x18, + 0xF8, 0x18, 0x1C, 0x1A, 0x19, 0x08, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, + 0x02, 0x01, 0x00, 0x80, 0x43, 0xFE, 0x1E, 0x11, 0x90, 0x38, 0x10, 0x08, + 0x04, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x04, 0x07, 0xFE, 0x1E, + 0x08, 0x64, 0x08, 0x02, 0x00, 0x80, 0x20, 0x70, 0x1C, 0x00, 0x80, 0x10, + 0x04, 0x01, 0x00, 0x70, 0x23, 0xF0, 0x06, 0x0A, 0x0A, 0x12, 0x12, 0x22, + 0x62, 0x42, 0x82, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x0F, 0x3F, 0x08, 0x22, + 0x00, 0x80, 0x20, 0x08, 0x03, 0xF0, 0x02, 0x00, 0x40, 0x10, 0x04, 0x01, + 0x00, 0xD0, 0x23, 0xF0, 0x07, 0x8E, 0x0C, 0x0C, 0x04, 0x02, 0x02, 0x31, + 0x66, 0xA0, 0xE0, 0x60, 0x28, 0x14, 0x09, 0x08, 0x7C, 0xFF, 0x81, 0x81, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08, 0x08, + 0x1C, 0x31, 0x20, 0x50, 0x28, 0x14, 0x09, 0x08, 0x78, 0x43, 0x40, 0xA0, + 0x30, 0x18, 0x16, 0x09, 0xF8, 0x1C, 0x31, 0x10, 0x50, 0x18, 0x0C, 0x05, + 0x06, 0x87, 0x3E, 0x80, 0x40, 0x20, 0x20, 0x30, 0x33, 0xF0, 0x7F, 0x70, + 0x00, 0x06, 0xF7, 0x39, 0xCE, 0x00, 0x00, 0x07, 0x73, 0x98, 0xCC, 0x00, + 0x00, 0xC0, 0x60, 0x18, 0x0C, 0x06, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x03, + 0x00, 0x30, 0x01, 0x00, 0xFF, 0xF0, 0x00, 0x00, 0x07, 0xFF, 0xC0, 0x06, + 0x00, 0x30, 0x01, 0x80, 0x18, 0x01, 0x80, 0xC0, 0x30, 0x18, 0x0C, 0x02, + 0x00, 0x00, 0x3C, 0x61, 0xA0, 0x40, 0x10, 0x08, 0x08, 0x08, 0x18, 0x08, + 0x04, 0x00, 0x00, 0x01, 0xC0, 0xE0, 0x3C, 0x62, 0xC1, 0x81, 0x81, 0x87, + 0x99, 0x91, 0x91, 0x91, 0x8F, 0x81, 0x80, 0x80, 0x40, 0x3F, 0x1F, 0x00, + 0x0C, 0x00, 0x48, 0x01, 0x20, 0x04, 0x80, 0x21, 0x00, 0x84, 0x02, 0x08, + 0x1F, 0xE0, 0x40, 0x81, 0x01, 0x08, 0x04, 0x20, 0x13, 0xE1, 0xF0, 0x7E, + 0x02, 0x1C, 0x20, 0x62, 0x02, 0x20, 0x22, 0x06, 0x3F, 0x82, 0x1C, 0x20, + 0x22, 0x01, 0x20, 0x12, 0x01, 0x20, 0x2F, 0xFC, 0x1E, 0x06, 0x39, 0x01, + 0x40, 0x28, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x02, 0x00, 0x20, + 0x16, 0x04, 0x3F, 0x00, 0x7C, 0x08, 0x71, 0x01, 0x20, 0x14, 0x02, 0x80, + 0x50, 0x0A, 0x01, 0x40, 0x28, 0x05, 0x00, 0xA0, 0x24, 0x0D, 0xFE, 0x00, + 0x7F, 0xE4, 0x04, 0x80, 0x90, 0x12, 0x00, 0x44, 0x0F, 0x81, 0x10, 0x22, + 0x04, 0x00, 0x80, 0x90, 0x12, 0x03, 0xFF, 0xC0, 0x7F, 0xE4, 0x04, 0x80, + 0x90, 0x12, 0x00, 0x44, 0x0F, 0x81, 0x10, 0x22, 0x04, 0x00, 0x80, 0x10, + 0x02, 0x01, 0xFC, 0x00, 0x0F, 0x06, 0x39, 0x01, 0x40, 0x08, 0x01, 0x00, + 0x20, 0x04, 0x00, 0x83, 0xF0, 0x0A, 0x01, 0x60, 0x26, 0x04, 0x7F, 0x80, + 0x70, 0xE2, 0x04, 0x20, 0x42, 0x04, 0x20, 0x42, 0x04, 0x3F, 0xC2, 0x04, + 0x20, 0x42, 0x04, 0x20, 0x42, 0x04, 0x20, 0x4F, 0x8F, 0xFF, 0x04, 0x02, + 0x01, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x87, + 0xFC, 0x0F, 0xE0, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, + 0x08, 0x80, 0x88, 0x08, 0x80, 0x88, 0x08, 0xC1, 0x03, 0xE0, 0x78, 0xF1, + 0x01, 0x08, 0x10, 0x43, 0x02, 0x30, 0x13, 0x00, 0xB0, 0x06, 0x60, 0x21, + 0x81, 0x04, 0x08, 0x10, 0x40, 0x82, 0x06, 0x7C, 0x1C, 0xFC, 0x04, 0x00, + 0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x04, 0x80, + 0x90, 0x12, 0x03, 0xFF, 0xC0, 0x70, 0x18, 0xC0, 0x73, 0x02, 0x8A, 0x0A, + 0x28, 0x48, 0x91, 0x22, 0x48, 0x88, 0xA2, 0x23, 0x08, 0x84, 0x22, 0x00, + 0x88, 0x02, 0x20, 0x0B, 0xE1, 0xF0, 0xE0, 0xF6, 0x02, 0x50, 0x25, 0x82, + 0x48, 0x24, 0x42, 0x44, 0x24, 0x22, 0x43, 0x24, 0x12, 0x40, 0xA4, 0x0A, + 0x40, 0x6F, 0x86, 0x0F, 0x01, 0x8C, 0x20, 0x64, 0x02, 0x40, 0x18, 0x01, + 0x80, 0x18, 0x01, 0x80, 0x1C, 0x01, 0x40, 0x36, 0x02, 0x30, 0x41, 0xF8, + 0x7E, 0x04, 0x38, 0x81, 0x10, 0x12, 0x02, 0x40, 0x48, 0x11, 0xFC, 0x20, + 0x04, 0x00, 0x80, 0x10, 0x02, 0x01, 0xFC, 0x00, 0x0F, 0x01, 0x8C, 0x20, + 0x64, 0x02, 0x40, 0x18, 0x01, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0x40, + 0x36, 0x02, 0x30, 0x41, 0xF8, 0x04, 0x01, 0xF9, 0x10, 0xE0, 0x7E, 0x01, + 0x0E, 0x08, 0x10, 0x40, 0x42, 0x02, 0x10, 0x30, 0x83, 0x07, 0xE0, 0x21, + 0x81, 0x06, 0x08, 0x10, 0x40, 0x42, 0x02, 0x7C, 0x0C, 0x1E, 0x0C, 0x74, + 0x0D, 0x01, 0x40, 0x18, 0x03, 0x80, 0x1E, 0x00, 0xC0, 0x18, 0x06, 0x01, + 0xC0, 0xEF, 0xC0, 0xFF, 0xF0, 0x86, 0x10, 0xC2, 0x10, 0x40, 0x08, 0x01, + 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x02, 0x00, 0x40, 0x7F, 0x00, 0xF0, + 0xF4, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, + 0x24, 0x02, 0x60, 0x22, 0x06, 0x30, 0x41, 0xF8, 0x78, 0x3C, 0x80, 0x22, + 0x01, 0x08, 0x04, 0x10, 0x10, 0x40, 0x80, 0x82, 0x02, 0x10, 0x08, 0x40, + 0x11, 0x00, 0x48, 0x01, 0xA0, 0x03, 0x00, 0x0C, 0x00, 0x78, 0x39, 0x00, + 0x22, 0x00, 0x88, 0xC2, 0x23, 0x08, 0x8A, 0x42, 0x29, 0x09, 0x24, 0x24, + 0x90, 0x91, 0x41, 0x85, 0x06, 0x14, 0x18, 0x50, 0x60, 0xC0, 0x70, 0x76, + 0x02, 0x20, 0x41, 0x0C, 0x08, 0x80, 0xD0, 0x06, 0x00, 0x60, 0x0D, 0x00, + 0x98, 0x10, 0x82, 0x04, 0x60, 0x2F, 0x0F, 0x70, 0x76, 0x02, 0x20, 0x41, + 0x0C, 0x18, 0x80, 0x90, 0x05, 0x00, 0x60, 0x02, 0x00, 0x20, 0x02, 0x00, + 0x20, 0x02, 0x01, 0xFC, 0x7F, 0x90, 0x24, 0x09, 0x04, 0x42, 0x00, 0x80, + 0x40, 0x20, 0x18, 0x04, 0x12, 0x05, 0x01, 0x40, 0x7F, 0xF0, 0xE8, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x8F, 0x80, 0x40, 0x10, 0x08, 0x02, + 0x01, 0x00, 0x40, 0x20, 0x18, 0x04, 0x02, 0x00, 0x80, 0x40, 0x10, 0x08, + 0x02, 0x01, 0x00, 0x40, 0xF1, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x1F, 0x00, 0x0C, 0x0D, 0x04, 0x44, 0x34, 0x08, 0x00, 0xFF, 0xFC, 0x84, + 0x30, 0x7F, 0x00, 0x10, 0x02, 0x00, 0x43, 0xF9, 0x81, 0x20, 0x24, 0x04, + 0x81, 0x8F, 0xDC, 0xC0, 0x04, 0x00, 0x40, 0x04, 0x00, 0x40, 0x04, 0xFC, + 0x50, 0x66, 0x02, 0x60, 0x14, 0x01, 0x40, 0x16, 0x01, 0x60, 0x25, 0x06, + 0xCF, 0xC0, 0x3F, 0xCC, 0x19, 0x01, 0x40, 0x08, 0x01, 0x00, 0x20, 0x02, + 0x01, 0x60, 0x47, 0xF0, 0x00, 0xC0, 0x04, 0x00, 0x40, 0x04, 0x00, 0x43, + 0xE4, 0x41, 0xC8, 0x0C, 0x80, 0x48, 0x04, 0x80, 0x48, 0x04, 0x80, 0xC4, + 0x1C, 0x3E, 0x70, 0x3F, 0x10, 0x28, 0x06, 0x01, 0xFF, 0xE0, 0x08, 0x02, + 0x00, 0x40, 0x4F, 0xE0, 0x00, 0x07, 0xF1, 0x00, 0x40, 0x10, 0x3F, 0xE1, + 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x0F, 0xF0, 0x3E, + 0x68, 0x2A, 0x03, 0x40, 0x68, 0x05, 0x01, 0xA0, 0x36, 0x0E, 0x63, 0x43, + 0x88, 0x01, 0x00, 0x40, 0x08, 0x3E, 0x00, 0x60, 0x02, 0x00, 0x20, 0x02, + 0x00, 0x20, 0x02, 0xF8, 0x30, 0x42, 0x04, 0x20, 0x42, 0x04, 0x20, 0x42, + 0x04, 0x20, 0x42, 0x04, 0xF8, 0xF0, 0x0C, 0x03, 0x00, 0xC0, 0x00, 0x00, + 0x1F, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x0F, + 0xFC, 0x04, 0x08, 0x10, 0x00, 0x1F, 0xC0, 0x81, 0x02, 0x04, 0x08, 0x10, + 0x20, 0x40, 0x81, 0x02, 0x0F, 0xF0, 0xC0, 0x08, 0x01, 0x00, 0x20, 0x04, + 0x00, 0x8F, 0x90, 0x82, 0x20, 0x48, 0x0F, 0x01, 0xB0, 0x23, 0x04, 0x30, + 0x83, 0x30, 0x78, 0x3C, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, + 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x0F, 0xFC, 0xFE, 0xF0, + 0xC6, 0x22, 0x10, 0x88, 0x42, 0x21, 0x08, 0x84, 0x22, 0x10, 0x88, 0x42, + 0x21, 0x0B, 0xC6, 0x30, 0x6F, 0x83, 0x04, 0x20, 0x42, 0x02, 0x20, 0x22, + 0x02, 0x20, 0x22, 0x02, 0x20, 0x2F, 0x8F, 0x3F, 0x0C, 0x13, 0x01, 0x40, + 0x28, 0x03, 0x00, 0x60, 0x14, 0x02, 0x40, 0x87, 0xE0, 0xCF, 0xC5, 0x06, + 0x60, 0x26, 0x01, 0x40, 0x16, 0x01, 0x60, 0x17, 0x02, 0x58, 0xC4, 0x70, + 0x40, 0x04, 0x00, 0x40, 0x0F, 0x80, 0x3F, 0x74, 0x1C, 0x80, 0xC8, 0x04, + 0x80, 0x48, 0x04, 0x80, 0x4C, 0x0C, 0x63, 0x41, 0xC4, 0x00, 0x40, 0x04, + 0x00, 0x40, 0x1E, 0x73, 0xC2, 0xC4, 0x60, 0x08, 0x01, 0x00, 0x20, 0x04, + 0x00, 0x80, 0x10, 0x1F, 0xF0, 0x3F, 0x90, 0x24, 0x09, 0x80, 0x1E, 0x00, + 0x60, 0x06, 0x01, 0xC0, 0xEF, 0xE0, 0x00, 0x04, 0x00, 0x80, 0x10, 0x0F, + 0xF8, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x01, 0x02, + 0x3F, 0x80, 0xE1, 0xE2, 0x02, 0x20, 0x22, 0x02, 0x20, 0x22, 0x02, 0x20, + 0x22, 0x06, 0x20, 0xA1, 0xF3, 0xF8, 0xF9, 0x01, 0x08, 0x10, 0x60, 0x81, + 0x0C, 0x08, 0x40, 0x22, 0x01, 0x20, 0x05, 0x00, 0x30, 0x00, 0xF0, 0x7A, + 0x01, 0x10, 0x08, 0x8C, 0x42, 0x62, 0x12, 0x90, 0xA5, 0x05, 0x18, 0x28, + 0xC0, 0x86, 0x00, 0x78, 0xF3, 0x04, 0x18, 0x80, 0xD0, 0x06, 0x00, 0x70, + 0x09, 0x81, 0x0C, 0x20, 0x6F, 0x8F, 0xF0, 0xF2, 0x02, 0x20, 0x41, 0x04, + 0x10, 0x80, 0x88, 0x09, 0x00, 0x50, 0x05, 0x00, 0x20, 0x02, 0x00, 0x40, + 0x04, 0x07, 0xE0, 0xFF, 0x41, 0xA0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, + 0xC0, 0xFF, 0xC0, 0x00, 0x61, 0x04, 0x10, 0x41, 0x04, 0x63, 0x02, 0x04, + 0x10, 0x41, 0x04, 0x10, 0x30, 0x7F, 0xFF, 0xC0, 0x03, 0x02, 0x08, 0x20, + 0x82, 0x08, 0x30, 0x72, 0x08, 0x20, 0x82, 0x08, 0x43, 0x00, 0x78, 0x71, + 0x30, 0x30, 0xFF, 0xFE, 0x00, 0x18, 0x00, 0x61, 0xE1, 0x98, 0x66, 0x40, + 0x98, 0x01, 0x60, 0x05, 0x80, 0x26, 0x01, 0x18, 0x18, 0x60, 0x41, 0x81, + 0x06, 0x00, 0x18, 0x00, 0x60, 0xE1, 0x83, 0x86, 0x00, 0x1F, 0xFF, 0xC0, + 0x00, 0xFC, 0x00, 0x92, 0x4B, 0x6D, 0xB0, 0x08, 0x08, 0x08, 0x3E, 0x63, + 0x81, 0x80, 0x80, 0x80, 0x80, 0x41, 0x3E, 0x08, 0x08, 0x08, 0x0E, 0x0C, + 0xC2, 0x00, 0x80, 0x20, 0x08, 0x0F, 0xC0, 0x40, 0x10, 0x04, 0x01, 0x00, + 0x80, 0x20, 0x7F, 0xF0, 0x07, 0x81, 0x87, 0x30, 0x32, 0x02, 0x40, 0x04, + 0x00, 0xFF, 0x84, 0x00, 0xFF, 0x84, 0x00, 0x60, 0x02, 0x00, 0x10, 0x30, + 0xFC, 0x70, 0x76, 0x02, 0x20, 0x41, 0x0C, 0x18, 0x80, 0x90, 0x07, 0x03, + 0xFC, 0x02, 0x00, 0x20, 0x3F, 0xC0, 0x20, 0x02, 0x01, 0xF8, 0x20, 0x84, + 0xC0, 0xE0, 0x10, 0x1E, 0x0C, 0x74, 0x0D, 0x01, 0x40, 0x18, 0x03, 0x80, + 0x1E, 0x00, 0xC0, 0x18, 0x06, 0x01, 0xC0, 0xEF, 0xC0, 0x1F, 0xC4, 0x08, + 0x81, 0x10, 0x0D, 0x81, 0x18, 0x20, 0xC3, 0x06, 0x30, 0x61, 0x84, 0x0B, + 0x80, 0xC0, 0x08, 0x83, 0x1F, 0xC0, 0x31, 0x86, 0x80, 0xC0, 0x00, 0x00, + 0x0F, 0xE4, 0x09, 0x02, 0x60, 0x07, 0x80, 0x18, 0x01, 0x80, 0x70, 0x3B, + 0xF8, 0x07, 0x80, 0x61, 0x82, 0x01, 0x10, 0xD2, 0x4C, 0xC6, 0x21, 0x18, + 0x80, 0x62, 0x01, 0x88, 0x06, 0x21, 0x14, 0x7C, 0xD8, 0x02, 0x30, 0x30, + 0x3F, 0x80, 0x30, 0x90, 0x13, 0xE8, 0x50, 0xBF, 0x80, 0x08, 0x23, 0x08, + 0xC2, 0x30, 0xCC, 0x31, 0x86, 0x18, 0x61, 0x84, 0x18, 0x41, 0x04, 0xFF, + 0xE0, 0x04, 0x00, 0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0xFF, 0xE0, 0x07, + 0x80, 0x61, 0x82, 0x01, 0x13, 0xC2, 0x44, 0xC6, 0x11, 0x18, 0x44, 0x61, + 0xE1, 0x84, 0x86, 0x11, 0x14, 0xE6, 0xD8, 0x02, 0x30, 0x30, 0x3F, 0x80, + 0xFE, 0x79, 0x0A, 0x0C, 0x18, 0x49, 0x8C, 0x00, 0x04, 0x00, 0x80, 0x10, + 0x02, 0x00, 0x41, 0xFF, 0xC1, 0x00, 0x20, 0x04, 0x00, 0x80, 0x00, 0x00, + 0x0F, 0xFE, 0x31, 0x28, 0x41, 0x08, 0x42, 0x30, 0xFC, 0x31, 0x20, 0x42, + 0x18, 0x10, 0x61, 0x78, 0x21, 0x84, 0xC0, 0xC0, 0x00, 0x7F, 0x90, 0x24, + 0x09, 0x04, 0x42, 0x00, 0x80, 0x40, 0x20, 0x18, 0x04, 0x12, 0x05, 0x01, + 0x40, 0x7F, 0xF0, 0xE1, 0xE2, 0x02, 0x20, 0x22, 0x02, 0x20, 0x22, 0x02, + 0x20, 0x22, 0x06, 0x20, 0xE3, 0xF3, 0x20, 0x02, 0x00, 0x20, 0x02, 0x00, + 0x20, 0x00, 0x07, 0xCF, 0xA3, 0x14, 0x62, 0x8C, 0x51, 0x8A, 0x31, 0x43, + 0xA8, 0x1D, 0x00, 0xA0, 0x14, 0x02, 0x80, 0x50, 0x0A, 0x01, 0x41, 0xE6, + 0x74, 0x42, 0x1A, 0x06, 0x00, 0x00, 0x07, 0xFA, 0x0D, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x0E, 0x07, 0xFE, 0x27, 0x08, 0x42, 0x10, 0x84, 0xF8, + 0x39, 0x8A, 0x0C, 0x18, 0x30, 0x9E, 0x00, 0x84, 0x18, 0x41, 0x84, 0x18, + 0xC1, 0x8C, 0x31, 0x8C, 0x63, 0x08, 0xC2, 0x10, 0x80, 0x03, 0xFC, 0x74, + 0x12, 0x10, 0x50, 0x41, 0x41, 0x06, 0x04, 0x88, 0x1E, 0x20, 0x48, 0x81, + 0x23, 0x04, 0x04, 0x10, 0x58, 0x41, 0x31, 0x04, 0x3F, 0xF0, 0x3C, 0xF1, + 0x0A, 0x24, 0x30, 0xE0, 0x41, 0x81, 0xFE, 0x04, 0x08, 0x10, 0x10, 0xC0, + 0x42, 0x84, 0xF1, 0xE0, 0x38, 0xC1, 0x8C, 0x00, 0x07, 0x07, 0x60, 0x22, + 0x04, 0x10, 0xC1, 0x88, 0x09, 0x00, 0x50, 0x06, 0x00, 0x20, 0x02, 0x00, + 0x20, 0x02, 0x00, 0x20, 0x1F, 0xC0, 0x1C, 0x1C, 0x00, 0x00, 0x00, 0x08, + 0x18, 0x60, 0xC0, 0x80, 0x80, 0x81, 0xC1, 0x7E, 0x08, 0x00, 0x30, 0x00, + 0x20, 0x00, 0x40, 0x00, 0x00, 0x7C, 0x00, 0x30, 0x01, 0x20, 0x04, 0x80, + 0x12, 0x00, 0x84, 0x02, 0x10, 0x08, 0x20, 0x7F, 0x81, 0x02, 0x04, 0x04, + 0x20, 0x10, 0x80, 0x4F, 0x87, 0xC0, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, + 0x80, 0x00, 0x00, 0x7C, 0x00, 0x30, 0x01, 0x20, 0x04, 0x80, 0x12, 0x00, + 0x84, 0x02, 0x10, 0x08, 0x20, 0x7F, 0x81, 0x02, 0x04, 0x04, 0x20, 0x10, + 0x80, 0x4F, 0x87, 0xC0, 0x03, 0x00, 0x1A, 0x00, 0x84, 0x00, 0x00, 0x1F, + 0x00, 0x0C, 0x00, 0x48, 0x01, 0x20, 0x04, 0x80, 0x21, 0x00, 0x84, 0x02, + 0x08, 0x1F, 0xE0, 0x40, 0x81, 0x01, 0x08, 0x04, 0x20, 0x13, 0xE1, 0xF0, + 0x06, 0x20, 0x27, 0x00, 0x00, 0x07, 0xC0, 0x03, 0x00, 0x12, 0x00, 0x48, + 0x01, 0x20, 0x08, 0x40, 0x21, 0x00, 0x82, 0x07, 0xF8, 0x10, 0x20, 0x40, + 0x42, 0x01, 0x08, 0x04, 0xF8, 0x7C, 0x08, 0x60, 0x71, 0x80, 0x00, 0x07, + 0xC0, 0x03, 0x00, 0x12, 0x00, 0x48, 0x01, 0x20, 0x08, 0x40, 0x21, 0x00, + 0x82, 0x07, 0xF8, 0x10, 0x20, 0x40, 0x42, 0x01, 0x08, 0x04, 0xF8, 0x7C, + 0x03, 0x80, 0x12, 0x00, 0x48, 0x01, 0xE0, 0x00, 0x00, 0x7C, 0x00, 0x30, + 0x01, 0x20, 0x04, 0x80, 0x12, 0x00, 0x84, 0x02, 0x10, 0x08, 0x20, 0x7F, + 0x81, 0x02, 0x04, 0x04, 0x20, 0x10, 0x80, 0x4F, 0x87, 0xC0, 0x1F, 0xFC, + 0x14, 0x10, 0x50, 0x42, 0x41, 0x09, 0x04, 0x24, 0x80, 0x9E, 0x04, 0x48, + 0x1F, 0x20, 0x44, 0x02, 0x10, 0x48, 0x41, 0x21, 0x07, 0xDF, 0xF0, 0x1E, + 0x06, 0x39, 0x01, 0x40, 0x28, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, + 0x02, 0x00, 0x20, 0x16, 0x04, 0x3F, 0x01, 0x00, 0x30, 0x02, 0x03, 0xC0, + 0x10, 0x01, 0x00, 0x10, 0x01, 0x00, 0x00, 0xFF, 0xC8, 0x09, 0x01, 0x20, + 0x24, 0x00, 0x88, 0x1F, 0x02, 0x20, 0x44, 0x08, 0x01, 0x01, 0x20, 0x24, + 0x07, 0xFF, 0x80, 0x00, 0x00, 0x60, 0x18, 0x06, 0x00, 0x00, 0xFF, 0xC8, + 0x09, 0x01, 0x20, 0x24, 0x00, 0x88, 0x1F, 0x02, 0x20, 0x44, 0x08, 0x01, + 0x01, 0x20, 0x24, 0x07, 0xFF, 0x80, 0x06, 0x01, 0xE0, 0x42, 0x00, 0x07, + 0xFE, 0x40, 0x48, 0x09, 0x01, 0x20, 0x04, 0x40, 0xF8, 0x11, 0x02, 0x20, + 0x40, 0x08, 0x09, 0x01, 0x20, 0x3F, 0xFC, 0x30, 0xC6, 0x38, 0x00, 0x3F, + 0xF2, 0x02, 0x40, 0x48, 0x09, 0x00, 0x22, 0x07, 0xC0, 0x88, 0x11, 0x02, + 0x00, 0x40, 0x48, 0x09, 0x01, 0xFF, 0xE0, 0x00, 0x18, 0x06, 0x01, 0x80, + 0x07, 0xF8, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x40, 0x20, + 0x10, 0x08, 0x04, 0x3F, 0xE0, 0x00, 0x01, 0x03, 0x03, 0x00, 0x07, 0xF8, + 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, + 0x04, 0x3F, 0xE0, 0x18, 0x1A, 0x10, 0xC0, 0x0F, 0xF0, 0x40, 0x20, 0x10, + 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x7F, 0xC0, + 0x43, 0x71, 0x80, 0x1F, 0xE0, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, + 0x01, 0x00, 0x80, 0x40, 0x20, 0x10, 0xFF, 0x80, 0x3E, 0x02, 0x1C, 0x20, + 0x22, 0x01, 0x20, 0x12, 0x01, 0x7E, 0x1A, 0x11, 0x20, 0x12, 0x01, 0x20, + 0x12, 0x02, 0x20, 0x67, 0xF8, 0x1C, 0x43, 0x38, 0x00, 0x0E, 0x0F, 0x60, + 0x25, 0x02, 0x58, 0x24, 0x82, 0x44, 0x24, 0x42, 0x42, 0x24, 0x32, 0x41, + 0x24, 0x0A, 0x40, 0xA4, 0x06, 0xF8, 0x60, 0x00, 0x00, 0x80, 0x06, 0x00, + 0x20, 0x00, 0x00, 0xF0, 0x18, 0xC2, 0x06, 0x40, 0x24, 0x01, 0x80, 0x18, + 0x01, 0x80, 0x18, 0x01, 0xC0, 0x14, 0x03, 0x60, 0x23, 0x04, 0x1F, 0x80, + 0x00, 0x80, 0x10, 0x02, 0x00, 0x40, 0x00, 0x00, 0xF0, 0x18, 0xC2, 0x06, + 0x40, 0x24, 0x01, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0xC0, 0x14, 0x03, + 0x60, 0x23, 0x04, 0x1F, 0x80, 0x06, 0x00, 0xD0, 0x10, 0x80, 0x00, 0x0F, + 0x01, 0x8C, 0x20, 0x64, 0x02, 0x40, 0x18, 0x01, 0x80, 0x18, 0x01, 0x80, + 0x1C, 0x01, 0x40, 0x36, 0x02, 0x30, 0x41, 0xF8, 0x0C, 0x41, 0x38, 0x00, + 0x00, 0xF0, 0x18, 0xC2, 0x06, 0x40, 0x24, 0x01, 0x80, 0x18, 0x01, 0x80, + 0x18, 0x01, 0xC0, 0x14, 0x03, 0x60, 0x23, 0x04, 0x1F, 0x80, 0x10, 0xC3, + 0x8C, 0x00, 0x00, 0xF0, 0x18, 0xC2, 0x06, 0x40, 0x24, 0x01, 0x80, 0x18, + 0x01, 0x80, 0x18, 0x01, 0xC0, 0x14, 0x03, 0x60, 0x23, 0x04, 0x1F, 0x80, + 0x81, 0xA1, 0x89, 0x83, 0x81, 0x81, 0xA1, 0x89, 0x82, 0x80, 0x00, 0x00, + 0x00, 0xF1, 0x18, 0xE2, 0x06, 0x40, 0x64, 0x09, 0x81, 0x18, 0x21, 0x86, + 0x18, 0x41, 0xC8, 0x15, 0x03, 0x60, 0x27, 0x04, 0x5F, 0x88, 0x00, 0x00, + 0x00, 0x80, 0x06, 0x00, 0x20, 0x00, 0x0F, 0x0F, 0x40, 0x24, 0x02, 0x40, + 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x26, 0x02, 0x20, + 0x63, 0x04, 0x1F, 0x80, 0x00, 0x80, 0x10, 0x02, 0x00, 0x40, 0x00, 0x0F, + 0x0F, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, + 0x02, 0x40, 0x26, 0x02, 0x20, 0x63, 0x04, 0x1F, 0x80, 0x06, 0x00, 0xD0, + 0x10, 0x80, 0x00, 0xF0, 0xF4, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, + 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x60, 0x22, 0x06, 0x30, 0x41, 0xF8, + 0x10, 0xC3, 0x8C, 0x00, 0x0F, 0x0F, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, + 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x26, 0x02, 0x20, 0x63, 0x04, + 0x1F, 0x80, 0x00, 0x80, 0x10, 0x02, 0x00, 0x40, 0x00, 0x07, 0x07, 0x60, + 0x22, 0x04, 0x10, 0xC1, 0x88, 0x09, 0x00, 0x50, 0x06, 0x00, 0x20, 0x02, + 0x00, 0x20, 0x02, 0x00, 0x20, 0x1F, 0xC0, 0x7E, 0x04, 0x00, 0x80, 0x1F, + 0x02, 0x1C, 0x40, 0x88, 0x09, 0x01, 0x20, 0x24, 0x08, 0xFE, 0x10, 0x02, + 0x01, 0xFC, 0x00, 0x00, 0x03, 0xE0, 0x84, 0x30, 0x44, 0x08, 0x82, 0x11, + 0xC2, 0x0C, 0x40, 0x48, 0x05, 0x00, 0xA0, 0x14, 0x42, 0x88, 0xF8, 0xF0, + 0x30, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x20, 0x04, 0x00, + 0x87, 0xF3, 0x02, 0x40, 0x48, 0x09, 0x03, 0x1F, 0xB8, 0x02, 0x00, 0x80, + 0x20, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x20, 0x04, 0x00, 0x87, 0xF3, 0x02, + 0x40, 0x48, 0x09, 0x03, 0x1F, 0xB8, 0x0C, 0x03, 0xC0, 0x8C, 0x00, 0x00, + 0x00, 0xFE, 0x00, 0x20, 0x04, 0x00, 0x87, 0xF3, 0x02, 0x40, 0x48, 0x09, + 0x03, 0x1F, 0xB8, 0x18, 0x84, 0xE0, 0x00, 0x00, 0x07, 0xF0, 0x01, 0x00, + 0x20, 0x04, 0x3F, 0x98, 0x12, 0x02, 0x40, 0x48, 0x18, 0xFD, 0xC0, 0x63, + 0x8C, 0x70, 0x00, 0x00, 0x07, 0xF0, 0x01, 0x00, 0x20, 0x04, 0x3F, 0x98, + 0x12, 0x02, 0x40, 0x48, 0x18, 0xFD, 0xC0, 0x0E, 0x02, 0x40, 0x48, 0x07, + 0x00, 0x00, 0x00, 0x1F, 0xC0, 0x04, 0x00, 0x80, 0x10, 0xFE, 0x60, 0x48, + 0x09, 0x01, 0x20, 0x63, 0xF7, 0x3E, 0xF0, 0x0A, 0x20, 0x10, 0x80, 0x41, + 0x3F, 0xFD, 0x04, 0x08, 0x10, 0x20, 0x40, 0x43, 0x85, 0xF7, 0xE0, 0x3F, + 0xCC, 0x19, 0x01, 0x40, 0x08, 0x01, 0x00, 0x20, 0x02, 0x01, 0x60, 0x47, + 0xF0, 0x10, 0x03, 0x00, 0x20, 0x3C, 0x00, 0x10, 0x02, 0x00, 0x40, 0x00, + 0x00, 0x0F, 0xC4, 0x0A, 0x01, 0x80, 0x7F, 0xF8, 0x02, 0x00, 0x80, 0x10, + 0x13, 0xF8, 0x03, 0x01, 0x00, 0x80, 0x00, 0x00, 0x0F, 0xC4, 0x0A, 0x01, + 0x80, 0x7F, 0xF8, 0x02, 0x00, 0x80, 0x10, 0x13, 0xF8, 0x04, 0x06, 0x83, + 0x10, 0x82, 0x00, 0x0F, 0xC4, 0x0A, 0x01, 0x80, 0x7F, 0xF8, 0x02, 0x00, + 0x80, 0x10, 0x13, 0xF8, 0x31, 0x8C, 0x60, 0x00, 0x00, 0x3F, 0x10, 0x28, + 0x06, 0x01, 0xFF, 0xE0, 0x08, 0x02, 0x00, 0x40, 0x4F, 0xE0, 0x30, 0x02, + 0x00, 0x40, 0x00, 0x00, 0x1F, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, + 0x10, 0x04, 0x01, 0x0F, 0xFC, 0x02, 0x01, 0x00, 0x80, 0x00, 0x00, 0x1F, + 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x0F, 0xFC, + 0x08, 0x05, 0x82, 0x30, 0x00, 0x00, 0x1F, 0x00, 0x40, 0x10, 0x04, 0x01, + 0x00, 0x40, 0x10, 0x04, 0x01, 0x0F, 0xFC, 0x63, 0x98, 0xE0, 0x00, 0x00, + 0x7C, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x3F, + 0xF0, 0x30, 0x81, 0xE0, 0x78, 0x00, 0x80, 0x08, 0x7F, 0x98, 0x36, 0x02, + 0x80, 0x70, 0x06, 0x00, 0xC0, 0x2C, 0x04, 0xC1, 0x0F, 0xC0, 0x1C, 0x43, + 0x38, 0x00, 0x00, 0x00, 0x6F, 0x83, 0x04, 0x20, 0x42, 0x02, 0x20, 0x22, + 0x02, 0x20, 0x22, 0x02, 0x20, 0x2F, 0x8F, 0x10, 0x01, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x7E, 0x18, 0x26, 0x02, 0x80, 0x50, 0x06, 0x00, 0xC0, 0x28, + 0x04, 0x81, 0x0F, 0xC0, 0x02, 0x00, 0x80, 0x20, 0x00, 0x00, 0x00, 0x7E, + 0x18, 0x26, 0x02, 0x80, 0x50, 0x06, 0x00, 0xC0, 0x28, 0x04, 0x81, 0x0F, + 0xC0, 0x0C, 0x03, 0x40, 0xC4, 0x00, 0x00, 0x00, 0x7E, 0x18, 0x26, 0x02, + 0x80, 0x50, 0x06, 0x00, 0xC0, 0x28, 0x04, 0x81, 0x0F, 0xC0, 0x18, 0x84, + 0xE0, 0x00, 0x00, 0x03, 0xF0, 0xC1, 0x30, 0x14, 0x02, 0x80, 0x30, 0x06, + 0x01, 0x40, 0x24, 0x08, 0x7E, 0x00, 0x71, 0x8E, 0x30, 0x00, 0x00, 0x03, + 0xF0, 0xC1, 0x30, 0x14, 0x02, 0x80, 0x30, 0x06, 0x01, 0x40, 0x24, 0x08, + 0x7E, 0x00, 0x0C, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, + 0x00, 0x00, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x11, 0xFA, 0x30, 0x46, + 0x0A, 0x41, 0x24, 0x21, 0x44, 0x14, 0x82, 0x70, 0x22, 0x04, 0x5F, 0x88, + 0x00, 0x08, 0x00, 0x40, 0x02, 0x00, 0x00, 0x00, 0x0E, 0x1E, 0x20, 0x22, + 0x02, 0x20, 0x22, 0x02, 0x20, 0x22, 0x02, 0x20, 0x62, 0x0A, 0x1F, 0x30, + 0x01, 0x00, 0x60, 0x0C, 0x00, 0x00, 0x00, 0x0E, 0x1E, 0x20, 0x22, 0x02, + 0x20, 0x22, 0x02, 0x20, 0x22, 0x02, 0x20, 0x62, 0x0A, 0x1F, 0x30, 0x06, + 0x00, 0xF0, 0x18, 0x80, 0x00, 0x00, 0x0E, 0x1E, 0x20, 0x22, 0x02, 0x20, + 0x22, 0x02, 0x20, 0x22, 0x02, 0x20, 0x62, 0x0A, 0x1F, 0x30, 0x30, 0xC3, + 0x0C, 0x00, 0x00, 0x00, 0xE1, 0xE2, 0x02, 0x20, 0x22, 0x02, 0x20, 0x22, + 0x02, 0x20, 0x22, 0x06, 0x20, 0xA1, 0xF3, 0x00, 0x80, 0x10, 0x02, 0x00, + 0x00, 0x00, 0x0F, 0x0F, 0x20, 0x22, 0x04, 0x10, 0x41, 0x08, 0x08, 0x80, + 0x90, 0x05, 0x00, 0x50, 0x02, 0x00, 0x20, 0x04, 0x00, 0x40, 0x7E, 0x00, + 0xC0, 0x04, 0x00, 0x40, 0x04, 0x00, 0x4F, 0xC5, 0x06, 0x60, 0x26, 0x01, + 0x40, 0x16, 0x01, 0x60, 0x17, 0x02, 0x58, 0xC4, 0x70, 0x40, 0x04, 0x00, + 0x40, 0x0F, 0x80, 0x38, 0xC3, 0x8C, 0x00, 0x00, 0x00, 0xF0, 0xF2, 0x02, + 0x20, 0x41, 0x04, 0x10, 0x80, 0x88, 0x09, 0x00, 0x50, 0x05, 0x00, 0x20, + 0x02, 0x00, 0x40, 0x04, 0x07, 0xE0 }; + +const GFXglyph FreeMono12pt8bGlyphs[] PROGMEM = { + { 0, 1, 1, 14, 0, 0 }, // 0x20 ' ' U+0020 + { 1, 3, 15, 14, 6, -14 }, // 0x21 '!' U+0021 + { 7, 8, 7, 14, 3, -14 }, // 0x22 '"' U+0022 + { 14, 10, 17, 14, 2, -15 }, // 0x23 '#' U+0023 + { 36, 9, 18, 14, 3, -15 }, // 0x24 '$' U+0024 + { 57, 10, 15, 14, 2, -14 }, // 0x25 '%' U+0025 + { 76, 8, 12, 14, 3, -11 }, // 0x26 '&' U+0026 + { 88, 3, 7, 14, 6, -14 }, // 0x27 ''' U+0027 + { 91, 4, 18, 14, 7, -14 }, // 0x28 '(' U+0028 + { 100, 3, 18, 14, 4, -14 }, // 0x29 ')' U+0029 + { 107, 9, 9, 14, 3, -14 }, // 0x2a '*' U+002A + { 118, 11, 12, 14, 2, -12 }, // 0x2b '+' U+002B + { 135, 5, 6, 14, 3, -2 }, // 0x2c ',' U+002C + { 139, 11, 1, 14, 2, -6 }, // 0x2d '-' U+002D + { 141, 4, 3, 14, 5, -2 }, // 0x2e '.' U+002E + { 143, 9, 18, 14, 3, -15 }, // 0x2f '/' U+002F + { 164, 9, 15, 14, 3, -14 }, // 0x30 '0' U+0030 + { 181, 9, 15, 14, 3, -14 }, // 0x31 '1' U+0031 + { 198, 9, 15, 14, 2, -14 }, // 0x32 '2' U+0032 + { 215, 10, 15, 14, 2, -14 }, // 0x33 '3' U+0033 + { 234, 8, 15, 14, 3, -14 }, // 0x34 '4' U+0034 + { 249, 10, 15, 14, 2, -14 }, // 0x35 '5' U+0035 + { 268, 9, 15, 14, 3, -14 }, // 0x36 '6' U+0036 + { 285, 8, 15, 14, 3, -14 }, // 0x37 '7' U+0037 + { 300, 9, 15, 14, 3, -14 }, // 0x38 '8' U+0038 + { 317, 9, 15, 14, 3, -14 }, // 0x39 '9' U+0039 + { 334, 4, 10, 14, 5, -9 }, // 0x3a ':' U+003A + { 339, 5, 13, 14, 3, -9 }, // 0x3b ';' U+003B + { 348, 11, 11, 14, 2, -11 }, // 0x3c '<' U+003C + { 364, 12, 4, 14, 1, -8 }, // 0x3d '=' U+003D + { 370, 11, 11, 14, 2, -11 }, // 0x3e '>' U+003E + { 386, 9, 14, 14, 3, -13 }, // 0x3f '?' U+003F + { 402, 8, 16, 14, 3, -14 }, // 0x40 '@' U+0040 + { 418, 14, 14, 14, 0, -13 }, // 0x41 'A' U+0041 + { 443, 12, 14, 14, 1, -13 }, // 0x42 'B' U+0042 + { 464, 11, 14, 14, 2, -13 }, // 0x43 'C' U+0043 + { 484, 11, 14, 14, 1, -13 }, // 0x44 'D' U+0044 + { 504, 11, 14, 14, 1, -13 }, // 0x45 'E' U+0045 + { 524, 11, 14, 14, 1, -13 }, // 0x46 'F' U+0046 + { 544, 11, 14, 14, 2, -13 }, // 0x47 'G' U+0047 + { 564, 12, 14, 14, 1, -13 }, // 0x48 'H' U+0048 + { 585, 9, 14, 14, 3, -13 }, // 0x49 'I' U+0049 + { 601, 12, 14, 14, 2, -13 }, // 0x4a 'J' U+004A + { 622, 13, 14, 14, 1, -13 }, // 0x4b 'K' U+004B + { 645, 11, 14, 14, 2, -13 }, // 0x4c 'L' U+004C + { 665, 14, 14, 14, 0, -13 }, // 0x4d 'M' U+004D + { 690, 12, 14, 14, 1, -13 }, // 0x4e 'N' U+004E + { 711, 12, 14, 14, 1, -13 }, // 0x4f 'O' U+004F + { 732, 11, 14, 14, 1, -13 }, // 0x50 'P' U+0050 + { 752, 12, 17, 14, 1, -13 }, // 0x51 'Q' U+0051 + { 778, 13, 14, 14, 1, -13 }, // 0x52 'R' U+0052 + { 801, 10, 14, 14, 2, -13 }, // 0x53 'S' U+0053 + { 819, 11, 14, 14, 2, -13 }, // 0x54 'T' U+0054 + { 839, 12, 14, 14, 1, -13 }, // 0x55 'U' U+0055 + { 860, 14, 14, 14, 0, -13 }, // 0x56 'V' U+0056 + { 885, 14, 14, 14, 0, -13 }, // 0x57 'W' U+0057 + { 910, 12, 14, 14, 1, -13 }, // 0x58 'X' U+0058 + { 931, 12, 14, 14, 1, -13 }, // 0x59 'Y' U+0059 + { 952, 10, 14, 14, 2, -13 }, // 0x5a 'Z' U+005A + { 970, 4, 18, 14, 7, -14 }, // 0x5b '[' U+005B + { 979, 9, 18, 14, 3, -15 }, // 0x5c '\' U+005C + { 1000, 4, 18, 14, 4, -14 }, // 0x5d ']' U+005D + { 1009, 9, 7, 14, 3, -14 }, // 0x5e '^' U+005E + { 1017, 14, 1, 14, 0, 3 }, // 0x5f '_' U+005F + { 1019, 4, 3, 14, 4, -14 }, // 0x60 '`' U+0060 + { 1021, 11, 10, 14, 2, -9 }, // 0x61 'a' U+0061 + { 1035, 12, 15, 14, 1, -14 }, // 0x62 'b' U+0062 + { 1058, 11, 10, 14, 2, -9 }, // 0x63 'c' U+0063 + { 1072, 12, 15, 14, 2, -14 }, // 0x64 'd' U+0064 + { 1095, 10, 10, 14, 2, -9 }, // 0x65 'e' U+0065 + { 1108, 10, 15, 14, 3, -14 }, // 0x66 'f' U+0066 + { 1127, 11, 14, 14, 2, -9 }, // 0x67 'g' U+0067 + { 1147, 12, 15, 14, 1, -14 }, // 0x68 'h' U+0068 + { 1170, 10, 15, 14, 2, -14 }, // 0x69 'i' U+0069 + { 1189, 7, 19, 14, 4, -14 }, // 0x6a 'j' U+006A + { 1206, 11, 15, 14, 2, -14 }, // 0x6b 'k' U+006B + { 1227, 10, 15, 14, 2, -14 }, // 0x6c 'l' U+006C + { 1246, 14, 10, 14, 0, -9 }, // 0x6d 'm' U+006D + { 1264, 12, 10, 14, 1, -9 }, // 0x6e 'n' U+006E + { 1279, 11, 10, 14, 2, -9 }, // 0x6f 'o' U+006F + { 1293, 12, 14, 14, 1, -9 }, // 0x70 'p' U+0070 + { 1314, 12, 14, 14, 2, -9 }, // 0x71 'q' U+0071 + { 1335, 11, 10, 14, 2, -9 }, // 0x72 'r' U+0072 + { 1349, 10, 10, 14, 2, -9 }, // 0x73 's' U+0073 + { 1362, 11, 14, 14, 1, -13 }, // 0x74 't' U+0074 + { 1382, 12, 10, 14, 1, -9 }, // 0x75 'u' U+0075 + { 1397, 13, 10, 14, 1, -9 }, // 0x76 'v' U+0076 + { 1414, 13, 10, 14, 1, -9 }, // 0x77 'w' U+0077 + { 1431, 12, 10, 14, 1, -9 }, // 0x78 'x' U+0078 + { 1446, 12, 14, 14, 1, -9 }, // 0x79 'y' U+0079 + { 1467, 9, 10, 14, 3, -9 }, // 0x7a 'z' U+007A + { 1479, 6, 18, 14, 4, -14 }, // 0x7b '{' U+007B + { 1493, 1, 18, 14, 7, -14 }, // 0x7c '|' U+007C + { 1496, 6, 18, 14, 5, -14 }, // 0x7d '}' U+007D + { 1510, 10, 3, 14, 2, -7 }, // 0x7e '~' U+007E + { 1514, 14, 19, 14, 0, -16 }, // 0x7f 'REPLACEMENT CHARACTER *' U+2370 + { 1548, 1, 1, 14, 0, 0 }, // 0x80 'NO-BREAK SPACE' U+00A0 + { 1549, 3, 15, 14, 6, -10 }, // 0x81 'INVERTED EXCLAMATION MARK' U+00A1 + { 1555, 8, 15, 14, 3, -14 }, // 0x82 'CENT SIGN' U+00A2 + { 1570, 10, 14, 14, 2, -13 }, // 0x83 'POUND SIGN' U+00A3 + { 1588, 12, 14, 14, 1, -13 }, // 0x84 'EURO SIGN *' U+20AC + { 1609, 12, 14, 14, 1, -13 }, // 0x85 'YEN SIGN' U+00A5 + { 1630, 10, 18, 14, 2, -17 }, // 0x86 'LATIN CAPITAL LETTER S WITH CARON *' U+0160 + { 1653, 11, 15, 14, 2, -13 }, // 0x87 'SECTION SIGN' U+00A7 + { 1674, 10, 15, 14, 2, -14 }, // 0x88 'LATIN SMALL LETTER S WITH CARON *' U+0161 + { 1693, 14, 14, 14, 0, -13 }, // 0x89 'COPYRIGHT SIGN' U+00A9 + { 1718, 7, 7, 14, 4, -13 }, // 0x8a 'FEMININE ORDINAL INDICATOR' U+00AA + { 1725, 11, 10, 14, 2, -9 }, // 0x8b 'LEFT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00AB + { 1739, 11, 7, 14, 2, -10 }, // 0x8c 'NOT SIGN' U+00AC + { 1749, 11, 1, 14, 2, -6 }, // 0x8d 'SOFT HYPHEN' U+00AD + { 1751, 14, 14, 14, 0, -13 }, // 0x8e 'REGISTERED SIGN' U+00AE + { 1776, 7, 1, 14, 4, -13 }, // 0x8f 'MACRON' U+00AF + { 1777, 7, 7, 14, 4, -14 }, // 0x90 'DEGREE SIGN' U+00B0 + { 1784, 11, 13, 14, 2, -12 }, // 0x91 'PLUS-MINUS SIGN' U+00B1 + { 1802, 6, 9, 14, 4, -14 }, // 0x92 'SUPERSCRIPT TWO' U+00B2 + { 1809, 6, 9, 14, 4, -14 }, // 0x93 'SUPERSCRIPT THREE' U+00B3 + { 1816, 10, 18, 14, 2, -17 }, // 0x94 'LATIN CAPITAL LETTER Z WITH CARON *' U+017D + { 1839, 12, 15, 14, 1, -9 }, // 0x95 'MICRO SIGN' U+00B5 + { 1862, 11, 16, 14, 2, -14 }, // 0x96 'PILCROW SIGN' U+00B6 + { 1884, 2, 3, 14, 6, -6 }, // 0x97 'MIDDLE DOT' U+00B7 + { 1885, 9, 15, 14, 3, -14 }, // 0x98 'LATIN SMALL LETTER Z WITH CARON *' U+017E + { 1902, 5, 9, 14, 5, -14 }, // 0x99 'SUPERSCRIPT ONE' U+00B9 + { 1908, 7, 7, 14, 4, -13 }, // 0x9a 'MASCULINE ORDINAL INDICATOR' U+00BA + { 1915, 11, 10, 14, 2, -9 }, // 0x9b 'RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00BB + { 1929, 14, 14, 14, 0, -13 }, // 0x9c 'LATIN CAPITAL LIGATURE OE *' U+0152 + { 1954, 14, 10, 14, 0, -9 }, // 0x9d 'LATIN SMALL LIGATURE OE *' U+0153 + { 1972, 12, 17, 14, 1, -16 }, // 0x9e 'LATIN CAPITAL LETTER Y WITH DIAERESIS *' U+0178 + { 1998, 8, 14, 14, 3, -9 }, // 0x9f 'INVERTED QUESTION MARK' U+00BF + { 2012, 14, 19, 14, 0, -18 }, // 0xa0 'LATIN CAPITAL LETTER A WITH GRAVE' U+00C0 + { 2046, 14, 19, 14, 0, -18 }, // 0xa1 'LATIN CAPITAL LETTER A WITH ACUTE' U+00C1 + { 2080, 14, 18, 14, 0, -17 }, // 0xa2 'LATIN CAPITAL LETTER A WITH CIRCUMFLEX' U+00C2 + { 2112, 14, 17, 14, 0, -16 }, // 0xa3 'LATIN CAPITAL LETTER A WITH TILDE' U+00C3 + { 2142, 14, 17, 14, 0, -16 }, // 0xa4 'LATIN CAPITAL LETTER A WITH DIAERESIS' U+00C4 + { 2172, 14, 19, 14, 0, -18 }, // 0xa5 'LATIN CAPITAL LETTER A WITH RING ABOVE' U+00C5 + { 2206, 14, 14, 14, 0, -13 }, // 0xa6 'LATIN CAPITAL LETTER AE' U+00C6 + { 2231, 11, 18, 14, 2, -13 }, // 0xa7 'LATIN CAPITAL LETTER C WITH CEDILLA' U+00C7 + { 2256, 11, 19, 14, 1, -18 }, // 0xa8 'LATIN CAPITAL LETTER E WITH GRAVE' U+00C8 + { 2283, 11, 19, 14, 1, -18 }, // 0xa9 'LATIN CAPITAL LETTER E WITH ACUTE' U+00C9 + { 2310, 11, 18, 14, 1, -17 }, // 0xaa 'LATIN CAPITAL LETTER E WITH CIRCUMFLEX' U+00CA + { 2335, 11, 17, 14, 1, -16 }, // 0xab 'LATIN CAPITAL LETTER E WITH DIAERESIS' U+00CB + { 2359, 9, 19, 14, 3, -18 }, // 0xac 'LATIN CAPITAL LETTER I WITH GRAVE' U+00CC + { 2381, 9, 19, 14, 3, -18 }, // 0xad 'LATIN CAPITAL LETTER I WITH ACUTE' U+00CD + { 2403, 9, 18, 14, 3, -17 }, // 0xae 'LATIN CAPITAL LETTER I WITH CIRCUMFLEX' U+00CE + { 2424, 9, 17, 14, 3, -16 }, // 0xaf 'LATIN CAPITAL LETTER I WITH DIAERESIS' U+00CF + { 2444, 12, 14, 14, 0, -13 }, // 0xb0 'LATIN CAPITAL LETTER ETH' U+00D0 + { 2465, 12, 17, 14, 1, -16 }, // 0xb1 'LATIN CAPITAL LETTER N WITH TILDE' U+00D1 + { 2491, 12, 19, 14, 1, -18 }, // 0xb2 'LATIN CAPITAL LETTER O WITH GRAVE' U+00D2 + { 2520, 12, 19, 14, 1, -18 }, // 0xb3 'LATIN CAPITAL LETTER O WITH ACUTE' U+00D3 + { 2549, 12, 18, 14, 1, -17 }, // 0xb4 'LATIN CAPITAL LETTER O WITH CIRCUMFLEX' U+00D4 + { 2576, 12, 17, 14, 1, -16 }, // 0xb5 'LATIN CAPITAL LETTER O WITH TILDE' U+00D5 + { 2602, 12, 17, 14, 1, -16 }, // 0xb6 'LATIN CAPITAL LETTER O WITH DIAERESIS' U+00D6 + { 2628, 9, 9, 14, 3, -10 }, // 0xb7 'MULTIPLICATION SIGN' U+00D7 + { 2639, 12, 16, 14, 1, -14 }, // 0xb8 'LATIN CAPITAL LETTER O WITH STROKE' U+00D8 + { 2663, 12, 19, 14, 1, -18 }, // 0xb9 'LATIN CAPITAL LETTER U WITH GRAVE' U+00D9 + { 2692, 12, 19, 14, 1, -18 }, // 0xba 'LATIN CAPITAL LETTER U WITH ACUTE' U+00DA + { 2721, 12, 18, 14, 1, -17 }, // 0xbb 'LATIN CAPITAL LETTER U WITH CIRCUMFLEX' U+00DB + { 2748, 12, 17, 14, 1, -16 }, // 0xbc 'LATIN CAPITAL LETTER U WITH DIAERESIS' U+00DC + { 2774, 12, 19, 14, 1, -18 }, // 0xbd 'LATIN CAPITAL LETTER Y WITH ACUTE' U+00DD + { 2803, 11, 14, 14, 1, -13 }, // 0xbe 'LATIN CAPITAL LETTER THORN' U+00DE + { 2823, 11, 15, 14, 1, -14 }, // 0xbf 'LATIN SMALL LETTER SHARP S' U+00DF + { 2844, 11, 15, 14, 2, -14 }, // 0xc0 'LATIN SMALL LETTER A WITH GRAVE' U+00E0 + { 2865, 11, 15, 14, 2, -14 }, // 0xc1 'LATIN SMALL LETTER A WITH ACUTE' U+00E1 + { 2886, 11, 15, 14, 2, -14 }, // 0xc2 'LATIN SMALL LETTER A WITH CIRCUMFLEX' U+00E2 + { 2907, 11, 14, 14, 2, -13 }, // 0xc3 'LATIN SMALL LETTER A WITH TILDE' U+00E3 + { 2927, 11, 14, 14, 2, -13 }, // 0xc4 'LATIN SMALL LETTER A WITH DIAERESIS' U+00E4 + { 2947, 11, 16, 14, 2, -15 }, // 0xc5 'LATIN SMALL LETTER A WITH RING ABOVE' U+00E5 + { 2969, 14, 10, 14, 0, -9 }, // 0xc6 'LATIN SMALL LETTER AE' U+00E6 + { 2987, 11, 14, 14, 2, -9 }, // 0xc7 'LATIN SMALL LETTER C WITH CEDILLA' U+00E7 + { 3007, 10, 15, 14, 2, -14 }, // 0xc8 'LATIN SMALL LETTER E WITH GRAVE' U+00E8 + { 3026, 10, 15, 14, 2, -14 }, // 0xc9 'LATIN SMALL LETTER E WITH ACUTE' U+00E9 + { 3045, 10, 15, 14, 2, -14 }, // 0xca 'LATIN SMALL LETTER E WITH CIRCUMFLEX' U+00EA + { 3064, 10, 14, 14, 2, -13 }, // 0xcb 'LATIN SMALL LETTER E WITH DIAERESIS' U+00EB + { 3082, 10, 15, 14, 2, -14 }, // 0xcc 'LATIN SMALL LETTER I WITH GRAVE' U+00EC + { 3101, 10, 15, 14, 2, -14 }, // 0xcd 'LATIN SMALL LETTER I WITH ACUTE' U+00ED + { 3120, 10, 15, 14, 2, -14 }, // 0xce 'LATIN SMALL LETTER I WITH CIRCUMFLEX' U+00EE + { 3139, 10, 14, 14, 2, -13 }, // 0xcf 'LATIN SMALL LETTER I WITH DIAERESIS' U+00EF + { 3157, 11, 15, 14, 2, -14 }, // 0xd0 'LATIN SMALL LETTER ETH' U+00F0 + { 3178, 12, 14, 14, 1, -13 }, // 0xd1 'LATIN SMALL LETTER N WITH TILDE' U+00F1 + { 3199, 11, 15, 14, 2, -14 }, // 0xd2 'LATIN SMALL LETTER O WITH GRAVE' U+00F2 + { 3220, 11, 15, 14, 2, -14 }, // 0xd3 'LATIN SMALL LETTER O WITH ACUTE' U+00F3 + { 3241, 11, 15, 14, 2, -14 }, // 0xd4 'LATIN SMALL LETTER O WITH CIRCUMFLEX' U+00F4 + { 3262, 11, 14, 14, 2, -13 }, // 0xd5 'LATIN SMALL LETTER O WITH TILDE' U+00F5 + { 3282, 11, 14, 14, 2, -13 }, // 0xd6 'LATIN SMALL LETTER O WITH DIAERESIS' U+00F6 + { 3302, 11, 12, 14, 2, -12 }, // 0xd7 'DIVISION SIGN' U+00F7 + { 3319, 12, 12, 14, 1, -10 }, // 0xd8 'LATIN SMALL LETTER O WITH STROKE' U+00F8 + { 3337, 12, 15, 14, 1, -14 }, // 0xd9 'LATIN SMALL LETTER U WITH GRAVE' U+00F9 + { 3360, 12, 15, 14, 1, -14 }, // 0xda 'LATIN SMALL LETTER U WITH ACUTE' U+00FA + { 3383, 12, 15, 14, 1, -14 }, // 0xdb 'LATIN SMALL LETTER U WITH CIRCUMFLEX' U+00FB + { 3406, 12, 14, 14, 1, -13 }, // 0xdc 'LATIN SMALL LETTER U WITH DIAERESIS' U+00FC + { 3427, 12, 19, 14, 1, -14 }, // 0xdd 'LATIN SMALL LETTER Y WITH ACUTE' U+00FD + { 3456, 12, 18, 14, 1, -13 }, // 0xde 'LATIN SMALL LETTER THORN' U+00FE + { 3483, 12, 18, 14, 1, -13 } }; // 0xdf 'LATIN SMALL LETTER Y WITH DIAERESIS' U+000FF + +const GFXfont FreeMono12pt8b PROGMEM = { + (uint8_t *)FreeMono12pt8bBitmaps, + (GFXglyph *)FreeMono12pt8bGlyphs, + 0x20, 0xDF, 26 }; + +// Approx. 4861 bytes diff --git a/RX_FSK/src/fonts/FreeMono9pt7b.h b/RX_FSK/src/fonts/FreeMono9pt7b.h new file mode 100644 index 0000000..c82d786 --- /dev/null +++ b/RX_FSK/src/fonts/FreeMono9pt7b.h @@ -0,0 +1,176 @@ +const uint8_t FreeMono9pt7bBitmaps[] PROGMEM = { + 0xAA, 0xA8, 0x0C, 0xED, 0x24, 0x92, 0x48, 0x24, 0x48, 0x91, 0x2F, 0xE4, + 0x89, 0x7F, 0x28, 0x51, 0x22, 0x40, 0x08, 0x3E, 0x62, 0x40, 0x30, 0x0E, + 0x01, 0x81, 0xC3, 0xBE, 0x08, 0x08, 0x71, 0x12, 0x23, 0x80, 0x23, 0xB8, + 0x0E, 0x22, 0x44, 0x70, 0x38, 0x81, 0x02, 0x06, 0x1A, 0x65, 0x46, 0xC8, + 0xEC, 0xE9, 0x24, 0x5A, 0xAA, 0xA9, 0x40, 0xA9, 0x55, 0x5A, 0x80, 0x10, + 0x22, 0x4B, 0xE3, 0x05, 0x11, 0x00, 0x10, 0x20, 0x47, 0xF1, 0x02, 0x04, + 0x00, 0x6B, 0x48, 0xFF, 0x00, 0xF0, 0x02, 0x08, 0x10, 0x60, 0x81, 0x04, + 0x08, 0x20, 0x41, 0x02, 0x08, 0x00, 0x38, 0x8A, 0x0C, 0x18, 0x30, 0x60, + 0xC1, 0x82, 0x88, 0xE0, 0x27, 0x28, 0x42, 0x10, 0x84, 0x21, 0x3E, 0x38, + 0x8A, 0x08, 0x10, 0x20, 0x82, 0x08, 0x61, 0x03, 0xF8, 0x7C, 0x06, 0x02, + 0x02, 0x1C, 0x06, 0x01, 0x01, 0x01, 0x42, 0x3C, 0x18, 0xA2, 0x92, 0x8A, + 0x28, 0xBF, 0x08, 0x21, 0xC0, 0x7C, 0x81, 0x03, 0xE4, 0x40, 0x40, 0x81, + 0x03, 0x88, 0xE0, 0x1E, 0x41, 0x04, 0x0B, 0x98, 0xB0, 0xC1, 0xC2, 0x88, + 0xE0, 0xFE, 0x04, 0x08, 0x20, 0x40, 0x82, 0x04, 0x08, 0x20, 0x40, 0x38, + 0x8A, 0x0C, 0x14, 0x47, 0x11, 0x41, 0x83, 0x8C, 0xE0, 0x38, 0x8A, 0x1C, + 0x18, 0x68, 0xCE, 0x81, 0x04, 0x13, 0xC0, 0xF0, 0x0F, 0x6C, 0x00, 0xD2, + 0xD2, 0x00, 0x03, 0x04, 0x18, 0x60, 0x60, 0x18, 0x04, 0x03, 0xFF, 0x80, + 0x00, 0x1F, 0xF0, 0x40, 0x18, 0x03, 0x00, 0x60, 0x20, 0x60, 0xC0, 0x80, + 0x3D, 0x84, 0x08, 0x30, 0xC2, 0x00, 0x00, 0x00, 0x30, 0x3C, 0x46, 0x82, + 0x8E, 0xB2, 0xA2, 0xA2, 0x9F, 0x80, 0x80, 0x40, 0x3C, 0x3C, 0x01, 0x40, + 0x28, 0x09, 0x01, 0x10, 0x42, 0x0F, 0xC1, 0x04, 0x40, 0x9E, 0x3C, 0xFE, + 0x21, 0x90, 0x48, 0x67, 0xE2, 0x09, 0x02, 0x81, 0x41, 0xFF, 0x80, 0x3E, + 0xB0, 0xF0, 0x30, 0x08, 0x04, 0x02, 0x00, 0x80, 0x60, 0x8F, 0x80, 0xFE, + 0x21, 0x90, 0x68, 0x14, 0x0A, 0x05, 0x02, 0x83, 0x43, 0x7F, 0x00, 0xFF, + 0x20, 0x90, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x81, 0x40, 0xFF, 0xC0, 0xFF, + 0xA0, 0x50, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x80, 0x40, 0x78, 0x00, 0x1E, + 0x98, 0x6C, 0x0A, 0x00, 0x80, 0x20, 0xF8, 0x0B, 0x02, 0x60, 0x87, 0xC0, + 0xE3, 0xA0, 0x90, 0x48, 0x27, 0xF2, 0x09, 0x04, 0x82, 0x41, 0x71, 0xC0, + 0xF9, 0x08, 0x42, 0x10, 0x84, 0x27, 0xC0, 0x1F, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x82, 0x82, 0xC6, 0x78, 0xE3, 0xA1, 0x11, 0x09, 0x05, 0x83, 0x21, + 0x08, 0x84, 0x41, 0x70, 0xC0, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41, + 0x41, 0x41, 0xFF, 0xE0, 0xEC, 0x19, 0x45, 0x28, 0xA4, 0xA4, 0x94, 0x91, + 0x12, 0x02, 0x40, 0x5C, 0x1C, 0xC3, 0xB0, 0x94, 0x4A, 0x24, 0x92, 0x49, + 0x14, 0x8A, 0x43, 0x70, 0x80, 0x1E, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06, + 0x02, 0x82, 0x63, 0x0F, 0x00, 0xFE, 0x43, 0x41, 0x41, 0x42, 0x7C, 0x40, + 0x40, 0x40, 0xF0, 0x1C, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06, 0x02, 0x82, + 0x63, 0x1F, 0x04, 0x07, 0x92, 0x30, 0xFE, 0x21, 0x90, 0x48, 0x24, 0x23, + 0xE1, 0x10, 0x84, 0x41, 0x70, 0xC0, 0x3A, 0xCD, 0x0A, 0x03, 0x01, 0x80, + 0xC1, 0xC7, 0x78, 0xFF, 0xC4, 0x62, 0x21, 0x00, 0x80, 0x40, 0x20, 0x10, + 0x08, 0x1F, 0x00, 0xE3, 0xA0, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x82, + 0x22, 0x0E, 0x00, 0xF1, 0xE8, 0x10, 0x82, 0x10, 0x42, 0x10, 0x22, 0x04, + 0x80, 0x50, 0x0C, 0x00, 0x80, 0xF1, 0xE8, 0x09, 0x11, 0x25, 0x44, 0xA8, + 0x55, 0x0C, 0xA1, 0x8C, 0x31, 0x84, 0x30, 0xE3, 0xA0, 0x88, 0x82, 0x80, + 0x80, 0xC0, 0x90, 0x44, 0x41, 0x71, 0xC0, 0xE3, 0xA0, 0x88, 0x82, 0x81, + 0x40, 0x40, 0x20, 0x10, 0x08, 0x1F, 0x00, 0xFD, 0x0A, 0x20, 0x81, 0x04, + 0x10, 0x21, 0x83, 0xFC, 0xEA, 0xAA, 0xAA, 0xC0, 0x80, 0x81, 0x03, 0x02, + 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0xD5, 0x55, 0x55, 0xC0, + 0x10, 0x51, 0x22, 0x28, 0x20, 0xFF, 0xE0, 0x88, 0x80, 0x7E, 0x00, 0x80, + 0x47, 0xEC, 0x14, 0x0A, 0x0C, 0xFB, 0xC0, 0x20, 0x10, 0x0B, 0xC6, 0x12, + 0x05, 0x02, 0x81, 0x40, 0xB0, 0xB7, 0x80, 0x3A, 0x8E, 0x0C, 0x08, 0x10, + 0x10, 0x9E, 0x03, 0x00, 0x80, 0x47, 0xA4, 0x34, 0x0A, 0x05, 0x02, 0x81, + 0x21, 0x8F, 0x60, 0x3C, 0x43, 0x81, 0xFF, 0x80, 0x80, 0x61, 0x3E, 0x3D, + 0x04, 0x3E, 0x41, 0x04, 0x10, 0x41, 0x0F, 0x80, 0x3D, 0xA1, 0xA0, 0x50, + 0x28, 0x14, 0x09, 0x0C, 0x7A, 0x01, 0x01, 0x87, 0x80, 0xC0, 0x20, 0x10, + 0x0B, 0xC6, 0x32, 0x09, 0x04, 0x82, 0x41, 0x20, 0xB8, 0xE0, 0x10, 0x01, + 0xC0, 0x81, 0x02, 0x04, 0x08, 0x11, 0xFC, 0x10, 0x3E, 0x10, 0x84, 0x21, + 0x08, 0x42, 0x3F, 0x00, 0xC0, 0x40, 0x40, 0x4F, 0x44, 0x58, 0x70, 0x48, + 0x44, 0x42, 0xC7, 0x70, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23, + 0xF8, 0xB7, 0x64, 0x62, 0x31, 0x18, 0x8C, 0x46, 0x23, 0x91, 0x5E, 0x31, + 0x90, 0x48, 0x24, 0x12, 0x09, 0x05, 0xC7, 0x3E, 0x31, 0xA0, 0x30, 0x18, + 0x0C, 0x05, 0x8C, 0x7C, 0xDE, 0x30, 0x90, 0x28, 0x14, 0x0A, 0x05, 0x84, + 0xBC, 0x40, 0x20, 0x38, 0x00, 0x3D, 0xA1, 0xA0, 0x50, 0x28, 0x14, 0x09, + 0x0C, 0x7A, 0x01, 0x00, 0x80, 0xE0, 0xCE, 0xA1, 0x82, 0x04, 0x08, 0x10, + 0x7C, 0x3A, 0x8D, 0x0B, 0x80, 0xF0, 0x70, 0xDE, 0x40, 0x40, 0xFC, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x41, 0x3E, 0xC3, 0x41, 0x41, 0x41, 0x41, 0x41, + 0x43, 0x3D, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x20, 0xA0, 0x50, 0x10, 0xE3, + 0xC0, 0x92, 0x4B, 0x25, 0x92, 0xA9, 0x98, 0x44, 0xE3, 0x31, 0x05, 0x01, + 0x01, 0x41, 0x11, 0x05, 0xC7, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x40, 0xA0, + 0x60, 0x10, 0x10, 0x08, 0x3E, 0x00, 0xFD, 0x08, 0x20, 0x82, 0x08, 0x10, + 0xBF, 0x29, 0x24, 0xA2, 0x49, 0x26, 0xFF, 0xF8, 0x89, 0x24, 0x8A, 0x49, + 0x2C, 0x61, 0x24, 0x30 }; + +const GFXglyph FreeMono9pt7bGlyphs[] PROGMEM = { + { 0, 0, 0, 11, 0, 1 }, // 0x20 ' ' + { 0, 2, 11, 11, 4, -10 }, // 0x21 '!' + { 3, 6, 5, 11, 2, -10 }, // 0x22 '"' + { 7, 7, 12, 11, 2, -10 }, // 0x23 '#' + { 18, 8, 12, 11, 1, -10 }, // 0x24 '$' + { 30, 7, 11, 11, 2, -10 }, // 0x25 '%' + { 40, 7, 10, 11, 2, -9 }, // 0x26 '&' + { 49, 3, 5, 11, 4, -10 }, // 0x27 ''' + { 51, 2, 13, 11, 5, -10 }, // 0x28 '(' + { 55, 2, 13, 11, 4, -10 }, // 0x29 ')' + { 59, 7, 7, 11, 2, -10 }, // 0x2A '*' + { 66, 7, 7, 11, 2, -8 }, // 0x2B '+' + { 73, 3, 5, 11, 2, -1 }, // 0x2C ',' + { 75, 9, 1, 11, 1, -5 }, // 0x2D '-' + { 77, 2, 2, 11, 4, -1 }, // 0x2E '.' + { 78, 7, 13, 11, 2, -11 }, // 0x2F '/' + { 90, 7, 11, 11, 2, -10 }, // 0x30 '0' + { 100, 5, 11, 11, 3, -10 }, // 0x31 '1' + { 107, 7, 11, 11, 2, -10 }, // 0x32 '2' + { 117, 8, 11, 11, 1, -10 }, // 0x33 '3' + { 128, 6, 11, 11, 3, -10 }, // 0x34 '4' + { 137, 7, 11, 11, 2, -10 }, // 0x35 '5' + { 147, 7, 11, 11, 2, -10 }, // 0x36 '6' + { 157, 7, 11, 11, 2, -10 }, // 0x37 '7' + { 167, 7, 11, 11, 2, -10 }, // 0x38 '8' + { 177, 7, 11, 11, 2, -10 }, // 0x39 '9' + { 187, 2, 8, 11, 4, -7 }, // 0x3A ':' + { 189, 3, 11, 11, 3, -7 }, // 0x3B ';' + { 194, 8, 8, 11, 1, -8 }, // 0x3C '<' + { 202, 9, 4, 11, 1, -6 }, // 0x3D '=' + { 207, 9, 8, 11, 1, -8 }, // 0x3E '>' + { 216, 7, 10, 11, 2, -9 }, // 0x3F '?' + { 225, 8, 12, 11, 2, -10 }, // 0x40 '@' + { 237, 11, 10, 11, 0, -9 }, // 0x41 'A' + { 251, 9, 10, 11, 1, -9 }, // 0x42 'B' + { 263, 9, 10, 11, 1, -9 }, // 0x43 'C' + { 275, 9, 10, 11, 1, -9 }, // 0x44 'D' + { 287, 9, 10, 11, 1, -9 }, // 0x45 'E' + { 299, 9, 10, 11, 1, -9 }, // 0x46 'F' + { 311, 10, 10, 11, 1, -9 }, // 0x47 'G' + { 324, 9, 10, 11, 1, -9 }, // 0x48 'H' + { 336, 5, 10, 11, 3, -9 }, // 0x49 'I' + { 343, 8, 10, 11, 2, -9 }, // 0x4A 'J' + { 353, 9, 10, 11, 1, -9 }, // 0x4B 'K' + { 365, 8, 10, 11, 2, -9 }, // 0x4C 'L' + { 375, 11, 10, 11, 0, -9 }, // 0x4D 'M' + { 389, 9, 10, 11, 1, -9 }, // 0x4E 'N' + { 401, 9, 10, 11, 1, -9 }, // 0x4F 'O' + { 413, 8, 10, 11, 1, -9 }, // 0x50 'P' + { 423, 9, 13, 11, 1, -9 }, // 0x51 'Q' + { 438, 9, 10, 11, 1, -9 }, // 0x52 'R' + { 450, 7, 10, 11, 2, -9 }, // 0x53 'S' + { 459, 9, 10, 11, 1, -9 }, // 0x54 'T' + { 471, 9, 10, 11, 1, -9 }, // 0x55 'U' + { 483, 11, 10, 11, 0, -9 }, // 0x56 'V' + { 497, 11, 10, 11, 0, -9 }, // 0x57 'W' + { 511, 9, 10, 11, 1, -9 }, // 0x58 'X' + { 523, 9, 10, 11, 1, -9 }, // 0x59 'Y' + { 535, 7, 10, 11, 2, -9 }, // 0x5A 'Z' + { 544, 2, 13, 11, 5, -10 }, // 0x5B '[' + { 548, 7, 13, 11, 2, -11 }, // 0x5C '\' + { 560, 2, 13, 11, 4, -10 }, // 0x5D ']' + { 564, 7, 5, 11, 2, -10 }, // 0x5E '^' + { 569, 11, 1, 11, 0, 2 }, // 0x5F '_' + { 571, 3, 3, 11, 3, -11 }, // 0x60 '`' + { 573, 9, 8, 11, 1, -7 }, // 0x61 'a' + { 582, 9, 11, 11, 1, -10 }, // 0x62 'b' + { 595, 7, 8, 11, 2, -7 }, // 0x63 'c' + { 602, 9, 11, 11, 1, -10 }, // 0x64 'd' + { 615, 8, 8, 11, 1, -7 }, // 0x65 'e' + { 623, 6, 11, 11, 3, -10 }, // 0x66 'f' + { 632, 9, 11, 11, 1, -7 }, // 0x67 'g' + { 645, 9, 11, 11, 1, -10 }, // 0x68 'h' + { 658, 7, 10, 11, 2, -9 }, // 0x69 'i' + { 667, 5, 13, 11, 3, -9 }, // 0x6A 'j' + { 676, 8, 11, 11, 2, -10 }, // 0x6B 'k' + { 687, 7, 11, 11, 2, -10 }, // 0x6C 'l' + { 697, 9, 8, 11, 1, -7 }, // 0x6D 'm' + { 706, 9, 8, 11, 1, -7 }, // 0x6E 'n' + { 715, 9, 8, 11, 1, -7 }, // 0x6F 'o' + { 724, 9, 11, 11, 1, -7 }, // 0x70 'p' + { 737, 9, 11, 11, 1, -7 }, // 0x71 'q' + { 750, 7, 8, 11, 3, -7 }, // 0x72 'r' + { 757, 7, 8, 11, 2, -7 }, // 0x73 's' + { 764, 8, 10, 11, 2, -9 }, // 0x74 't' + { 774, 8, 8, 11, 1, -7 }, // 0x75 'u' + { 782, 9, 8, 11, 1, -7 }, // 0x76 'v' + { 791, 9, 8, 11, 1, -7 }, // 0x77 'w' + { 800, 9, 8, 11, 1, -7 }, // 0x78 'x' + { 809, 9, 11, 11, 1, -7 }, // 0x79 'y' + { 822, 7, 8, 11, 2, -7 }, // 0x7A 'z' + { 829, 3, 13, 11, 4, -10 }, // 0x7B '{' + { 834, 1, 13, 11, 5, -10 }, // 0x7C '|' + { 836, 3, 13, 11, 4, -10 }, // 0x7D '}' + { 841, 7, 3, 11, 2, -6 } }; // 0x7E '~' + +const GFXfont FreeMono9pt7b PROGMEM = { + (uint8_t *)FreeMono9pt7bBitmaps, + (GFXglyph *)FreeMono9pt7bGlyphs, + 0x20, 0x7E, 18 }; + +// Approx. 1516 bytes diff --git a/RX_FSK/src/fonts/FreeMono9pt8b.h b/RX_FSK/src/fonts/FreeMono9pt8b.h new file mode 100644 index 0000000..870cc1c --- /dev/null +++ b/RX_FSK/src/fonts/FreeMono9pt8b.h @@ -0,0 +1,374 @@ +const uint8_t FreeMono9pt8bBitmaps[] PROGMEM = { + 0x00, 0x55, 0x54, 0x1C, 0xDE, 0xF7, 0x39, 0x80, 0x20, 0x50, 0xA1, 0x42, + 0x9F, 0xCA, 0x14, 0xFE, 0x91, 0x22, 0x44, 0x80, 0x10, 0x21, 0xB4, 0x08, + 0x08, 0x0F, 0x01, 0x83, 0x0B, 0xE0, 0x81, 0x02, 0x00, 0x71, 0x22, 0x44, + 0x86, 0x23, 0xB8, 0x0E, 0x22, 0x44, 0x70, 0x78, 0x81, 0x02, 0x06, 0x12, + 0xA6, 0x44, 0x76, 0xD9, 0x24, 0x25, 0x25, 0x24, 0x49, 0x12, 0x91, 0x24, + 0x9B, 0x49, 0x48, 0x10, 0x22, 0x4B, 0xE2, 0x89, 0x00, 0x00, 0x08, 0x04, + 0x02, 0x01, 0x00, 0x83, 0xF8, 0x20, 0x10, 0x08, 0x00, 0x37, 0x64, 0x40, + 0x7F, 0x00, 0xFC, 0x02, 0x08, 0x10, 0x40, 0x82, 0x04, 0x10, 0x20, 0x41, + 0x02, 0x08, 0x00, 0x38, 0x8A, 0x14, 0x18, 0x30, 0x60, 0xC1, 0x82, 0x89, + 0xE0, 0x30, 0xA2, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23, 0xF8, 0x79, + 0x0A, 0x10, 0x20, 0x41, 0x04, 0x10, 0x41, 0x07, 0xF8, 0x79, 0x08, 0x08, + 0x20, 0xC3, 0x80, 0x81, 0x02, 0x07, 0xF0, 0x0C, 0x28, 0x91, 0x24, 0x48, + 0xA1, 0x7F, 0x04, 0x08, 0x78, 0x7D, 0x02, 0x04, 0x07, 0xC0, 0x40, 0x81, + 0x03, 0x09, 0xF0, 0x1E, 0x41, 0x02, 0x08, 0x96, 0xB0, 0xC1, 0x42, 0x84, + 0xF0, 0xFF, 0x04, 0x10, 0x20, 0x41, 0x02, 0x04, 0x10, 0x20, 0x40, 0x79, + 0x0A, 0x0C, 0x14, 0x47, 0x31, 0x41, 0x83, 0x09, 0xF0, 0x38, 0x8A, 0x0C, + 0x18, 0x28, 0xCE, 0x81, 0x04, 0x09, 0xE0, 0x1F, 0x00, 0x3F, 0x03, 0x30, + 0x03, 0x76, 0x44, 0x00, 0x03, 0x04, 0x18, 0x60, 0x60, 0x18, 0x04, 0x03, + 0xFF, 0x80, 0x00, 0x1F, 0xF0, 0x40, 0x18, 0x03, 0x00, 0x60, 0x20, 0x60, + 0xC0, 0x80, 0xFD, 0x04, 0x08, 0x10, 0xC2, 0x04, 0x00, 0x10, 0x70, 0x78, + 0x8A, 0x14, 0x29, 0xD4, 0xA9, 0x4A, 0x89, 0x01, 0x01, 0xE0, 0x3C, 0x01, + 0x40, 0x48, 0x09, 0x01, 0x10, 0x42, 0x0F, 0xC1, 0x04, 0x40, 0x9E, 0x3C, + 0xFE, 0x20, 0x90, 0x48, 0x27, 0xE2, 0x09, 0x02, 0x81, 0x41, 0x7F, 0x00, + 0x3F, 0x20, 0xA0, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x41, 0x1F, 0x00, + 0xFC, 0x42, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0xFC, 0xFF, 0x41, + 0x41, 0x40, 0x78, 0x48, 0x40, 0x41, 0x41, 0xFF, 0xFF, 0x41, 0x40, 0x40, + 0x78, 0x48, 0x40, 0x40, 0x40, 0xF8, 0x3F, 0x20, 0xA0, 0x10, 0x08, 0x04, + 0x3E, 0x05, 0x02, 0x41, 0x1F, 0x80, 0xE3, 0x20, 0x90, 0x48, 0x27, 0xF2, + 0x09, 0x04, 0x82, 0x41, 0x73, 0xC0, 0xFE, 0x20, 0x40, 0x81, 0x02, 0x04, + 0x08, 0x11, 0xFC, 0x3F, 0x02, 0x01, 0x00, 0x80, 0x40, 0x22, 0x11, 0x08, + 0x84, 0x3C, 0x00, 0xF3, 0xA1, 0x11, 0x09, 0x05, 0x83, 0x21, 0x08, 0x84, + 0x42, 0x78, 0xC0, 0xF8, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x82, 0x41, + 0x20, 0xFF, 0xC0, 0xE0, 0xCC, 0x29, 0x45, 0x29, 0x24, 0xA4, 0x94, 0x91, + 0x12, 0x02, 0x40, 0x5E, 0x3C, 0x61, 0xCC, 0x23, 0x08, 0xA2, 0x24, 0x89, + 0x22, 0x28, 0x8A, 0x21, 0x9C, 0x20, 0x3E, 0x20, 0xA0, 0x50, 0x18, 0x0C, + 0x06, 0x03, 0x02, 0x41, 0x1F, 0x00, 0xFE, 0x41, 0x41, 0x41, 0x42, 0x7C, + 0x40, 0x40, 0x40, 0xF8, 0x3E, 0x20, 0xA0, 0x50, 0x18, 0x0C, 0x06, 0x03, + 0x02, 0x41, 0x1B, 0x06, 0x07, 0xF0, 0xFE, 0x10, 0x44, 0x11, 0x04, 0x42, + 0x1F, 0x04, 0x21, 0x08, 0x41, 0x3C, 0x30, 0x7F, 0x06, 0x0C, 0x07, 0x01, + 0x80, 0x81, 0x83, 0xF8, 0xFF, 0xC4, 0x42, 0x01, 0x00, 0x80, 0x40, 0x20, + 0x10, 0x08, 0x1F, 0x00, 0xE3, 0xA0, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, + 0x82, 0x41, 0x1F, 0x00, 0xF1, 0xE8, 0x10, 0x82, 0x10, 0x82, 0x10, 0x22, + 0x04, 0x80, 0x50, 0x0C, 0x00, 0x80, 0xF1, 0xD0, 0x14, 0x49, 0x32, 0x4A, + 0x92, 0xA3, 0x28, 0xCA, 0x31, 0x88, 0x60, 0xE3, 0xA1, 0x08, 0x82, 0x80, + 0x80, 0xC0, 0x50, 0x44, 0x41, 0x71, 0xC0, 0xE3, 0xA1, 0x08, 0x82, 0x81, + 0x80, 0x40, 0x20, 0x10, 0x08, 0x1F, 0x00, 0xFD, 0x0A, 0x20, 0x41, 0x04, + 0x10, 0xA1, 0x83, 0xFC, 0xF2, 0x49, 0x24, 0x92, 0x4E, 0x81, 0x01, 0x02, + 0x02, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0xE4, 0x92, 0x49, + 0x24, 0x9E, 0x10, 0x51, 0x24, 0x28, 0x20, 0xFF, 0xE0, 0x11, 0x80, 0x1C, + 0x31, 0x00, 0x83, 0xC6, 0x24, 0x12, 0x08, 0xFB, 0xE0, 0x08, 0x02, 0x00, + 0xB8, 0x31, 0x88, 0x22, 0x04, 0x81, 0x20, 0x48, 0x2F, 0xF0, 0x38, 0x46, + 0x82, 0x80, 0x80, 0x80, 0x81, 0x7E, 0x03, 0x00, 0x40, 0x10, 0x64, 0x67, + 0x20, 0x48, 0x12, 0x04, 0x81, 0x10, 0xC3, 0xD8, 0x1C, 0x62, 0x81, 0x81, + 0xFE, 0x80, 0x40, 0x3F, 0x1F, 0x20, 0x20, 0x7C, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0xFE, 0x39, 0xA3, 0xA0, 0x50, 0x28, 0x14, 0x09, 0x0C, 0x7A, + 0x01, 0x01, 0x07, 0x80, 0xC0, 0x20, 0x10, 0x0B, 0x86, 0x22, 0x09, 0x04, + 0x82, 0x41, 0x20, 0xB8, 0xE0, 0x10, 0x20, 0x03, 0x81, 0x02, 0x04, 0x08, + 0x10, 0x23, 0xF8, 0x10, 0x81, 0xF0, 0x84, 0x21, 0x08, 0x42, 0x10, 0xFC, + 0xC0, 0x20, 0x10, 0x08, 0xC4, 0x42, 0x41, 0x40, 0x50, 0x44, 0x21, 0x31, + 0xE0, 0xF0, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23, 0xF8, 0x59, + 0x8C, 0xD1, 0x11, 0x22, 0x24, 0x44, 0x88, 0x91, 0x17, 0x33, 0x5C, 0x31, + 0x10, 0x48, 0x24, 0x12, 0x09, 0x05, 0xC7, 0x1C, 0x31, 0x10, 0x50, 0x28, + 0x14, 0x09, 0x04, 0x7C, 0x6E, 0x0C, 0x62, 0x08, 0x81, 0x20, 0x48, 0x23, + 0x08, 0xBC, 0x20, 0x08, 0x07, 0x00, 0x1D, 0x98, 0xC8, 0x12, 0x04, 0x81, + 0x20, 0x44, 0x30, 0xF4, 0x01, 0x00, 0x40, 0x38, 0xC6, 0x59, 0x20, 0x40, + 0x40, 0x40, 0x40, 0xFC, 0x39, 0x8E, 0x03, 0x01, 0xC0, 0x60, 0xFE, 0x40, + 0x40, 0xFC, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x3F, 0xC3, 0x20, 0x90, + 0x48, 0x24, 0x12, 0x09, 0x0C, 0x7B, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x21, + 0x20, 0x50, 0x10, 0xC1, 0xC0, 0xA2, 0x49, 0x25, 0x52, 0xB1, 0x98, 0x44, + 0x63, 0x20, 0x88, 0x83, 0x81, 0x81, 0x21, 0x09, 0xC7, 0xC3, 0x20, 0x90, + 0x44, 0x42, 0x20, 0xA0, 0x50, 0x10, 0x08, 0x08, 0x1E, 0x00, 0xFF, 0x0A, + 0x20, 0x81, 0x04, 0x10, 0xFF, 0x12, 0x22, 0x22, 0xC2, 0x22, 0x22, 0x30, + 0xFF, 0xF8, 0xC1, 0x08, 0x42, 0x10, 0x64, 0x21, 0x08, 0x44, 0x00, 0xE2, + 0x38, 0xFF, 0xF0, 0x06, 0xFC, 0xD0, 0x58, 0x0B, 0x01, 0x60, 0xCC, 0x21, + 0x84, 0x30, 0x06, 0x10, 0xC7, 0x18, 0x03, 0xFF, 0xC0, 0x00, 0xC0, 0x55, + 0x54, 0x10, 0x43, 0x91, 0x82, 0x08, 0x11, 0x38, 0x41, 0x00, 0x3C, 0x20, + 0x20, 0x20, 0xF8, 0x20, 0x20, 0x20, 0x21, 0x7F, 0x3F, 0xA0, 0x90, 0x10, + 0x0F, 0xE7, 0xE2, 0x00, 0x80, 0x20, 0x8F, 0x80, 0xE3, 0xA1, 0x08, 0x82, + 0x81, 0x83, 0xF8, 0x20, 0x7C, 0x08, 0x1F, 0x00, 0x6C, 0x20, 0x03, 0xF8, + 0x30, 0x60, 0x38, 0x0C, 0x04, 0x0C, 0x1F, 0xC0, 0x1F, 0x10, 0x88, 0x4C, + 0x09, 0x82, 0x30, 0x84, 0x31, 0x07, 0x01, 0x10, 0x8F, 0x80, 0x00, 0xD8, + 0x40, 0x03, 0x98, 0xE0, 0x30, 0x1C, 0x06, 0x0F, 0xE0, 0x3F, 0x08, 0x12, + 0x3D, 0x48, 0x9A, 0x03, 0x40, 0x64, 0x4A, 0x72, 0x40, 0x87, 0xE0, 0xF0, + 0xBD, 0x2F, 0x80, 0x00, 0x08, 0x88, 0x88, 0xCC, 0x43, 0x10, 0x44, 0x11, + 0xFF, 0x80, 0x40, 0x20, 0x10, 0x00, 0x7F, 0x00, 0x3F, 0x08, 0x12, 0x79, + 0x49, 0x19, 0x23, 0x3C, 0x64, 0x8A, 0xCA, 0x40, 0x87, 0xE0, 0xF8, 0xF4, + 0x63, 0x17, 0x00, 0x00, 0x04, 0x02, 0x01, 0x0F, 0xF0, 0x40, 0x20, 0x10, + 0x00, 0x7F, 0x80, 0x79, 0x12, 0x4F, 0x71, 0x13, 0x1F, 0x04, 0xD0, 0x40, + 0x0F, 0xD0, 0xA2, 0x04, 0x10, 0x41, 0x0A, 0x18, 0x3F, 0xC0, 0xC3, 0x20, + 0x90, 0x48, 0x24, 0x12, 0x09, 0x0C, 0xDB, 0x50, 0x20, 0x10, 0x08, 0x00, + 0x3F, 0x6A, 0xCA, 0xCA, 0x4A, 0x7A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x3B, + 0x50, 0x00, 0xD8, 0x40, 0x0F, 0xF0, 0xA2, 0x08, 0x10, 0x41, 0x0F, 0xF0, + 0x62, 0x22, 0x27, 0xF4, 0x63, 0x17, 0x00, 0x00, 0x22, 0x18, 0x86, 0x61, + 0x11, 0x11, 0x11, 0x10, 0x3F, 0xC8, 0x8A, 0x11, 0x42, 0x08, 0x71, 0x0A, + 0x21, 0x02, 0x21, 0x44, 0x27, 0xFC, 0x31, 0x92, 0x98, 0x46, 0x11, 0x87, + 0xA1, 0x04, 0xC1, 0xEF, 0x22, 0x11, 0x00, 0x1C, 0x74, 0x21, 0x10, 0x50, + 0x30, 0x08, 0x04, 0x02, 0x01, 0x03, 0xE0, 0x10, 0xE0, 0x00, 0x10, 0xC4, + 0x20, 0x82, 0x17, 0xC0, 0x10, 0x01, 0x00, 0x10, 0x00, 0x03, 0xC0, 0x14, + 0x04, 0x80, 0x90, 0x11, 0x04, 0x20, 0xFC, 0x10, 0x44, 0x09, 0xE3, 0xC0, + 0x02, 0x00, 0x80, 0x20, 0x00, 0x03, 0xC0, 0x14, 0x04, 0x80, 0x90, 0x11, + 0x04, 0x20, 0xFC, 0x10, 0x44, 0x09, 0xE3, 0xC0, 0x04, 0x01, 0x40, 0x44, + 0x00, 0x03, 0xC0, 0x14, 0x04, 0x80, 0x90, 0x11, 0x04, 0x20, 0xFC, 0x10, + 0x44, 0x09, 0xE3, 0xC0, 0x08, 0x02, 0xE0, 0x00, 0x1E, 0x00, 0xA0, 0x24, + 0x04, 0x80, 0x88, 0x21, 0x07, 0xE0, 0x82, 0x20, 0x4F, 0x1E, 0x11, 0x02, + 0x20, 0x00, 0x1E, 0x00, 0xA0, 0x24, 0x04, 0x80, 0x88, 0x21, 0x07, 0xE0, + 0x82, 0x20, 0x4F, 0x1E, 0x0E, 0x02, 0x40, 0x30, 0x00, 0x03, 0xC0, 0x14, + 0x04, 0x80, 0x90, 0x11, 0x04, 0x20, 0xFC, 0x10, 0x44, 0x09, 0xE3, 0xC0, + 0x3F, 0xC2, 0x88, 0x51, 0x0A, 0x02, 0x70, 0x4A, 0x0F, 0x01, 0x21, 0x44, + 0x3D, 0xFC, 0x3F, 0x20, 0xA0, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x41, + 0x1B, 0x02, 0x00, 0x81, 0xC0, 0x20, 0x10, 0x08, 0x00, 0xFF, 0x41, 0x41, + 0x40, 0x78, 0x48, 0x40, 0x41, 0x41, 0xFF, 0x04, 0x08, 0x10, 0x00, 0xFF, + 0x41, 0x41, 0x40, 0x78, 0x48, 0x40, 0x41, 0x41, 0xFF, 0x00, 0x1C, 0x22, + 0x00, 0xFF, 0x41, 0x41, 0x40, 0x78, 0x48, 0x40, 0x41, 0x41, 0xFF, 0x22, + 0x66, 0x00, 0xFF, 0x41, 0x41, 0x40, 0x78, 0x48, 0x40, 0x41, 0x41, 0xFF, + 0x20, 0x20, 0x00, 0x0F, 0xE2, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81, 0x1F, + 0xC0, 0x04, 0x10, 0x40, 0x0F, 0xE2, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81, + 0x1F, 0xC0, 0x10, 0x51, 0x10, 0x0F, 0xE2, 0x04, 0x08, 0x10, 0x20, 0x40, + 0x81, 0x1F, 0xC0, 0x44, 0x88, 0x07, 0xF1, 0x02, 0x04, 0x08, 0x10, 0x20, + 0x40, 0x8F, 0xE0, 0x7E, 0x10, 0x88, 0x24, 0x1F, 0xC9, 0x04, 0x82, 0x41, + 0x21, 0x3F, 0x00, 0x19, 0x09, 0x80, 0x01, 0x87, 0x30, 0x8C, 0x22, 0x88, + 0x92, 0x24, 0x88, 0xA2, 0x28, 0x86, 0x70, 0x80, 0x20, 0x0C, 0x00, 0x00, + 0x03, 0xE2, 0x0A, 0x05, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x24, 0x11, 0xF0, + 0x04, 0x04, 0x04, 0x00, 0x03, 0xE2, 0x0A, 0x05, 0x01, 0x80, 0xC0, 0x60, + 0x30, 0x24, 0x11, 0xF0, 0x08, 0x0A, 0x08, 0x80, 0x03, 0xE2, 0x0A, 0x05, + 0x01, 0x80, 0xC0, 0x60, 0x30, 0x24, 0x11, 0xF0, 0x10, 0x17, 0x00, 0x07, + 0xC4, 0x14, 0x0A, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x48, 0x23, 0xE0, 0x22, + 0x11, 0x00, 0x07, 0xC4, 0x14, 0x0A, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x48, + 0x23, 0xE0, 0x84, 0x90, 0xC1, 0x84, 0x90, 0x80, 0x00, 0x9F, 0x90, 0x50, + 0x68, 0x4C, 0x46, 0x43, 0x21, 0xA1, 0x20, 0xAD, 0x81, 0x00, 0x20, 0x0C, + 0x00, 0x00, 0x0E, 0x3A, 0x09, 0x04, 0x82, 0x41, 0x20, 0x90, 0x48, 0x24, + 0x11, 0xF0, 0x04, 0x04, 0x04, 0x00, 0x0E, 0x3A, 0x09, 0x04, 0x82, 0x41, + 0x20, 0x90, 0x48, 0x24, 0x11, 0xF0, 0x08, 0x0A, 0x08, 0x80, 0x0E, 0x3A, + 0x09, 0x04, 0x82, 0x41, 0x20, 0x90, 0x48, 0x24, 0x11, 0xF0, 0x22, 0x11, + 0x00, 0x1C, 0x74, 0x12, 0x09, 0x04, 0x82, 0x41, 0x20, 0x90, 0x48, 0x23, + 0xE0, 0x04, 0x04, 0x04, 0x00, 0x0E, 0x3A, 0x10, 0x88, 0x28, 0x18, 0x04, + 0x02, 0x01, 0x00, 0x81, 0xF0, 0xF8, 0x40, 0x7C, 0x43, 0x41, 0x41, 0x41, + 0x7E, 0x40, 0xF8, 0x1C, 0x11, 0x08, 0x84, 0x42, 0xC1, 0x18, 0x82, 0x41, + 0x20, 0x94, 0x79, 0xC0, 0x20, 0x08, 0x02, 0x00, 0x01, 0xC3, 0x10, 0x08, + 0x3C, 0x62, 0x41, 0x20, 0x8F, 0xB0, 0x00, 0x06, 0x04, 0x00, 0x01, 0xC3, + 0x10, 0x08, 0x3C, 0x62, 0x41, 0x20, 0x8F, 0xB0, 0x18, 0x12, 0x00, 0x03, + 0x86, 0x20, 0x10, 0x78, 0xC4, 0x82, 0x41, 0x1F, 0x60, 0x3E, 0x00, 0x07, + 0x0C, 0x40, 0x20, 0xF1, 0x89, 0x04, 0x82, 0x3E, 0xC0, 0x22, 0x33, 0x00, + 0x03, 0x86, 0x20, 0x10, 0x78, 0xC4, 0x82, 0x41, 0x1F, 0x60, 0x1C, 0x12, + 0x05, 0x01, 0x01, 0xC3, 0x10, 0x08, 0x3C, 0x62, 0x41, 0x20, 0x8F, 0xB0, + 0x39, 0x91, 0x90, 0x44, 0xF1, 0x47, 0xA1, 0x08, 0x41, 0xFF, 0x38, 0x46, + 0x82, 0x80, 0x80, 0x80, 0x81, 0x6E, 0x10, 0x08, 0x38, 0x00, 0x10, 0x08, + 0x00, 0x1C, 0x62, 0x81, 0x81, 0xFE, 0x80, 0x40, 0x3F, 0x00, 0x04, 0x18, + 0x00, 0x1C, 0x62, 0x81, 0x81, 0xFE, 0x80, 0x40, 0x3F, 0x08, 0x36, 0x00, + 0x1C, 0x62, 0x81, 0x81, 0xFE, 0x80, 0x40, 0x3F, 0x22, 0x22, 0x00, 0x1C, + 0x62, 0x81, 0x81, 0xFE, 0x80, 0x40, 0x3F, 0x40, 0x40, 0x40, 0x07, 0x02, + 0x04, 0x08, 0x10, 0x20, 0x47, 0xF0, 0x00, 0x30, 0x80, 0x07, 0x02, 0x04, + 0x08, 0x10, 0x20, 0x47, 0xF0, 0x30, 0x90, 0x03, 0x81, 0x02, 0x04, 0x08, + 0x10, 0x23, 0xF8, 0x45, 0x98, 0x03, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23, + 0xF8, 0x36, 0x0E, 0x00, 0x83, 0xC6, 0x32, 0x0A, 0x05, 0x02, 0x81, 0x20, + 0x8F, 0x80, 0x3E, 0x00, 0x17, 0x0C, 0x44, 0x12, 0x09, 0x04, 0x82, 0x41, + 0x71, 0xC0, 0x00, 0x08, 0x02, 0x00, 0x01, 0xC3, 0x11, 0x05, 0x02, 0x81, + 0x40, 0x90, 0x47, 0xC0, 0x00, 0x02, 0x06, 0x00, 0x01, 0xC3, 0x11, 0x05, + 0x02, 0x81, 0x40, 0x90, 0x47, 0xC0, 0x18, 0x13, 0x00, 0x03, 0x86, 0x22, + 0x0A, 0x05, 0x02, 0x81, 0x20, 0x8F, 0x80, 0x3E, 0x00, 0x07, 0x0C, 0x44, + 0x14, 0x0A, 0x05, 0x02, 0x41, 0x1F, 0x00, 0x22, 0x11, 0x00, 0x03, 0x86, + 0x22, 0x0A, 0x05, 0x02, 0x81, 0x20, 0x8F, 0x80, 0x08, 0x04, 0x00, 0x00, + 0x00, 0x03, 0xF8, 0x00, 0x00, 0x08, 0x04, 0x00, 0x1D, 0x31, 0x10, 0xD0, + 0xA8, 0x94, 0x89, 0x84, 0xEC, 0x88, 0x00, 0x00, 0x08, 0x02, 0x00, 0x0C, + 0x32, 0x09, 0x04, 0x82, 0x41, 0x20, 0x90, 0xC7, 0xB0, 0x04, 0x04, 0x04, + 0x00, 0x0C, 0x32, 0x09, 0x04, 0x82, 0x41, 0x20, 0x90, 0xC7, 0xB0, 0x18, + 0x12, 0x00, 0x18, 0x64, 0x12, 0x09, 0x04, 0x82, 0x41, 0x21, 0x8F, 0x60, + 0x22, 0x33, 0x00, 0x18, 0x64, 0x12, 0x09, 0x04, 0x82, 0x41, 0x21, 0x8F, + 0x60, 0x02, 0x02, 0x02, 0x00, 0x0C, 0x32, 0x09, 0x04, 0x44, 0x22, 0x0A, + 0x05, 0x01, 0x00, 0x80, 0x81, 0xE0, 0xE0, 0x08, 0x02, 0x00, 0xB8, 0x31, + 0x88, 0x22, 0x04, 0x81, 0x20, 0x8C, 0x22, 0xF0, 0x80, 0x20, 0x1C, 0x00, + 0x22, 0x11, 0x00, 0x18, 0x64, 0x12, 0x08, 0x88, 0x44, 0x14, 0x0A, 0x02, + 0x01, 0x01, 0x03, 0xC0 }; + +const GFXglyph FreeMono9pt8bGlyphs[] PROGMEM = { + { 0, 1, 1, 11, 0, 0 }, // 0x20 ' ' U+0020 + { 1, 2, 11, 11, 4, -10 }, // 0x21 '!' U+0021 + { 4, 5, 5, 11, 3, -10 }, // 0x22 '"' U+0022 + { 8, 7, 13, 11, 2, -11 }, // 0x23 '#' U+0023 + { 20, 7, 14, 11, 2, -11 }, // 0x24 '$' U+0024 + { 33, 7, 11, 11, 2, -10 }, // 0x25 '%' U+0025 + { 43, 7, 9, 11, 2, -8 }, // 0x26 '&' U+0026 + { 51, 3, 5, 11, 4, -10 }, // 0x27 ''' U+0027 + { 53, 3, 13, 11, 5, -10 }, // 0x28 '(' U+0028 + { 58, 3, 13, 11, 3, -10 }, // 0x29 ')' U+0029 + { 63, 7, 7, 11, 2, -10 }, // 0x2a '*' U+002A + { 70, 9, 9, 11, 1, -9 }, // 0x2b '+' U+002B + { 81, 4, 6, 11, 2, -2 }, // 0x2c ',' U+002C + { 84, 9, 1, 11, 1, -5 }, // 0x2d '-' U+002D + { 86, 3, 2, 11, 4, -1 }, // 0x2e '.' U+002E + { 87, 7, 13, 11, 2, -11 }, // 0x2f '/' U+002F + { 99, 7, 11, 11, 2, -10 }, // 0x30 '0' U+0030 + { 109, 7, 11, 11, 2, -10 }, // 0x31 '1' U+0031 + { 119, 7, 11, 11, 2, -10 }, // 0x32 '2' U+0032 + { 129, 7, 11, 11, 2, -10 }, // 0x33 '3' U+0033 + { 139, 7, 11, 11, 2, -10 }, // 0x34 '4' U+0034 + { 149, 7, 11, 11, 2, -10 }, // 0x35 '5' U+0035 + { 159, 7, 11, 11, 2, -10 }, // 0x36 '6' U+0036 + { 169, 7, 11, 11, 2, -10 }, // 0x37 '7' U+0037 + { 179, 7, 11, 11, 2, -10 }, // 0x38 '8' U+0038 + { 189, 7, 11, 11, 2, -10 }, // 0x39 '9' U+0039 + { 199, 3, 8, 11, 4, -7 }, // 0x3a ':' U+003A + { 202, 4, 11, 11, 2, -7 }, // 0x3b ';' U+003B + { 208, 8, 8, 11, 1, -8 }, // 0x3c '<' U+003C + { 216, 9, 4, 11, 1, -6 }, // 0x3d '=' U+003D + { 221, 9, 8, 11, 1, -8 }, // 0x3e '>' U+003E + { 230, 7, 10, 11, 2, -9 }, // 0x3f '?' U+003F + { 239, 7, 12, 11, 2, -10 }, // 0x40 '@' U+0040 + { 250, 11, 10, 11, 0, -9 }, // 0x41 'A' U+0041 + { 264, 9, 10, 11, 1, -9 }, // 0x42 'B' U+0042 + { 276, 9, 10, 11, 1, -9 }, // 0x43 'C' U+0043 + { 288, 8, 10, 11, 1, -9 }, // 0x44 'D' U+0044 + { 298, 8, 10, 11, 1, -9 }, // 0x45 'E' U+0045 + { 308, 8, 10, 11, 1, -9 }, // 0x46 'F' U+0046 + { 318, 9, 10, 11, 1, -9 }, // 0x47 'G' U+0047 + { 330, 9, 10, 11, 1, -9 }, // 0x48 'H' U+0048 + { 342, 7, 10, 11, 2, -9 }, // 0x49 'I' U+0049 + { 351, 9, 10, 11, 2, -9 }, // 0x4a 'J' U+004A + { 363, 9, 10, 11, 1, -9 }, // 0x4b 'K' U+004B + { 375, 9, 10, 11, 1, -9 }, // 0x4c 'L' U+004C + { 387, 11, 10, 11, 0, -9 }, // 0x4d 'M' U+004D + { 401, 10, 10, 11, 0, -9 }, // 0x4e 'N' U+004E + { 414, 9, 10, 11, 1, -9 }, // 0x4f 'O' U+004F + { 426, 8, 10, 11, 1, -9 }, // 0x50 'P' U+0050 + { 436, 9, 12, 11, 1, -9 }, // 0x51 'Q' U+0051 + { 450, 10, 10, 11, 1, -9 }, // 0x52 'R' U+0052 + { 463, 7, 10, 11, 2, -9 }, // 0x53 'S' U+0053 + { 472, 9, 10, 11, 1, -9 }, // 0x54 'T' U+0054 + { 484, 9, 10, 11, 1, -9 }, // 0x55 'U' U+0055 + { 496, 11, 10, 11, 0, -9 }, // 0x56 'V' U+0056 + { 510, 10, 10, 11, 0, -9 }, // 0x57 'W' U+0057 + { 523, 9, 10, 11, 1, -9 }, // 0x58 'X' U+0058 + { 535, 9, 10, 11, 1, -9 }, // 0x59 'Y' U+0059 + { 547, 7, 10, 11, 2, -9 }, // 0x5a 'Z' U+005A + { 556, 3, 13, 11, 5, -10 }, // 0x5b '[' U+005B + { 561, 7, 13, 11, 2, -11 }, // 0x5c '\' U+005C + { 573, 3, 13, 11, 3, -10 }, // 0x5d ']' U+005D + { 578, 7, 5, 11, 2, -10 }, // 0x5e '^' U+005E + { 583, 11, 1, 11, 0, 2 }, // 0x5f '_' U+005F + { 585, 3, 3, 11, 3, -11 }, // 0x60 '`' U+0060 + { 587, 9, 8, 11, 1, -7 }, // 0x61 'a' U+0061 + { 596, 10, 11, 11, 0, -10 }, // 0x62 'b' U+0062 + { 610, 8, 8, 11, 2, -7 }, // 0x63 'c' U+0063 + { 618, 10, 11, 11, 1, -10 }, // 0x64 'd' U+0064 + { 632, 8, 8, 11, 1, -7 }, // 0x65 'e' U+0065 + { 640, 8, 11, 11, 2, -10 }, // 0x66 'f' U+0066 + { 651, 9, 11, 11, 1, -7 }, // 0x67 'g' U+0067 + { 664, 9, 11, 11, 1, -10 }, // 0x68 'h' U+0068 + { 677, 7, 11, 11, 2, -10 }, // 0x69 'i' U+0069 + { 687, 5, 14, 11, 3, -10 }, // 0x6a 'j' U+006A + { 696, 9, 11, 11, 1, -10 }, // 0x6b 'k' U+006B + { 709, 7, 11, 11, 2, -10 }, // 0x6c 'l' U+006C + { 719, 11, 8, 11, 0, -7 }, // 0x6d 'm' U+006D + { 730, 9, 8, 11, 1, -7 }, // 0x6e 'n' U+006E + { 739, 9, 8, 11, 1, -7 }, // 0x6f 'o' U+006F + { 748, 10, 11, 11, 0, -7 }, // 0x70 'p' U+0070 + { 762, 10, 11, 11, 1, -7 }, // 0x71 'q' U+0071 + { 776, 8, 8, 11, 2, -7 }, // 0x72 'r' U+0072 + { 784, 7, 8, 11, 2, -7 }, // 0x73 's' U+0073 + { 791, 8, 10, 11, 1, -9 }, // 0x74 't' U+0074 + { 801, 9, 8, 11, 1, -7 }, // 0x75 'u' U+0075 + { 810, 9, 8, 11, 1, -7 }, // 0x76 'v' U+0076 + { 819, 9, 8, 11, 1, -7 }, // 0x77 'w' U+0077 + { 828, 9, 8, 11, 1, -7 }, // 0x78 'x' U+0078 + { 837, 9, 11, 11, 1, -7 }, // 0x79 'y' U+0079 + { 850, 7, 8, 11, 2, -7 }, // 0x7a 'z' U+007A + { 857, 4, 13, 11, 3, -10 }, // 0x7b '{' U+007B + { 864, 1, 13, 11, 5, -10 }, // 0x7c '|' U+007C + { 866, 5, 13, 11, 3, -10 }, // 0x7d '}' U+007D + { 875, 7, 2, 11, 2, -5 }, // 0x7e '~' U+007E + { 877, 11, 14, 11, 0, -11 }, // 0x7f 'REPLACEMENT CHARACTER *' U+2370 + { 897, 1, 1, 11, 0, 0 }, // 0x80 'NO-BREAK SPACE' U+00A0 + { 898, 2, 11, 11, 4, -7 }, // 0x81 'INVERTED EXCLAMATION MARK' U+00A1 + { 901, 6, 11, 11, 2, -10 }, // 0x82 'CENT SIGN' U+00A2 + { 910, 8, 10, 11, 1, -9 }, // 0x83 'POUND SIGN' U+00A3 + { 920, 9, 10, 11, 1, -9 }, // 0x84 'EURO SIGN *' U+20AC + { 932, 9, 10, 11, 1, -9 }, // 0x85 'YEN SIGN' U+00A5 + { 944, 7, 13, 11, 2, -12 }, // 0x86 'LATIN CAPITAL LETTER S WITH CARON *' U+0160 + { 956, 9, 12, 11, 1, -10 }, // 0x87 'SECTION SIGN' U+00A7 + { 970, 7, 12, 11, 2, -11 }, // 0x88 'LATIN SMALL LETTER S WITH CARON *' U+0161 + { 981, 11, 10, 11, 0, -9 }, // 0x89 'COPYRIGHT SIGN' U+00A9 + { 995, 5, 5, 11, 3, -9 }, // 0x8a 'FEMININE ORDINAL INDICATOR' U+00AA + { 999, 9, 8, 11, 1, -7 }, // 0x8b 'LEFT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00AB + { 1008, 9, 5, 11, 1, -7 }, // 0x8c 'NOT SIGN' U+00AC + { 1014, 9, 1, 11, 1, -5 }, // 0x8d 'SOFT HYPHEN' U+00AD + { 1016, 11, 10, 11, 0, -9 }, // 0x8e 'REGISTERED SIGN' U+00AE + { 1030, 5, 1, 11, 3, -10 }, // 0x8f 'MACRON' U+00AF + { 1031, 5, 5, 11, 3, -10 }, // 0x90 'DEGREE SIGN' U+00B0 + { 1035, 9, 10, 11, 1, -9 }, // 0x91 'PLUS-MINUS SIGN' U+00B1 + { 1047, 4, 6, 11, 3, -10 }, // 0x92 'SUPERSCRIPT TWO' U+00B2 + { 1050, 4, 6, 11, 3, -10 }, // 0x93 'SUPERSCRIPT THREE' U+00B3 + { 1053, 7, 14, 11, 2, -13 }, // 0x94 'LATIN CAPITAL LETTER Z WITH CARON *' U+017D + { 1066, 9, 12, 11, 1, -7 }, // 0x95 'MICRO SIGN' U+00B5 + { 1080, 8, 12, 11, 1, -10 }, // 0x96 'PILCROW SIGN' U+00B6 + { 1092, 2, 2, 11, 4, -4 }, // 0x97 'MIDDLE DOT' U+00B7 + { 1093, 7, 12, 11, 2, -11 }, // 0x98 'LATIN SMALL LETTER Z WITH CARON *' U+017E + { 1104, 4, 6, 11, 3, -10 }, // 0x99 'SUPERSCRIPT ONE' U+00B9 + { 1107, 5, 5, 11, 3, -9 }, // 0x9a 'MASCULINE ORDINAL INDICATOR' U+00BA + { 1111, 9, 8, 11, 1, -7 }, // 0x9b 'RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00BB + { 1120, 11, 10, 11, 0, -9 }, // 0x9c 'LATIN CAPITAL LIGATURE OE *' U+0152 + { 1134, 10, 8, 11, 0, -7 }, // 0x9d 'LATIN SMALL LIGATURE OE *' U+0153 + { 1144, 9, 13, 11, 1, -12 }, // 0x9e 'LATIN CAPITAL LETTER Y WITH DIAERESIS *' U+0178 + { 1159, 6, 11, 11, 2, -7 }, // 0x9f 'INVERTED QUESTION MARK' U+00BF + { 1168, 11, 14, 11, 0, -13 }, // 0xa0 'LATIN CAPITAL LETTER A WITH GRAVE' U+00C0 + { 1188, 11, 14, 11, 0, -13 }, // 0xa1 'LATIN CAPITAL LETTER A WITH ACUTE' U+00C1 + { 1208, 11, 14, 11, 0, -13 }, // 0xa2 'LATIN CAPITAL LETTER A WITH CIRCUMFLEX' U+00C2 + { 1228, 11, 13, 11, 0, -12 }, // 0xa3 'LATIN CAPITAL LETTER A WITH TILDE' U+00C3 + { 1246, 11, 13, 11, 0, -12 }, // 0xa4 'LATIN CAPITAL LETTER A WITH DIAERESIS' U+00C4 + { 1264, 11, 14, 11, 0, -13 }, // 0xa5 'LATIN CAPITAL LETTER A WITH RING ABOVE' U+00C5 + { 1284, 11, 10, 11, 0, -9 }, // 0xa6 'LATIN CAPITAL LETTER AE' U+00C6 + { 1298, 9, 13, 11, 1, -9 }, // 0xa7 'LATIN CAPITAL LETTER C WITH CEDILLA' U+00C7 + { 1313, 8, 14, 11, 1, -13 }, // 0xa8 'LATIN CAPITAL LETTER E WITH GRAVE' U+00C8 + { 1327, 8, 14, 11, 1, -13 }, // 0xa9 'LATIN CAPITAL LETTER E WITH ACUTE' U+00C9 + { 1341, 8, 14, 11, 1, -13 }, // 0xaa 'LATIN CAPITAL LETTER E WITH CIRCUMFLEX' U+00CA + { 1355, 8, 13, 11, 1, -12 }, // 0xab 'LATIN CAPITAL LETTER E WITH DIAERESIS' U+00CB + { 1368, 7, 14, 11, 2, -13 }, // 0xac 'LATIN CAPITAL LETTER I WITH GRAVE' U+00CC + { 1381, 7, 14, 11, 2, -13 }, // 0xad 'LATIN CAPITAL LETTER I WITH ACUTE' U+00CD + { 1394, 7, 14, 11, 2, -13 }, // 0xae 'LATIN CAPITAL LETTER I WITH CIRCUMFLEX' U+00CE + { 1407, 7, 13, 11, 2, -12 }, // 0xaf 'LATIN CAPITAL LETTER I WITH DIAERESIS' U+00CF + { 1419, 9, 10, 11, 0, -9 }, // 0xb0 'LATIN CAPITAL LETTER ETH' U+00D0 + { 1431, 10, 13, 11, 0, -12 }, // 0xb1 'LATIN CAPITAL LETTER N WITH TILDE' U+00D1 + { 1448, 9, 14, 11, 1, -13 }, // 0xb2 'LATIN CAPITAL LETTER O WITH GRAVE' U+00D2 + { 1464, 9, 14, 11, 1, -13 }, // 0xb3 'LATIN CAPITAL LETTER O WITH ACUTE' U+00D3 + { 1480, 9, 14, 11, 1, -13 }, // 0xb4 'LATIN CAPITAL LETTER O WITH CIRCUMFLEX' U+00D4 + { 1496, 9, 13, 11, 1, -12 }, // 0xb5 'LATIN CAPITAL LETTER O WITH TILDE' U+00D5 + { 1511, 9, 13, 11, 1, -12 }, // 0xb6 'LATIN CAPITAL LETTER O WITH DIAERESIS' U+00D6 + { 1526, 7, 6, 11, 2, -7 }, // 0xb7 'MULTIPLICATION SIGN' U+00D7 + { 1532, 9, 12, 11, 1, -10 }, // 0xb8 'LATIN CAPITAL LETTER O WITH STROKE' U+00D8 + { 1546, 9, 14, 11, 1, -13 }, // 0xb9 'LATIN CAPITAL LETTER U WITH GRAVE' U+00D9 + { 1562, 9, 14, 11, 1, -13 }, // 0xba 'LATIN CAPITAL LETTER U WITH ACUTE' U+00DA + { 1578, 9, 14, 11, 1, -13 }, // 0xbb 'LATIN CAPITAL LETTER U WITH CIRCUMFLEX' U+00DB + { 1594, 9, 13, 11, 1, -12 }, // 0xbc 'LATIN CAPITAL LETTER U WITH DIAERESIS' U+00DC + { 1609, 9, 14, 11, 1, -13 }, // 0xbd 'LATIN CAPITAL LETTER Y WITH ACUTE' U+00DD + { 1625, 8, 10, 11, 1, -9 }, // 0xbe 'LATIN CAPITAL LETTER THORN' U+00DE + { 1635, 9, 11, 11, 0, -10 }, // 0xbf 'LATIN SMALL LETTER SHARP S' U+00DF + { 1648, 9, 12, 11, 1, -11 }, // 0xc0 'LATIN SMALL LETTER A WITH GRAVE' U+00E0 + { 1662, 9, 12, 11, 1, -11 }, // 0xc1 'LATIN SMALL LETTER A WITH ACUTE' U+00E1 + { 1676, 9, 11, 11, 1, -10 }, // 0xc2 'LATIN SMALL LETTER A WITH CIRCUMFLEX' U+00E2 + { 1689, 9, 10, 11, 1, -9 }, // 0xc3 'LATIN SMALL LETTER A WITH TILDE' U+00E3 + { 1701, 9, 11, 11, 1, -10 }, // 0xc4 'LATIN SMALL LETTER A WITH DIAERESIS' U+00E4 + { 1714, 9, 12, 11, 1, -11 }, // 0xc5 'LATIN SMALL LETTER A WITH RING ABOVE' U+00E5 + { 1728, 10, 8, 11, 0, -7 }, // 0xc6 'LATIN SMALL LETTER AE' U+00E6 + { 1738, 8, 11, 11, 2, -7 }, // 0xc7 'LATIN SMALL LETTER C WITH CEDILLA' U+00E7 + { 1749, 8, 12, 11, 1, -11 }, // 0xc8 'LATIN SMALL LETTER E WITH GRAVE' U+00E8 + { 1761, 8, 12, 11, 1, -11 }, // 0xc9 'LATIN SMALL LETTER E WITH ACUTE' U+00E9 + { 1773, 8, 11, 11, 1, -10 }, // 0xca 'LATIN SMALL LETTER E WITH CIRCUMFLEX' U+00EA + { 1784, 8, 11, 11, 1, -10 }, // 0xcb 'LATIN SMALL LETTER E WITH DIAERESIS' U+00EB + { 1795, 7, 12, 11, 2, -11 }, // 0xcc 'LATIN SMALL LETTER I WITH GRAVE' U+00EC + { 1806, 7, 12, 11, 2, -11 }, // 0xcd 'LATIN SMALL LETTER I WITH ACUTE' U+00ED + { 1817, 7, 11, 11, 2, -10 }, // 0xce 'LATIN SMALL LETTER I WITH CIRCUMFLEX' U+00EE + { 1827, 7, 11, 11, 2, -10 }, // 0xcf 'LATIN SMALL LETTER I WITH DIAERESIS' U+00EF + { 1837, 9, 11, 11, 1, -10 }, // 0xd0 'LATIN SMALL LETTER ETH' U+00F0 + { 1850, 9, 10, 11, 1, -9 }, // 0xd1 'LATIN SMALL LETTER N WITH TILDE' U+00F1 + { 1862, 9, 12, 11, 1, -11 }, // 0xd2 'LATIN SMALL LETTER O WITH GRAVE' U+00F2 + { 1876, 9, 12, 11, 1, -11 }, // 0xd3 'LATIN SMALL LETTER O WITH ACUTE' U+00F3 + { 1890, 9, 11, 11, 1, -10 }, // 0xd4 'LATIN SMALL LETTER O WITH CIRCUMFLEX' U+00F4 + { 1903, 9, 10, 11, 1, -9 }, // 0xd5 'LATIN SMALL LETTER O WITH TILDE' U+00F5 + { 1915, 9, 11, 11, 1, -10 }, // 0xd6 'LATIN SMALL LETTER O WITH DIAERESIS' U+00F6 + { 1928, 9, 10, 11, 1, -9 }, // 0xd7 'DIVISION SIGN' U+00F7 + { 1940, 9, 9, 11, 1, -7 }, // 0xd8 'LATIN SMALL LETTER O WITH STROKE' U+00F8 + { 1951, 9, 12, 11, 1, -11 }, // 0xd9 'LATIN SMALL LETTER U WITH GRAVE' U+00F9 + { 1965, 9, 12, 11, 1, -11 }, // 0xda 'LATIN SMALL LETTER U WITH ACUTE' U+00FA + { 1979, 9, 11, 11, 1, -10 }, // 0xdb 'LATIN SMALL LETTER U WITH CIRCUMFLEX' U+00FB + { 1992, 9, 11, 11, 1, -10 }, // 0xdc 'LATIN SMALL LETTER U WITH DIAERESIS' U+00FC + { 2005, 9, 15, 11, 1, -11 }, // 0xdd 'LATIN SMALL LETTER Y WITH ACUTE' U+00FD + { 2022, 10, 14, 11, 0, -10 }, // 0xde 'LATIN SMALL LETTER THORN' U+00FE + { 2040, 9, 14, 11, 1, -10 } }; // 0xdf 'LATIN SMALL LETTER Y WITH DIAERESIS' U+000FF + +const GFXfont FreeMono9pt8b PROGMEM = { + (uint8_t *)FreeMono9pt8bBitmaps, + (GFXglyph *)FreeMono9pt8bGlyphs, + 0x20, 0xDF, 19 }; + +// Approx. 3407 bytes diff --git a/RX_FSK/src/fonts/FreeSans12pt7b.h b/RX_FSK/src/fonts/FreeSans12pt7b.h new file mode 100644 index 0000000..9ecbb8f --- /dev/null +++ b/RX_FSK/src/fonts/FreeSans12pt7b.h @@ -0,0 +1,270 @@ +const uint8_t FreeSans12pt7bBitmaps[] PROGMEM = { + 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xCF, 0x3C, 0xF3, 0x8A, 0x20, 0x06, 0x30, + 0x31, 0x03, 0x18, 0x18, 0xC7, 0xFF, 0xBF, 0xFC, 0x31, 0x03, 0x18, 0x18, + 0xC7, 0xFF, 0xBF, 0xFC, 0x31, 0x01, 0x18, 0x18, 0xC0, 0xC6, 0x06, 0x30, + 0x04, 0x03, 0xE1, 0xFF, 0x72, 0x6C, 0x47, 0x88, 0xF1, 0x07, 0x20, 0x7E, + 0x03, 0xF0, 0x17, 0x02, 0x3C, 0x47, 0x88, 0xF1, 0x1B, 0x26, 0x7F, 0xC3, + 0xE0, 0x10, 0x02, 0x00, 0x00, 0x06, 0x03, 0xC0, 0x40, 0x7E, 0x0C, 0x0E, + 0x70, 0x80, 0xC3, 0x18, 0x0C, 0x31, 0x00, 0xE7, 0x30, 0x07, 0xE6, 0x00, + 0x3C, 0x40, 0x00, 0x0C, 0x7C, 0x00, 0x8F, 0xE0, 0x19, 0xC7, 0x01, 0x18, + 0x30, 0x31, 0x83, 0x02, 0x1C, 0x70, 0x40, 0xFE, 0x04, 0x07, 0xC0, 0x0F, + 0x00, 0x7E, 0x03, 0x9C, 0x0C, 0x30, 0x30, 0xC0, 0xE7, 0x01, 0xF8, 0x03, + 0x80, 0x3E, 0x01, 0xCC, 0x6E, 0x19, 0xB0, 0x7C, 0xC0, 0xF3, 0x03, 0xCE, + 0x1F, 0x9F, 0xE6, 0x1E, 0x1C, 0xFF, 0xA0, 0x08, 0x8C, 0x66, 0x31, 0x98, + 0xC6, 0x31, 0x8C, 0x63, 0x08, 0x63, 0x08, 0x61, 0x0C, 0x20, 0x82, 0x18, + 0xC3, 0x18, 0xC3, 0x18, 0xC6, 0x31, 0x8C, 0x62, 0x31, 0x88, 0xC4, 0x62, + 0x00, 0x10, 0x23, 0x5B, 0xE3, 0x8D, 0x91, 0x00, 0x0C, 0x03, 0x00, 0xC0, + 0x30, 0xFF, 0xFF, 0xF0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0xF5, 0x60, + 0xFF, 0xF0, 0xF0, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x02, 0x0C, 0x10, 0x20, + 0xC1, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, + 0x6E, 0x0F, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C, + 0x0E, 0xC1, 0x9C, 0x71, 0xFC, 0x1F, 0x00, 0x08, 0xCF, 0xFF, 0x8C, 0x63, + 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0x1F, 0x0F, 0xF9, 0x87, 0x60, 0x7C, + 0x06, 0x00, 0xC0, 0x18, 0x07, 0x01, 0xC0, 0xF0, 0x78, 0x1C, 0x06, 0x00, + 0x80, 0x30, 0x07, 0xFF, 0xFF, 0xE0, 0x3F, 0x0F, 0xF3, 0x87, 0x60, 0x6C, + 0x0C, 0x01, 0x80, 0x70, 0x7C, 0x0F, 0x80, 0x18, 0x01, 0x80, 0x3C, 0x07, + 0x80, 0xD8, 0x73, 0xFC, 0x1F, 0x00, 0x01, 0x80, 0x70, 0x0E, 0x03, 0xC0, + 0xD8, 0x1B, 0x06, 0x61, 0x8C, 0x21, 0x8C, 0x33, 0x06, 0x7F, 0xFF, 0xFE, + 0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x3F, 0xCF, 0xF9, 0x80, 0x30, 0x06, + 0x00, 0xDE, 0x1F, 0xE7, 0x0E, 0x00, 0xE0, 0x0C, 0x01, 0x80, 0x30, 0x07, + 0x81, 0xF8, 0x73, 0xFC, 0x1F, 0x00, 0x0F, 0x07, 0xF9, 0xC3, 0x30, 0x74, + 0x01, 0x80, 0x33, 0xC7, 0xFE, 0xF0, 0xDC, 0x1F, 0x01, 0xE0, 0x3C, 0x06, + 0xC1, 0xDC, 0x71, 0xFC, 0x1F, 0x00, 0xFF, 0xFF, 0xFC, 0x01, 0x00, 0x60, + 0x18, 0x02, 0x00, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x30, 0x04, 0x01, 0x80, + 0x30, 0x06, 0x01, 0x80, 0x30, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x66, + 0x0C, 0xC1, 0x8C, 0x61, 0xFC, 0x3F, 0x8E, 0x3B, 0x01, 0xE0, 0x3C, 0x07, + 0x80, 0xD8, 0x31, 0xFC, 0x1F, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x6C, + 0x07, 0x80, 0xF0, 0x1E, 0x07, 0x61, 0xEF, 0xFC, 0x79, 0x80, 0x30, 0x05, + 0x81, 0x98, 0x73, 0xFC, 0x1E, 0x00, 0xF0, 0x00, 0x03, 0xC0, 0xF0, 0x00, + 0x0F, 0x56, 0x00, 0x00, 0x07, 0x01, 0xE0, 0xF8, 0x3C, 0x0F, 0x00, 0xE0, + 0x07, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x01, 0xFF, 0xFF, 0xFF, 0x00, + 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x0E, 0x00, 0x78, 0x01, 0xF0, 0x07, + 0xC0, 0x0F, 0x00, 0x70, 0x1E, 0x0F, 0x03, 0xC0, 0xF0, 0x08, 0x00, 0x1F, + 0x1F, 0xEE, 0x1B, 0x03, 0xC0, 0xC0, 0x30, 0x0C, 0x06, 0x03, 0x81, 0xC0, + 0xE0, 0x30, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0xFE, + 0x00, 0x0F, 0xFE, 0x00, 0xF0, 0x3E, 0x07, 0x00, 0x3C, 0x38, 0x00, 0x30, + 0xC1, 0xE0, 0x66, 0x0F, 0xD9, 0xD8, 0x61, 0xC3, 0xC3, 0x07, 0x0F, 0x1C, + 0x1C, 0x3C, 0x60, 0x60, 0xF1, 0x81, 0x83, 0xC6, 0x06, 0x1B, 0x18, 0x38, + 0xEE, 0x71, 0xE7, 0x18, 0xFD, 0xF8, 0x71, 0xE7, 0xC0, 0xE0, 0x00, 0x01, + 0xE0, 0x00, 0x01, 0xFF, 0xC0, 0x01, 0xFC, 0x00, 0x03, 0xC0, 0x03, 0xC0, + 0x03, 0xC0, 0x07, 0xE0, 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30, + 0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x1C, + 0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, 0x60, 0x06, 0xFF, 0xC7, 0xFF, 0x30, + 0x19, 0x80, 0x6C, 0x03, 0x60, 0x1B, 0x00, 0xD8, 0x0C, 0xFF, 0xC7, 0xFF, + 0x30, 0x0D, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x06, 0xFF, 0xF7, + 0xFE, 0x00, 0x07, 0xE0, 0x3F, 0xF0, 0xE0, 0x73, 0x80, 0x66, 0x00, 0x6C, + 0x00, 0x30, 0x00, 0x60, 0x00, 0xC0, 0x01, 0x80, 0x03, 0x00, 0x06, 0x00, + 0x06, 0x00, 0x6C, 0x00, 0xDC, 0x03, 0x1E, 0x0E, 0x1F, 0xF8, 0x0F, 0xC0, + 0xFF, 0x83, 0xFF, 0x8C, 0x07, 0x30, 0x0E, 0xC0, 0x1B, 0x00, 0x7C, 0x00, + 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x1F, 0x00, + 0x6C, 0x03, 0xB0, 0x1C, 0xFF, 0xE3, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, + 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xEF, 0xFE, 0xC0, + 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xFF, 0xDF, + 0xFB, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x00, + 0x07, 0xF0, 0x1F, 0xFC, 0x3C, 0x1E, 0x70, 0x06, 0x60, 0x03, 0xE0, 0x00, + 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x7F, 0xC0, 0x03, 0xC0, 0x03, + 0x60, 0x03, 0x60, 0x07, 0x30, 0x0F, 0x3C, 0x1F, 0x1F, 0xFB, 0x07, 0xE1, + 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, + 0x03, 0xFF, 0xFF, 0xFF, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, + 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x01, + 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60, + 0x3C, 0x1E, 0x0F, 0x07, 0xC7, 0x7F, 0x1F, 0x00, 0xC0, 0x3B, 0x01, 0xCC, + 0x0E, 0x30, 0x70, 0xC3, 0x83, 0x1C, 0x0C, 0xE0, 0x33, 0x80, 0xDE, 0x03, + 0xDC, 0x0E, 0x38, 0x30, 0x60, 0xC1, 0xC3, 0x03, 0x8C, 0x06, 0x30, 0x1C, + 0xC0, 0x3B, 0x00, 0x60, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, + 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, + 0xFF, 0xFF, 0xF0, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x0F, 0xD0, + 0x0F, 0xD8, 0x1B, 0xD8, 0x1B, 0xD8, 0x1B, 0xCC, 0x33, 0xCC, 0x33, 0xCC, + 0x33, 0xC6, 0x63, 0xC6, 0x63, 0xC6, 0x63, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC1, 0x83, 0xE0, 0x1F, 0x00, 0xFC, 0x07, 0xE0, 0x3D, 0x81, 0xEE, + 0x0F, 0x30, 0x79, 0xC3, 0xC6, 0x1E, 0x18, 0xF0, 0xE7, 0x83, 0x3C, 0x1D, + 0xE0, 0x6F, 0x01, 0xF8, 0x0F, 0xC0, 0x3E, 0x01, 0xC0, 0x03, 0xE0, 0x0F, + 0xFC, 0x0F, 0x07, 0x86, 0x00, 0xC6, 0x00, 0x33, 0x00, 0x1B, 0x00, 0x07, + 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0xF0, 0x00, 0x78, 0x00, 0x36, 0x00, + 0x33, 0x00, 0x18, 0xC0, 0x18, 0x78, 0x3C, 0x1F, 0xFC, 0x03, 0xF8, 0x00, + 0xFF, 0x8F, 0xFE, 0xC0, 0x6C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x07, + 0xFF, 0xEF, 0xFC, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, + 0xC0, 0x0C, 0x00, 0x03, 0xE0, 0x0F, 0xFC, 0x0F, 0x07, 0x86, 0x00, 0xC6, + 0x00, 0x33, 0x00, 0x1B, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00, + 0xF0, 0x00, 0x78, 0x00, 0x36, 0x00, 0x33, 0x01, 0x98, 0xC0, 0xFC, 0x78, + 0x3C, 0x1F, 0xFF, 0x03, 0xF9, 0x80, 0x00, 0x40, 0xFF, 0xC3, 0xFF, 0xCC, + 0x03, 0xB0, 0x06, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xB0, 0x0C, 0xFF, 0xE3, + 0xFF, 0xCC, 0x03, 0xB0, 0x06, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xB0, 0x06, + 0xC0, 0x1B, 0x00, 0x70, 0x0F, 0xE0, 0x7F, 0xC3, 0x83, 0x9C, 0x07, 0x60, + 0x0D, 0x80, 0x06, 0x00, 0x1E, 0x00, 0x3F, 0x80, 0x3F, 0xC0, 0x0F, 0x80, + 0x07, 0xC0, 0x0F, 0x00, 0x3E, 0x00, 0xDE, 0x0E, 0x3F, 0xF0, 0x3F, 0x80, + 0xFF, 0xFF, 0xFF, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, + 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, + 0x06, 0x00, 0x60, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, + 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, + 0xE0, 0x0F, 0x80, 0xEE, 0x0E, 0x3F, 0xE0, 0x7C, 0x00, 0x60, 0x06, 0xC0, + 0x1D, 0xC0, 0x31, 0x80, 0x63, 0x01, 0xC7, 0x03, 0x06, 0x06, 0x0C, 0x1C, + 0x1C, 0x30, 0x18, 0x60, 0x31, 0xC0, 0x73, 0x00, 0x66, 0x00, 0xDC, 0x01, + 0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x00, 0xE0, 0x30, 0x1D, 0x80, 0xE0, + 0x76, 0x07, 0x81, 0xD8, 0x1E, 0x06, 0x70, 0x7C, 0x18, 0xC1, 0xB0, 0xE3, + 0x0C, 0xC3, 0x8C, 0x33, 0x0C, 0x38, 0xC6, 0x30, 0x67, 0x18, 0xC1, 0x98, + 0x67, 0x06, 0x61, 0xD8, 0x1D, 0x83, 0x60, 0x3C, 0x0D, 0x80, 0xF0, 0x3E, + 0x03, 0xC0, 0x70, 0x0F, 0x01, 0xC0, 0x18, 0x07, 0x00, 0x70, 0x0E, 0x60, + 0x38, 0xE0, 0x60, 0xE1, 0xC0, 0xC3, 0x01, 0xCC, 0x01, 0xF8, 0x01, 0xE0, + 0x03, 0x80, 0x07, 0x80, 0x1F, 0x00, 0x33, 0x00, 0xE7, 0x03, 0x86, 0x06, + 0x0E, 0x1C, 0x0E, 0x70, 0x0C, 0xC0, 0x1C, 0x60, 0x06, 0x70, 0x0E, 0x30, + 0x1C, 0x38, 0x18, 0x1C, 0x38, 0x0C, 0x30, 0x0E, 0x70, 0x06, 0x60, 0x03, + 0xC0, 0x03, 0xC0, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, + 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xC0, 0x0E, + 0x00, 0xE0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x70, 0x07, 0x00, 0x30, 0x03, + 0x80, 0x38, 0x03, 0x80, 0x18, 0x01, 0xC0, 0x1C, 0x00, 0xFF, 0xFF, 0xFF, + 0xC0, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCF, + 0xF0, 0x81, 0x81, 0x02, 0x06, 0x04, 0x08, 0x18, 0x10, 0x20, 0x60, 0x40, + 0x81, 0x81, 0x02, 0x06, 0x04, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x3F, 0xF0, 0x0C, 0x0E, 0x05, 0x86, 0xC3, 0x21, 0x19, + 0x8C, 0x83, 0xC1, 0x80, 0xFF, 0xFE, 0xE3, 0x8C, 0x30, 0x3F, 0x07, 0xF8, + 0xE1, 0xCC, 0x0C, 0x00, 0xC0, 0x1C, 0x3F, 0xCF, 0x8C, 0xC0, 0xCC, 0x0C, + 0xE3, 0xC7, 0xEF, 0x3C, 0x70, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, + 0x0C, 0xF8, 0xDF, 0xCF, 0x0E, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, + 0x3C, 0x03, 0xE0, 0x6F, 0x0E, 0xDF, 0xCC, 0xF8, 0x1F, 0x0F, 0xE7, 0x1B, + 0x83, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x38, 0x37, 0x1C, 0xFE, 0x1F, + 0x00, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x3C, 0xCF, 0xFB, 0x8F, + 0xE0, 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF8, 0x3B, 0x8F, 0x3F, + 0x63, 0xCC, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x3C, 0x07, 0xFF, 0xFF, 0xFE, + 0x00, 0xC0, 0x1C, 0x0D, 0xC3, 0x1F, 0xE1, 0xF0, 0x3B, 0xD8, 0xC6, 0x7F, + 0xEC, 0x63, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x00, 0x1E, 0x67, 0xFD, 0xC7, + 0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D, 0xC7, 0x9F, + 0xB1, 0xE6, 0x00, 0xC0, 0x3E, 0x0E, 0x7F, 0xC7, 0xE0, 0xC0, 0x30, 0x0C, + 0x03, 0x00, 0xC0, 0x33, 0xCD, 0xFB, 0xC7, 0xE0, 0xF0, 0x3C, 0x0F, 0x03, + 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x30, 0xF0, 0x3F, 0xFF, 0xFF, + 0xF0, 0x33, 0x00, 0x03, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, + 0xE0, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, 0x01, 0x83, 0x30, 0xC6, 0x30, + 0xCC, 0x1B, 0x83, 0xF0, 0x77, 0x0C, 0x61, 0x8E, 0x30, 0xE6, 0x0C, 0xC1, + 0xD8, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xCF, 0x1F, 0x6F, 0xDF, 0xFC, + 0x78, 0xFC, 0x18, 0x3C, 0x0C, 0x1E, 0x06, 0x0F, 0x03, 0x07, 0x81, 0x83, + 0xC0, 0xC1, 0xE0, 0x60, 0xF0, 0x30, 0x78, 0x18, 0x3C, 0x0C, 0x18, 0xCF, + 0x37, 0xEF, 0x1F, 0x83, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, + 0x0F, 0x03, 0xC0, 0xC0, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x7C, 0x07, 0x80, + 0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D, 0xC7, 0x1F, 0xC1, 0xF0, 0xCF, 0x8D, + 0xFC, 0xF0, 0xEE, 0x06, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3E, + 0x07, 0xF0, 0xEF, 0xFC, 0xCF, 0x8C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x00, + 0x1E, 0x67, 0xFD, 0xC7, 0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, + 0x7C, 0x1D, 0xC7, 0x9F, 0xF1, 0xE6, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60, + 0xCF, 0x7F, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x3E, 0x1F, + 0xEE, 0x1B, 0x00, 0xC0, 0x3C, 0x07, 0xF0, 0x3E, 0x01, 0xF0, 0x3E, 0x1D, + 0xFE, 0x3E, 0x00, 0x63, 0x19, 0xFF, 0xB1, 0x8C, 0x63, 0x18, 0xC6, 0x31, + 0xE7, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, + 0xF0, 0x7E, 0x3D, 0xFB, 0x3C, 0xC0, 0xE0, 0x66, 0x06, 0x60, 0x67, 0x0C, + 0x30, 0xC3, 0x0C, 0x39, 0x81, 0x98, 0x19, 0x81, 0xF0, 0x0F, 0x00, 0xE0, + 0x0E, 0x00, 0xC1, 0xC1, 0xB0, 0xE1, 0xD8, 0x70, 0xCC, 0x2C, 0x66, 0x36, + 0x31, 0x9B, 0x18, 0xCD, 0x98, 0x64, 0x6C, 0x16, 0x36, 0x0F, 0x1A, 0x07, + 0x8F, 0x03, 0x83, 0x80, 0xC1, 0xC0, 0x60, 0xEE, 0x18, 0xC6, 0x0C, 0xC1, + 0xF0, 0x1C, 0x01, 0x80, 0x78, 0x1B, 0x03, 0x30, 0xC7, 0x30, 0x66, 0x06, + 0xE0, 0x6C, 0x0D, 0x83, 0x38, 0x63, 0x0C, 0x63, 0x0E, 0x60, 0xCC, 0x1B, + 0x03, 0x60, 0x3C, 0x07, 0x00, 0xE0, 0x18, 0x03, 0x00, 0xE0, 0x78, 0x0E, + 0x00, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0x03, 0x81, 0xC0, 0x60, 0x30, + 0x18, 0x0E, 0x03, 0xFF, 0xFF, 0xC0, 0x19, 0xCC, 0x63, 0x18, 0xC6, 0x31, + 0x99, 0x86, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x1C, 0x60, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFC, 0xC7, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x0C, 0x33, 0x31, + 0x8C, 0x63, 0x18, 0xC6, 0x73, 0x00, 0x70, 0x3E, 0x09, 0xE4, 0x1F, 0x03, + 0x80 }; + +const GFXglyph FreeSans12pt7bGlyphs[] PROGMEM = { + { 0, 0, 0, 6, 0, 1 }, // 0x20 ' ' + { 0, 2, 18, 8, 3, -17 }, // 0x21 '!' + { 5, 6, 6, 8, 1, -16 }, // 0x22 '"' + { 10, 13, 16, 13, 0, -15 }, // 0x23 '#' + { 36, 11, 20, 13, 1, -17 }, // 0x24 '$' + { 64, 20, 17, 21, 1, -16 }, // 0x25 '%' + { 107, 14, 17, 16, 1, -16 }, // 0x26 '&' + { 137, 2, 6, 5, 1, -16 }, // 0x27 ''' + { 139, 5, 23, 8, 2, -17 }, // 0x28 '(' + { 154, 5, 23, 8, 1, -17 }, // 0x29 ')' + { 169, 7, 7, 9, 1, -17 }, // 0x2A '*' + { 176, 10, 11, 14, 2, -10 }, // 0x2B '+' + { 190, 2, 6, 7, 2, -1 }, // 0x2C ',' + { 192, 6, 2, 8, 1, -7 }, // 0x2D '-' + { 194, 2, 2, 6, 2, -1 }, // 0x2E '.' + { 195, 7, 18, 7, 0, -17 }, // 0x2F '/' + { 211, 11, 17, 13, 1, -16 }, // 0x30 '0' + { 235, 5, 17, 13, 3, -16 }, // 0x31 '1' + { 246, 11, 17, 13, 1, -16 }, // 0x32 '2' + { 270, 11, 17, 13, 1, -16 }, // 0x33 '3' + { 294, 11, 17, 13, 1, -16 }, // 0x34 '4' + { 318, 11, 17, 13, 1, -16 }, // 0x35 '5' + { 342, 11, 17, 13, 1, -16 }, // 0x36 '6' + { 366, 11, 17, 13, 1, -16 }, // 0x37 '7' + { 390, 11, 17, 13, 1, -16 }, // 0x38 '8' + { 414, 11, 17, 13, 1, -16 }, // 0x39 '9' + { 438, 2, 13, 6, 2, -12 }, // 0x3A ':' + { 442, 2, 16, 6, 2, -11 }, // 0x3B ';' + { 446, 12, 12, 14, 1, -11 }, // 0x3C '<' + { 464, 12, 6, 14, 1, -8 }, // 0x3D '=' + { 473, 12, 12, 14, 1, -11 }, // 0x3E '>' + { 491, 10, 18, 13, 2, -17 }, // 0x3F '?' + { 514, 22, 21, 24, 1, -17 }, // 0x40 '@' + { 572, 16, 18, 16, 0, -17 }, // 0x41 'A' + { 608, 13, 18, 16, 2, -17 }, // 0x42 'B' + { 638, 15, 18, 17, 1, -17 }, // 0x43 'C' + { 672, 14, 18, 17, 2, -17 }, // 0x44 'D' + { 704, 12, 18, 15, 2, -17 }, // 0x45 'E' + { 731, 11, 18, 14, 2, -17 }, // 0x46 'F' + { 756, 16, 18, 18, 1, -17 }, // 0x47 'G' + { 792, 13, 18, 17, 2, -17 }, // 0x48 'H' + { 822, 2, 18, 7, 2, -17 }, // 0x49 'I' + { 827, 9, 18, 13, 1, -17 }, // 0x4A 'J' + { 848, 14, 18, 16, 2, -17 }, // 0x4B 'K' + { 880, 10, 18, 14, 2, -17 }, // 0x4C 'L' + { 903, 16, 18, 20, 2, -17 }, // 0x4D 'M' + { 939, 13, 18, 18, 2, -17 }, // 0x4E 'N' + { 969, 17, 18, 19, 1, -17 }, // 0x4F 'O' + { 1008, 12, 18, 16, 2, -17 }, // 0x50 'P' + { 1035, 17, 19, 19, 1, -17 }, // 0x51 'Q' + { 1076, 14, 18, 17, 2, -17 }, // 0x52 'R' + { 1108, 14, 18, 16, 1, -17 }, // 0x53 'S' + { 1140, 12, 18, 15, 1, -17 }, // 0x54 'T' + { 1167, 13, 18, 17, 2, -17 }, // 0x55 'U' + { 1197, 15, 18, 15, 0, -17 }, // 0x56 'V' + { 1231, 22, 18, 22, 0, -17 }, // 0x57 'W' + { 1281, 15, 18, 16, 0, -17 }, // 0x58 'X' + { 1315, 16, 18, 16, 0, -17 }, // 0x59 'Y' + { 1351, 13, 18, 15, 1, -17 }, // 0x5A 'Z' + { 1381, 4, 23, 7, 2, -17 }, // 0x5B '[' + { 1393, 7, 18, 7, 0, -17 }, // 0x5C '\' + { 1409, 4, 23, 7, 1, -17 }, // 0x5D ']' + { 1421, 9, 9, 11, 1, -16 }, // 0x5E '^' + { 1432, 15, 1, 13, -1, 4 }, // 0x5F '_' + { 1434, 5, 4, 6, 1, -17 }, // 0x60 '`' + { 1437, 12, 13, 13, 1, -12 }, // 0x61 'a' + { 1457, 12, 18, 13, 1, -17 }, // 0x62 'b' + { 1484, 10, 13, 12, 1, -12 }, // 0x63 'c' + { 1501, 11, 18, 13, 1, -17 }, // 0x64 'd' + { 1526, 11, 13, 13, 1, -12 }, // 0x65 'e' + { 1544, 5, 18, 7, 1, -17 }, // 0x66 'f' + { 1556, 11, 18, 13, 1, -12 }, // 0x67 'g' + { 1581, 10, 18, 13, 1, -17 }, // 0x68 'h' + { 1604, 2, 18, 5, 2, -17 }, // 0x69 'i' + { 1609, 4, 23, 6, 0, -17 }, // 0x6A 'j' + { 1621, 11, 18, 12, 1, -17 }, // 0x6B 'k' + { 1646, 2, 18, 5, 1, -17 }, // 0x6C 'l' + { 1651, 17, 13, 19, 1, -12 }, // 0x6D 'm' + { 1679, 10, 13, 13, 1, -12 }, // 0x6E 'n' + { 1696, 11, 13, 13, 1, -12 }, // 0x6F 'o' + { 1714, 12, 17, 13, 1, -12 }, // 0x70 'p' + { 1740, 11, 17, 13, 1, -12 }, // 0x71 'q' + { 1764, 6, 13, 8, 1, -12 }, // 0x72 'r' + { 1774, 10, 13, 12, 1, -12 }, // 0x73 's' + { 1791, 5, 16, 7, 1, -15 }, // 0x74 't' + { 1801, 10, 13, 13, 1, -12 }, // 0x75 'u' + { 1818, 12, 13, 12, 0, -12 }, // 0x76 'v' + { 1838, 17, 13, 17, 0, -12 }, // 0x77 'w' + { 1866, 11, 13, 11, 0, -12 }, // 0x78 'x' + { 1884, 11, 18, 11, 0, -12 }, // 0x79 'y' + { 1909, 10, 13, 12, 1, -12 }, // 0x7A 'z' + { 1926, 5, 23, 8, 1, -17 }, // 0x7B '{' + { 1941, 2, 23, 6, 2, -17 }, // 0x7C '|' + { 1947, 5, 23, 8, 2, -17 }, // 0x7D '}' + { 1962, 10, 5, 12, 1, -10 } }; // 0x7E '~' + +const GFXfont FreeSans12pt7b PROGMEM = { + (uint8_t *)FreeSans12pt7bBitmaps, + (GFXglyph *)FreeSans12pt7bGlyphs, + 0x20, 0x7E, 29 }; + +// Approx. 2641 bytes diff --git a/RX_FSK/src/fonts/FreeSans12pt8b.h b/RX_FSK/src/fonts/FreeSans12pt8b.h new file mode 100644 index 0000000..4411f8c --- /dev/null +++ b/RX_FSK/src/fonts/FreeSans12pt8b.h @@ -0,0 +1,596 @@ +const uint8_t FreeSans12pt8bBitmaps[] PROGMEM = { + 0x00, 0xFF, 0xFF, 0xFF, 0xF3, 0xF0, 0xCF, 0x3C, 0xF3, 0x4D, 0x10, 0x06, + 0x30, 0x31, 0x01, 0x18, 0x18, 0xC0, 0xC6, 0x3F, 0xFD, 0xFF, 0xE1, 0x98, + 0x18, 0xC0, 0xC6, 0x06, 0x31, 0xFF, 0xE1, 0x88, 0x08, 0xC0, 0xC6, 0x06, + 0x30, 0x31, 0x80, 0x04, 0x03, 0xF1, 0xFF, 0x32, 0x7C, 0x47, 0x88, 0xF1, + 0x07, 0x20, 0x7C, 0x07, 0xF0, 0x1F, 0x02, 0x70, 0x47, 0x88, 0xF1, 0x1E, + 0x23, 0x64, 0xE7, 0xF8, 0x10, 0x02, 0x00, 0x40, 0x00, 0x06, 0x07, 0xC0, + 0x40, 0xE6, 0x0C, 0x0C, 0x30, 0x80, 0x83, 0x18, 0x0C, 0x31, 0x00, 0xC6, + 0x30, 0x07, 0xE2, 0x00, 0x38, 0x60, 0x00, 0x0C, 0x38, 0x00, 0xC7, 0xC0, + 0x18, 0xC6, 0x01, 0x18, 0x30, 0x31, 0x83, 0x02, 0x08, 0x20, 0x60, 0xC6, + 0x04, 0x07, 0xC0, 0x0F, 0x00, 0x7E, 0x03, 0x8C, 0x0C, 0x30, 0x30, 0xC0, + 0x67, 0x01, 0xF8, 0x03, 0xC0, 0x1E, 0x00, 0xCC, 0x66, 0x39, 0xB0, 0x7C, + 0xC0, 0xF3, 0x01, 0x8E, 0x0F, 0x1C, 0xFE, 0x3F, 0x9C, 0x10, 0x00, 0xFF, + 0x50, 0x08, 0x8C, 0x46, 0x31, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0xC2, + 0x18, 0x43, 0x08, 0x60, 0x86, 0x18, 0xC3, 0x18, 0x43, 0x18, 0xC6, 0x31, + 0x8C, 0x63, 0x11, 0x8C, 0x46, 0x23, 0x00, 0x10, 0x22, 0x4F, 0xF3, 0x85, + 0x1B, 0x00, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x0F, 0xFF, 0x06, + 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0xFF, 0x97, 0xA0, 0xFC, 0xFF, + 0x80, 0x06, 0x0C, 0x10, 0x20, 0xC1, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x02, + 0x0C, 0x10, 0x20, 0xC1, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x6E, 0x0F, + 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3E, 0x06, 0xC1, + 0xD8, 0x31, 0xCE, 0x3F, 0x80, 0x80, 0x04, 0x30, 0xFF, 0xFC, 0x30, 0xC3, + 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x1F, 0x07, 0xF9, 0xC3, 0xB0, + 0x3C, 0x07, 0x80, 0xC0, 0x18, 0x07, 0x01, 0xC0, 0xF0, 0x78, 0x1C, 0x07, + 0x01, 0xC0, 0x30, 0x07, 0xFF, 0xFF, 0xE0, 0x1F, 0x0F, 0xF9, 0x83, 0x70, + 0x7C, 0x0E, 0x01, 0xC0, 0x30, 0x7C, 0x0F, 0x80, 0x38, 0x01, 0x80, 0x3C, + 0x07, 0x80, 0xF8, 0x3B, 0x8E, 0x3F, 0x80, 0x80, 0x01, 0x80, 0x70, 0x0E, + 0x03, 0xC0, 0xD8, 0x33, 0x06, 0x61, 0x8C, 0x61, 0x8C, 0x33, 0x06, 0x7F, + 0xFF, 0xFE, 0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x3F, 0xCF, 0xF9, 0x80, + 0x30, 0x06, 0x00, 0xC0, 0x1F, 0xE3, 0xFE, 0xE0, 0xE0, 0x0C, 0x01, 0x80, + 0x30, 0x07, 0x80, 0xF8, 0x3B, 0x8E, 0x3F, 0x80, 0x80, 0x0F, 0x07, 0xF9, + 0xC3, 0x30, 0x36, 0x01, 0x80, 0x30, 0x86, 0xFC, 0xF9, 0xDC, 0x1F, 0x81, + 0xE0, 0x3C, 0x06, 0xC0, 0xD8, 0x3B, 0xCE, 0x3F, 0x80, 0x80, 0xFF, 0xFF, + 0xFC, 0x01, 0x80, 0x60, 0x0C, 0x03, 0x00, 0xC0, 0x18, 0x06, 0x00, 0xC0, + 0x30, 0x06, 0x00, 0xC0, 0x30, 0x06, 0x00, 0xC0, 0x38, 0x00, 0x1F, 0x07, + 0xF9, 0xC3, 0x30, 0x7E, 0x06, 0xC1, 0xD8, 0x31, 0xFC, 0x3F, 0x8E, 0x1B, + 0x81, 0xE0, 0x3C, 0x07, 0x80, 0xF8, 0x3B, 0x8E, 0x3F, 0x80, 0x80, 0x1F, + 0x07, 0xF1, 0x87, 0x70, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x07, 0x60, 0xEF, + 0xFC, 0x7D, 0x80, 0x30, 0x07, 0x81, 0x98, 0x33, 0x9C, 0x3F, 0x00, 0x80, + 0xFC, 0x00, 0x0F, 0xC0, 0xFC, 0x00, 0x0F, 0xD7, 0x00, 0x00, 0x30, 0x1F, + 0x07, 0x81, 0xE0, 0xF8, 0x0E, 0x00, 0x78, 0x01, 0xE0, 0x07, 0xC0, 0x0F, + 0x00, 0x30, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xF0, 0xC0, 0x0F, + 0x80, 0x1E, 0x00, 0x78, 0x01, 0xF0, 0x03, 0x01, 0xE0, 0x78, 0x3E, 0x0F, + 0x00, 0xC0, 0x00, 0x1E, 0x1F, 0xE6, 0x1F, 0x03, 0xC0, 0xF0, 0x30, 0x0C, + 0x06, 0x03, 0x01, 0x80, 0xC0, 0x30, 0x0C, 0x00, 0x00, 0x00, 0x30, 0x0C, + 0x03, 0x00, 0x00, 0x7C, 0x00, 0x0F, 0xFE, 0x00, 0x70, 0x3C, 0x07, 0x00, + 0x38, 0x38, 0x00, 0x70, 0xC0, 0x40, 0xE6, 0x0F, 0xD9, 0x98, 0x71, 0xC7, + 0xC3, 0x87, 0x0F, 0x0C, 0x0C, 0x3C, 0x30, 0x70, 0xF1, 0xC1, 0x86, 0xC7, + 0x06, 0x1B, 0x1C, 0x38, 0xEC, 0x39, 0xE7, 0x18, 0x7D, 0xF8, 0x70, 0x01, + 0x00, 0xE0, 0x00, 0x01, 0xC0, 0x00, 0x03, 0xF3, 0xC0, 0x03, 0xFF, 0x00, + 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xE0, 0x06, 0x60, 0x06, 0x60, + 0x0E, 0x70, 0x0C, 0x30, 0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, + 0x3F, 0xFC, 0x30, 0x0C, 0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, 0x60, 0x07, + 0xFE, 0x07, 0xFF, 0x30, 0x79, 0x80, 0xEC, 0x03, 0x60, 0x1B, 0x00, 0xD8, + 0x0C, 0xFF, 0xC7, 0xFF, 0x30, 0x1D, 0x80, 0x7C, 0x01, 0xE0, 0x0F, 0x00, + 0xF8, 0x0E, 0xFF, 0xF7, 0xFE, 0x00, 0x03, 0xC0, 0x1F, 0xF0, 0xF0, 0xE1, + 0x80, 0xE7, 0x00, 0xEC, 0x01, 0xF8, 0x00, 0x70, 0x00, 0xC0, 0x01, 0x80, + 0x03, 0x00, 0x07, 0x00, 0x06, 0x00, 0x6C, 0x01, 0xDC, 0x03, 0x9C, 0x0E, + 0x1F, 0x78, 0x1F, 0xE0, 0x04, 0x00, 0xFE, 0x03, 0xFF, 0x8C, 0x1F, 0x30, + 0x0E, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, + 0x00, 0xF0, 0x03, 0xC0, 0x1F, 0x00, 0x6C, 0x03, 0xB0, 0x1C, 0xFF, 0xE3, + 0xFF, 0x00, 0xFF, 0xF7, 0xFF, 0xB0, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x03, + 0x00, 0x18, 0x00, 0xFF, 0xF7, 0xFF, 0xB0, 0x01, 0x80, 0x0C, 0x00, 0x60, + 0x03, 0x00, 0x18, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xFF, 0xFF, 0xC0, + 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xEF, 0xFE, 0xC0, + 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0x03, + 0xE0, 0x0F, 0xF8, 0x1E, 0x3C, 0x38, 0x0E, 0x70, 0x06, 0x60, 0x07, 0xE0, + 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x7F, 0xE0, 0x03, 0xE0, + 0x03, 0x60, 0x03, 0x70, 0x07, 0x38, 0x0F, 0x1F, 0x7B, 0x0F, 0xF3, 0x00, + 0x80, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, + 0x78, 0x03, 0xFF, 0xFF, 0xFF, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, + 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFC, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, + 0x00, 0xC0, 0x30, 0x0C, 0x03, 0xE0, 0xF8, 0x3E, 0x0D, 0x87, 0x73, 0x8F, + 0xE0, 0x40, 0xC0, 0x1F, 0x00, 0xEC, 0x07, 0x30, 0x38, 0xC1, 0xC3, 0x0E, + 0x0C, 0x70, 0x33, 0x80, 0xDE, 0x03, 0xFC, 0x0F, 0x38, 0x38, 0x60, 0xC1, + 0xC3, 0x03, 0x8C, 0x06, 0x30, 0x1C, 0xC0, 0x3B, 0x00, 0x60, 0xC0, 0x18, + 0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x03, + 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xFF, 0xFF, 0xFC, 0xE0, + 0x07, 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xD8, 0x1B, 0xD8, + 0x1B, 0xD8, 0x1B, 0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x33, 0xC6, 0x63, 0xC6, + 0x63, 0xC6, 0x63, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC1, 0x83, 0xC0, + 0x1F, 0x80, 0x7F, 0x01, 0xFC, 0x07, 0xF8, 0x1F, 0x60, 0x7C, 0xC1, 0xF3, + 0x87, 0xC6, 0x1F, 0x0C, 0x7C, 0x39, 0xF0, 0x67, 0xC1, 0xDF, 0x03, 0xFC, + 0x07, 0xF0, 0x1F, 0xC0, 0x3F, 0x00, 0x70, 0x03, 0xE0, 0x07, 0xFC, 0x0F, + 0x8F, 0x07, 0x01, 0xC7, 0x00, 0x73, 0x00, 0x1B, 0x80, 0x0D, 0x80, 0x07, + 0xC0, 0x01, 0xE0, 0x00, 0xF0, 0x00, 0x78, 0x00, 0x7E, 0x00, 0x33, 0x00, + 0x19, 0xC0, 0x1C, 0x70, 0x1C, 0x1F, 0x7C, 0x07, 0xFC, 0x00, 0x20, 0x00, + 0xFE, 0x07, 0xFF, 0x30, 0x7D, 0x80, 0x6C, 0x03, 0xE0, 0x1F, 0x00, 0xF8, + 0x07, 0xC0, 0xF7, 0xFF, 0x3F, 0xC1, 0x80, 0x0C, 0x00, 0x60, 0x03, 0x00, + 0x18, 0x00, 0xC0, 0x06, 0x00, 0x00, 0x03, 0xE0, 0x07, 0xFC, 0x0F, 0x8F, + 0x07, 0x01, 0xC7, 0x00, 0x73, 0x00, 0x1B, 0x80, 0x0D, 0x80, 0x07, 0xC0, + 0x01, 0xE0, 0x00, 0xF0, 0x00, 0xF8, 0x00, 0x7E, 0x00, 0x33, 0x01, 0x19, + 0xC0, 0xDC, 0x70, 0x3C, 0x1F, 0x7E, 0x07, 0xFF, 0x80, 0x20, 0xC0, 0xFF, + 0x03, 0xFF, 0xCC, 0x0F, 0xB0, 0x06, 0xC0, 0x1F, 0x00, 0x7C, 0x01, 0xB0, + 0x06, 0xC0, 0xF3, 0xFF, 0x8C, 0x0F, 0x30, 0x06, 0xC0, 0x1B, 0x00, 0x6C, + 0x01, 0xB0, 0x06, 0xC0, 0x1F, 0x00, 0x70, 0x07, 0x80, 0xFF, 0x87, 0x87, + 0x18, 0x0E, 0x60, 0x19, 0x80, 0x66, 0x00, 0x1E, 0x00, 0x3F, 0x80, 0x3F, + 0xC0, 0x0F, 0x80, 0x07, 0xC0, 0x1F, 0x00, 0x3E, 0x01, 0xDC, 0x06, 0x7E, + 0xF8, 0x7F, 0x80, 0x20, 0x00, 0xFF, 0xFF, 0xFF, 0xF0, 0x38, 0x00, 0xE0, + 0x03, 0x80, 0x0E, 0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x0E, 0x00, 0x38, + 0x00, 0xE0, 0x03, 0x80, 0x0E, 0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x0E, + 0x00, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, + 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, + 0x80, 0x6C, 0x07, 0x7D, 0xF1, 0xFF, 0x00, 0x80, 0xC0, 0x0F, 0x00, 0x3E, + 0x01, 0xD8, 0x06, 0x70, 0x18, 0xC0, 0xE3, 0x03, 0x0E, 0x0C, 0x18, 0x70, + 0x61, 0x81, 0xC6, 0x03, 0x38, 0x0C, 0xC0, 0x3B, 0x00, 0x6C, 0x01, 0xE0, + 0x07, 0x80, 0x0E, 0x00, 0xC0, 0x70, 0x1E, 0x03, 0x80, 0xF0, 0x1C, 0x0F, + 0xC1, 0xE0, 0x76, 0x0D, 0x83, 0x30, 0x6C, 0x19, 0x83, 0x61, 0xCE, 0x33, + 0x8E, 0x31, 0x8C, 0x61, 0x8C, 0x63, 0x0C, 0xE3, 0x18, 0x76, 0x0D, 0xC1, + 0xB0, 0x6C, 0x0D, 0x83, 0x60, 0x78, 0x1F, 0x03, 0xC0, 0x78, 0x0E, 0x03, + 0x80, 0x70, 0x1C, 0x00, 0xE0, 0x0C, 0xC0, 0x39, 0xC0, 0xE1, 0xC1, 0x81, + 0x87, 0x03, 0x9C, 0x03, 0xB0, 0x03, 0xC0, 0x07, 0x80, 0x0F, 0x00, 0x1E, + 0x00, 0x76, 0x01, 0xCE, 0x03, 0x0C, 0x0E, 0x0C, 0x38, 0x1C, 0x60, 0x1D, + 0xC0, 0x38, 0xE0, 0x07, 0x70, 0x06, 0x30, 0x0E, 0x38, 0x1C, 0x18, 0x18, + 0x1C, 0x38, 0x0E, 0x30, 0x06, 0x70, 0x07, 0x60, 0x03, 0xC0, 0x01, 0xC0, + 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, + 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xC0, 0x0E, 0x00, 0xE0, 0x06, 0x00, 0x70, + 0x07, 0x00, 0x70, 0x07, 0x00, 0x38, 0x03, 0x80, 0x38, 0x03, 0x80, 0x18, + 0x01, 0xC0, 0x1C, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCF, 0xF0, 0x81, 0x03, 0x02, 0x04, + 0x0C, 0x08, 0x10, 0x30, 0x20, 0x40, 0xC0, 0x81, 0x03, 0x02, 0x04, 0x0C, + 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0xF0, + 0x0C, 0x0E, 0x05, 0x86, 0xC3, 0x21, 0x19, 0x8C, 0x83, 0xC1, 0x80, 0xFF, + 0xFE, 0xC3, 0x0C, 0x20, 0x1F, 0x07, 0xFC, 0x60, 0xC6, 0x0C, 0x00, 0xC0, + 0x1C, 0x3F, 0xC7, 0x8C, 0xE0, 0xCC, 0x0C, 0xC0, 0xCE, 0x3E, 0x7E, 0x70, + 0x02, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0xF0, 0xDF, 0xCF, + 0x0E, 0xE0, 0x6E, 0x06, 0xC0, 0x6C, 0x07, 0xC0, 0x7C, 0x06, 0xE0, 0x6E, + 0x0E, 0xF9, 0xCD, 0xF8, 0x00, 0x00, 0x1F, 0x0F, 0xE6, 0x1F, 0x83, 0xC0, + 0xF0, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x3E, 0x0D, 0xC7, 0x3F, 0x81, 0x00, + 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x3C, 0xDF, 0xDB, 0x8F, 0xE0, + 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x3F, 0x07, 0x7B, 0xE7, + 0xEC, 0x10, 0x00, 0x0F, 0x07, 0xF9, 0xC3, 0x30, 0x3C, 0x07, 0x80, 0xFF, + 0xFE, 0x00, 0xC0, 0x18, 0x0D, 0x83, 0xBC, 0xE3, 0xF8, 0x08, 0x00, 0x04, + 0x73, 0x0C, 0x33, 0xFF, 0xCC, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, + 0xC0, 0x1E, 0x67, 0xED, 0x87, 0xF0, 0x7C, 0x0F, 0x80, 0xF0, 0x1E, 0x03, + 0xC0, 0x78, 0x1F, 0x83, 0xB9, 0xF3, 0xF6, 0x00, 0xF0, 0x37, 0x06, 0x7F, + 0xC7, 0xE0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x33, 0xCF, 0xFB, 0x87, + 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, + 0x30, 0xFC, 0x3F, 0xFF, 0xFF, 0xF0, 0x33, 0x30, 0x03, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0x3F, 0xE0, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, + 0x01, 0x81, 0xB0, 0x66, 0x18, 0xC6, 0x19, 0x83, 0x70, 0x7B, 0x0E, 0x71, + 0x86, 0x30, 0xE6, 0x0C, 0xC0, 0xD8, 0x1C, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, + 0xDE, 0x1E, 0xFF, 0x7F, 0xE3, 0xC3, 0xC1, 0x83, 0xC1, 0x83, 0xC1, 0x83, + 0xC1, 0x83, 0xC1, 0x83, 0xC1, 0x83, 0xC1, 0x83, 0xC1, 0x83, 0xC1, 0x83, + 0xC1, 0x83, 0xCF, 0x3F, 0xEE, 0x1F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, + 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xC0, 0x1F, 0x07, 0xF1, 0xC7, 0x70, + 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0D, 0x83, 0xBD, 0xE3, + 0xF8, 0x08, 0x00, 0xCF, 0x0D, 0xFC, 0xF0, 0xCE, 0x06, 0xE0, 0x6C, 0x06, + 0xC0, 0x7C, 0x07, 0xC0, 0x6E, 0x06, 0xE0, 0xEF, 0x9C, 0xDF, 0x8C, 0x00, + 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0x1E, 0x6F, 0xFD, 0xC7, 0xF0, 0x7C, + 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x1F, 0x83, 0xBD, 0xF3, 0xF6, + 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, 0xDF, 0xFF, 0x30, 0xC3, 0x0C, + 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x1E, 0x1F, 0xEE, 0x1B, 0x06, 0xC0, 0x3C, + 0x07, 0xF0, 0x3E, 0x01, 0xF0, 0x3C, 0x0F, 0xCE, 0x7F, 0x82, 0x00, 0x30, + 0xC3, 0x3F, 0xFC, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0F, 0x08, + 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC1, 0xF0, + 0x7C, 0x1F, 0x8F, 0x7E, 0xC4, 0x00, 0xE0, 0x76, 0x06, 0x60, 0x67, 0x0C, + 0x30, 0xC3, 0x0C, 0x39, 0x81, 0x98, 0x19, 0x81, 0xB0, 0x0F, 0x00, 0xE0, + 0x0E, 0x00, 0xC1, 0xC1, 0xF0, 0xE1, 0xD8, 0x70, 0xCC, 0x2C, 0x66, 0x36, + 0x31, 0x9B, 0x38, 0xCD, 0x98, 0x64, 0x6C, 0x36, 0x36, 0x0F, 0x1E, 0x07, + 0x8F, 0x03, 0x83, 0x80, 0xC1, 0x80, 0x60, 0x6E, 0x1C, 0xC3, 0x0C, 0xC1, + 0xF0, 0x1E, 0x01, 0x80, 0x78, 0x0F, 0x03, 0x30, 0xC7, 0x38, 0x66, 0x06, + 0x60, 0x6C, 0x0D, 0x81, 0x98, 0x63, 0x0C, 0x63, 0x86, 0x60, 0xCC, 0x1B, + 0x81, 0xE0, 0x3C, 0x07, 0x00, 0x60, 0x0C, 0x03, 0x00, 0x60, 0x78, 0x0F, + 0x00, 0xFF, 0xFF, 0xF0, 0x18, 0x0E, 0x07, 0x03, 0x80, 0xC0, 0x60, 0x30, + 0x1C, 0x0E, 0x03, 0xFF, 0xFF, 0xC0, 0x04, 0xF3, 0x0C, 0x30, 0xC3, 0x0C, + 0x30, 0xC6, 0x30, 0xE1, 0x83, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xE1, 0xC0, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x87, 0x18, 0x42, 0x10, 0x84, 0x21, + 0x8C, 0x31, 0x98, 0xC4, 0x21, 0x08, 0x42, 0x73, 0x80, 0x00, 0x3E, 0x1D, + 0xC6, 0x1F, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xF0, 0x07, 0x80, 0x3C, 0x01, + 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, + 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0xFC, + 0xFF, 0xFF, 0xFF, 0xF0, 0x04, 0x00, 0x80, 0x3C, 0x1F, 0xE7, 0x4E, 0xC8, + 0xD9, 0x1E, 0x20, 0xC4, 0x18, 0x83, 0x10, 0x32, 0x36, 0x46, 0x7B, 0x87, + 0xE0, 0x30, 0x04, 0x00, 0x80, 0x00, 0x01, 0xF8, 0x79, 0xC6, 0x0E, 0xE0, + 0x6E, 0x06, 0xE0, 0x06, 0x00, 0x70, 0x0F, 0xF0, 0x38, 0x01, 0x80, 0x18, + 0x01, 0x00, 0x30, 0x06, 0x00, 0xFF, 0xEE, 0xFF, 0x00, 0x80, 0x01, 0xF0, + 0x1F, 0xF0, 0xE0, 0x87, 0x00, 0x18, 0x00, 0xC0, 0x0F, 0xFF, 0x3F, 0xFC, + 0x30, 0x03, 0xFF, 0x8F, 0xFC, 0x0C, 0x00, 0x38, 0x00, 0x60, 0x01, 0xC0, + 0x03, 0xC6, 0x07, 0xF8, 0x00, 0x00, 0x60, 0x1B, 0x01, 0x8C, 0x0C, 0x60, + 0xC1, 0x86, 0x0C, 0x60, 0x36, 0x00, 0xF0, 0x07, 0xF1, 0xFF, 0x80, 0xC0, + 0x06, 0x03, 0xFF, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x03, 0x00, 0x0C, 0xC0, + 0x16, 0x00, 0x78, 0x00, 0x00, 0x07, 0x80, 0xFF, 0x87, 0x87, 0x18, 0x0E, + 0x60, 0x19, 0x80, 0x66, 0x00, 0x1E, 0x00, 0x3F, 0x80, 0x3F, 0xC0, 0x0F, + 0x80, 0x07, 0xC0, 0x1F, 0x00, 0x3E, 0x01, 0xDC, 0x06, 0x7E, 0xF8, 0x7F, + 0x80, 0x20, 0x00, 0x00, 0x03, 0xF0, 0xE7, 0x18, 0x63, 0x0C, 0x60, 0x0E, + 0x01, 0xF0, 0x67, 0x98, 0x7B, 0x03, 0xE0, 0x37, 0x06, 0xF0, 0xC7, 0x18, + 0x7E, 0x07, 0x80, 0x31, 0x87, 0x30, 0x67, 0x1C, 0x7F, 0x07, 0xC0, 0x21, + 0x0C, 0xC1, 0xE0, 0x70, 0x00, 0x07, 0x87, 0xFB, 0x86, 0xC1, 0xB0, 0x0F, + 0x01, 0xFC, 0x0F, 0x80, 0x7C, 0x0F, 0x03, 0xF3, 0x9F, 0xE0, 0x80, 0x03, + 0xE0, 0x03, 0xFF, 0x01, 0x80, 0xE0, 0xC0, 0x0C, 0x61, 0xE1, 0xB0, 0xCC, + 0x6C, 0x61, 0x8F, 0x10, 0x63, 0x8C, 0x00, 0xE3, 0x00, 0x38, 0xC0, 0x0F, + 0x10, 0x63, 0xC6, 0x18, 0x90, 0xFC, 0x66, 0x1E, 0x30, 0xC0, 0x1C, 0x1C, + 0x0E, 0x01, 0xFE, 0x00, 0x08, 0x00, 0x39, 0xDB, 0x10, 0x67, 0x50, 0xA3, + 0x7F, 0x01, 0xFF, 0xF8, 0x00, 0x18, 0xDC, 0xF8, 0xC8, 0x47, 0x31, 0xCE, + 0x23, 0xFF, 0xFF, 0xFF, 0x00, 0x30, 0x03, 0x00, 0x30, 0x03, 0x00, 0x30, + 0xFC, 0x03, 0xE0, 0x03, 0xFF, 0x01, 0x80, 0xE0, 0xC0, 0x0C, 0x67, 0xF1, + 0xB1, 0x8E, 0x6C, 0x61, 0x8F, 0x18, 0x63, 0x86, 0x38, 0xE1, 0xFC, 0x38, + 0x61, 0x8F, 0x18, 0x63, 0xC6, 0x18, 0x91, 0x86, 0x66, 0x60, 0xF0, 0xC0, + 0x1C, 0x1C, 0x0E, 0x01, 0xFE, 0x00, 0x08, 0x00, 0xFF, 0xF0, 0x7D, 0x8A, + 0x1C, 0x38, 0x7F, 0x8E, 0x00, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, + 0x0F, 0xFF, 0xFF, 0xF0, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x00, + 0x00, 0x00, 0xFF, 0xF0, 0x3C, 0x66, 0x43, 0x43, 0x02, 0x0E, 0x38, 0x60, + 0x40, 0xFF, 0x3C, 0x66, 0x42, 0x02, 0x1E, 0x1E, 0x03, 0xC3, 0x43, 0x7E, + 0x00, 0x08, 0xC0, 0x6C, 0x01, 0xC0, 0x00, 0x0F, 0xFF, 0xFF, 0xFC, 0x00, + 0xE0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x70, 0x07, 0x00, 0x70, 0x03, 0x80, + 0x38, 0x03, 0x80, 0x38, 0x01, 0x80, 0x1C, 0x01, 0xC0, 0x0F, 0xFF, 0xFF, + 0xFC, 0xC0, 0xD8, 0x1B, 0x03, 0x60, 0x6C, 0x0D, 0x81, 0xB0, 0x36, 0x06, + 0xC1, 0xD8, 0x3B, 0x07, 0x71, 0xEF, 0xEF, 0xA0, 0x30, 0x06, 0x00, 0xC0, + 0x18, 0x00, 0x03, 0xF3, 0xFF, 0x7E, 0x47, 0xE4, 0xFE, 0x4F, 0xE4, 0xFE, + 0x4F, 0xE4, 0x7E, 0x47, 0xE4, 0x3E, 0x40, 0xE4, 0x06, 0x40, 0x64, 0x06, + 0x40, 0x64, 0x06, 0x40, 0x64, 0x06, 0x40, 0x64, 0x06, 0x40, 0x64, 0xFF, + 0x80, 0x21, 0x0C, 0xC1, 0xE0, 0x30, 0x00, 0x3F, 0xFF, 0xFC, 0x06, 0x03, + 0x81, 0xC0, 0xE0, 0x30, 0x18, 0x0C, 0x07, 0x03, 0x80, 0xFF, 0xFF, 0xF0, + 0x33, 0xF3, 0x33, 0x33, 0x33, 0x38, 0xDB, 0x1C, 0x38, 0x70, 0xF1, 0x3E, + 0x01, 0xFF, 0xF8, 0xC4, 0x73, 0x8C, 0xE2, 0x13, 0x1F, 0x3B, 0x18, 0x00, + 0x07, 0x8F, 0xFC, 0x7F, 0xBF, 0xF3, 0x87, 0xC0, 0x1C, 0x0F, 0x00, 0x60, + 0x1C, 0x01, 0x80, 0x30, 0x0E, 0x00, 0xC0, 0x30, 0x03, 0x00, 0xC0, 0x0F, + 0xFF, 0x00, 0x3F, 0xFC, 0x00, 0xC0, 0x30, 0x03, 0x00, 0xE0, 0x0C, 0x01, + 0x80, 0x30, 0x06, 0x01, 0xC0, 0x1C, 0x0F, 0x00, 0x3F, 0xEF, 0xFC, 0x3F, + 0x3F, 0xF0, 0x1F, 0x07, 0x83, 0xF9, 0xFE, 0x71, 0xF8, 0x7E, 0x0F, 0x03, + 0xC0, 0x60, 0x3C, 0x06, 0x03, 0xC0, 0x7F, 0xFC, 0x06, 0x00, 0xC0, 0x60, + 0x0C, 0x07, 0x03, 0x60, 0xF0, 0x77, 0xBF, 0xCE, 0x3F, 0x9F, 0xC0, 0x40, + 0x20, 0x06, 0x60, 0x06, 0x60, 0x00, 0x00, 0xE0, 0x07, 0x70, 0x06, 0x30, + 0x0E, 0x38, 0x1C, 0x18, 0x18, 0x1C, 0x38, 0x0E, 0x30, 0x06, 0x70, 0x07, + 0x60, 0x03, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, + 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x0C, 0x03, 0x00, 0xC0, 0x00, + 0x00, 0x03, 0x00, 0xC0, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x00, 0xC0, 0xF0, + 0x3C, 0x0F, 0x86, 0x7F, 0x87, 0x80, 0x07, 0x00, 0x03, 0x00, 0x01, 0x80, + 0x00, 0x00, 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xE0, 0x06, 0x60, + 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30, 0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, + 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x0C, 0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, + 0x60, 0x07, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x01, 0xC0, + 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xE0, 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, + 0x0C, 0x30, 0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, + 0x30, 0x0C, 0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, 0x60, 0x07, 0x03, 0xC0, + 0x03, 0xC0, 0x06, 0x60, 0x00, 0x00, 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0, + 0x03, 0xE0, 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30, 0x0C, 0x30, + 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x0C, 0x30, 0x0C, + 0x70, 0x0E, 0x60, 0x06, 0x60, 0x07, 0x07, 0xB0, 0x0D, 0xE0, 0x00, 0x00, + 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xE0, 0x06, 0x60, 0x06, 0x60, + 0x0E, 0x70, 0x0C, 0x30, 0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, + 0x3F, 0xFC, 0x30, 0x0C, 0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, 0x60, 0x07, + 0x06, 0x60, 0x06, 0x60, 0x00, 0x00, 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0, + 0x03, 0xE0, 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30, 0x0C, 0x30, + 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x0C, 0x30, 0x0C, + 0x70, 0x0E, 0x60, 0x06, 0x60, 0x07, 0x03, 0xC0, 0x03, 0x40, 0x06, 0x60, + 0x03, 0xC0, 0x01, 0x80, 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xE0, + 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30, 0x0C, 0x30, 0x1C, 0x38, + 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x0C, 0x30, 0x0C, 0x70, 0x0E, + 0x60, 0x06, 0x60, 0x07, 0x01, 0xFF, 0xFC, 0x03, 0xFF, 0xF8, 0x06, 0x60, + 0x00, 0x18, 0xC0, 0x00, 0x31, 0x80, 0x00, 0xE3, 0x00, 0x01, 0x86, 0x00, + 0x03, 0x0C, 0x00, 0x0C, 0x1F, 0xFC, 0x18, 0x3F, 0xF8, 0x70, 0x60, 0x00, + 0xFF, 0xC0, 0x01, 0xFF, 0x80, 0x07, 0x03, 0x00, 0x0C, 0x06, 0x00, 0x38, + 0x0C, 0x00, 0x60, 0x1F, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xC0, 0x1F, 0xF0, + 0xF0, 0xE1, 0x80, 0xE7, 0x00, 0xEC, 0x01, 0xF8, 0x00, 0x70, 0x00, 0xC0, + 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x06, 0x00, 0x6C, 0x01, 0xDC, 0x03, + 0x9C, 0x0E, 0x1F, 0x78, 0x1F, 0xE0, 0x04, 0x00, 0x0C, 0x00, 0x0C, 0x00, + 0x18, 0x01, 0xF0, 0x00, 0x1C, 0x00, 0x30, 0x00, 0x80, 0x00, 0x0F, 0xFF, + 0x7F, 0xFB, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, 0x0F, + 0xFF, 0x7F, 0xFB, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, + 0x0F, 0xFF, 0xFF, 0xFC, 0x03, 0x80, 0x18, 0x01, 0x80, 0x00, 0x0F, 0xFF, + 0x7F, 0xFB, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, 0x0F, + 0xFF, 0x7F, 0xFB, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, + 0x0F, 0xFF, 0xFF, 0xFC, 0x07, 0x00, 0x6C, 0x06, 0x60, 0x00, 0x0F, 0xFF, + 0x7F, 0xFB, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, 0x0F, + 0xFF, 0x7F, 0xFB, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, + 0x0F, 0xFF, 0xFF, 0xFC, 0x1D, 0xC0, 0xEE, 0x00, 0x01, 0xFF, 0xEF, 0xFF, + 0x60, 0x03, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0xFF, 0xEF, + 0xFF, 0x60, 0x03, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0xFF, + 0xFF, 0xFF, 0x80, 0xE1, 0x84, 0x13, 0x9C, 0xE7, 0x39, 0xCE, 0x73, 0x9C, + 0xE7, 0x39, 0xCE, 0x73, 0x9C, 0x33, 0x30, 0x0E, 0x73, 0x9C, 0xE7, 0x39, + 0xCE, 0x73, 0x9C, 0xE7, 0x39, 0xCE, 0x70, 0x38, 0xD9, 0x14, 0x03, 0x87, + 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, + 0xC3, 0x87, 0x00, 0xEF, 0xDC, 0x01, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, + 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3, 0x80, 0x3F, 0x80, + 0x3F, 0xF8, 0x30, 0x7C, 0x30, 0x0E, 0x30, 0x06, 0x30, 0x06, 0x30, 0x07, + 0x30, 0x03, 0xFF, 0x03, 0xFF, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, + 0x30, 0x06, 0x30, 0x0E, 0x30, 0x1C, 0x3F, 0xF8, 0x3F, 0xF0, 0x0C, 0x40, + 0x7F, 0x01, 0x08, 0x30, 0x07, 0xE0, 0x1F, 0xC0, 0x7F, 0x01, 0xFE, 0x07, + 0xD8, 0x1F, 0x30, 0x7C, 0xE1, 0xF1, 0x87, 0xC3, 0x1F, 0x0E, 0x7C, 0x19, + 0xF0, 0x77, 0xC0, 0xFF, 0x01, 0xFC, 0x07, 0xF0, 0x0F, 0xC0, 0x1C, 0x07, + 0x00, 0x00, 0xC0, 0x00, 0x20, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x7F, 0xC0, + 0xF8, 0xF0, 0x70, 0x1C, 0x70, 0x07, 0x30, 0x01, 0xB8, 0x00, 0xD8, 0x00, + 0x7C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x07, 0x80, 0x07, 0xE0, 0x03, 0x30, + 0x01, 0x9C, 0x01, 0xC7, 0x01, 0xC1, 0xF7, 0xC0, 0x7F, 0xC0, 0x02, 0x00, + 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x7F, + 0xC0, 0xF8, 0xF0, 0x70, 0x1C, 0x70, 0x07, 0x30, 0x01, 0xB8, 0x00, 0xD8, + 0x00, 0x7C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x07, 0x80, 0x07, 0xE0, 0x03, + 0x30, 0x01, 0x9C, 0x01, 0xC7, 0x01, 0xC1, 0xF7, 0xC0, 0x7F, 0xC0, 0x02, + 0x00, 0x01, 0xC0, 0x01, 0xB0, 0x01, 0x88, 0x00, 0x00, 0x00, 0x3E, 0x00, + 0x7F, 0xC0, 0xF8, 0xF0, 0x70, 0x1C, 0x70, 0x07, 0x30, 0x01, 0xB8, 0x00, + 0xD8, 0x00, 0x7C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x07, 0x80, 0x07, 0xE0, + 0x03, 0x30, 0x01, 0x9C, 0x01, 0xC7, 0x01, 0xC1, 0xF7, 0xC0, 0x7F, 0xC0, + 0x02, 0x00, 0x07, 0xB0, 0x03, 0xF8, 0x00, 0x00, 0x00, 0x7C, 0x00, 0xFF, + 0x81, 0xF1, 0xE0, 0xE0, 0x38, 0xE0, 0x0E, 0x60, 0x03, 0x70, 0x01, 0xB0, + 0x00, 0xF8, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F, 0xC0, 0x06, + 0x60, 0x03, 0x38, 0x03, 0x8E, 0x03, 0x83, 0xEF, 0x80, 0xFF, 0x80, 0x04, + 0x00, 0x07, 0x70, 0x03, 0xB8, 0x00, 0x00, 0x00, 0x7C, 0x00, 0xFF, 0x81, + 0xF1, 0xE0, 0xE0, 0x38, 0xE0, 0x0E, 0x60, 0x03, 0x70, 0x01, 0xB0, 0x00, + 0xF8, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F, 0xC0, 0x06, 0x60, + 0x03, 0x38, 0x03, 0x8E, 0x03, 0x83, 0xEF, 0x80, 0xFF, 0x80, 0x04, 0x00, + 0x40, 0x98, 0x63, 0x30, 0x78, 0x0C, 0x07, 0x83, 0x31, 0x86, 0x40, 0x80, + 0x03, 0xC1, 0x87, 0xFD, 0x8F, 0x8F, 0x86, 0x01, 0xC7, 0x00, 0xF7, 0x00, + 0xDB, 0x00, 0xCD, 0x80, 0xC7, 0xC0, 0xC3, 0xE0, 0xC1, 0xF0, 0xC0, 0xF8, + 0xC0, 0x7E, 0xC0, 0x33, 0xC0, 0x19, 0xC0, 0x18, 0x70, 0x1C, 0x5F, 0x7C, + 0x67, 0xFC, 0x00, 0x20, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x0C, + 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, + 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF8, 0x06, + 0xC0, 0x77, 0xDF, 0x1F, 0xF0, 0x08, 0x00, 0x01, 0xC0, 0x18, 0x00, 0x80, + 0x08, 0x0C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, + 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, + 0xF8, 0x06, 0xC0, 0x77, 0xDF, 0x1F, 0xF0, 0x08, 0x00, 0x07, 0x00, 0x2C, + 0x03, 0x30, 0x00, 0x0C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, + 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, + 0x1E, 0x00, 0xF8, 0x06, 0xC0, 0x77, 0xDF, 0x1F, 0xF0, 0x08, 0x00, 0x0C, + 0xC0, 0x66, 0x00, 0x01, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, + 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, + 0x03, 0xC0, 0x1F, 0x00, 0xD8, 0x0E, 0xFB, 0xE3, 0xFE, 0x01, 0x00, 0x00, + 0xE0, 0x00, 0xC0, 0x01, 0x80, 0x00, 0x00, 0xE0, 0x07, 0x70, 0x06, 0x30, + 0x0E, 0x38, 0x1C, 0x18, 0x18, 0x1C, 0x38, 0x0E, 0x30, 0x06, 0x70, 0x07, + 0x60, 0x03, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, + 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0xC0, 0x06, 0x00, 0x30, 0x01, + 0xFE, 0x0F, 0xFE, 0x60, 0x7B, 0x00, 0xD8, 0x07, 0xC0, 0x3E, 0x01, 0xF0, + 0x0D, 0x83, 0xEF, 0xFE, 0x60, 0x03, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00, + 0x00, 0x7F, 0x8F, 0x3C, 0xC0, 0xEC, 0x06, 0xC0, 0x6C, 0x0E, 0xC1, 0xCC, + 0x78, 0xC7, 0xEC, 0x06, 0xC0, 0x7C, 0x07, 0xC0, 0x7C, 0x06, 0xC0, 0x6C, + 0xFC, 0xCF, 0x80, 0x1C, 0x00, 0xC0, 0x06, 0x00, 0x00, 0x1F, 0x07, 0xFC, + 0x60, 0xC6, 0x0C, 0x00, 0xC0, 0x1C, 0x3F, 0xC7, 0x8C, 0xE0, 0xCC, 0x0C, + 0xC0, 0xCE, 0x3E, 0x7E, 0x70, 0x02, 0x03, 0x00, 0x60, 0x0C, 0x00, 0x00, + 0x1F, 0x07, 0xFC, 0x60, 0xC6, 0x0C, 0x00, 0xC0, 0x1C, 0x3F, 0xC7, 0x8C, + 0xE0, 0xCC, 0x0C, 0xC0, 0xCE, 0x3E, 0x7E, 0x70, 0x02, 0x0E, 0x01, 0xB0, + 0x11, 0x80, 0x00, 0x1F, 0x07, 0xFC, 0x60, 0xC6, 0x0C, 0x00, 0xC0, 0x1C, + 0x3F, 0xC7, 0x8C, 0xE0, 0xCC, 0x0C, 0xC0, 0xCE, 0x3E, 0x7E, 0x70, 0x02, + 0x1C, 0x83, 0xF8, 0x00, 0x00, 0x00, 0x1F, 0x07, 0xFC, 0x60, 0xC6, 0x0C, + 0x00, 0xC0, 0x1C, 0x3F, 0xC7, 0x8C, 0xE0, 0xCC, 0x0C, 0xC0, 0xCE, 0x3E, + 0x7E, 0x70, 0x02, 0x3B, 0x83, 0xB8, 0x00, 0x00, 0x00, 0x1F, 0x07, 0xFC, + 0x60, 0xC6, 0x0C, 0x00, 0xC0, 0x1C, 0x3F, 0xC7, 0x8C, 0xE0, 0xCC, 0x0C, + 0xC0, 0xCE, 0x3E, 0x7E, 0x70, 0x02, 0x04, 0x00, 0xF0, 0x19, 0x01, 0xB0, + 0x0F, 0x00, 0x00, 0x1F, 0x07, 0xFC, 0x60, 0xC6, 0x0C, 0x00, 0xC0, 0x1C, + 0x3F, 0xC7, 0x8C, 0xE0, 0xCC, 0x0C, 0xC0, 0xCE, 0x3E, 0x7E, 0x70, 0x02, + 0x1F, 0x0F, 0x0F, 0xF7, 0xF9, 0x83, 0xC3, 0xB0, 0x70, 0x30, 0x0C, 0x06, + 0x03, 0x80, 0xCF, 0xFF, 0xFB, 0xC6, 0x00, 0xE0, 0xC0, 0x18, 0x1C, 0x0F, + 0x03, 0x83, 0xF1, 0xDC, 0xE7, 0xE3, 0xF8, 0x00, 0x08, 0x00, 0x1F, 0x0F, + 0xE6, 0x1F, 0x83, 0xC0, 0xF0, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x3E, 0x0D, + 0xC7, 0x3F, 0x83, 0x00, 0xC0, 0x0C, 0x03, 0x0F, 0x80, 0x38, 0x03, 0x80, + 0x30, 0x03, 0x00, 0x00, 0x1E, 0x0F, 0xF3, 0x86, 0x60, 0x78, 0x0F, 0x01, + 0xFF, 0xFC, 0x01, 0x80, 0x30, 0x1B, 0x07, 0x79, 0xC7, 0xF0, 0x10, 0x00, + 0x03, 0x80, 0x60, 0x18, 0x06, 0x00, 0x00, 0x1E, 0x0F, 0xF3, 0x86, 0x60, + 0x78, 0x0F, 0x01, 0xFF, 0xFC, 0x01, 0x80, 0x30, 0x1B, 0x07, 0x79, 0xC7, + 0xF0, 0x10, 0x00, 0x0F, 0x03, 0x60, 0x66, 0x00, 0x00, 0xF0, 0x7F, 0x9C, + 0x33, 0x03, 0xC0, 0x78, 0x0F, 0xFF, 0xE0, 0x0C, 0x01, 0x80, 0xD8, 0x3B, + 0xCE, 0x3F, 0x80, 0x80, 0x19, 0x83, 0x30, 0x00, 0x00, 0x00, 0xF0, 0x7F, + 0x9C, 0x33, 0x03, 0xC0, 0x78, 0x0F, 0xFF, 0xE0, 0x0C, 0x01, 0x80, 0xD8, + 0x3B, 0xCE, 0x3F, 0x80, 0x80, 0xE3, 0x0C, 0x30, 0x18, 0xC6, 0x31, 0x8C, + 0x63, 0x18, 0xC6, 0x31, 0x80, 0x39, 0x99, 0x80, 0x31, 0x8C, 0x63, 0x18, + 0xC6, 0x31, 0x8C, 0x63, 0x00, 0x30, 0xF1, 0xB6, 0x20, 0x06, 0x0C, 0x18, + 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xCF, 0x30, 0x00, + 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0x20, 0x07, + 0xE0, 0x70, 0x3F, 0x00, 0x30, 0x3F, 0x0F, 0xF3, 0x8E, 0xE0, 0xF8, 0x0F, + 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1B, 0x07, 0x7B, 0xC7, 0xF0, 0x10, + 0x00, 0x39, 0x1F, 0xC4, 0x20, 0x00, 0xCF, 0x3F, 0xEE, 0x1F, 0x03, 0xC0, + 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xC0, 0x38, + 0x03, 0x00, 0x30, 0x03, 0x00, 0x00, 0x3E, 0x0F, 0xE3, 0x8E, 0xE0, 0xF8, + 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1B, 0x07, 0x7B, 0xC7, 0xF0, + 0x10, 0x00, 0x03, 0x80, 0xE0, 0x18, 0x06, 0x00, 0x00, 0x3E, 0x0F, 0xE3, + 0x8E, 0xE0, 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1B, 0x07, + 0x7B, 0xC7, 0xF0, 0x10, 0x00, 0x0E, 0x01, 0xC0, 0x6C, 0x18, 0xC0, 0x00, + 0x3E, 0x0F, 0xE3, 0x8E, 0xE0, 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, + 0xF0, 0x1B, 0x07, 0x7B, 0xC7, 0xF0, 0x10, 0x00, 0x1C, 0x87, 0xF0, 0x00, + 0x00, 0x01, 0xF0, 0x7F, 0x1C, 0x77, 0x07, 0xC0, 0x78, 0x0F, 0x01, 0xE0, + 0x3C, 0x07, 0x80, 0xD8, 0x3B, 0xDE, 0x3F, 0x80, 0x80, 0x3B, 0x87, 0x70, + 0xEE, 0x00, 0x00, 0x00, 0x3E, 0x0F, 0xE3, 0x8E, 0xE0, 0xF8, 0x0F, 0x01, + 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1B, 0x07, 0x7B, 0xC7, 0xF0, 0x10, 0x00, + 0x06, 0x00, 0x60, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, + 0x06, 0x00, 0x60, 0x06, 0x00, 0x0F, 0x80, 0xFE, 0x8E, 0x38, 0xE0, 0xE6, + 0x0B, 0x30, 0x99, 0x8C, 0xCC, 0xC6, 0x6C, 0x33, 0x41, 0x8C, 0x1C, 0x79, + 0xC5, 0xFC, 0x01, 0x00, 0x70, 0x0C, 0x01, 0x80, 0x30, 0x00, 0x30, 0x3C, + 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x7C, 0x1F, 0x07, + 0xE3, 0xDF, 0xB1, 0x00, 0x07, 0x03, 0x80, 0xC0, 0x60, 0x00, 0x30, 0x3C, + 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x7C, 0x1F, 0x07, + 0xE3, 0xDF, 0xB1, 0x00, 0x1C, 0x07, 0x03, 0x60, 0x8C, 0x00, 0x30, 0x3C, + 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x7C, 0x1F, 0x07, + 0xE3, 0xDF, 0xB1, 0x00, 0x77, 0x1D, 0xC7, 0x70, 0x00, 0x00, 0x30, 0x3C, + 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x7C, 0x1F, 0x07, + 0xE3, 0xDF, 0xB1, 0x00, 0x03, 0x80, 0x60, 0x18, 0x06, 0x00, 0x00, 0xC0, + 0xD8, 0x1B, 0x03, 0x30, 0xC6, 0x18, 0xC7, 0x0C, 0xC1, 0x98, 0x37, 0x03, + 0xC0, 0x78, 0x0E, 0x00, 0xC0, 0x18, 0x06, 0x00, 0xC0, 0xF0, 0x1E, 0x00, + 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xCF, 0x0D, 0xFC, 0xF0, 0xCE, 0x06, + 0xE0, 0x6C, 0x06, 0xC0, 0x7C, 0x07, 0xC0, 0x6E, 0x06, 0xE0, 0xEF, 0x9C, + 0xDF, 0x8C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0x19, 0x83, 0x30, + 0x66, 0x00, 0x00, 0x00, 0xC0, 0xD8, 0x1B, 0x03, 0x30, 0xC6, 0x18, 0xC7, + 0x0C, 0xC1, 0x98, 0x37, 0x03, 0xC0, 0x78, 0x0E, 0x00, 0xC0, 0x18, 0x06, + 0x00, 0xC0, 0xF0, 0x1E, 0x00 }; + +const GFXglyph FreeSans12pt8bGlyphs[] PROGMEM = { + { 0, 1, 1, 7, 0, 0 }, // 0x20 ' ' U+0020 + { 1, 2, 18, 7, 3, -17 }, // 0x21 '!' U+0021 + { 6, 6, 6, 9, 1, -16 }, // 0x22 '"' U+0022 + { 11, 13, 17, 13, 0, -16 }, // 0x23 '#' U+0023 + { 39, 11, 21, 13, 1, -17 }, // 0x24 '$' U+0024 + { 68, 20, 17, 21, 1, -16 }, // 0x25 '%' U+0025 + { 111, 14, 18, 16, 1, -16 }, // 0x26 '&' U+0026 + { 143, 2, 6, 5, 1, -16 }, // 0x27 ''' U+0027 + { 145, 5, 23, 8, 2, -17 }, // 0x28 '(' U+0028 + { 160, 5, 23, 8, 1, -17 }, // 0x29 ')' U+0029 + { 175, 7, 7, 9, 1, -17 }, // 0x2a '*' U+002A + { 182, 12, 11, 14, 1, -10 }, // 0x2b '+' U+002B + { 199, 3, 7, 7, 2, -2 }, // 0x2c ',' U+002C + { 202, 6, 1, 8, 1, -6 }, // 0x2d '-' U+002D + { 203, 3, 3, 7, 2, -2 }, // 0x2e '.' U+002E + { 205, 7, 18, 7, 0, -17 }, // 0x2f '/' U+002F + { 221, 11, 18, 13, 1, -16 }, // 0x30 '0' U+0030 + { 246, 6, 17, 13, 2, -16 }, // 0x31 '1' U+0031 + { 259, 11, 17, 13, 1, -16 }, // 0x32 '2' U+0032 + { 283, 11, 18, 13, 1, -16 }, // 0x33 '3' U+0033 + { 308, 11, 17, 13, 1, -16 }, // 0x34 '4' U+0034 + { 332, 11, 18, 13, 1, -16 }, // 0x35 '5' U+0035 + { 357, 11, 18, 13, 1, -16 }, // 0x36 '6' U+0036 + { 382, 11, 17, 13, 1, -16 }, // 0x37 '7' U+0037 + { 406, 11, 18, 13, 1, -16 }, // 0x38 '8' U+0038 + { 431, 11, 18, 13, 1, -16 }, // 0x39 '9' U+0039 + { 456, 2, 13, 7, 3, -12 }, // 0x3a ':' U+003A + { 460, 2, 17, 7, 3, -12 }, // 0x3b ';' U+003B + { 465, 12, 11, 14, 1, -10 }, // 0x3c '<' U+003C + { 482, 12, 5, 14, 1, -7 }, // 0x3d '=' U+003D + { 490, 12, 11, 14, 1, -10 }, // 0x3e '>' U+003E + { 507, 10, 18, 13, 2, -17 }, // 0x3f '?' U+003F + { 530, 22, 21, 24, 1, -17 }, // 0x40 '@' U+0040 + { 588, 16, 18, 16, 0, -17 }, // 0x41 'A' U+0041 + { 624, 13, 18, 16, 2, -17 }, // 0x42 'B' U+0042 + { 654, 15, 19, 17, 1, -17 }, // 0x43 'C' U+0043 + { 690, 14, 18, 17, 2, -17 }, // 0x44 'D' U+0044 + { 722, 13, 18, 16, 2, -17 }, // 0x45 'E' U+0045 + { 752, 12, 18, 15, 2, -17 }, // 0x46 'F' U+0046 + { 779, 16, 19, 19, 1, -17 }, // 0x47 'G' U+0047 + { 817, 13, 18, 17, 2, -17 }, // 0x48 'H' U+0048 + { 847, 3, 18, 7, 2, -17 }, // 0x49 'I' U+0049 + { 854, 10, 19, 12, 0, -17 }, // 0x4a 'J' U+004A + { 878, 14, 18, 16, 2, -17 }, // 0x4b 'K' U+004B + { 910, 11, 18, 13, 2, -17 }, // 0x4c 'L' U+004C + { 935, 16, 18, 20, 2, -17 }, // 0x4d 'M' U+004D + { 971, 14, 18, 17, 2, -17 }, // 0x4e 'N' U+004E + { 1003, 17, 19, 19, 1, -17 }, // 0x4f 'O' U+004F + { 1044, 13, 18, 16, 2, -17 }, // 0x50 'P' U+0050 + { 1074, 17, 19, 19, 1, -17 }, // 0x51 'Q' U+0051 + { 1115, 14, 18, 17, 2, -17 }, // 0x52 'R' U+0052 + { 1147, 14, 19, 16, 1, -17 }, // 0x53 'S' U+0053 + { 1181, 14, 18, 15, 0, -17 }, // 0x54 'T' U+0054 + { 1213, 13, 19, 17, 2, -17 }, // 0x55 'U' U+0055 + { 1244, 14, 18, 16, 1, -17 }, // 0x56 'V' U+0056 + { 1276, 21, 18, 23, 1, -17 }, // 0x57 'W' U+0057 + { 1324, 15, 18, 16, 1, -17 }, // 0x58 'X' U+0058 + { 1358, 16, 18, 16, 0, -17 }, // 0x59 'Y' U+0059 + { 1394, 13, 18, 15, 1, -17 }, // 0x5a 'Z' U+005A + { 1424, 4, 23, 7, 2, -17 }, // 0x5b '[' U+005B + { 1436, 7, 18, 7, 0, -17 }, // 0x5c '\' U+005C + { 1452, 4, 23, 7, 1, -17 }, // 0x5d ']' U+005D + { 1464, 9, 9, 11, 1, -16 }, // 0x5e '^' U+005E + { 1475, 15, 1, 13, -1, 4 }, // 0x5f '_' U+005F + { 1477, 5, 4, 8, 1, -17 }, // 0x60 '`' U+0060 + { 1480, 12, 14, 13, 1, -12 }, // 0x61 'a' U+0061 + { 1501, 12, 19, 13, 1, -17 }, // 0x62 'b' U+0062 + { 1530, 10, 14, 12, 1, -12 }, // 0x63 'c' U+0063 + { 1548, 11, 19, 13, 1, -17 }, // 0x64 'd' U+0064 + { 1575, 11, 14, 13, 1, -12 }, // 0x65 'e' U+0065 + { 1595, 6, 18, 7, 0, -17 }, // 0x66 'f' U+0066 + { 1609, 11, 18, 13, 1, -12 }, // 0x67 'g' U+0067 + { 1634, 10, 18, 13, 2, -17 }, // 0x68 'h' U+0068 + { 1657, 2, 18, 5, 2, -17 }, // 0x69 'i' U+0069 + { 1662, 4, 23, 5, 0, -17 }, // 0x6a 'j' U+006A + { 1674, 11, 18, 12, 1, -17 }, // 0x6b 'k' U+006B + { 1699, 2, 18, 5, 2, -17 }, // 0x6c 'l' U+006C + { 1704, 16, 13, 20, 2, -12 }, // 0x6d 'm' U+006D + { 1730, 10, 13, 13, 2, -12 }, // 0x6e 'n' U+006E + { 1747, 11, 14, 13, 1, -12 }, // 0x6f 'o' U+006F + { 1767, 12, 18, 13, 1, -12 }, // 0x70 'p' U+0070 + { 1794, 11, 18, 13, 1, -12 }, // 0x71 'q' U+0071 + { 1819, 6, 13, 8, 2, -12 }, // 0x72 'r' U+0072 + { 1829, 10, 14, 12, 1, -12 }, // 0x73 's' U+0073 + { 1847, 6, 17, 7, 0, -15 }, // 0x74 't' U+0074 + { 1860, 10, 14, 13, 2, -12 }, // 0x75 'u' U+0075 + { 1878, 12, 13, 12, 0, -12 }, // 0x76 'v' U+0076 + { 1898, 17, 13, 17, 0, -12 }, // 0x77 'w' U+0077 + { 1926, 11, 13, 12, 0, -12 }, // 0x78 'x' U+0078 + { 1944, 11, 18, 12, 0, -12 }, // 0x79 'y' U+0079 + { 1969, 10, 13, 12, 1, -12 }, // 0x7a 'z' U+007A + { 1986, 6, 23, 8, 1, -17 }, // 0x7b '{' U+007B + { 2004, 2, 23, 6, 2, -17 }, // 0x7c '|' U+007C + { 2010, 5, 23, 8, 1, -17 }, // 0x7d '}' U+007D + { 2025, 10, 5, 14, 2, -10 }, // 0x7e '~' U+007E + { 2032, 13, 18, 17, 2, -17 }, // 0x7f 'REPLACEMENT CHARACTER *' U+2370 + { 2062, 1, 1, 7, 0, 0 }, // 0x80 'NO-BREAK SPACE' U+00A0 + { 2063, 2, 18, 7, 3, -12 }, // 0x81 'INVERTED EXCLAMATION MARK' U+00A1 + { 2068, 11, 18, 13, 1, -14 }, // 0x82 'CENT SIGN' U+00A2 + { 2093, 12, 19, 13, 1, -17 }, // 0x83 'POUND SIGN' U+00A3 + { 2122, 14, 18, 16, 1, -16 }, // 0x84 'EURO SIGN *' U+20AC + { 2154, 13, 17, 13, 0, -16 }, // 0x85 'YEN SIGN' U+00A5 + { 2182, 14, 23, 16, 1, -21 }, // 0x86 'LATIN CAPITAL LETTER S WITH CARON *' U+0160 + { 2223, 11, 23, 13, 1, -17 }, // 0x87 'SECTION SIGN' U+00A7 + { 2255, 10, 19, 12, 1, -17 }, // 0x88 'LATIN SMALL LETTER S WITH CARON *' U+0161 + { 2279, 18, 19, 18, 0, -17 }, // 0x89 'COPYRIGHT SIGN' U+00A9 + { 2322, 7, 11, 9, 1, -17 }, // 0x8a 'FEMININE ORDINAL INDICATOR' U+00AA + { 2332, 9, 8, 11, 1, -10 }, // 0x8b 'LEFT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00AB + { 2341, 12, 7, 14, 1, -8 }, // 0x8c 'NOT SIGN' U+00AC + { 2352, 6, 1, 8, 1, -6 }, // 0x8d 'SOFT HYPHEN' U+00AD + { 2353, 18, 19, 18, 0, -17 }, // 0x8e 'REGISTERED SIGN' U+00AE + { 2396, 6, 2, 8, 1, -16 }, // 0x8f 'MACRON' U+00AF + { 2398, 7, 7, 15, 4, -15 }, // 0x90 'DEGREE SIGN' U+00B0 + { 2405, 12, 15, 14, 1, -14 }, // 0x91 'PLUS-MINUS SIGN' U+00B1 + { 2428, 8, 10, 8, 0, -16 }, // 0x92 'SUPERSCRIPT TWO' U+00B2 + { 2438, 8, 11, 8, 0, -16 }, // 0x93 'SUPERSCRIPT THREE' U+00B3 + { 2449, 13, 22, 15, 1, -21 }, // 0x94 'LATIN CAPITAL LETTER Z WITH CARON *' U+017D + { 2485, 11, 18, 13, 2, -12 }, // 0x95 'MICRO SIGN' U+00B5 + { 2510, 12, 22, 13, 1, -17 }, // 0x96 'PILCROW SIGN' U+00B6 + { 2543, 3, 3, 7, 2, -7 }, // 0x97 'MIDDLE DOT' U+00B7 + { 2545, 10, 18, 12, 1, -17 }, // 0x98 'LATIN SMALL LETTER Z WITH CARON *' U+017E + { 2568, 4, 10, 8, 2, -16 }, // 0x99 'SUPERSCRIPT ONE' U+00B9 + { 2573, 7, 11, 9, 1, -17 }, // 0x9a 'MASCULINE ORDINAL INDICATOR' U+00BA + { 2583, 9, 8, 11, 1, -9 }, // 0x9b 'RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00BB + { 2592, 22, 18, 24, 1, -17 }, // 0x9c 'LATIN CAPITAL LIGATURE OE *' U+0152 + { 2642, 20, 14, 23, 1, -12 }, // 0x9d 'LATIN SMALL LIGATURE OE *' U+0153 + { 2677, 16, 21, 16, 0, -20 }, // 0x9e 'LATIN CAPITAL LETTER Y WITH DIAERESIS *' U+0178 + { 2719, 10, 18, 13, 3, -12 }, // 0x9f 'INVERTED QUESTION MARK' U+00BF + { 2742, 16, 22, 16, 0, -21 }, // 0xa0 'LATIN CAPITAL LETTER A WITH GRAVE' U+00C0 + { 2786, 16, 22, 16, 0, -21 }, // 0xa1 'LATIN CAPITAL LETTER A WITH ACUTE' U+00C1 + { 2830, 16, 22, 16, 0, -21 }, // 0xa2 'LATIN CAPITAL LETTER A WITH CIRCUMFLEX' U+00C2 + { 2874, 16, 21, 16, 0, -20 }, // 0xa3 'LATIN CAPITAL LETTER A WITH TILDE' U+00C3 + { 2916, 16, 21, 16, 0, -20 }, // 0xa4 'LATIN CAPITAL LETTER A WITH DIAERESIS' U+00C4 + { 2958, 16, 23, 16, 0, -22 }, // 0xa5 'LATIN CAPITAL LETTER A WITH RING ABOVE' U+00C5 + { 3004, 23, 18, 24, 0, -17 }, // 0xa6 'LATIN CAPITAL LETTER AE' U+00C6 + { 3056, 15, 23, 17, 1, -17 }, // 0xa7 'LATIN CAPITAL LETTER C WITH CEDILLA' U+00C7 + { 3100, 13, 22, 16, 2, -21 }, // 0xa8 'LATIN CAPITAL LETTER E WITH GRAVE' U+00C8 + { 3136, 13, 22, 16, 2, -21 }, // 0xa9 'LATIN CAPITAL LETTER E WITH ACUTE' U+00C9 + { 3172, 13, 22, 16, 2, -21 }, // 0xaa 'LATIN CAPITAL LETTER E WITH CIRCUMFLEX' U+00CA + { 3208, 13, 21, 16, 2, -20 }, // 0xab 'LATIN CAPITAL LETTER E WITH DIAERESIS' U+00CB + { 3243, 5, 22, 7, 0, -21 }, // 0xac 'LATIN CAPITAL LETTER I WITH GRAVE' U+00CC + { 3257, 5, 22, 7, 2, -21 }, // 0xad 'LATIN CAPITAL LETTER I WITH ACUTE' U+00CD + { 3271, 7, 22, 7, 0, -21 }, // 0xae 'LATIN CAPITAL LETTER I WITH CIRCUMFLEX' U+00CE + { 3291, 7, 21, 7, 0, -20 }, // 0xaf 'LATIN CAPITAL LETTER I WITH DIAERESIS' U+00CF + { 3310, 16, 18, 17, 0, -17 }, // 0xb0 'LATIN CAPITAL LETTER ETH' U+00D0 + { 3346, 14, 21, 17, 2, -20 }, // 0xb1 'LATIN CAPITAL LETTER N WITH TILDE' U+00D1 + { 3383, 17, 23, 19, 1, -21 }, // 0xb2 'LATIN CAPITAL LETTER O WITH GRAVE' U+00D2 + { 3432, 17, 23, 19, 1, -21 }, // 0xb3 'LATIN CAPITAL LETTER O WITH ACUTE' U+00D3 + { 3481, 17, 23, 19, 1, -21 }, // 0xb4 'LATIN CAPITAL LETTER O WITH CIRCUMFLEX' U+00D4 + { 3530, 17, 22, 19, 1, -20 }, // 0xb5 'LATIN CAPITAL LETTER O WITH TILDE' U+00D5 + { 3577, 17, 22, 19, 1, -20 }, // 0xb6 'LATIN CAPITAL LETTER O WITH DIAERESIS' U+00D6 + { 3624, 10, 9, 14, 2, -9 }, // 0xb7 'MULTIPLICATION SIGN' U+00D7 + { 3636, 17, 19, 19, 1, -17 }, // 0xb8 'LATIN CAPITAL LETTER O WITH STROKE' U+00D8 + { 3677, 13, 23, 17, 2, -21 }, // 0xb9 'LATIN CAPITAL LETTER U WITH GRAVE' U+00D9 + { 3715, 13, 23, 17, 2, -21 }, // 0xba 'LATIN CAPITAL LETTER U WITH ACUTE' U+00DA + { 3753, 13, 23, 17, 2, -21 }, // 0xbb 'LATIN CAPITAL LETTER U WITH CIRCUMFLEX' U+00DB + { 3791, 13, 22, 17, 2, -20 }, // 0xbc 'LATIN CAPITAL LETTER U WITH DIAERESIS' U+00DC + { 3827, 16, 22, 16, 0, -21 }, // 0xbd 'LATIN CAPITAL LETTER Y WITH ACUTE' U+00DD + { 3871, 13, 18, 16, 2, -17 }, // 0xbe 'LATIN CAPITAL LETTER THORN' U+00DE + { 3901, 12, 17, 15, 2, -16 }, // 0xbf 'LATIN SMALL LETTER SHARP S' U+00DF + { 3927, 12, 18, 13, 1, -16 }, // 0xc0 'LATIN SMALL LETTER A WITH GRAVE' U+00E0 + { 3954, 12, 18, 13, 1, -16 }, // 0xc1 'LATIN SMALL LETTER A WITH ACUTE' U+00E1 + { 3981, 12, 18, 13, 1, -16 }, // 0xc2 'LATIN SMALL LETTER A WITH CIRCUMFLEX' U+00E2 + { 4008, 12, 18, 13, 1, -16 }, // 0xc3 'LATIN SMALL LETTER A WITH TILDE' U+00E3 + { 4035, 12, 18, 13, 1, -16 }, // 0xc4 'LATIN SMALL LETTER A WITH DIAERESIS' U+00E4 + { 4062, 12, 20, 13, 1, -18 }, // 0xc5 'LATIN SMALL LETTER A WITH RING ABOVE' U+00E5 + { 4092, 19, 14, 22, 1, -12 }, // 0xc6 'LATIN SMALL LETTER AE' U+00E6 + { 4126, 10, 18, 12, 1, -12 }, // 0xc7 'LATIN SMALL LETTER C WITH CEDILLA' U+00E7 + { 4149, 11, 19, 13, 1, -17 }, // 0xc8 'LATIN SMALL LETTER E WITH GRAVE' U+00E8 + { 4176, 11, 19, 13, 1, -17 }, // 0xc9 'LATIN SMALL LETTER E WITH ACUTE' U+00E9 + { 4203, 11, 18, 13, 1, -16 }, // 0xca 'LATIN SMALL LETTER E WITH CIRCUMFLEX' U+00EA + { 4228, 11, 18, 13, 1, -16 }, // 0xcb 'LATIN SMALL LETTER E WITH DIAERESIS' U+00EB + { 4253, 5, 18, 6, 0, -17 }, // 0xcc 'LATIN SMALL LETTER I WITH GRAVE' U+00EC + { 4265, 5, 18, 6, 1, -17 }, // 0xcd 'LATIN SMALL LETTER I WITH ACUTE' U+00ED + { 4277, 7, 18, 6, 0, -17 }, // 0xce 'LATIN SMALL LETTER I WITH CIRCUMFLEX' U+00EE + { 4293, 6, 17, 6, 0, -16 }, // 0xcf 'LATIN SMALL LETTER I WITH DIAERESIS' U+00EF + { 4306, 11, 19, 13, 1, -17 }, // 0xd0 'LATIN SMALL LETTER ETH' U+00F0 + { 4333, 10, 17, 13, 2, -16 }, // 0xd1 'LATIN SMALL LETTER N WITH TILDE' U+00F1 + { 4355, 11, 19, 13, 1, -17 }, // 0xd2 'LATIN SMALL LETTER O WITH GRAVE' U+00F2 + { 4382, 11, 19, 13, 1, -17 }, // 0xd3 'LATIN SMALL LETTER O WITH ACUTE' U+00F3 + { 4409, 11, 19, 13, 1, -17 }, // 0xd4 'LATIN SMALL LETTER O WITH CIRCUMFLEX' U+00F4 + { 4436, 11, 18, 13, 1, -16 }, // 0xd5 'LATIN SMALL LETTER O WITH TILDE' U+00F5 + { 4461, 11, 19, 13, 1, -17 }, // 0xd6 'LATIN SMALL LETTER O WITH DIAERESIS' U+00F6 + { 4488, 12, 11, 14, 1, -10 }, // 0xd7 'DIVISION SIGN' U+00F7 + { 4505, 13, 14, 15, 0, -12 }, // 0xd8 'LATIN SMALL LETTER O WITH STROKE' U+00F8 + { 4528, 10, 19, 13, 2, -17 }, // 0xd9 'LATIN SMALL LETTER U WITH GRAVE' U+00F9 + { 4552, 10, 19, 13, 2, -17 }, // 0xda 'LATIN SMALL LETTER U WITH ACUTE' U+00FA + { 4576, 10, 19, 13, 2, -17 }, // 0xdb 'LATIN SMALL LETTER U WITH CIRCUMFLEX' U+00FB + { 4600, 10, 19, 13, 2, -17 }, // 0xdc 'LATIN SMALL LETTER U WITH DIAERESIS' U+00FC + { 4624, 11, 23, 12, 0, -17 }, // 0xdd 'LATIN SMALL LETTER Y WITH ACUTE' U+00FD + { 4656, 12, 22, 13, 1, -16 }, // 0xde 'LATIN SMALL LETTER THORN' U+00FE + { 4689, 11, 23, 12, 0, -17 } }; // 0xdf 'LATIN SMALL LETTER Y WITH DIAERESIS' U+000FF + +const GFXfont FreeSans12pt8b PROGMEM = { + (uint8_t *)FreeSans12pt8bBitmaps, + (GFXglyph *)FreeSans12pt8bGlyphs, + 0x20, 0xDF, 33 }; + +// Approx. 6072 bytes diff --git a/RX_FSK/src/fonts/FreeSans18pt7b.h b/RX_FSK/src/fonts/FreeSans18pt7b.h new file mode 100644 index 0000000..82ac479 --- /dev/null +++ b/RX_FSK/src/fonts/FreeSans18pt7b.h @@ -0,0 +1,451 @@ +const uint8_t FreeSans18pt7bBitmaps[] PROGMEM = { + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE9, 0x20, 0x3F, 0xFC, 0xE3, 0xF1, + 0xF8, 0xFC, 0x7E, 0x3F, 0x1F, 0x8E, 0x82, 0x41, 0x00, 0x01, 0xC3, 0x80, + 0x38, 0x70, 0x06, 0x0E, 0x00, 0xC1, 0x80, 0x38, 0x70, 0x07, 0x0E, 0x0F, + 0xFF, 0xF9, 0xFF, 0xFF, 0x3F, 0xFF, 0xE0, 0xE1, 0xC0, 0x1C, 0x38, 0x03, + 0x87, 0x00, 0x70, 0xE0, 0x0C, 0x18, 0x3F, 0xFF, 0xF7, 0xFF, 0xFE, 0xFF, + 0xFF, 0xC1, 0xC3, 0x80, 0x30, 0x60, 0x06, 0x0C, 0x01, 0xC3, 0x80, 0x38, + 0x70, 0x07, 0x0E, 0x00, 0xC1, 0x80, 0x03, 0x00, 0x0F, 0xC0, 0x3F, 0xF0, + 0x3F, 0xF8, 0x7B, 0x3C, 0xF3, 0x1C, 0xE3, 0x0E, 0xE3, 0x0E, 0xE3, 0x0E, + 0xE3, 0x00, 0xE3, 0x00, 0xF3, 0x00, 0x7B, 0x00, 0x7F, 0x80, 0x1F, 0xF0, + 0x07, 0xFC, 0x03, 0x7E, 0x03, 0x0F, 0x03, 0x07, 0xE3, 0x07, 0xE3, 0x07, + 0xE3, 0x07, 0xE3, 0x0F, 0x73, 0x3E, 0x7F, 0xFC, 0x3F, 0xF8, 0x0F, 0xE0, + 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x78, 0x00, + 0xE0, 0x0F, 0xF0, 0x06, 0x00, 0xFF, 0xC0, 0x70, 0x07, 0x0E, 0x07, 0x00, + 0x70, 0x38, 0x38, 0x03, 0x00, 0xC3, 0x80, 0x18, 0x06, 0x1C, 0x00, 0xE0, + 0x71, 0xC0, 0x03, 0x87, 0x8C, 0x00, 0x1F, 0xF8, 0xE0, 0x00, 0x7F, 0x86, + 0x00, 0x01, 0xF8, 0x70, 0x00, 0x00, 0x03, 0x03, 0xC0, 0x00, 0x38, 0x7F, + 0x80, 0x01, 0x87, 0xFE, 0x00, 0x1C, 0x38, 0x70, 0x00, 0xC3, 0x81, 0xC0, + 0x0E, 0x18, 0x06, 0x00, 0xE0, 0xC0, 0x30, 0x07, 0x07, 0x03, 0x80, 0x70, + 0x1C, 0x38, 0x03, 0x80, 0xFF, 0xC0, 0x38, 0x03, 0xFC, 0x01, 0x80, 0x07, + 0x80, 0x01, 0xF0, 0x00, 0x7F, 0x80, 0x0F, 0xFC, 0x01, 0xE1, 0xE0, 0x1C, + 0x0E, 0x01, 0xC0, 0xE0, 0x1C, 0x0E, 0x01, 0xE1, 0xE0, 0x0E, 0x3C, 0x00, + 0x77, 0x80, 0x07, 0xF0, 0x00, 0x7C, 0x00, 0x0F, 0xE0, 0x03, 0xCF, 0x1C, + 0x78, 0x79, 0xC7, 0x03, 0xDC, 0xE0, 0x1F, 0x8E, 0x00, 0xF8, 0xE0, 0x0F, + 0x0E, 0x00, 0x70, 0xF0, 0x0F, 0x87, 0xC3, 0xFC, 0x7F, 0xFD, 0xC3, 0xFF, + 0x0E, 0x0F, 0xC0, 0xF0, 0xFF, 0xFF, 0xFA, 0x40, 0x06, 0x06, 0x0C, 0x0C, + 0x18, 0x18, 0x38, 0x30, 0x70, 0x70, 0x70, 0x60, 0xE0, 0xE0, 0xE0, 0xE0, + 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0x60, 0x70, 0x70, 0x70, 0x30, 0x38, 0x18, + 0x18, 0x0C, 0x0C, 0x06, 0x03, 0xC0, 0x60, 0x30, 0x30, 0x38, 0x18, 0x1C, + 0x0C, 0x0E, 0x0E, 0x0E, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x06, 0x0E, 0x0E, 0x0E, 0x0C, 0x1C, 0x18, 0x38, 0x30, 0x30, + 0x60, 0xC0, 0x0C, 0x03, 0x00, 0xC3, 0xB7, 0xFF, 0xC7, 0x81, 0xE0, 0xEC, + 0x73, 0x88, 0x40, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, + 0x80, 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x80, 0x01, + 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0xFF, + 0xF6, 0xDA, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0xC0, 0x30, 0x18, + 0x06, 0x01, 0x80, 0xC0, 0x30, 0x0C, 0x06, 0x01, 0x80, 0x60, 0x30, 0x0C, + 0x03, 0x00, 0xC0, 0x60, 0x18, 0x06, 0x03, 0x00, 0xC0, 0x30, 0x18, 0x06, + 0x01, 0x80, 0xC0, 0x30, 0x00, 0x07, 0xE0, 0x0F, 0xF8, 0x1F, 0xFC, 0x3C, + 0x3C, 0x78, 0x1E, 0x70, 0x0E, 0x70, 0x0E, 0xE0, 0x07, 0xE0, 0x07, 0xE0, + 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, + 0x07, 0xE0, 0x07, 0xE0, 0x0F, 0x70, 0x0E, 0x70, 0x0E, 0x78, 0x1E, 0x3C, + 0x3C, 0x1F, 0xF8, 0x1F, 0xF0, 0x07, 0xE0, 0x03, 0x03, 0x07, 0x0F, 0x3F, + 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xE0, 0x1F, 0xF8, + 0x3F, 0xFC, 0x7C, 0x3E, 0x70, 0x0F, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0xF8, + 0x03, 0xF0, 0x07, 0xC0, 0x1F, 0x00, 0x3C, 0x00, 0x38, 0x00, 0x70, 0x00, + 0x60, 0x00, 0xE0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xF0, + 0x07, 0xFE, 0x07, 0xFF, 0x87, 0x83, 0xC3, 0x80, 0xF3, 0x80, 0x39, 0xC0, + 0x1C, 0xE0, 0x0E, 0x00, 0x07, 0x00, 0x0F, 0x00, 0x7F, 0x00, 0x3F, 0x00, + 0x1F, 0xE0, 0x00, 0x78, 0x00, 0x1E, 0x00, 0x07, 0x00, 0x03, 0xF0, 0x01, + 0xF8, 0x00, 0xFE, 0x00, 0x77, 0x00, 0x73, 0xE0, 0xF8, 0xFF, 0xF8, 0x3F, + 0xF8, 0x07, 0xF0, 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x78, 0x00, 0xF8, + 0x00, 0xF8, 0x01, 0xF8, 0x03, 0xB8, 0x03, 0x38, 0x07, 0x38, 0x0E, 0x38, + 0x1C, 0x38, 0x18, 0x38, 0x38, 0x38, 0x70, 0x38, 0x60, 0x38, 0xE0, 0x38, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x1F, 0xFF, 0x0F, 0xFF, 0x8F, 0xFF, + 0xC7, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x39, + 0xF0, 0x3F, 0xFE, 0x1F, 0xFF, 0x8F, 0x83, 0xE7, 0x00, 0xF0, 0x00, 0x3C, + 0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xFC, 0x00, + 0xEF, 0x00, 0x73, 0xC0, 0xF0, 0xFF, 0xF8, 0x3F, 0xF8, 0x07, 0xE0, 0x00, + 0x03, 0xE0, 0x0F, 0xF8, 0x1F, 0xFC, 0x3C, 0x1E, 0x38, 0x0E, 0x70, 0x0E, + 0x70, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE3, 0xE0, 0xEF, 0xF8, 0xFF, 0xFC, + 0xFC, 0x3E, 0xF0, 0x0E, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, + 0x60, 0x07, 0x70, 0x0F, 0x70, 0x0E, 0x3C, 0x3E, 0x3F, 0xFC, 0x1F, 0xF8, + 0x07, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x00, 0x0E, + 0x00, 0x1C, 0x00, 0x18, 0x00, 0x38, 0x00, 0x70, 0x00, 0x60, 0x00, 0xE0, + 0x00, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0C, 0x00, + 0x1C, 0x00, 0x1C, 0x00, 0x07, 0xF0, 0x0F, 0xFE, 0x0F, 0xFF, 0x87, 0x83, + 0xC7, 0x80, 0xF3, 0x80, 0x39, 0xC0, 0x1C, 0xE0, 0x0E, 0x78, 0x0F, 0x1E, + 0x0F, 0x07, 0xFF, 0x01, 0xFF, 0x03, 0xFF, 0xE3, 0xE0, 0xF9, 0xC0, 0x1D, + 0xC0, 0x0F, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFC, 0x00, 0xF7, 0x00, + 0x73, 0xE0, 0xF8, 0xFF, 0xF8, 0x3F, 0xF8, 0x07, 0xF0, 0x00, 0x07, 0xE0, + 0x1F, 0xF8, 0x3F, 0xFC, 0x7C, 0x3C, 0x70, 0x0E, 0xF0, 0x0E, 0xE0, 0x06, + 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x0F, 0x70, 0x0F, 0x78, 0x3F, + 0x3F, 0xFF, 0x1F, 0xF7, 0x07, 0xC7, 0x00, 0x07, 0x00, 0x06, 0x00, 0x0E, + 0x70, 0x0E, 0x70, 0x1C, 0x78, 0x3C, 0x3F, 0xF8, 0x1F, 0xF0, 0x07, 0xC0, + 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x07, 0xFF, 0x80, 0xFF, 0xF0, 0x00, 0x00, + 0x00, 0x07, 0xFF, 0xB6, 0xD6, 0x00, 0x00, 0x80, 0x03, 0xC0, 0x07, 0xE0, + 0x0F, 0xC0, 0x3F, 0x80, 0x7E, 0x00, 0xFC, 0x01, 0xF0, 0x00, 0xE0, 0x00, + 0x7C, 0x00, 0x1F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x80, 0x07, 0xF0, 0x00, + 0x7E, 0x00, 0x0F, 0x00, 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x80, 0x80, 0x00, 0x70, 0x00, 0x3E, 0x00, 0x0F, 0xE0, 0x00, 0xFC, + 0x00, 0x1F, 0xC0, 0x03, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0x80, 0x0F, 0xC0, + 0x1F, 0x80, 0x7F, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x01, 0xC0, 0x00, + 0x80, 0x00, 0x00, 0x0F, 0xC0, 0x7F, 0xE1, 0xFF, 0xE3, 0xC3, 0xEF, 0x01, + 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0x00, 0x0E, 0x00, 0x38, 0x00, 0xF0, + 0x07, 0xC0, 0x1F, 0x00, 0x7C, 0x00, 0xE0, 0x03, 0xC0, 0x07, 0x00, 0x0E, + 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC0, 0x03, 0x80, + 0x07, 0x00, 0x0E, 0x00, 0x00, 0x07, 0xF8, 0x00, 0x00, 0x3F, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0xC0, 0x01, 0xF8, 0x0F, 0xE0, 0x03, 0xE0, 0x01, 0xF0, + 0x07, 0x80, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x3C, 0x1E, 0x00, 0x00, 0x1E, + 0x3C, 0x03, 0xE0, 0x1E, 0x38, 0x0F, 0xF3, 0x8E, 0x78, 0x1E, 0x3F, 0x0F, + 0x70, 0x38, 0x1F, 0x07, 0x70, 0x78, 0x0F, 0x07, 0xE0, 0x70, 0x0E, 0x07, + 0xE0, 0x70, 0x0E, 0x07, 0xE0, 0xE0, 0x0E, 0x07, 0xE0, 0xE0, 0x1C, 0x07, + 0xE0, 0xE0, 0x1C, 0x0E, 0xE0, 0xE0, 0x1C, 0x0E, 0xE0, 0xE0, 0x38, 0x1C, + 0xF0, 0x70, 0x78, 0x3C, 0x70, 0x78, 0xFC, 0x78, 0x78, 0x3F, 0xDF, 0xF0, + 0x38, 0x1F, 0x0F, 0xC0, 0x3C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, + 0x0F, 0x80, 0x00, 0x00, 0x07, 0xF0, 0x0E, 0x00, 0x01, 0xFF, 0xFE, 0x00, + 0x00, 0x7F, 0xFE, 0x00, 0x00, 0x1F, 0xF0, 0x00, 0x00, 0xF8, 0x00, 0x03, + 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x7F, 0x00, 0x01, 0xDC, 0x00, 0x07, 0x78, + 0x00, 0x3C, 0xE0, 0x00, 0xE3, 0x80, 0x03, 0x8F, 0x00, 0x1E, 0x1C, 0x00, + 0x70, 0x70, 0x01, 0xC1, 0xE0, 0x0E, 0x03, 0x80, 0x38, 0x0E, 0x00, 0xE0, + 0x3C, 0x07, 0xFF, 0xF0, 0x1F, 0xFF, 0xE0, 0xFF, 0xFF, 0x83, 0xC0, 0x0E, + 0x0E, 0x00, 0x3C, 0x78, 0x00, 0xF1, 0xE0, 0x01, 0xC7, 0x00, 0x07, 0xBC, + 0x00, 0x1E, 0xF0, 0x00, 0x3B, 0x80, 0x00, 0xF0, 0xFF, 0xFC, 0x1F, 0xFF, + 0xE3, 0xFF, 0xFE, 0x70, 0x03, 0xCE, 0x00, 0x3D, 0xC0, 0x03, 0xB8, 0x00, + 0x77, 0x00, 0x0E, 0xE0, 0x01, 0xDC, 0x00, 0x73, 0x80, 0x1E, 0x7F, 0xFF, + 0x8F, 0xFF, 0xF1, 0xFF, 0xFF, 0x38, 0x00, 0xF7, 0x00, 0x0E, 0xE0, 0x00, + 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x03, + 0xF8, 0x00, 0xF7, 0xFF, 0xFC, 0xFF, 0xFF, 0x1F, 0xFF, 0x80, 0x00, 0xFF, + 0x00, 0x0F, 0xFF, 0x00, 0xFF, 0xFE, 0x07, 0xE0, 0x7C, 0x3E, 0x00, 0x78, + 0xF0, 0x00, 0xE7, 0x80, 0x03, 0xDC, 0x00, 0x07, 0x70, 0x00, 0x03, 0x80, + 0x00, 0x0E, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, 0x00, 0x03, 0x80, 0x00, + 0x0E, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, 0x00, 0x1D, 0xC0, 0x00, 0x77, + 0x00, 0x03, 0xDE, 0x00, 0x0E, 0x3C, 0x00, 0x78, 0xF8, 0x03, 0xC1, 0xF8, + 0x1F, 0x03, 0xFF, 0xF8, 0x03, 0xFF, 0xC0, 0x03, 0xF8, 0x00, 0xFF, 0xF8, + 0x0F, 0xFF, 0xE0, 0xFF, 0xFF, 0x0E, 0x00, 0xF8, 0xE0, 0x03, 0xCE, 0x00, + 0x1C, 0xE0, 0x00, 0xEE, 0x00, 0x0E, 0xE0, 0x00, 0xFE, 0x00, 0x07, 0xE0, + 0x00, 0x7E, 0x00, 0x07, 0xE0, 0x00, 0x7E, 0x00, 0x07, 0xE0, 0x00, 0x7E, + 0x00, 0x07, 0xE0, 0x00, 0x7E, 0x00, 0x0F, 0xE0, 0x00, 0xEE, 0x00, 0x0E, + 0xE0, 0x01, 0xEE, 0x00, 0x3C, 0xE0, 0x0F, 0x8F, 0xFF, 0xF0, 0xFF, 0xFE, + 0x0F, 0xFF, 0x80, 0xFF, 0xFF, 0xBF, 0xFF, 0xEF, 0xFF, 0xFB, 0x80, 0x00, + 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, + 0x00, 0x0E, 0x00, 0x03, 0xFF, 0xFE, 0xFF, 0xFF, 0xBF, 0xFF, 0xEE, 0x00, + 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, + 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x0E, 0x00, + 0x07, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x38, + 0x00, 0x1F, 0xFF, 0xCF, 0xFF, 0xE7, 0xFF, 0xF3, 0x80, 0x01, 0xC0, 0x00, + 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x00, + 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x00, 0x00, 0x7F, + 0x80, 0x03, 0xFF, 0xE0, 0x07, 0xFF, 0xF8, 0x0F, 0x80, 0xFC, 0x1E, 0x00, + 0x3E, 0x3C, 0x00, 0x0E, 0x78, 0x00, 0x0F, 0x70, 0x00, 0x07, 0x70, 0x00, + 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x03, + 0xFF, 0xE0, 0x03, 0xFF, 0xE0, 0x03, 0xFF, 0xE0, 0x00, 0x07, 0xF0, 0x00, + 0x07, 0x70, 0x00, 0x07, 0x70, 0x00, 0x0F, 0x78, 0x00, 0x0F, 0x3C, 0x00, + 0x1F, 0x1E, 0x00, 0x3F, 0x0F, 0xC0, 0xF7, 0x07, 0xFF, 0xE7, 0x03, 0xFF, + 0xC3, 0x00, 0xFF, 0x03, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, + 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, + 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, + 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, + 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, + 0x1C, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC0, + 0x07, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1F, 0x80, 0x7E, + 0x01, 0xF8, 0x07, 0xE0, 0x1F, 0xC0, 0xF7, 0x87, 0x9F, 0xFE, 0x3F, 0xF0, + 0x3F, 0x00, 0xE0, 0x01, 0xEE, 0x00, 0x3C, 0xE0, 0x07, 0x8E, 0x00, 0xF0, + 0xE0, 0x1E, 0x0E, 0x03, 0xE0, 0xE0, 0x7C, 0x0E, 0x0F, 0x80, 0xE1, 0xF0, + 0x0E, 0x1E, 0x00, 0xE3, 0xC0, 0x0E, 0x7C, 0x00, 0xEF, 0xE0, 0x0F, 0xCE, + 0x00, 0xF8, 0xF0, 0x0F, 0x07, 0x80, 0xE0, 0x3C, 0x0E, 0x03, 0xC0, 0xE0, + 0x1E, 0x0E, 0x00, 0xF0, 0xE0, 0x0F, 0x0E, 0x00, 0x78, 0xE0, 0x03, 0xCE, + 0x00, 0x3C, 0xE0, 0x01, 0xEE, 0x00, 0x0F, 0xE0, 0x01, 0xC0, 0x03, 0x80, + 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0xE0, 0x01, + 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, + 0x00, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, + 0x38, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF8, 0x00, 0x1F, 0xF8, + 0x00, 0x1F, 0xF8, 0x00, 0x1F, 0xFC, 0x00, 0x3F, 0xFC, 0x00, 0x3F, 0xFC, + 0x00, 0x3F, 0xEE, 0x00, 0x77, 0xEE, 0x00, 0x77, 0xEE, 0x00, 0x77, 0xE7, + 0x00, 0xE7, 0xE7, 0x00, 0xE7, 0xE7, 0x00, 0xE7, 0xE3, 0x81, 0xC7, 0xE3, + 0x81, 0xC7, 0xE3, 0x81, 0xC7, 0xE1, 0xC3, 0x87, 0xE1, 0xC3, 0x87, 0xE1, + 0xC3, 0x87, 0xE0, 0xE7, 0x07, 0xE0, 0xE7, 0x07, 0xE0, 0xE7, 0x07, 0xE0, + 0x7E, 0x07, 0xE0, 0x7E, 0x07, 0xE0, 0x7E, 0x07, 0xE0, 0x3C, 0x07, 0xE0, + 0x3C, 0x07, 0xF0, 0x00, 0x7F, 0x00, 0x07, 0xF8, 0x00, 0x7F, 0xC0, 0x07, + 0xFC, 0x00, 0x7F, 0xE0, 0x07, 0xEF, 0x00, 0x7E, 0x70, 0x07, 0xE7, 0x80, + 0x7E, 0x3C, 0x07, 0xE1, 0xC0, 0x7E, 0x1E, 0x07, 0xE0, 0xE0, 0x7E, 0x0F, + 0x07, 0xE0, 0x78, 0x7E, 0x03, 0x87, 0xE0, 0x3C, 0x7E, 0x01, 0xE7, 0xE0, + 0x0E, 0x7E, 0x00, 0xF7, 0xE0, 0x07, 0xFE, 0x00, 0x3F, 0xE0, 0x03, 0xFE, + 0x00, 0x1F, 0xE0, 0x01, 0xFE, 0x00, 0x0F, 0x00, 0x7F, 0x00, 0x01, 0xFF, + 0xF0, 0x01, 0xFF, 0xFC, 0x01, 0xF0, 0x1F, 0x01, 0xE0, 0x03, 0xC1, 0xE0, + 0x00, 0xF1, 0xE0, 0x00, 0x3C, 0xE0, 0x00, 0x0E, 0x70, 0x00, 0x07, 0x70, + 0x00, 0x03, 0xF8, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x3F, + 0x00, 0x00, 0x1F, 0x80, 0x00, 0x0F, 0xC0, 0x00, 0x07, 0xE0, 0x00, 0x03, + 0xB8, 0x00, 0x03, 0x9C, 0x00, 0x01, 0xCF, 0x00, 0x01, 0xE3, 0xC0, 0x01, + 0xE0, 0xF0, 0x01, 0xE0, 0x3E, 0x03, 0xE0, 0x0F, 0xFF, 0xE0, 0x03, 0xFF, + 0xE0, 0x00, 0x3F, 0x80, 0x00, 0xFF, 0xFC, 0x3F, 0xFF, 0x8F, 0xFF, 0xF3, + 0x80, 0x3E, 0xE0, 0x03, 0xF8, 0x00, 0x7E, 0x00, 0x1F, 0x80, 0x07, 0xE0, + 0x01, 0xF8, 0x00, 0x7E, 0x00, 0x3F, 0x80, 0x1E, 0xFF, 0xFF, 0x3F, 0xFF, + 0x8F, 0xFF, 0xC3, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, + 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, + 0x00, 0x38, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x01, 0xFF, 0xF0, 0x01, 0xFF, + 0xFC, 0x01, 0xF0, 0x1F, 0x01, 0xE0, 0x03, 0xC1, 0xE0, 0x00, 0xF1, 0xE0, + 0x00, 0x3C, 0xE0, 0x00, 0x0E, 0x70, 0x00, 0x07, 0x70, 0x00, 0x01, 0xF8, + 0x00, 0x00, 0xFC, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x1F, + 0x80, 0x00, 0x0F, 0xC0, 0x00, 0x07, 0xE0, 0x00, 0x07, 0xB8, 0x00, 0x03, + 0x9C, 0x00, 0x01, 0xCF, 0x00, 0x39, 0xE3, 0xC0, 0x1F, 0xE0, 0xF0, 0x07, + 0xE0, 0x3E, 0x03, 0xF0, 0x0F, 0xFF, 0xFC, 0x03, 0xFF, 0xEE, 0x00, 0x3F, + 0x83, 0x80, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x20, 0xFF, 0xFE, 0x0F, 0xFF, + 0xF8, 0xFF, 0xFF, 0xCE, 0x00, 0x3C, 0xE0, 0x01, 0xEE, 0x00, 0x0E, 0xE0, + 0x00, 0xEE, 0x00, 0x0E, 0xE0, 0x00, 0xEE, 0x00, 0x0E, 0xE0, 0x01, 0xCE, + 0x00, 0x3C, 0xFF, 0xFF, 0x8F, 0xFF, 0xF0, 0xFF, 0xFF, 0x8E, 0x00, 0x3C, + 0xE0, 0x01, 0xEE, 0x00, 0x0E, 0xE0, 0x00, 0xEE, 0x00, 0x0E, 0xE0, 0x00, + 0xEE, 0x00, 0x0E, 0xE0, 0x00, 0xEE, 0x00, 0x0E, 0xE0, 0x00, 0xFE, 0x00, + 0x0F, 0x03, 0xFC, 0x00, 0xFF, 0xF0, 0x1F, 0xFF, 0x83, 0xE0, 0x7C, 0x38, + 0x01, 0xE7, 0x00, 0x0E, 0x70, 0x00, 0xE7, 0x00, 0x00, 0x70, 0x00, 0x07, + 0x80, 0x00, 0x3E, 0x00, 0x01, 0xFE, 0x00, 0x0F, 0xFE, 0x00, 0x3F, 0xF8, + 0x00, 0x3F, 0xE0, 0x00, 0x3E, 0x00, 0x00, 0xF0, 0x00, 0x07, 0xE0, 0x00, + 0x7E, 0x00, 0x07, 0xF0, 0x00, 0x77, 0x80, 0x0E, 0x7C, 0x03, 0xE3, 0xFF, + 0xFC, 0x1F, 0xFF, 0x80, 0x3F, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x80, 0x70, 0x00, 0x0E, 0x00, 0x01, 0xC0, 0x00, 0x38, 0x00, 0x07, + 0x00, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0x03, 0x80, 0x00, 0x70, 0x00, 0x0E, + 0x00, 0x01, 0xC0, 0x00, 0x38, 0x00, 0x07, 0x00, 0x00, 0xE0, 0x00, 0x1C, + 0x00, 0x03, 0x80, 0x00, 0x70, 0x00, 0x0E, 0x00, 0x01, 0xC0, 0x00, 0x38, + 0x00, 0x07, 0x00, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0xE0, 0x00, 0xFC, 0x00, + 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, + 0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, + 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00, + 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7F, 0x00, 0x1E, 0xF0, 0x07, + 0x9F, 0x01, 0xF1, 0xFF, 0xFC, 0x1F, 0xFE, 0x00, 0x7F, 0x00, 0xE0, 0x00, + 0x7F, 0x80, 0x03, 0xFC, 0x00, 0x1C, 0xE0, 0x01, 0xE7, 0x80, 0x0F, 0x3C, + 0x00, 0x70, 0xE0, 0x07, 0x87, 0x80, 0x3C, 0x1C, 0x01, 0xC0, 0xE0, 0x0E, + 0x07, 0x80, 0xE0, 0x1C, 0x07, 0x00, 0xE0, 0x38, 0x07, 0x83, 0x80, 0x1C, + 0x1C, 0x00, 0xE0, 0xE0, 0x07, 0x8E, 0x00, 0x1C, 0x70, 0x00, 0xE3, 0x80, + 0x07, 0xB8, 0x00, 0x1D, 0xC0, 0x00, 0xEE, 0x00, 0x07, 0xE0, 0x00, 0x1F, + 0x00, 0x00, 0xF8, 0x00, 0x03, 0x80, 0x00, 0x70, 0x03, 0xC0, 0x0F, 0x70, + 0x03, 0xC0, 0x0F, 0x78, 0x03, 0xE0, 0x0F, 0x78, 0x03, 0xE0, 0x0E, 0x38, + 0x07, 0xE0, 0x0E, 0x38, 0x07, 0xF0, 0x1E, 0x3C, 0x07, 0x70, 0x1E, 0x3C, + 0x07, 0x70, 0x1C, 0x1C, 0x0E, 0x70, 0x1C, 0x1C, 0x0E, 0x38, 0x3C, 0x1C, + 0x0E, 0x38, 0x3C, 0x1E, 0x1E, 0x38, 0x38, 0x0E, 0x1C, 0x38, 0x38, 0x0E, + 0x1C, 0x1C, 0x38, 0x0E, 0x1C, 0x1C, 0x78, 0x0F, 0x3C, 0x1C, 0x70, 0x07, + 0x38, 0x0E, 0x70, 0x07, 0x38, 0x0E, 0x70, 0x07, 0x38, 0x0E, 0x70, 0x07, + 0x70, 0x0E, 0xE0, 0x03, 0xF0, 0x07, 0xE0, 0x03, 0xF0, 0x07, 0xE0, 0x03, + 0xF0, 0x07, 0xE0, 0x03, 0xE0, 0x03, 0xC0, 0x01, 0xE0, 0x03, 0xC0, 0x01, + 0xE0, 0x03, 0xC0, 0xF0, 0x00, 0x7B, 0xC0, 0x07, 0x8F, 0x00, 0x38, 0x78, + 0x03, 0xC1, 0xE0, 0x3C, 0x07, 0x81, 0xC0, 0x3C, 0x1E, 0x00, 0xF1, 0xE0, + 0x03, 0x8E, 0x00, 0x1E, 0xF0, 0x00, 0x7F, 0x00, 0x01, 0xF0, 0x00, 0x0F, + 0x80, 0x00, 0x7C, 0x00, 0x07, 0xF0, 0x00, 0x3B, 0x80, 0x03, 0xDE, 0x00, + 0x3C, 0x78, 0x01, 0xC1, 0xC0, 0x1E, 0x0F, 0x01, 0xE0, 0x3C, 0x0E, 0x00, + 0xE0, 0xF0, 0x07, 0x8F, 0x00, 0x1E, 0x70, 0x00, 0xF7, 0x80, 0x03, 0xC0, + 0xF0, 0x00, 0x3C, 0xF0, 0x00, 0x78, 0xF0, 0x01, 0xE1, 0xE0, 0x03, 0x81, + 0xE0, 0x0F, 0x01, 0xC0, 0x1C, 0x03, 0xC0, 0x78, 0x03, 0xC1, 0xE0, 0x07, + 0x83, 0x80, 0x07, 0x8F, 0x00, 0x07, 0x1C, 0x00, 0x0F, 0x78, 0x00, 0x0E, + 0xE0, 0x00, 0x0F, 0x80, 0x00, 0x1F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x38, + 0x00, 0x00, 0x70, 0x00, 0x00, 0xE0, 0x00, 0x01, 0xC0, 0x00, 0x03, 0x80, + 0x00, 0x07, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x38, 0x00, + 0x00, 0x70, 0x00, 0x7F, 0xFF, 0xEF, 0xFF, 0xFD, 0xFF, 0xFF, 0x80, 0x00, + 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x80, 0x01, 0xE0, 0x00, 0x78, 0x00, 0x1E, + 0x00, 0x07, 0x80, 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0xC0, + 0x00, 0x78, 0x00, 0x1E, 0x00, 0x07, 0x80, 0x01, 0xE0, 0x00, 0x7C, 0x00, + 0x0F, 0x00, 0x03, 0xC0, 0x00, 0xF0, 0x00, 0x3E, 0x00, 0x07, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xF8, 0xE3, 0x8E, 0x38, 0xE3, + 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, + 0x8E, 0x38, 0xE3, 0x8F, 0xFF, 0xFC, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x60, + 0x0C, 0x03, 0x00, 0xC0, 0x18, 0x06, 0x01, 0x80, 0x20, 0x0C, 0x03, 0x00, + 0x40, 0x18, 0x06, 0x01, 0x80, 0x30, 0x0C, 0x03, 0x00, 0x60, 0x18, 0x06, + 0x00, 0xC0, 0x30, 0xFF, 0xFF, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, + 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, + 0x1C, 0x7F, 0xFF, 0xFC, 0x07, 0x00, 0x78, 0x03, 0xC0, 0x3F, 0x01, 0xD8, + 0x0C, 0xE0, 0xE3, 0x06, 0x1C, 0x70, 0xE3, 0x83, 0x18, 0x1D, 0xC0, 0x6C, + 0x03, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xF0, 0xF0, 0xE0, 0xE0, + 0xE0, 0x07, 0xF0, 0x0F, 0xFC, 0x0F, 0xFF, 0x0F, 0x03, 0xC7, 0x00, 0xE0, + 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0xFE, 0x0F, 0xFF, 0x1F, 0xF3, + 0x9F, 0x01, 0xCF, 0x00, 0xE7, 0x00, 0x73, 0x80, 0x79, 0xE0, 0xFC, 0x7F, + 0xEF, 0x9F, 0xE3, 0xC7, 0xE1, 0xE0, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE3, 0xE0, 0xEF, 0xF8, + 0xFF, 0xFC, 0xFC, 0x3E, 0xF8, 0x1E, 0xF0, 0x0E, 0xE0, 0x0F, 0xE0, 0x07, + 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x0E, + 0xF8, 0x1E, 0xFC, 0x3C, 0xEF, 0xFC, 0xEF, 0xF8, 0xE3, 0xE0, 0x07, 0xF0, + 0x1F, 0xF8, 0x3F, 0xFC, 0x3C, 0x1E, 0x78, 0x0E, 0x70, 0x07, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x07, + 0x70, 0x07, 0x78, 0x0E, 0x7C, 0x1E, 0x3F, 0xFC, 0x1F, 0xF8, 0x07, 0xE0, + 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, + 0x1C, 0x00, 0x0E, 0x0F, 0xC7, 0x1F, 0xFB, 0x9F, 0xFF, 0xDF, 0x07, 0xEF, + 0x01, 0xF7, 0x00, 0x7F, 0x80, 0x3F, 0x80, 0x0F, 0xC0, 0x07, 0xE0, 0x03, + 0xF0, 0x01, 0xF8, 0x00, 0xFC, 0x00, 0x77, 0x00, 0x7B, 0xC0, 0x7D, 0xF0, + 0x7E, 0x7F, 0xFB, 0x1F, 0xF9, 0x83, 0xF0, 0xC0, 0x07, 0xE0, 0x1F, 0xF8, + 0x3F, 0xFC, 0x7C, 0x1E, 0x70, 0x0E, 0x60, 0x06, 0xE0, 0x07, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x70, 0x07, + 0x78, 0x0E, 0x3C, 0x1E, 0x3F, 0xFC, 0x1F, 0xF8, 0x07, 0xE0, 0x0E, 0x3C, + 0xF9, 0xC3, 0x87, 0x0E, 0x7F, 0xFF, 0xFC, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, + 0x38, 0x70, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0x07, 0xC7, 0x1F, + 0xF7, 0x3F, 0xFF, 0x3C, 0x3F, 0x78, 0x0F, 0x70, 0x0F, 0xE0, 0x07, 0xE0, + 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0x70, + 0x0F, 0x78, 0x0F, 0x7C, 0x3F, 0x3F, 0xF7, 0x1F, 0xE7, 0x07, 0xC7, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x0E, 0x70, 0x0E, 0x78, 0x1E, 0x3F, 0xFC, 0x1F, + 0xF8, 0x07, 0xE0, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, + 0x1C, 0x00, 0x38, 0x00, 0x71, 0xF8, 0xE7, 0xFD, 0xDF, 0xFB, 0xF0, 0xFF, + 0xC0, 0xFF, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, + 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, + 0xE0, 0x0F, 0xC0, 0x1C, 0xFF, 0xF0, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFC, 0x1C, 0x71, 0xC7, 0x00, 0x00, 0x07, 0x1C, 0x71, 0xC7, 0x1C, + 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, + 0x73, 0xFF, 0xFB, 0xC0, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x3C, 0xE0, 0x78, 0xE0, 0xF0, + 0xE1, 0xE0, 0xE3, 0xC0, 0xE7, 0x80, 0xEF, 0x00, 0xEF, 0x80, 0xFF, 0x80, + 0xFB, 0xC0, 0xF1, 0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0xE0, 0x70, 0xE0, 0x78, + 0xE0, 0x3C, 0xE0, 0x1C, 0xE0, 0x1E, 0xE0, 0x0E, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xE3, 0xE0, 0xF8, 0xE7, 0xF1, 0xFE, + 0xEF, 0xFB, 0xFE, 0xF8, 0x7F, 0x0F, 0xF0, 0x3E, 0x07, 0xF0, 0x1C, 0x07, + 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, + 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, + 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, 0xE0, 0x1C, 0x07, + 0xE0, 0x1C, 0x07, 0xE3, 0xF1, 0xCF, 0xFB, 0xBF, 0xF7, 0xE1, 0xFF, 0x81, + 0xFE, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, + 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, + 0x1F, 0x80, 0x38, 0x07, 0xF0, 0x0F, 0xFE, 0x0F, 0xFF, 0x87, 0x83, 0xC7, + 0x80, 0xF3, 0x80, 0x3B, 0x80, 0x1F, 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x01, + 0xF8, 0x00, 0xFC, 0x00, 0x7E, 0x00, 0x3B, 0x80, 0x39, 0xE0, 0x3C, 0x78, + 0x3C, 0x3F, 0xFE, 0x0F, 0xFE, 0x01, 0xFC, 0x00, 0xE3, 0xE0, 0xE7, 0xF8, + 0xEF, 0xFC, 0xFC, 0x3E, 0xF8, 0x1E, 0xF0, 0x0E, 0xE0, 0x0F, 0xE0, 0x07, + 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x0E, + 0xF8, 0x1E, 0xFC, 0x3E, 0xFF, 0xFC, 0xEF, 0xF8, 0xE3, 0xE0, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x07, 0xE1, + 0x8F, 0xFC, 0xCF, 0xFF, 0x67, 0x83, 0xF7, 0x80, 0xFB, 0x80, 0x3F, 0xC0, + 0x1F, 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFC, 0x00, 0x7E, + 0x00, 0x3B, 0x80, 0x3D, 0xE0, 0x3E, 0xF8, 0x3F, 0x3F, 0xFF, 0x8F, 0xFD, + 0xC1, 0xF8, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00, + 0x07, 0x00, 0x03, 0x80, 0xE3, 0xF7, 0xFB, 0xFF, 0x8F, 0x07, 0x83, 0x81, + 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x70, + 0x38, 0x00, 0x0F, 0xC0, 0xFF, 0x87, 0xFF, 0x3C, 0x1E, 0xE0, 0x3B, 0x80, + 0x0E, 0x00, 0x3C, 0x00, 0x7F, 0x00, 0xFF, 0x80, 0xFF, 0x80, 0x7F, 0x00, + 0x3F, 0x80, 0x7E, 0x01, 0xFC, 0x1F, 0x7F, 0xF8, 0xFF, 0xC1, 0xFC, 0x00, + 0x38, 0x70, 0xE1, 0xCF, 0xFF, 0xFF, 0x9C, 0x38, 0x70, 0xE1, 0xC3, 0x87, + 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3, 0xE7, 0xC7, 0x80, 0xE0, 0x0F, 0xC0, + 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, + 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x03, 0xFC, + 0x0F, 0xFC, 0x3F, 0x7F, 0xEE, 0xFF, 0x9C, 0x7E, 0x38, 0x70, 0x03, 0xB8, + 0x03, 0x9C, 0x01, 0xC7, 0x00, 0xE3, 0x80, 0xE1, 0xC0, 0x70, 0x70, 0x38, + 0x38, 0x38, 0x1C, 0x1C, 0x07, 0x0E, 0x03, 0x8E, 0x01, 0xC7, 0x00, 0x77, + 0x00, 0x3B, 0x80, 0x1D, 0xC0, 0x07, 0xC0, 0x03, 0xE0, 0x01, 0xF0, 0x00, + 0x70, 0x00, 0xF0, 0x1C, 0x03, 0xB8, 0x1F, 0x03, 0xDC, 0x0F, 0x81, 0xCE, + 0x07, 0xC0, 0xE7, 0x83, 0xE0, 0x71, 0xC3, 0xB8, 0x70, 0xE1, 0xDC, 0x38, + 0x70, 0xEE, 0x1C, 0x1C, 0x63, 0x0E, 0x0E, 0x71, 0xCE, 0x07, 0x38, 0xE7, + 0x03, 0x9C, 0x73, 0x80, 0xEC, 0x19, 0x80, 0x7E, 0x0F, 0xC0, 0x3F, 0x07, + 0xE0, 0x0F, 0x83, 0xF0, 0x07, 0x80, 0xF0, 0x03, 0xC0, 0x78, 0x01, 0xE0, + 0x3C, 0x00, 0x70, 0x07, 0x38, 0x0E, 0x3C, 0x1C, 0x1C, 0x1C, 0x0E, 0x38, + 0x0F, 0x70, 0x07, 0x70, 0x03, 0xE0, 0x03, 0xC0, 0x01, 0xC0, 0x03, 0xE0, + 0x07, 0xE0, 0x07, 0x70, 0x0E, 0x78, 0x1E, 0x38, 0x1C, 0x1C, 0x38, 0x1E, + 0x78, 0x0E, 0x70, 0x07, 0x70, 0x07, 0x38, 0x03, 0x9C, 0x01, 0xC7, 0x01, + 0xC3, 0x80, 0xE1, 0xC0, 0x70, 0x70, 0x70, 0x38, 0x38, 0x1C, 0x3C, 0x07, + 0x1C, 0x03, 0x8E, 0x01, 0xCE, 0x00, 0x77, 0x00, 0x3B, 0x80, 0x1F, 0x80, + 0x07, 0xC0, 0x03, 0xE0, 0x01, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x38, + 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x0E, 0x00, 0x3F, 0x00, 0x1F, 0x00, 0x0F, + 0x00, 0x00, 0x7F, 0xFC, 0xFF, 0xF9, 0xFF, 0xF0, 0x00, 0xE0, 0x03, 0x80, + 0x0E, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x1C, 0x00, 0x70, + 0x01, 0xE0, 0x07, 0x80, 0x1E, 0x00, 0x78, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF8, 0x07, 0x0F, 0x1F, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, + 0x1C, 0x1C, 0x1C, 0x1C, 0x38, 0xF8, 0xE0, 0xF8, 0x38, 0x1C, 0x1C, 0x1C, + 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1F, 0x0F, 0x07, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xE0, 0xF0, 0xF8, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x1C, 0x1F, + 0x07, 0x1F, 0x1C, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, + 0x38, 0x38, 0xF8, 0xF0, 0xE0, 0x38, 0x00, 0xFC, 0x03, 0xFC, 0x1F, 0x3E, + 0x3C, 0x1F, 0xE0, 0x1F, 0x80, 0x1E, 0x00}; + +const GFXglyph FreeSans18pt7bGlyphs[] PROGMEM = { + {0, 0, 0, 9, 0, 1}, // 0x20 ' ' + {0, 3, 26, 12, 4, -25}, // 0x21 '!' + {10, 9, 9, 12, 1, -24}, // 0x22 '"' + {21, 19, 24, 19, 0, -23}, // 0x23 '#' + {78, 16, 30, 19, 2, -26}, // 0x24 '$' + {138, 29, 25, 31, 1, -24}, // 0x25 '%' + {229, 20, 25, 23, 2, -24}, // 0x26 '&' + {292, 3, 9, 7, 2, -24}, // 0x27 ''' + {296, 8, 33, 12, 3, -25}, // 0x28 '(' + {329, 8, 33, 12, 1, -25}, // 0x29 ')' + {362, 10, 10, 14, 2, -25}, // 0x2A '*' + {375, 16, 16, 20, 2, -15}, // 0x2B '+' + {407, 3, 9, 10, 3, -3}, // 0x2C ',' + {411, 8, 3, 12, 2, -10}, // 0x2D '-' + {414, 3, 4, 9, 3, -3}, // 0x2E '.' + {416, 10, 26, 10, 0, -25}, // 0x2F '/' + {449, 16, 25, 19, 2, -24}, // 0x30 '0' + {499, 8, 25, 19, 4, -24}, // 0x31 '1' + {524, 16, 25, 19, 2, -24}, // 0x32 '2' + {574, 17, 25, 19, 1, -24}, // 0x33 '3' + {628, 16, 25, 19, 1, -24}, // 0x34 '4' + {678, 17, 25, 19, 1, -24}, // 0x35 '5' + {732, 16, 25, 19, 2, -24}, // 0x36 '6' + {782, 16, 25, 19, 2, -24}, // 0x37 '7' + {832, 17, 25, 19, 1, -24}, // 0x38 '8' + {886, 16, 25, 19, 1, -24}, // 0x39 '9' + {936, 3, 19, 9, 3, -18}, // 0x3A ':' + {944, 3, 24, 9, 3, -18}, // 0x3B ';' + {953, 17, 17, 20, 2, -16}, // 0x3C '<' + {990, 17, 9, 20, 2, -12}, // 0x3D '=' + {1010, 17, 17, 20, 2, -16}, // 0x3E '>' + {1047, 15, 26, 19, 3, -25}, // 0x3F '?' + {1096, 32, 31, 36, 1, -25}, // 0x40 '@' + {1220, 22, 26, 23, 1, -25}, // 0x41 'A' + {1292, 19, 26, 23, 3, -25}, // 0x42 'B' + {1354, 22, 26, 25, 1, -25}, // 0x43 'C' + {1426, 20, 26, 24, 3, -25}, // 0x44 'D' + {1491, 18, 26, 22, 3, -25}, // 0x45 'E' + {1550, 17, 26, 21, 3, -25}, // 0x46 'F' + {1606, 24, 26, 27, 1, -25}, // 0x47 'G' + {1684, 19, 26, 25, 3, -25}, // 0x48 'H' + {1746, 3, 26, 10, 4, -25}, // 0x49 'I' + {1756, 14, 26, 18, 1, -25}, // 0x4A 'J' + {1802, 20, 26, 24, 3, -25}, // 0x4B 'K' + {1867, 15, 26, 20, 3, -25}, // 0x4C 'L' + {1916, 24, 26, 30, 3, -25}, // 0x4D 'M' + {1994, 20, 26, 26, 3, -25}, // 0x4E 'N' + {2059, 25, 26, 27, 1, -25}, // 0x4F 'O' + {2141, 18, 26, 23, 3, -25}, // 0x50 'P' + {2200, 25, 28, 27, 1, -25}, // 0x51 'Q' + {2288, 20, 26, 25, 3, -25}, // 0x52 'R' + {2353, 20, 26, 23, 1, -25}, // 0x53 'S' + {2418, 19, 26, 22, 1, -25}, // 0x54 'T' + {2480, 19, 26, 25, 3, -25}, // 0x55 'U' + {2542, 21, 26, 23, 1, -25}, // 0x56 'V' + {2611, 32, 26, 33, 0, -25}, // 0x57 'W' + {2715, 21, 26, 23, 1, -25}, // 0x58 'X' + {2784, 23, 26, 24, 0, -25}, // 0x59 'Y' + {2859, 19, 26, 22, 1, -25}, // 0x5A 'Z' + {2921, 6, 33, 10, 2, -25}, // 0x5B '[' + {2946, 10, 26, 10, 0, -25}, // 0x5C '\' + {2979, 6, 33, 10, 1, -25}, // 0x5D ']' + {3004, 13, 13, 16, 2, -24}, // 0x5E '^' + {3026, 21, 2, 19, -1, 5}, // 0x5F '_' + {3032, 7, 5, 9, 1, -25}, // 0x60 '`' + {3037, 17, 19, 19, 1, -18}, // 0x61 'a' + {3078, 16, 26, 20, 2, -25}, // 0x62 'b' + {3130, 16, 19, 18, 1, -18}, // 0x63 'c' + {3168, 17, 26, 20, 1, -25}, // 0x64 'd' + {3224, 16, 19, 19, 1, -18}, // 0x65 'e' + {3262, 7, 26, 10, 1, -25}, // 0x66 'f' + {3285, 16, 27, 19, 1, -18}, // 0x67 'g' + {3339, 15, 26, 19, 2, -25}, // 0x68 'h' + {3388, 3, 26, 8, 2, -25}, // 0x69 'i' + {3398, 6, 34, 9, 0, -25}, // 0x6A 'j' + {3424, 16, 26, 18, 2, -25}, // 0x6B 'k' + {3476, 3, 26, 7, 2, -25}, // 0x6C 'l' + {3486, 24, 19, 28, 2, -18}, // 0x6D 'm' + {3543, 15, 19, 19, 2, -18}, // 0x6E 'n' + {3579, 17, 19, 19, 1, -18}, // 0x6F 'o' + {3620, 16, 25, 20, 2, -18}, // 0x70 'p' + {3670, 17, 25, 20, 1, -18}, // 0x71 'q' + {3724, 9, 19, 12, 2, -18}, // 0x72 'r' + {3746, 14, 19, 17, 2, -18}, // 0x73 's' + {3780, 7, 23, 10, 1, -22}, // 0x74 't' + {3801, 15, 19, 19, 2, -18}, // 0x75 'u' + {3837, 17, 19, 17, 0, -18}, // 0x76 'v' + {3878, 25, 19, 25, 0, -18}, // 0x77 'w' + {3938, 16, 19, 17, 0, -18}, // 0x78 'x' + {3976, 17, 27, 17, 0, -18}, // 0x79 'y' + {4034, 15, 19, 17, 1, -18}, // 0x7A 'z' + {4070, 8, 33, 12, 1, -25}, // 0x7B '{' + {4103, 2, 33, 9, 3, -25}, // 0x7C '|' + {4112, 8, 33, 12, 3, -25}, // 0x7D '}' + {4145, 15, 7, 18, 1, -15}}; // 0x7E '~' + +const GFXfont FreeSans18pt7b PROGMEM = {(uint8_t *)FreeSans18pt7bBitmaps, + (GFXglyph *)FreeSans18pt7bGlyphs, 0x20, + 0x7E, 42}; + +// Approx. 4831 bytes diff --git a/RX_FSK/src/fonts/FreeSans18pt8b.h b/RX_FSK/src/fonts/FreeSans18pt8b.h new file mode 100644 index 0000000..53ec130 --- /dev/null +++ b/RX_FSK/src/fonts/FreeSans18pt8b.h @@ -0,0 +1,1030 @@ +const uint8_t FreeSans18pt8bBitmaps[] PROGMEM = { + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDB, 0x6D, 0xB0, 0x3F, 0xFC, 0xE7, + 0xF3, 0xF9, 0xFC, 0xFE, 0x3F, 0x1B, 0x8C, 0x86, 0x43, 0x00, 0x01, 0xC3, + 0x80, 0x38, 0x70, 0x06, 0x0C, 0x00, 0xC1, 0x80, 0x38, 0x70, 0x07, 0x0E, + 0x0F, 0xFF, 0xF9, 0xFF, 0xFF, 0x3F, 0xFF, 0xE0, 0xE1, 0xC0, 0x1C, 0x38, + 0x03, 0x87, 0x00, 0x70, 0xE0, 0x0C, 0x18, 0x01, 0x83, 0x07, 0xFF, 0xFE, + 0xFF, 0xFF, 0xC1, 0xC3, 0x80, 0x38, 0x70, 0x06, 0x0C, 0x01, 0xC3, 0x80, + 0x38, 0x70, 0x07, 0x0E, 0x00, 0xE1, 0xC0, 0x18, 0x30, 0x00, 0x01, 0xC0, + 0x00, 0xE0, 0x01, 0xFC, 0x03, 0xFF, 0x83, 0xFF, 0xE3, 0xCE, 0x79, 0xC7, + 0x1C, 0xE3, 0x8E, 0x61, 0xC3, 0x38, 0xE0, 0x1C, 0x70, 0x0F, 0x38, 0x03, + 0xFC, 0x01, 0xFF, 0x00, 0x3F, 0xF0, 0x07, 0xFC, 0x01, 0xFF, 0x00, 0xE3, + 0xC0, 0x70, 0xE0, 0x38, 0x7E, 0x1C, 0x3F, 0x0E, 0x1F, 0x87, 0x0E, 0xE3, + 0x8F, 0x79, 0xCF, 0x1F, 0xFF, 0x07, 0xFF, 0x00, 0x7E, 0x00, 0x1C, 0x00, + 0x0E, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x78, 0x00, 0x60, 0x0F, + 0xF0, 0x06, 0x00, 0xFF, 0xC0, 0x30, 0x07, 0x0E, 0x03, 0x00, 0x70, 0x38, + 0x38, 0x03, 0x01, 0xC1, 0x80, 0x18, 0x0E, 0x1C, 0x00, 0xE0, 0x70, 0xC0, + 0x03, 0x07, 0x0E, 0x00, 0x1F, 0xF8, 0x60, 0x00, 0x7F, 0x87, 0x00, 0x00, + 0xF0, 0x30, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x18, 0x3F, 0x00, 0x01, + 0x83, 0xFC, 0x00, 0x1C, 0x3C, 0x70, 0x00, 0xC1, 0x81, 0xC0, 0x0E, 0x1C, + 0x0E, 0x00, 0x60, 0xE0, 0x30, 0x07, 0x07, 0x01, 0x80, 0x30, 0x38, 0x1C, + 0x03, 0x80, 0xE1, 0xC0, 0x18, 0x07, 0xFE, 0x01, 0x80, 0x0F, 0xE0, 0x0C, + 0x00, 0x18, 0x00, 0x01, 0xE0, 0x00, 0x7F, 0x00, 0x0F, 0xF8, 0x01, 0xC1, + 0xC0, 0x1C, 0x1C, 0x01, 0xC0, 0xC0, 0x1C, 0x1C, 0x01, 0xC1, 0xC0, 0x1E, + 0x3C, 0x00, 0xF7, 0x80, 0x07, 0xF0, 0x00, 0x7C, 0x00, 0x0F, 0xC0, 0x03, + 0xFE, 0x1C, 0x78, 0xF1, 0xC7, 0x07, 0x9C, 0xE0, 0x39, 0xCE, 0x03, 0xF8, + 0xE0, 0x1F, 0x8E, 0x00, 0xF0, 0xE0, 0x0F, 0x8F, 0x01, 0xF8, 0x78, 0x3D, + 0xC7, 0xFF, 0x9E, 0x3F, 0xF0, 0xF0, 0x78, 0x00, 0xFF, 0xFF, 0xF6, 0x40, + 0x06, 0x0C, 0x30, 0xE1, 0x87, 0x0C, 0x38, 0x70, 0xC3, 0x87, 0x0E, 0x1C, + 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0E, 0x1C, 0x38, 0x70, 0x60, 0xE1, 0xC1, + 0x83, 0x83, 0x07, 0x06, 0x06, 0xC0, 0x60, 0x70, 0x30, 0x38, 0x18, 0x1C, + 0x0C, 0x0C, 0x0E, 0x0E, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x06, 0x0E, 0x0E, 0x0C, 0x0C, 0x1C, 0x18, 0x38, 0x30, + 0x70, 0x60, 0x06, 0x00, 0xC0, 0x18, 0x23, 0x27, 0xFE, 0x7F, 0x83, 0x80, + 0xF8, 0x39, 0x86, 0x30, 0x40, 0x00, 0x01, 0x80, 0x00, 0xC0, 0x00, 0x60, + 0x00, 0x30, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x06, 0x00, 0x03, 0x00, 0xFF, + 0xFF, 0xFF, 0xFF, 0xC0, 0x60, 0x00, 0x30, 0x00, 0x18, 0x00, 0x0C, 0x00, + 0x06, 0x00, 0x03, 0x00, 0x01, 0x80, 0x00, 0xFF, 0xFF, 0x33, 0x36, 0xC0, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xC0, 0x30, 0x18, 0x06, 0x01, 0x80, + 0xC0, 0x30, 0x0C, 0x06, 0x01, 0x80, 0x60, 0x10, 0x0C, 0x03, 0x00, 0xC0, + 0x60, 0x18, 0x06, 0x03, 0x00, 0xC0, 0x30, 0x18, 0x06, 0x01, 0x80, 0xC0, + 0x30, 0x0C, 0x00, 0x03, 0xE0, 0x07, 0xFC, 0x07, 0xFF, 0x03, 0xC3, 0xC3, + 0x80, 0xE1, 0xC0, 0x79, 0xC0, 0x1C, 0xE0, 0x0E, 0x70, 0x07, 0x38, 0x03, + 0xDC, 0x00, 0xEE, 0x00, 0x7F, 0x00, 0x3F, 0x80, 0x1D, 0xC0, 0x0E, 0xE0, + 0x0F, 0x70, 0x07, 0xB8, 0x03, 0x9C, 0x01, 0xCE, 0x00, 0xE3, 0x80, 0xF1, + 0xC0, 0x70, 0x70, 0x78, 0x3F, 0xF8, 0x0F, 0xF8, 0x01, 0xF0, 0x00, 0x03, + 0x03, 0x07, 0x07, 0x1F, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x03, 0xE0, 0x07, 0xFE, 0x07, 0xFF, 0x87, 0x83, 0xE3, 0x80, 0x73, 0xC0, + 0x3D, 0xC0, 0x0E, 0xE0, 0x07, 0x70, 0x03, 0x80, 0x03, 0xC0, 0x01, 0xC0, + 0x01, 0xE0, 0x03, 0xE0, 0x07, 0xE0, 0x07, 0xC0, 0x0F, 0xC0, 0x0F, 0x80, + 0x0F, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x07, 0x00, 0x03, 0x80, 0x03, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x03, 0xE0, 0x0F, 0xFC, 0x0F, 0xFF, + 0x07, 0x83, 0xC7, 0x80, 0xF3, 0x80, 0x39, 0xC0, 0x1C, 0xE0, 0x0E, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x80, 0x3F, 0x80, 0x1F, 0x80, 0x0F, 0xF0, + 0x00, 0x3C, 0x00, 0x0E, 0x00, 0x07, 0x80, 0x01, 0xF8, 0x00, 0xFC, 0x00, + 0xF7, 0x00, 0x73, 0x80, 0x79, 0xF0, 0x78, 0x7F, 0xFC, 0x1F, 0xF8, 0x01, + 0xF0, 0x00, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F, 0x80, 0x0F, + 0xC0, 0x0F, 0xE0, 0x07, 0xF0, 0x07, 0x78, 0x07, 0x3C, 0x03, 0x9E, 0x03, + 0x8F, 0x03, 0x87, 0x83, 0x83, 0xC1, 0xC1, 0xE1, 0xC0, 0xF1, 0xC0, 0x78, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x07, 0x80, 0x03, 0xC0, 0x01, + 0xE0, 0x00, 0xF0, 0x00, 0x78, 0x00, 0x3C, 0x00, 0x1F, 0xFF, 0x0F, 0xFF, + 0x87, 0xFF, 0xC7, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, + 0x00, 0x38, 0x00, 0x1B, 0xFC, 0x1F, 0xFF, 0x0F, 0xCF, 0xC7, 0x80, 0xF3, + 0x80, 0x38, 0x00, 0x1E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, + 0xFC, 0x00, 0xF7, 0x00, 0x73, 0xC0, 0x78, 0xF0, 0x78, 0x7F, 0xF8, 0x1F, + 0xF8, 0x01, 0xF0, 0x00, 0x01, 0xE0, 0x03, 0xFE, 0x03, 0xFF, 0x83, 0xC3, + 0xC3, 0xC0, 0xF1, 0xC0, 0x39, 0xE0, 0x1C, 0xE0, 0x00, 0x70, 0x00, 0x38, + 0x00, 0x1C, 0xFE, 0x0F, 0xFF, 0xC7, 0xF3, 0xE7, 0xE0, 0x79, 0xE0, 0x1C, + 0xE0, 0x0F, 0x70, 0x03, 0xB8, 0x01, 0xDC, 0x00, 0xEE, 0x00, 0x77, 0x80, + 0x71, 0xC0, 0x78, 0xF8, 0x78, 0x3F, 0xFC, 0x0F, 0xF8, 0x01, 0xF0, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x1C, + 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0x70, 0x00, 0xE0, 0x00, 0xE0, + 0x01, 0xC0, 0x01, 0xC0, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x1C, 0x00, + 0x1C, 0x00, 0x01, 0xE0, 0x07, 0xFC, 0x07, 0xFF, 0x07, 0x83, 0xC3, 0x80, + 0xF3, 0xC0, 0x39, 0xC0, 0x1C, 0xE0, 0x0E, 0x78, 0x07, 0x1C, 0x07, 0x07, + 0x8F, 0x81, 0xFF, 0x01, 0xFF, 0xC1, 0xF1, 0xF1, 0xE0, 0x3C, 0xE0, 0x0E, + 0xF0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFE, 0x00, 0x77, 0x00, 0x7B, 0xC0, + 0x38, 0xF0, 0x7C, 0x7F, 0xFC, 0x0F, 0xFC, 0x01, 0xF0, 0x00, 0x03, 0xE0, + 0x07, 0xFC, 0x07, 0xFF, 0x07, 0x83, 0xC7, 0x80, 0xE3, 0x80, 0x39, 0xC0, + 0x1D, 0xE0, 0x0E, 0xE0, 0x07, 0xF8, 0x03, 0xFC, 0x01, 0xEE, 0x00, 0xF7, + 0x80, 0xF9, 0xF3, 0xFC, 0x7F, 0xEE, 0x1F, 0xC7, 0x00, 0x07, 0x80, 0x03, + 0x80, 0x01, 0xCE, 0x00, 0xE7, 0x00, 0xE3, 0xC0, 0x70, 0xF0, 0xF0, 0x3F, + 0xF8, 0x0F, 0xF0, 0x01, 0xE0, 0x00, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x3F, + 0xFC, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x32, 0x26, + 0xC0, 0x00, 0x00, 0x80, 0x01, 0xC0, 0x03, 0xE0, 0x0F, 0xE0, 0x1F, 0x80, + 0x3F, 0x00, 0xFE, 0x01, 0xF8, 0x00, 0xF0, 0x00, 0x7C, 0x00, 0x1F, 0x80, + 0x03, 0xF0, 0x00, 0x7F, 0x00, 0x07, 0xE0, 0x00, 0xFE, 0x00, 0x1F, 0x00, + 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x60, 0x00, 0x3E, + 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x80, 0x03, 0xF0, 0x00, 0x7E, + 0x00, 0x07, 0x80, 0x07, 0xC0, 0x0F, 0xC0, 0x3F, 0x00, 0x7E, 0x01, 0xFC, + 0x03, 0xF0, 0x01, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x0F, 0xC0, 0x7F, 0xE1, + 0xFF, 0xE3, 0x81, 0xEE, 0x01, 0xDC, 0x03, 0xF8, 0x03, 0xF0, 0x07, 0x00, + 0x1E, 0x00, 0x38, 0x00, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, + 0x01, 0xC0, 0x07, 0x80, 0x0F, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80, 0x0F, 0x00, 0x00, 0x03, 0xF8, + 0x00, 0x00, 0x1F, 0xFF, 0x00, 0x00, 0x7F, 0xFF, 0xC0, 0x01, 0xF8, 0x07, + 0xE0, 0x03, 0xC0, 0x00, 0xF8, 0x07, 0x80, 0x00, 0x78, 0x0F, 0x00, 0x00, + 0x3C, 0x1E, 0x00, 0x00, 0x1E, 0x1C, 0x03, 0xF3, 0x8E, 0x38, 0x0F, 0xFB, + 0x8F, 0x38, 0x1E, 0x1B, 0x87, 0x70, 0x3C, 0x0F, 0x07, 0x70, 0x38, 0x0F, + 0x07, 0x60, 0x70, 0x0F, 0x07, 0xE0, 0x70, 0x0E, 0x07, 0xE0, 0xF0, 0x0E, + 0x07, 0xE0, 0xE0, 0x0E, 0x07, 0xE0, 0xE0, 0x1C, 0x0E, 0xE0, 0xE0, 0x1C, + 0x0E, 0xF0, 0xF0, 0x3C, 0x1C, 0x70, 0x78, 0x7C, 0x3C, 0x70, 0x7D, 0xFE, + 0xF8, 0x78, 0x3F, 0xDF, 0xF0, 0x3C, 0x0F, 0x0F, 0xC0, 0x1E, 0x00, 0x00, + 0x00, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x80, 0x00, 0x00, 0x03, 0xE0, 0x02, + 0x00, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x7F, 0xFF, 0x00, 0x00, 0x0F, 0xF8, + 0x00, 0x00, 0x78, 0x00, 0x03, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x3F, 0x00, + 0x01, 0xFC, 0x00, 0x07, 0x78, 0x00, 0x1C, 0xE0, 0x00, 0xF3, 0x80, 0x03, + 0x8F, 0x00, 0x1E, 0x1C, 0x00, 0x70, 0x70, 0x01, 0xC1, 0xE0, 0x0F, 0x03, + 0x80, 0x38, 0x0E, 0x00, 0xE0, 0x3C, 0x07, 0x80, 0x70, 0x1F, 0xFF, 0xE0, + 0x7F, 0xFF, 0x83, 0xC0, 0x0E, 0x0E, 0x00, 0x3C, 0x38, 0x00, 0xF1, 0xE0, + 0x01, 0xC7, 0x00, 0x07, 0xBC, 0x00, 0x1E, 0xF0, 0x00, 0x3B, 0x80, 0x00, + 0xF0, 0xFF, 0xC0, 0x1F, 0xFF, 0xC3, 0xFF, 0xFC, 0x70, 0x1F, 0xCE, 0x00, + 0x79, 0xC0, 0x07, 0xB8, 0x00, 0xF7, 0x00, 0x1E, 0xE0, 0x03, 0xDC, 0x00, + 0x73, 0x80, 0x1E, 0x7F, 0xFF, 0x8F, 0xFF, 0xC1, 0xFF, 0xFE, 0x38, 0x03, + 0xE7, 0x00, 0x1E, 0xE0, 0x01, 0xDC, 0x00, 0x3F, 0x80, 0x03, 0xF0, 0x00, + 0xFE, 0x00, 0x1F, 0xC0, 0x03, 0xB8, 0x00, 0xF7, 0xFF, 0xFC, 0xFF, 0xFF, + 0x1F, 0xFF, 0x80, 0x00, 0xFE, 0x00, 0x1F, 0xFE, 0x00, 0xFF, 0xFC, 0x07, + 0xC0, 0xF8, 0x3C, 0x00, 0xF0, 0xE0, 0x01, 0xC7, 0x80, 0x07, 0x9C, 0x00, + 0x0E, 0xF0, 0x00, 0x03, 0x80, 0x00, 0x0E, 0x00, 0x00, 0x38, 0x00, 0x00, + 0xE0, 0x00, 0x03, 0x80, 0x00, 0x0E, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, + 0x00, 0x03, 0x80, 0x00, 0xFF, 0x00, 0x03, 0x9C, 0x00, 0x0E, 0x78, 0x00, + 0x78, 0xE0, 0x01, 0xC3, 0xE0, 0x0F, 0x07, 0xC0, 0xF8, 0x0F, 0xFF, 0xC0, + 0x0F, 0xFE, 0x00, 0x0F, 0xC0, 0x00, 0xFF, 0xC0, 0x0F, 0xFF, 0xE0, 0xFF, + 0xFF, 0x0E, 0x01, 0xF8, 0xE0, 0x03, 0xCE, 0x00, 0x1E, 0xE0, 0x00, 0xEE, + 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x07, 0xE0, 0x00, 0x7E, 0x00, 0x07, + 0xE0, 0x00, 0x7E, 0x00, 0x07, 0xE0, 0x00, 0x7E, 0x00, 0x07, 0xE0, 0x00, + 0x7E, 0x00, 0x07, 0xE0, 0x00, 0xFE, 0x00, 0x0E, 0xE0, 0x01, 0xEE, 0x00, + 0x3C, 0xE0, 0x07, 0xCF, 0xFF, 0xF8, 0xFF, 0xFE, 0x0F, 0xFF, 0x80, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, + 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, + 0x80, 0x00, 0xFF, 0xFF, 0xBF, 0xFF, 0xEE, 0x00, 0x03, 0x80, 0x00, 0xE0, + 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, + 0x0E, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, + 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0F, + 0xFF, 0xF7, 0xFF, 0xFB, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, + 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xC0, + 0x00, 0xE0, 0x00, 0x70, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x07, 0xFF, 0x80, + 0x3F, 0xFF, 0x80, 0xF8, 0x0F, 0x83, 0xE0, 0x07, 0x87, 0x00, 0x07, 0x9E, + 0x00, 0x0F, 0x38, 0x00, 0x0E, 0xF0, 0x00, 0x01, 0xC0, 0x00, 0x03, 0x80, + 0x00, 0x07, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x1C, 0x01, 0xFF, 0xF8, 0x03, + 0xFF, 0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0xC0, 0x00, + 0x3B, 0x80, 0x00, 0xF7, 0x80, 0x01, 0xE7, 0x80, 0x07, 0xCF, 0x80, 0x1F, + 0x8F, 0xC0, 0xF7, 0x0F, 0xFF, 0xCE, 0x07, 0xFF, 0x0C, 0x03, 0xF0, 0x00, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, + 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, + 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, + 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, + 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC0, + 0x07, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1C, 0x00, 0x70, + 0x01, 0xC0, 0x07, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1C, + 0x00, 0x7E, 0x01, 0xF8, 0x07, 0xE0, 0x3F, 0x80, 0xFF, 0x03, 0xBE, 0x1E, + 0x7F, 0xF0, 0xFF, 0x80, 0x78, 0x00, 0xE0, 0x00, 0xFE, 0x00, 0x1E, 0xE0, + 0x03, 0xCE, 0x00, 0x78, 0xE0, 0x0F, 0x0E, 0x01, 0xE0, 0xE0, 0x3C, 0x0E, + 0x07, 0x80, 0xE0, 0xF0, 0x0E, 0x1E, 0x00, 0xE3, 0xC0, 0x0E, 0x7C, 0x00, + 0xEF, 0xE0, 0x0F, 0xEE, 0x00, 0xFC, 0xF0, 0x0F, 0x87, 0x80, 0xF0, 0x38, + 0x0E, 0x03, 0xC0, 0xE0, 0x1E, 0x0E, 0x00, 0xF0, 0xE0, 0x0F, 0x0E, 0x00, + 0x78, 0xE0, 0x03, 0xCE, 0x00, 0x3C, 0xE0, 0x01, 0xEE, 0x00, 0x0F, 0xE0, + 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, + 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, + 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, + 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x1F, 0xF0, 0x00, 0x1F, 0xF8, 0x00, 0x3F, + 0xF8, 0x00, 0x3F, 0xFC, 0x00, 0x3F, 0xFC, 0x00, 0x77, 0xFC, 0x00, 0x77, + 0xEE, 0x00, 0x77, 0xEE, 0x00, 0xE7, 0xEE, 0x00, 0xE7, 0xE7, 0x00, 0xE7, + 0xE7, 0x01, 0xC7, 0xE7, 0x01, 0xC7, 0xE3, 0x81, 0xC7, 0xE3, 0x83, 0x87, + 0xE3, 0x83, 0x87, 0xE1, 0xC3, 0x87, 0xE1, 0xC7, 0x07, 0xE1, 0xC7, 0x07, + 0xE0, 0xE7, 0x07, 0xE0, 0xEE, 0x07, 0xE0, 0xEE, 0x07, 0xE0, 0x7E, 0x07, + 0xE0, 0x7C, 0x07, 0xE0, 0x7C, 0x07, 0xE0, 0x3C, 0x07, 0xE0, 0x00, 0x7F, + 0x00, 0x07, 0xF0, 0x00, 0x7F, 0x80, 0x07, 0xFC, 0x00, 0x7F, 0xC0, 0x07, + 0xFE, 0x00, 0x7E, 0xF0, 0x07, 0xE7, 0x00, 0x7E, 0x78, 0x07, 0xE3, 0xC0, + 0x7E, 0x1C, 0x07, 0xE1, 0xE0, 0x7E, 0x0F, 0x07, 0xE0, 0x70, 0x7E, 0x07, + 0x87, 0xE0, 0x38, 0x7E, 0x01, 0xC7, 0xE0, 0x1E, 0x7E, 0x00, 0xE7, 0xE0, + 0x0F, 0x7E, 0x00, 0x7F, 0xE0, 0x03, 0xFE, 0x00, 0x3F, 0xE0, 0x01, 0xFE, + 0x00, 0x0F, 0x00, 0x7F, 0x00, 0x00, 0xFF, 0xF0, 0x01, 0xFF, 0xFC, 0x01, + 0xF0, 0x1F, 0x01, 0xE0, 0x03, 0xC1, 0xE0, 0x00, 0xF0, 0xF0, 0x00, 0x38, + 0xF0, 0x00, 0x1E, 0x70, 0x00, 0x07, 0x38, 0x00, 0x03, 0xDC, 0x00, 0x01, + 0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3F, 0x80, 0x00, 0x1F, 0xC0, 0x00, + 0x0F, 0xE0, 0x00, 0x07, 0x70, 0x00, 0x07, 0xB8, 0x00, 0x03, 0xDE, 0x00, + 0x01, 0xCF, 0x00, 0x01, 0xE3, 0xC0, 0x00, 0xE1, 0xF0, 0x00, 0xF0, 0x7C, + 0x00, 0xF0, 0x1F, 0x81, 0xF0, 0x07, 0xFF, 0xF0, 0x00, 0xFF, 0xE0, 0x00, + 0x0F, 0xC0, 0x00, 0xFF, 0xE0, 0x1F, 0xFF, 0xC3, 0xFF, 0xFE, 0x70, 0x0F, + 0xCE, 0x00, 0x3D, 0xC0, 0x03, 0xB8, 0x00, 0x77, 0x00, 0x0F, 0xE0, 0x01, + 0xFC, 0x00, 0x3B, 0x80, 0x0F, 0x70, 0x03, 0xEF, 0xFF, 0xF9, 0xFF, 0xFE, + 0x3F, 0xFF, 0x87, 0x00, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0x03, 0x80, 0x00, + 0x70, 0x00, 0x0E, 0x00, 0x01, 0xC0, 0x00, 0x38, 0x00, 0x07, 0x00, 0x00, + 0xE0, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0xFF, 0xF0, 0x01, + 0xFF, 0xFC, 0x01, 0xF0, 0x1F, 0x01, 0xF0, 0x03, 0xC1, 0xE0, 0x00, 0xF0, + 0xF0, 0x00, 0x38, 0xF0, 0x00, 0x1E, 0x70, 0x00, 0x07, 0x38, 0x00, 0x03, + 0xDC, 0x00, 0x01, 0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3F, 0x80, 0x00, + 0x1F, 0xC0, 0x00, 0x0F, 0xE0, 0x00, 0x07, 0x70, 0x00, 0x07, 0xB8, 0x00, + 0x03, 0x9C, 0x00, 0x01, 0xCF, 0x00, 0x31, 0xE3, 0xC0, 0x3C, 0xE1, 0xE0, + 0x0F, 0xF0, 0x7C, 0x03, 0xF0, 0x1F, 0x83, 0xF8, 0x07, 0xFF, 0xFE, 0x00, + 0xFF, 0xE7, 0x80, 0x0F, 0x81, 0xC0, 0x00, 0x00, 0x40, 0xFF, 0xF0, 0x07, + 0xFF, 0xFC, 0x3F, 0xFF, 0xF1, 0xE0, 0x0F, 0xCF, 0x00, 0x1E, 0x78, 0x00, + 0x7B, 0xC0, 0x03, 0xDE, 0x00, 0x1E, 0xF0, 0x00, 0xF7, 0x80, 0x07, 0x3C, + 0x00, 0x39, 0xE0, 0x03, 0x8F, 0xFF, 0xF8, 0x7F, 0xFF, 0x83, 0xFF, 0xFF, + 0x1E, 0x00, 0x78, 0xF0, 0x01, 0xE7, 0x80, 0x07, 0x3C, 0x00, 0x39, 0xE0, + 0x01, 0xCF, 0x00, 0x0E, 0x78, 0x00, 0x73, 0xC0, 0x03, 0x9E, 0x00, 0x1E, + 0xF0, 0x00, 0xF7, 0x80, 0x03, 0xC0, 0x03, 0xF8, 0x00, 0xFF, 0xE0, 0x3F, + 0xFF, 0x83, 0xC0, 0x7C, 0x78, 0x03, 0xC7, 0x00, 0x1E, 0xF0, 0x00, 0xEF, + 0x00, 0x0E, 0xF0, 0x00, 0x07, 0x80, 0x00, 0x7E, 0x00, 0x03, 0xFC, 0x00, + 0x1F, 0xFC, 0x00, 0x7F, 0xF8, 0x00, 0x7F, 0xC0, 0x00, 0x7E, 0x00, 0x01, + 0xE0, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFF, 0x00, + 0x0E, 0x78, 0x01, 0xE7, 0xE0, 0x7C, 0x3F, 0xFF, 0x80, 0xFF, 0xF0, 0x01, + 0xF8, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x0E, 0x00, + 0x00, 0xE0, 0x00, 0x0E, 0x00, 0x00, 0xE0, 0x00, 0x0E, 0x00, 0x00, 0xE0, + 0x00, 0x0E, 0x00, 0x00, 0xE0, 0x00, 0x0E, 0x00, 0x00, 0xE0, 0x00, 0x0E, + 0x00, 0x00, 0xE0, 0x00, 0x0E, 0x00, 0x00, 0xE0, 0x00, 0x0E, 0x00, 0x00, + 0xE0, 0x00, 0x0E, 0x00, 0x00, 0xE0, 0x00, 0x0E, 0x00, 0x00, 0xE0, 0x00, + 0x0E, 0x00, 0x00, 0xE0, 0x00, 0x0E, 0x00, 0xE0, 0x00, 0xFE, 0x00, 0x0F, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, + 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, + 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, + 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xF0, 0x00, 0xEF, + 0x00, 0x1E, 0x78, 0x01, 0xE3, 0xE0, 0x7C, 0x1F, 0xFF, 0x80, 0xFF, 0xE0, + 0x01, 0xF8, 0x00, 0xF0, 0x00, 0x3F, 0xC0, 0x00, 0xE7, 0x00, 0x07, 0x9E, + 0x00, 0x1E, 0x78, 0x00, 0x70, 0xE0, 0x03, 0xC3, 0xC0, 0x0F, 0x07, 0x00, + 0x38, 0x1C, 0x01, 0xE0, 0x78, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0xF0, + 0x0F, 0x03, 0x80, 0x1C, 0x0E, 0x00, 0x70, 0x38, 0x01, 0xE1, 0xC0, 0x03, + 0x87, 0x00, 0x0E, 0x1C, 0x00, 0x1C, 0xE0, 0x00, 0x73, 0x80, 0x01, 0xCE, + 0x00, 0x03, 0xF0, 0x00, 0x0F, 0xC0, 0x00, 0x3F, 0x00, 0x00, 0x78, 0x00, + 0x01, 0xE0, 0x00, 0xE0, 0x03, 0x80, 0x0F, 0xF0, 0x03, 0xC0, 0x0E, 0xF0, + 0x07, 0xC0, 0x1E, 0x70, 0x07, 0xC0, 0x1E, 0x70, 0x07, 0xC0, 0x1E, 0x78, + 0x0E, 0xE0, 0x1C, 0x78, 0x0E, 0xE0, 0x3C, 0x38, 0x0E, 0xE0, 0x3C, 0x38, + 0x0E, 0x70, 0x3C, 0x38, 0x1C, 0x70, 0x38, 0x3C, 0x1C, 0x70, 0x38, 0x1C, + 0x1C, 0x70, 0x78, 0x1C, 0x1C, 0x38, 0x70, 0x1C, 0x38, 0x38, 0x70, 0x1E, + 0x38, 0x38, 0x70, 0x0E, 0x38, 0x1C, 0xF0, 0x0E, 0x70, 0x1C, 0xE0, 0x0E, + 0x70, 0x1C, 0xE0, 0x0F, 0x70, 0x1C, 0xE0, 0x07, 0x70, 0x0E, 0xE0, 0x07, + 0xE0, 0x0F, 0xC0, 0x07, 0xE0, 0x0F, 0xC0, 0x07, 0xE0, 0x0F, 0xC0, 0x03, + 0xE0, 0x07, 0xC0, 0x03, 0xC0, 0x07, 0x80, 0x03, 0xC0, 0x07, 0x80, 0xF0, + 0x00, 0x79, 0xE0, 0x01, 0xE3, 0xC0, 0x0F, 0x0F, 0x00, 0x78, 0x1E, 0x01, + 0xE0, 0x3C, 0x0F, 0x00, 0xF0, 0x78, 0x01, 0xE1, 0xC0, 0x03, 0xCF, 0x00, + 0x0F, 0x78, 0x00, 0x1F, 0xC0, 0x00, 0x3F, 0x00, 0x00, 0x78, 0x00, 0x03, + 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x7F, 0x00, 0x03, 0xDE, 0x00, 0x0E, 0x3C, + 0x00, 0x78, 0x78, 0x03, 0xC1, 0xE0, 0x0E, 0x03, 0xC0, 0x78, 0x07, 0x83, + 0xC0, 0x1E, 0x1E, 0x00, 0x3C, 0x78, 0x00, 0x7B, 0xC0, 0x01, 0xE0, 0xF8, + 0x00, 0x1E, 0xF0, 0x00, 0x3C, 0xF0, 0x00, 0xF1, 0xE0, 0x03, 0xC1, 0xE0, + 0x07, 0x81, 0xE0, 0x1E, 0x03, 0xC0, 0x38, 0x03, 0xC0, 0xF0, 0x03, 0x81, + 0xC0, 0x07, 0x87, 0x80, 0x07, 0x9E, 0x00, 0x0F, 0x38, 0x00, 0x0F, 0xF0, + 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x3C, 0x00, + 0x00, 0x78, 0x00, 0x00, 0xF0, 0x00, 0x01, 0xE0, 0x00, 0x03, 0xC0, 0x00, + 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x3C, 0x00, 0x00, + 0x78, 0x00, 0x7F, 0xFF, 0xEF, 0xFF, 0xFD, 0xFF, 0xFF, 0x80, 0x00, 0xF0, + 0x00, 0x3E, 0x00, 0x07, 0x80, 0x01, 0xE0, 0x00, 0x78, 0x00, 0x1E, 0x00, + 0x03, 0xC0, 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0xE0, 0x00, + 0x78, 0x00, 0x1E, 0x00, 0x07, 0x80, 0x01, 0xE0, 0x00, 0x3C, 0x00, 0x0F, + 0x00, 0x03, 0xC0, 0x00, 0xF0, 0x00, 0x3E, 0x00, 0x07, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0x0E, 0x1C, 0x38, 0x70, 0xE1, + 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, + 0x70, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x7F, 0xFE, 0xC0, 0x30, 0x0C, + 0x01, 0x80, 0x60, 0x18, 0x03, 0x00, 0xC0, 0x30, 0x04, 0x01, 0x80, 0x60, + 0x08, 0x03, 0x00, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x60, 0x0C, 0x03, 0x00, + 0xC0, 0x18, 0x06, 0x01, 0x80, 0x30, 0x0C, 0xFF, 0xFF, 0xC7, 0x1C, 0x71, + 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, + 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xFF, 0xFC, 0x07, 0x00, 0x78, 0x03, + 0xC0, 0x1F, 0x01, 0xD8, 0x0C, 0xE0, 0xE3, 0x06, 0x18, 0x30, 0xE3, 0x83, + 0x18, 0x1D, 0xC0, 0x6C, 0x03, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, + 0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0x03, 0xF0, 0x07, 0xFF, 0x03, 0xFF, 0xE0, + 0xF0, 0x78, 0x78, 0x0E, 0x1C, 0x01, 0xC0, 0x00, 0x70, 0x00, 0x3C, 0x00, + 0x7F, 0x03, 0xFF, 0xC3, 0xFE, 0x71, 0xF0, 0x1C, 0x70, 0x07, 0x1C, 0x01, + 0xCF, 0x00, 0xF1, 0xC0, 0x3C, 0x70, 0x3F, 0x1F, 0xFD, 0xF3, 0xFE, 0x7C, + 0x3E, 0x0F, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE3, 0xE0, 0xEF, 0xF8, 0xFF, 0xFC, 0xFC, 0x3E, + 0xF0, 0x0E, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, + 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x1E, + 0xFC, 0x3E, 0xFF, 0xFC, 0xEF, 0xF8, 0x03, 0xE0, 0x03, 0xE0, 0x0F, 0xF8, + 0x1F, 0xFC, 0x3C, 0x1E, 0x78, 0x0E, 0x70, 0x0E, 0xF0, 0x0E, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xF0, 0x07, + 0x70, 0x0E, 0x78, 0x0E, 0x3C, 0x1E, 0x1F, 0xFC, 0x0F, 0xF8, 0x03, 0xC0, + 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, + 0x00, 0x07, 0x07, 0xC7, 0x1F, 0xF7, 0x3F, 0xFF, 0x3C, 0x1F, 0x78, 0x0F, + 0x70, 0x0F, 0xF0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, + 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x07, 0x70, 0x0F, 0x78, 0x0F, 0x3C, 0x1F, + 0x3F, 0xFB, 0x1F, 0xF3, 0x07, 0xC0, 0x03, 0xE0, 0x07, 0xFC, 0x07, 0xFF, + 0x87, 0x83, 0xC3, 0x80, 0xF3, 0x80, 0x39, 0xC0, 0x0E, 0xE0, 0x07, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x07, 0x00, 0x03, 0x80, 0x1D, + 0xC0, 0x1C, 0xF0, 0x0E, 0x3C, 0x1E, 0x0F, 0xFF, 0x03, 0xFE, 0x00, 0x7C, + 0x00, 0x02, 0x1F, 0x3F, 0x38, 0x38, 0x38, 0x38, 0x38, 0xFF, 0xFF, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x03, 0xC0, 0x0F, 0xF7, 0x3F, 0xFF, 0x3C, 0x1F, 0x78, + 0x0F, 0x70, 0x0F, 0xF0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, + 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x07, 0x70, 0x0F, 0x78, 0x0F, 0x3C, + 0x3F, 0x3F, 0xF7, 0x0F, 0xE7, 0x07, 0xC7, 0x00, 0x07, 0x70, 0x07, 0x70, + 0x0E, 0x78, 0x1E, 0x3F, 0xFC, 0x1F, 0xF8, 0x01, 0x80, 0xE0, 0x01, 0xC0, + 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0xF8, + 0xE7, 0xF9, 0xDF, 0xFB, 0xF0, 0x7F, 0xC0, 0x7F, 0x00, 0xFE, 0x01, 0xF8, + 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, + 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1C, 0xFF, 0xF0, + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x1C, 0x71, 0xC7, 0x00, + 0x00, 0x00, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, + 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xFF, 0xFB, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x3C, 0xE0, 0x78, 0xE0, 0xF0, 0xE1, 0xE0, 0xE3, 0xC0, + 0xE7, 0x80, 0xEF, 0x00, 0xFF, 0x80, 0xFB, 0xC0, 0xF1, 0xC0, 0xE1, 0xE0, + 0xE0, 0xF0, 0xE0, 0x70, 0xE0, 0x78, 0xE0, 0x38, 0xE0, 0x3C, 0xE0, 0x1E, + 0xE0, 0x0E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, + 0x01, 0xE0, 0x7C, 0x73, 0xFC, 0xFF, 0x3B, 0xFE, 0xFF, 0xDF, 0x07, 0xE0, + 0xEF, 0x01, 0xE0, 0x7F, 0x80, 0xE0, 0x1F, 0x80, 0x70, 0x0F, 0xC0, 0x38, + 0x07, 0xE0, 0x1C, 0x03, 0xF0, 0x0E, 0x01, 0xF8, 0x07, 0x00, 0xFC, 0x03, + 0x80, 0x7E, 0x01, 0xC0, 0x3F, 0x00, 0xE0, 0x1F, 0x80, 0x70, 0x0F, 0xC0, + 0x38, 0x07, 0xE0, 0x1C, 0x03, 0xF0, 0x0E, 0x01, 0xF8, 0x07, 0x00, 0xE0, + 0x01, 0xF1, 0xCF, 0xF3, 0xBF, 0xF7, 0xE0, 0xFF, 0x80, 0xFE, 0x01, 0xFC, + 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, + 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x38, + 0x03, 0xE0, 0x07, 0xFC, 0x07, 0xFF, 0x07, 0x83, 0xC7, 0x80, 0xF3, 0x80, + 0x39, 0xC0, 0x1D, 0xE0, 0x07, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFC, + 0x00, 0x7F, 0x00, 0x3B, 0x80, 0x39, 0xC0, 0x1C, 0xF0, 0x1E, 0x3C, 0x1E, + 0x0F, 0xFE, 0x03, 0xFE, 0x00, 0x7C, 0x00, 0x03, 0xE0, 0xEF, 0xF8, 0xFF, + 0xFC, 0xFC, 0x3E, 0xF0, 0x0E, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, 0xE0, + 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xF0, + 0x0F, 0xF8, 0x1E, 0xFC, 0x3E, 0xFF, 0xFC, 0xEF, 0xF8, 0xE3, 0xE0, 0xE0, + 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, + 0x00, 0x07, 0xC0, 0x1F, 0xF3, 0x3F, 0xFB, 0x3C, 0x1F, 0x78, 0x0F, 0x70, + 0x0F, 0xF0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, + 0x07, 0xE0, 0x07, 0xF0, 0x07, 0x70, 0x0F, 0x78, 0x0F, 0x7C, 0x1F, 0x3F, + 0xFF, 0x1F, 0xF7, 0x03, 0xC7, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x03, 0xF3, 0xFB, 0xFF, 0xCF, + 0x87, 0x83, 0xC1, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, + 0xC0, 0xE0, 0x70, 0x38, 0x00, 0x07, 0xC0, 0x3F, 0xE0, 0xFF, 0xE3, 0xC1, + 0xE7, 0x01, 0xCE, 0x03, 0x9C, 0x00, 0x3C, 0x00, 0x7F, 0x00, 0x7F, 0xE0, + 0x1F, 0xF0, 0x07, 0xE0, 0x01, 0xE0, 0x01, 0xF8, 0x03, 0xF8, 0x07, 0x78, + 0x1C, 0xFF, 0xF8, 0xFF, 0xE0, 0x3E, 0x00, 0x1C, 0x0E, 0x07, 0x03, 0x81, + 0xC7, 0xFF, 0xFE, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x70, + 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xFC, 0x7E, 0x0F, 0xE0, 0x0F, + 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, + 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x03, + 0xFC, 0x07, 0xB8, 0x1F, 0x7F, 0xEE, 0x7F, 0x9C, 0x3C, 0x00, 0x70, 0x07, + 0xB8, 0x03, 0x9E, 0x01, 0xC7, 0x01, 0xE3, 0x80, 0xE1, 0xE0, 0x70, 0x70, + 0x70, 0x38, 0x38, 0x1E, 0x1C, 0x07, 0x1C, 0x03, 0x8E, 0x00, 0xE6, 0x00, + 0x77, 0x00, 0x3B, 0x80, 0x0F, 0x80, 0x07, 0xC0, 0x03, 0xE0, 0x00, 0xE0, + 0x00, 0xF0, 0x3C, 0x07, 0xB8, 0x1F, 0x03, 0x9C, 0x0F, 0x81, 0xCE, 0x07, + 0xC1, 0xE3, 0x87, 0x60, 0xE1, 0xC3, 0xB8, 0x70, 0xE1, 0xDC, 0x38, 0x70, + 0xCE, 0x38, 0x1C, 0xE3, 0x1C, 0x0E, 0x71, 0xCE, 0x07, 0x38, 0xE7, 0x01, + 0xD8, 0x77, 0x00, 0xEC, 0x1B, 0x80, 0x7E, 0x0F, 0xC0, 0x1F, 0x07, 0xC0, + 0x0F, 0x03, 0xE0, 0x07, 0x80, 0xF0, 0x03, 0xC0, 0x78, 0x00, 0xF0, 0x0E, + 0x70, 0x1C, 0x38, 0x38, 0x1C, 0x38, 0x1C, 0x70, 0x0E, 0xE0, 0x07, 0xE0, + 0x07, 0xC0, 0x03, 0x80, 0x07, 0xC0, 0x07, 0xE0, 0x0E, 0xE0, 0x1E, 0x70, + 0x1C, 0x78, 0x38, 0x38, 0x78, 0x1C, 0x70, 0x1E, 0xE0, 0x0E, 0xE0, 0x0E, + 0xE0, 0x0E, 0x70, 0x0E, 0x70, 0x1C, 0x70, 0x1C, 0x38, 0x3C, 0x38, 0x38, + 0x38, 0x38, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x0E, 0xE0, 0x0E, 0xE0, + 0x0E, 0xE0, 0x07, 0xC0, 0x07, 0xC0, 0x07, 0xC0, 0x03, 0x80, 0x03, 0x80, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x1E, 0x00, 0x7E, 0x00, 0x7C, 0x00, + 0x30, 0x00, 0x7F, 0xFE, 0xFF, 0xFC, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x80, + 0x1E, 0x00, 0x78, 0x00, 0xE0, 0x03, 0x80, 0x0F, 0x00, 0x3C, 0x00, 0xF0, + 0x03, 0xC0, 0x07, 0x00, 0x1C, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, + 0x01, 0x87, 0xC3, 0xE3, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, + 0x03, 0x81, 0xC0, 0xE0, 0x70, 0xF0, 0xF0, 0x78, 0x1E, 0x03, 0x01, 0xC0, + 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x70, 0x1F, + 0x0F, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xE0, 0xC0, 0xF0, 0xF8, 0x18, 0x18, 0x1C, 0x1C, 0x1C, 0x1C, + 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x0E, 0x07, 0x07, 0x0E, 0x1C, 0x1C, + 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x18, 0x38, 0xF8, 0xF0, + 0x7C, 0x01, 0xFC, 0x0F, 0x1E, 0x1E, 0x1F, 0xEC, 0x0F, 0xC0, 0x06, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x03, 0xE0, 0x00, 0xF8, + 0x00, 0x3E, 0x00, 0x0F, 0x80, 0x03, 0xE0, 0x00, 0xF8, 0x00, 0x3E, 0x00, + 0x0F, 0x80, 0x03, 0xE0, 0x00, 0xF8, 0x00, 0x3E, 0x00, 0x0F, 0x80, 0x03, + 0xE0, 0x00, 0xF8, 0x00, 0x3E, 0x00, 0x0F, 0x80, 0x03, 0xE0, 0x00, 0xF8, + 0x00, 0x3E, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, + 0xFF, 0xF0, 0x36, 0xDB, 0x6F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x01, 0x80, + 0x01, 0x80, 0x01, 0x80, 0x03, 0xE0, 0x0F, 0xF8, 0x3F, 0xFC, 0x3D, 0x9E, + 0x71, 0x8E, 0x71, 0x8E, 0xE1, 0x87, 0xE1, 0x80, 0xE1, 0x80, 0xE1, 0x80, + 0xE1, 0x80, 0xE1, 0x80, 0xE1, 0x80, 0xE1, 0x87, 0xF1, 0x8F, 0x79, 0x8E, + 0x3D, 0x9E, 0x3F, 0xFC, 0x0F, 0xF8, 0x03, 0xE0, 0x01, 0x80, 0x01, 0x80, + 0x01, 0x80, 0x00, 0x00, 0x01, 0xFF, 0x01, 0xFF, 0xE0, 0xF8, 0x7C, 0x38, + 0x0F, 0x1E, 0x01, 0xC7, 0x00, 0x39, 0xC0, 0x0E, 0x70, 0x03, 0x9C, 0x00, + 0x07, 0x80, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0x3F, 0xFC, 0x0F, 0xFF, 0x00, + 0x38, 0x00, 0x0E, 0x00, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0C, + 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xFF, 0xEE, 0xFF, 0xFF, 0xDC, 0x3F, + 0xE0, 0x01, 0xE0, 0x00, 0x1F, 0x00, 0x03, 0xFF, 0x00, 0x7F, 0xFE, 0x07, + 0xC0, 0xE0, 0x78, 0x01, 0x03, 0x80, 0x00, 0x3C, 0x00, 0x01, 0xC0, 0x00, + 0x1E, 0x00, 0x00, 0xE0, 0x00, 0x1F, 0xFF, 0xE1, 0xFF, 0xFF, 0x01, 0xC0, + 0x00, 0x0E, 0x00, 0x01, 0xFF, 0xFC, 0x1F, 0xFF, 0xE0, 0x1C, 0x00, 0x00, + 0xF0, 0x00, 0x03, 0x80, 0x00, 0x1E, 0x00, 0x00, 0x78, 0x00, 0x03, 0xE0, + 0x08, 0x0F, 0x81, 0xC0, 0x3F, 0xFE, 0x00, 0x7F, 0xE0, 0x00, 0xF8, 0x00, + 0x70, 0x00, 0xEE, 0x00, 0x38, 0xE0, 0x07, 0x1C, 0x01, 0xC1, 0xC0, 0x38, + 0x38, 0x0E, 0x03, 0x81, 0xC0, 0x38, 0x70, 0x07, 0x1C, 0x00, 0x73, 0x80, + 0x0E, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x00, 0x7F, 0xFF, 0x00, 0x38, 0x00, + 0x07, 0x00, 0x00, 0xE0, 0x07, 0xFF, 0xF0, 0xFF, 0xFE, 0x00, 0x70, 0x00, + 0x0E, 0x00, 0x01, 0xC0, 0x00, 0x38, 0x00, 0x07, 0x00, 0x00, 0xE0, 0x00, + 0x07, 0x0C, 0x00, 0x31, 0x80, 0x03, 0xB8, 0x00, 0x1F, 0x00, 0x00, 0xF0, + 0x00, 0x00, 0x00, 0x03, 0xF8, 0x00, 0xFF, 0xE0, 0x3F, 0xFF, 0x83, 0xC0, + 0x7C, 0x78, 0x03, 0xC7, 0x00, 0x1E, 0xF0, 0x00, 0xEF, 0x00, 0x0E, 0xF0, + 0x00, 0x07, 0x80, 0x00, 0x7E, 0x00, 0x03, 0xFC, 0x00, 0x1F, 0xFC, 0x00, + 0x7F, 0xF8, 0x00, 0x7F, 0xC0, 0x00, 0x7E, 0x00, 0x01, 0xE0, 0x00, 0x0F, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFF, 0x00, 0x0E, 0x78, 0x01, + 0xE7, 0xE0, 0x7C, 0x3F, 0xFF, 0x80, 0xFF, 0xF0, 0x01, 0xF8, 0x00, 0x00, + 0x00, 0x03, 0xFC, 0x03, 0xFF, 0x03, 0xC7, 0x81, 0xC0, 0xE0, 0xE0, 0x70, + 0x70, 0x38, 0x38, 0x1C, 0x1E, 0x00, 0x07, 0xC0, 0x07, 0xF0, 0x07, 0x3E, + 0x07, 0x0F, 0x83, 0x03, 0xF1, 0x80, 0x7D, 0xC0, 0x1E, 0x70, 0x07, 0xBC, + 0x01, 0xCF, 0x00, 0xE7, 0xE0, 0x70, 0xF8, 0x70, 0x3E, 0x38, 0x07, 0xF8, + 0x01, 0xF0, 0x00, 0x7C, 0x00, 0x0E, 0x0E, 0x07, 0x87, 0x01, 0xC3, 0x81, + 0xE1, 0xC0, 0xE0, 0x78, 0xF0, 0x3F, 0xF0, 0x0F, 0xF0, 0x00, 0x18, 0x38, + 0x38, 0xE0, 0x39, 0x80, 0x37, 0x00, 0x7C, 0x00, 0x70, 0x00, 0x00, 0x03, + 0xE0, 0x1F, 0xF0, 0x7F, 0xF1, 0xE0, 0xF3, 0x80, 0xE7, 0x01, 0xCE, 0x00, + 0x1E, 0x00, 0x3F, 0x80, 0x3F, 0xF0, 0x0F, 0xF8, 0x03, 0xF0, 0x00, 0xF0, + 0x00, 0xFC, 0x01, 0xFC, 0x03, 0xBC, 0x0E, 0x7F, 0xFC, 0x7F, 0xF0, 0x1F, + 0x00, 0x00, 0x7F, 0x80, 0x00, 0x7F, 0xF8, 0x00, 0x7C, 0x1F, 0x80, 0x3C, + 0x00, 0xF0, 0x1C, 0x00, 0x0E, 0x0E, 0x03, 0x81, 0xC7, 0x07, 0xF8, 0x31, + 0xC3, 0xFF, 0x0E, 0xE0, 0xC0, 0xC1, 0xB8, 0x70, 0x38, 0x7C, 0x18, 0x0E, + 0x0F, 0x0E, 0x00, 0x03, 0xC3, 0x80, 0x00, 0xF0, 0xE0, 0x00, 0x3C, 0x38, + 0x00, 0x0F, 0x0E, 0x01, 0x83, 0xC1, 0x80, 0xE1, 0xF8, 0x70, 0x38, 0x76, + 0x0E, 0x1C, 0x19, 0xC3, 0xFF, 0x0E, 0x30, 0x7F, 0x87, 0x0E, 0x03, 0x03, + 0xC1, 0xC0, 0x01, 0xE0, 0x3C, 0x00, 0xF0, 0x07, 0xF3, 0xF0, 0x00, 0x7F, + 0xF8, 0x00, 0x03, 0xF0, 0x00, 0x1F, 0x0F, 0xF1, 0x86, 0x30, 0xE0, 0x1C, + 0x3F, 0x9F, 0x77, 0x0E, 0xC1, 0xDC, 0x39, 0xFF, 0x9E, 0x70, 0x00, 0x00, + 0x3F, 0xF0, 0x08, 0x11, 0x83, 0x78, 0x7F, 0x1E, 0xC1, 0xC8, 0x10, 0xC1, + 0xCF, 0x1E, 0x78, 0x71, 0x83, 0x08, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, + 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x00, + 0x03, 0x00, 0x00, 0xC0, 0x00, 0x30, 0xFF, 0xFF, 0xFF, 0x00, 0x7F, 0x80, + 0x00, 0x7F, 0xF8, 0x00, 0x7C, 0x1F, 0x80, 0x3C, 0x00, 0xF0, 0x1C, 0x00, + 0x0E, 0x0E, 0x00, 0x01, 0xC7, 0x1F, 0xFC, 0x31, 0xC7, 0xFF, 0x8E, 0xE1, + 0xC0, 0xE1, 0xB8, 0x70, 0x18, 0x7C, 0x1C, 0x06, 0x0F, 0x07, 0x03, 0x83, + 0xC1, 0xFF, 0xC0, 0xF0, 0x7F, 0xE0, 0x3C, 0x1F, 0xFC, 0x0F, 0x07, 0x03, + 0x83, 0xC1, 0xC0, 0xE1, 0xF8, 0x70, 0x38, 0x76, 0x1C, 0x0E, 0x19, 0xC7, + 0x03, 0x8E, 0x31, 0xC0, 0x77, 0x0E, 0x00, 0x03, 0xC1, 0xC0, 0x01, 0xE0, + 0x3C, 0x00, 0xF0, 0x07, 0xF3, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x03, 0xF0, + 0x00, 0xFF, 0xFF, 0xFF, 0xFC, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x7C, 0x07, + 0x80, 0xF0, 0x1B, 0x06, 0x7B, 0xC7, 0xF0, 0x10, 0x00, 0x01, 0x80, 0x00, + 0xC0, 0x00, 0x60, 0x00, 0x30, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x06, 0x01, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x60, 0x00, 0x30, 0x00, 0x18, + 0x00, 0x0C, 0x00, 0x06, 0x00, 0x03, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFC, 0x1E, 0x1F, 0xE6, 0x1F, + 0x83, 0xC0, 0xF0, 0x30, 0x1C, 0x0E, 0x0F, 0x0F, 0x07, 0x03, 0x80, 0xC0, + 0x3F, 0xFF, 0xFC, 0x1E, 0x1F, 0xEE, 0x1B, 0x07, 0xC0, 0xC0, 0x70, 0xF8, + 0x3C, 0x03, 0xC0, 0x30, 0x0F, 0x03, 0xC0, 0xFC, 0xE7, 0xF0, 0x00, 0x03, + 0x0E, 0x00, 0x73, 0x80, 0x07, 0x60, 0x00, 0x7C, 0x00, 0x0F, 0x00, 0x00, + 0x00, 0x1F, 0xFF, 0xFB, 0xFF, 0xFF, 0x7F, 0xFF, 0xE0, 0x00, 0x3C, 0x00, + 0x0F, 0x80, 0x01, 0xE0, 0x00, 0x78, 0x00, 0x1E, 0x00, 0x07, 0x80, 0x00, + 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0xC0, 0x00, 0xF8, 0x00, 0x1E, + 0x00, 0x07, 0x80, 0x01, 0xE0, 0x00, 0x78, 0x00, 0x0F, 0x00, 0x03, 0xC0, + 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x80, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xE0, 0x0E, 0x70, 0x07, 0x38, 0x03, 0x9C, 0x01, 0xCE, + 0x00, 0xE7, 0x00, 0x73, 0x80, 0x39, 0xC0, 0x1C, 0xE0, 0x0E, 0x70, 0x07, + 0x38, 0x03, 0x9C, 0x01, 0xCE, 0x00, 0xE7, 0x00, 0xF3, 0xC0, 0x79, 0xE0, + 0x7C, 0xFF, 0xFF, 0xFF, 0xE7, 0xFB, 0xC1, 0xFC, 0x00, 0x0E, 0x00, 0x07, + 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x00, 0x01, + 0xFF, 0x0F, 0xFF, 0x3F, 0xFF, 0x7F, 0x8C, 0x7F, 0x8C, 0xFF, 0x8C, 0xFF, + 0x8C, 0xFF, 0x8C, 0xFF, 0x8C, 0xFF, 0x8C, 0xFF, 0x8C, 0xFF, 0x8C, 0xFF, + 0x8C, 0x7F, 0x8C, 0x3F, 0x8C, 0x1F, 0x8C, 0x07, 0x8C, 0x01, 0x8C, 0x01, + 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, + 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, 0x8C, 0x01, + 0x8C, 0x01, 0x8C, 0xFF, 0xFF, 0x18, 0x38, 0x38, 0x60, 0x39, 0x80, 0x3F, + 0x00, 0x7C, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFE, 0xFF, 0xFC, + 0x00, 0x70, 0x01, 0xC0, 0x07, 0x80, 0x1E, 0x00, 0x78, 0x00, 0xE0, 0x03, + 0x80, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x07, 0x00, 0x1C, 0x00, + 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x0C, 0x31, 0xFF, 0xFC, 0x30, 0xC3, + 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x1F, 0x0F, 0xE7, 0x1D, 0x83, 0xE0, + 0xF0, 0x3C, 0x0F, 0x83, 0x60, 0xDC, 0x73, 0xF8, 0x7C, 0x00, 0x00, 0x07, + 0xFC, 0x81, 0x0C, 0x18, 0xE1, 0xE7, 0x8F, 0x38, 0x30, 0x81, 0x38, 0x37, + 0x8F, 0xE1, 0xEC, 0x18, 0x81, 0x00, 0x00, 0xFC, 0x7F, 0xFF, 0x01, 0xFF, + 0xBF, 0xFF, 0x83, 0xFF, 0xFF, 0xFF, 0xC3, 0xE0, 0x7F, 0x00, 0x01, 0xE0, + 0x1F, 0x80, 0x01, 0xE0, 0x07, 0xC0, 0x00, 0xE0, 0x01, 0xE0, 0x00, 0xF0, + 0x00, 0xF0, 0x00, 0x70, 0x00, 0x78, 0x00, 0x38, 0x00, 0x3C, 0x00, 0x1C, + 0x00, 0x1E, 0x00, 0x0E, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x07, 0xFF, 0xF7, + 0x80, 0x03, 0xFF, 0xF9, 0xC0, 0x01, 0xFF, 0xFC, 0xE0, 0x00, 0xF0, 0x00, + 0x70, 0x00, 0x78, 0x00, 0x38, 0x00, 0x3C, 0x00, 0x1C, 0x00, 0x1E, 0x00, + 0x0F, 0x00, 0x0F, 0x00, 0x03, 0x80, 0x07, 0x80, 0x01, 0xE0, 0x07, 0xC0, + 0x00, 0x78, 0x07, 0xE0, 0x00, 0x1F, 0x0F, 0xFF, 0xFF, 0x07, 0xFF, 0x7F, + 0xFF, 0x81, 0xFF, 0x3F, 0xFF, 0xC0, 0x1E, 0x00, 0x00, 0x00, 0x03, 0xE0, + 0x0F, 0x80, 0x3F, 0xE0, 0xFF, 0x81, 0xFF, 0xCF, 0xFF, 0x0F, 0x07, 0xBC, + 0x1E, 0x78, 0x0F, 0xC0, 0x39, 0xC0, 0x1F, 0x00, 0x77, 0x00, 0x78, 0x01, + 0xFC, 0x00, 0xE0, 0x07, 0xE0, 0x03, 0xFF, 0xFF, 0x80, 0x0F, 0xFF, 0xFE, + 0x00, 0x3F, 0xFF, 0xF8, 0x00, 0xE0, 0x00, 0xF0, 0x03, 0x80, 0x01, 0xC0, + 0x1E, 0x00, 0x77, 0x00, 0x7C, 0x01, 0xDE, 0x03, 0xF0, 0x0E, 0x3C, 0x1E, + 0xF0, 0x78, 0x7F, 0xF3, 0xFF, 0xC0, 0xFF, 0x87, 0xFE, 0x00, 0xF8, 0x03, + 0xC0, 0x01, 0xE7, 0x80, 0x03, 0xCF, 0x00, 0x07, 0x9E, 0x00, 0x0F, 0x3C, + 0x00, 0x00, 0x00, 0x1F, 0x00, 0x03, 0xDE, 0x00, 0x07, 0x9E, 0x00, 0x1E, + 0x3C, 0x00, 0x78, 0x3C, 0x00, 0xF0, 0x3C, 0x03, 0xC0, 0x78, 0x07, 0x00, + 0x78, 0x1E, 0x00, 0x70, 0x38, 0x00, 0xF0, 0xF0, 0x00, 0xF3, 0xC0, 0x01, + 0xE7, 0x00, 0x01, 0xFE, 0x00, 0x01, 0xF8, 0x00, 0x03, 0xE0, 0x00, 0x03, + 0xC0, 0x00, 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x3C, + 0x00, 0x00, 0x78, 0x00, 0x00, 0xF0, 0x00, 0x01, 0xE0, 0x00, 0x03, 0xC0, + 0x00, 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x03, 0xC0, 0x07, 0x80, 0x0F, + 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xE0, 0x03, 0xC0, + 0x07, 0x80, 0x0E, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, + 0x00, 0x70, 0x01, 0xE0, 0x03, 0x80, 0x3F, 0x00, 0x7F, 0x00, 0xEE, 0x03, + 0xDE, 0x07, 0x1F, 0xFE, 0x1F, 0xF8, 0x0F, 0xC0, 0x03, 0xC0, 0x00, 0x07, + 0x80, 0x00, 0x06, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x00, 0x07, 0x80, 0x00, 0x3E, 0x00, 0x00, 0xFC, 0x00, 0x03, 0xF0, 0x00, + 0x1F, 0xC0, 0x00, 0x77, 0x80, 0x01, 0xCE, 0x00, 0x0F, 0x38, 0x00, 0x38, + 0xF0, 0x01, 0xE1, 0xC0, 0x07, 0x07, 0x00, 0x1C, 0x1E, 0x00, 0xF0, 0x38, + 0x03, 0x80, 0xE0, 0x0E, 0x03, 0xC0, 0x78, 0x07, 0x01, 0xFF, 0xFE, 0x07, + 0xFF, 0xF8, 0x3C, 0x00, 0xE0, 0xE0, 0x03, 0xC3, 0x80, 0x0F, 0x1E, 0x00, + 0x1C, 0x70, 0x00, 0x7B, 0xC0, 0x01, 0xEF, 0x00, 0x03, 0xB8, 0x00, 0x0F, + 0x00, 0x1E, 0x00, 0x00, 0x70, 0x00, 0x03, 0x80, 0x00, 0x1C, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80, 0x00, 0x3E, 0x00, 0x00, 0xFC, + 0x00, 0x03, 0xF0, 0x00, 0x1F, 0xC0, 0x00, 0x77, 0x80, 0x01, 0xCE, 0x00, + 0x0F, 0x38, 0x00, 0x38, 0xF0, 0x01, 0xE1, 0xC0, 0x07, 0x07, 0x00, 0x1C, + 0x1E, 0x00, 0xF0, 0x38, 0x03, 0x80, 0xE0, 0x0E, 0x03, 0xC0, 0x78, 0x07, + 0x01, 0xFF, 0xFE, 0x07, 0xFF, 0xF8, 0x3C, 0x00, 0xE0, 0xE0, 0x03, 0xC3, + 0x80, 0x0F, 0x1E, 0x00, 0x1C, 0x70, 0x00, 0x7B, 0xC0, 0x01, 0xEF, 0x00, + 0x03, 0xB8, 0x00, 0x0F, 0x00, 0xF8, 0x00, 0x03, 0xF0, 0x00, 0x1C, 0xC0, + 0x00, 0x63, 0x80, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80, 0x00, + 0x3E, 0x00, 0x00, 0xFC, 0x00, 0x03, 0xF0, 0x00, 0x1F, 0xC0, 0x00, 0x77, + 0x80, 0x01, 0xCE, 0x00, 0x0F, 0x38, 0x00, 0x38, 0xF0, 0x01, 0xE1, 0xC0, + 0x07, 0x07, 0x00, 0x1C, 0x1E, 0x00, 0xF0, 0x38, 0x03, 0x80, 0xE0, 0x0E, + 0x03, 0xC0, 0x78, 0x07, 0x01, 0xFF, 0xFE, 0x07, 0xFF, 0xF8, 0x3C, 0x00, + 0xE0, 0xE0, 0x03, 0xC3, 0x80, 0x0F, 0x1E, 0x00, 0x1C, 0x70, 0x00, 0x7B, + 0xC0, 0x01, 0xEF, 0x00, 0x03, 0xB8, 0x00, 0x0F, 0x01, 0xC3, 0x00, 0x0F, + 0xFC, 0x00, 0x37, 0xE0, 0x01, 0x81, 0x00, 0x00, 0x00, 0x00, 0x01, 0xE0, + 0x00, 0x0F, 0x80, 0x00, 0x3F, 0x00, 0x00, 0xFC, 0x00, 0x07, 0xF0, 0x00, + 0x1D, 0xE0, 0x00, 0x73, 0x80, 0x03, 0xCE, 0x00, 0x0E, 0x3C, 0x00, 0x78, + 0x70, 0x01, 0xC1, 0xC0, 0x07, 0x07, 0x80, 0x3C, 0x0E, 0x00, 0xE0, 0x38, + 0x03, 0x80, 0xF0, 0x1E, 0x01, 0xC0, 0x7F, 0xFF, 0x81, 0xFF, 0xFE, 0x0F, + 0x00, 0x38, 0x38, 0x00, 0xF0, 0xE0, 0x03, 0xC7, 0x80, 0x07, 0x1C, 0x00, + 0x1E, 0xF0, 0x00, 0x7B, 0xC0, 0x00, 0xEE, 0x00, 0x03, 0xC0, 0x03, 0xCF, + 0x00, 0x0F, 0x3C, 0x00, 0x3C, 0xF0, 0x00, 0xF3, 0xC0, 0x00, 0x00, 0x00, + 0x01, 0xE0, 0x00, 0x0F, 0x80, 0x00, 0x3F, 0x00, 0x00, 0xFC, 0x00, 0x07, + 0xF0, 0x00, 0x1D, 0xE0, 0x00, 0x73, 0x80, 0x03, 0x8E, 0x00, 0x0E, 0x3C, + 0x00, 0x78, 0x70, 0x01, 0xC1, 0xC0, 0x07, 0x07, 0x80, 0x3C, 0x0E, 0x00, + 0xE0, 0x38, 0x03, 0x80, 0xF0, 0x1E, 0x01, 0xC0, 0x7F, 0xFF, 0x81, 0xFF, + 0xFE, 0x0F, 0x00, 0x38, 0x38, 0x00, 0xF0, 0xE0, 0x03, 0xC7, 0x80, 0x07, + 0x1C, 0x00, 0x1E, 0xF0, 0x00, 0x7B, 0xC0, 0x00, 0xEE, 0x00, 0x03, 0xC0, + 0x00, 0x70, 0x00, 0x03, 0xF0, 0x00, 0x1D, 0xC0, 0x00, 0x63, 0x00, 0x01, + 0x8C, 0x00, 0x07, 0xF0, 0x00, 0x0F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x78, + 0x00, 0x03, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x3F, 0x00, 0x01, 0xFC, 0x00, + 0x07, 0x78, 0x00, 0x1C, 0xE0, 0x00, 0xF3, 0x80, 0x03, 0x8F, 0x00, 0x1E, + 0x1C, 0x00, 0x70, 0x70, 0x01, 0xC1, 0xE0, 0x0F, 0x03, 0x80, 0x38, 0x0E, + 0x00, 0xE0, 0x3C, 0x07, 0x80, 0x70, 0x1F, 0xFF, 0xE0, 0x7F, 0xFF, 0x83, + 0xC0, 0x0E, 0x0E, 0x00, 0x3C, 0x38, 0x00, 0xF1, 0xE0, 0x01, 0xC7, 0x00, + 0x07, 0xBC, 0x00, 0x1E, 0xF0, 0x00, 0x3B, 0x80, 0x00, 0xF0, 0x00, 0x1F, + 0xFF, 0xFF, 0x80, 0x1F, 0xFF, 0xFF, 0xC0, 0x0F, 0xFF, 0xFF, 0xE0, 0x07, + 0x1E, 0x00, 0x00, 0x07, 0x0F, 0x00, 0x00, 0x03, 0x87, 0x80, 0x00, 0x03, + 0xC3, 0xC0, 0x00, 0x01, 0xC1, 0xE0, 0x00, 0x00, 0xE0, 0xF0, 0x00, 0x00, + 0xE0, 0x78, 0x00, 0x00, 0x70, 0x3C, 0x00, 0x00, 0x78, 0x1E, 0x00, 0x00, + 0x38, 0x0F, 0xFF, 0xF0, 0x3C, 0x07, 0xFF, 0xF8, 0x1E, 0x03, 0xC0, 0x00, + 0x0E, 0x01, 0xE0, 0x00, 0x0F, 0xFF, 0xF0, 0x00, 0x07, 0xFF, 0xF8, 0x00, + 0x07, 0xFF, 0xFC, 0x00, 0x03, 0xC0, 0x1E, 0x00, 0x01, 0xC0, 0x0F, 0x00, + 0x01, 0xE0, 0x07, 0x80, 0x00, 0xE0, 0x03, 0xC0, 0x00, 0xF0, 0x01, 0xFF, + 0xFF, 0x78, 0x00, 0xFF, 0xFF, 0xB8, 0x00, 0x7F, 0xFF, 0xC0, 0x00, 0xFE, + 0x00, 0x1F, 0xFE, 0x00, 0xFF, 0xFC, 0x07, 0xC0, 0xF8, 0x3C, 0x00, 0xF0, + 0xE0, 0x01, 0xC7, 0x80, 0x07, 0x9C, 0x00, 0x0E, 0xF0, 0x00, 0x03, 0x80, + 0x00, 0x0E, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, 0x00, 0x03, 0x80, 0x00, + 0x0E, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, 0x00, 0x03, 0x80, 0x00, 0xFF, + 0x00, 0x03, 0x9C, 0x00, 0x0E, 0x78, 0x00, 0x78, 0xE0, 0x01, 0xC3, 0xE0, + 0x0F, 0x07, 0xC0, 0xF8, 0x0F, 0xFF, 0xC0, 0x0F, 0xFE, 0x00, 0x0F, 0xC0, + 0x00, 0x08, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x70, 0x00, 0x00, 0xE0, 0x00, + 0xC7, 0x00, 0x03, 0xFC, 0x00, 0x07, 0x80, 0x00, 0xE0, 0x00, 0x1C, 0x00, + 0x03, 0x80, 0x00, 0x60, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF8, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, + 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0F, 0xFF, 0xFB, + 0xFF, 0xFE, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, + 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x3F, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x78, 0x00, 0x1C, 0x00, 0x0E, 0x00, + 0x07, 0x00, 0x01, 0x80, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF8, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, + 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0F, 0xFF, 0xFB, + 0xFF, 0xFE, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, + 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x3F, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xE0, 0x00, 0xFC, 0x00, 0x33, 0x80, + 0x18, 0x60, 0x0E, 0x0C, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF8, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, + 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0F, 0xFF, 0xFB, + 0xFF, 0xFE, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, + 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x3F, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x3C, 0x03, 0xCF, 0x00, 0xF3, 0xC0, + 0x3C, 0xF0, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, + 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, + 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x3F, 0xFF, 0xEF, 0xFF, 0xFB, + 0x80, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xE0, + 0x00, 0x38, 0x00, 0x0E, 0x00, 0x03, 0x80, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFC, 0xF8, 0x70, 0x70, 0x60, 0x60, 0x07, 0x8F, 0x1E, 0x3C, + 0x78, 0xF1, 0xE3, 0xC7, 0x8F, 0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xC7, 0x8F, + 0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xC7, 0x8F, 0x1E, 0x1C, 0x38, 0x70, 0x60, + 0x00, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, + 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, + 0x78, 0x78, 0x78, 0x1E, 0x0F, 0xC7, 0x31, 0x86, 0xE1, 0xC0, 0x01, 0xE0, + 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, + 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, + 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0xF3, 0xFC, 0xFF, 0x3F, 0xCF, + 0x00, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, + 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, + 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x3F, 0xF0, + 0x00, 0xFF, 0xFE, 0x03, 0xFF, 0xFC, 0x0E, 0x01, 0xF8, 0x38, 0x00, 0xF0, + 0xE0, 0x01, 0xE3, 0x80, 0x03, 0x8E, 0x00, 0x0F, 0x38, 0x00, 0x3C, 0xE0, + 0x00, 0x73, 0x80, 0x01, 0xCE, 0x00, 0x07, 0xFF, 0xE0, 0x1F, 0xFF, 0x80, + 0x73, 0x80, 0x01, 0xCE, 0x00, 0x07, 0x38, 0x00, 0x1C, 0xE0, 0x00, 0x73, + 0x80, 0x03, 0xCE, 0x00, 0x0E, 0x38, 0x00, 0x78, 0xE0, 0x03, 0xC3, 0x80, + 0x1F, 0x0F, 0xFF, 0xF8, 0x3F, 0xFF, 0x80, 0xFF, 0xF8, 0x00, 0x07, 0xC6, + 0x00, 0x7F, 0xE0, 0x0C, 0x7C, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x7F, 0x00, + 0x07, 0xF0, 0x00, 0x7F, 0x80, 0x07, 0xFC, 0x00, 0x7F, 0xC0, 0x07, 0xFE, + 0x00, 0x7E, 0xF0, 0x07, 0xE7, 0x00, 0x7E, 0x78, 0x07, 0xE3, 0xC0, 0x7E, + 0x1C, 0x07, 0xE1, 0xE0, 0x7E, 0x0F, 0x07, 0xE0, 0x70, 0x7E, 0x07, 0x87, + 0xE0, 0x38, 0x7E, 0x01, 0xC7, 0xE0, 0x1E, 0x7E, 0x00, 0xE7, 0xE0, 0x0F, + 0x7E, 0x00, 0x7F, 0xE0, 0x03, 0xFE, 0x00, 0x3F, 0xE0, 0x01, 0xFE, 0x00, + 0x0F, 0x00, 0xF0, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x03, + 0x80, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFC, 0x00, 0x03, + 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x07, 0xC0, 0x7C, 0x07, 0x80, 0x0F, 0x07, + 0x80, 0x03, 0xC3, 0xC0, 0x00, 0xE3, 0xC0, 0x00, 0x79, 0xC0, 0x00, 0x1C, + 0xE0, 0x00, 0x0F, 0x70, 0x00, 0x07, 0xF8, 0x00, 0x01, 0xFC, 0x00, 0x00, + 0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3F, 0x80, 0x00, 0x1D, 0xC0, 0x00, + 0x1E, 0xE0, 0x00, 0x0F, 0x78, 0x00, 0x07, 0x3C, 0x00, 0x07, 0x8F, 0x00, + 0x03, 0x87, 0xC0, 0x03, 0xC1, 0xF0, 0x03, 0xC0, 0x7E, 0x07, 0xC0, 0x1F, + 0xFF, 0xC0, 0x03, 0xFF, 0x80, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x07, 0x80, + 0x00, 0x07, 0x80, 0x00, 0x03, 0x80, 0x00, 0x03, 0x80, 0x00, 0x03, 0x80, + 0x00, 0x00, 0x00, 0x00, 0x01, 0xFC, 0x00, 0x03, 0xFF, 0xC0, 0x07, 0xFF, + 0xF0, 0x07, 0xC0, 0x7C, 0x07, 0x80, 0x0F, 0x07, 0x80, 0x03, 0xC3, 0xC0, + 0x00, 0xE3, 0xC0, 0x00, 0x79, 0xC0, 0x00, 0x1C, 0xE0, 0x00, 0x0F, 0x70, + 0x00, 0x07, 0xF8, 0x00, 0x01, 0xFC, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x7F, + 0x00, 0x00, 0x3F, 0x80, 0x00, 0x1D, 0xC0, 0x00, 0x1E, 0xE0, 0x00, 0x0F, + 0x78, 0x00, 0x07, 0x3C, 0x00, 0x07, 0x8F, 0x00, 0x03, 0x87, 0xC0, 0x03, + 0xC1, 0xF0, 0x03, 0xC0, 0x7E, 0x07, 0xC0, 0x1F, 0xFF, 0xC0, 0x03, 0xFF, + 0x80, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x1F, 0x80, 0x00, + 0x1C, 0xC0, 0x00, 0x1C, 0x70, 0x00, 0x0C, 0x1C, 0x00, 0x00, 0x00, 0x00, + 0x01, 0xFC, 0x00, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x07, 0xC0, 0x7C, + 0x07, 0x80, 0x0F, 0x07, 0x80, 0x03, 0xC3, 0xC0, 0x00, 0xE3, 0xC0, 0x00, + 0x79, 0xC0, 0x00, 0x1C, 0xE0, 0x00, 0x0F, 0x70, 0x00, 0x07, 0xF8, 0x00, + 0x01, 0xFC, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3F, 0x80, + 0x00, 0x1D, 0xC0, 0x00, 0x1E, 0xE0, 0x00, 0x0F, 0x78, 0x00, 0x07, 0x3C, + 0x00, 0x07, 0x8F, 0x00, 0x03, 0x87, 0xC0, 0x03, 0xC1, 0xF0, 0x03, 0xC0, + 0x7E, 0x07, 0xC0, 0x1F, 0xFF, 0xC0, 0x03, 0xFF, 0x80, 0x00, 0x3F, 0x00, + 0x00, 0x00, 0x70, 0xC0, 0x00, 0x7F, 0xE0, 0x00, 0x77, 0xE0, 0x00, 0x30, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x03, 0xF8, 0x00, 0x07, 0xFF, 0x80, 0x0F, + 0xFF, 0xE0, 0x0F, 0x80, 0xF8, 0x0F, 0x00, 0x1E, 0x0F, 0x00, 0x07, 0x87, + 0x80, 0x01, 0xC7, 0x80, 0x00, 0xF3, 0x80, 0x00, 0x39, 0xC0, 0x00, 0x1E, + 0xE0, 0x00, 0x0F, 0xF0, 0x00, 0x03, 0xF8, 0x00, 0x01, 0xFC, 0x00, 0x00, + 0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3B, 0x80, 0x00, 0x3D, 0xC0, 0x00, + 0x1E, 0xF0, 0x00, 0x0E, 0x78, 0x00, 0x0F, 0x1E, 0x00, 0x07, 0x0F, 0x80, + 0x07, 0x83, 0xE0, 0x07, 0x80, 0xFC, 0x0F, 0x80, 0x3F, 0xFF, 0x80, 0x07, + 0xFF, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xF3, 0xC0, 0x00, 0x79, 0xE0, 0x00, + 0x3C, 0xF0, 0x00, 0x1E, 0x78, 0x00, 0x00, 0x00, 0x00, 0x03, 0xF8, 0x00, + 0x07, 0xFF, 0x80, 0x0F, 0xFF, 0xE0, 0x0F, 0x80, 0xF8, 0x0F, 0x00, 0x1E, + 0x0F, 0x00, 0x07, 0x87, 0x80, 0x01, 0xC7, 0x80, 0x00, 0xF3, 0x80, 0x00, + 0x39, 0xC0, 0x00, 0x1E, 0xE0, 0x00, 0x0F, 0xF0, 0x00, 0x03, 0xF8, 0x00, + 0x01, 0xFC, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3B, 0x80, + 0x00, 0x3D, 0xC0, 0x00, 0x1E, 0xF0, 0x00, 0x0E, 0x78, 0x00, 0x0F, 0x1E, + 0x00, 0x07, 0x0F, 0x80, 0x07, 0x83, 0xE0, 0x07, 0x80, 0xFC, 0x0F, 0x80, + 0x3F, 0xFF, 0x80, 0x07, 0xFF, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x09, 0x80, + 0x77, 0x03, 0x8F, 0x1C, 0x1E, 0xE0, 0x3F, 0x00, 0x78, 0x01, 0xF0, 0x0F, + 0xE0, 0x73, 0xC3, 0x87, 0x9C, 0x0F, 0x60, 0x1C, 0x00, 0x20, 0x00, 0x7F, + 0x01, 0x80, 0xFF, 0xF1, 0x81, 0xFF, 0xFD, 0xC1, 0xF0, 0x1F, 0xC1, 0xE0, + 0x03, 0xC1, 0xE0, 0x01, 0xF0, 0xE0, 0x01, 0xF8, 0xF0, 0x01, 0xDE, 0x70, + 0x01, 0xC7, 0x38, 0x00, 0xC3, 0xBC, 0x00, 0xC1, 0xFE, 0x00, 0xC0, 0xFF, + 0x00, 0xC0, 0x3F, 0x00, 0xC0, 0x1F, 0xC0, 0xE0, 0x0F, 0xE0, 0xE0, 0x0F, + 0xF0, 0xE0, 0x07, 0xB8, 0xE0, 0x03, 0x9C, 0xE0, 0x01, 0xCF, 0xE0, 0x01, + 0xE3, 0xE0, 0x00, 0xE1, 0xE0, 0x00, 0xF0, 0x7C, 0x01, 0xF0, 0x7F, 0x83, + 0xF0, 0x67, 0xFF, 0xF0, 0x60, 0xFF, 0xE0, 0x10, 0x0F, 0x80, 0x00, 0x07, + 0x80, 0x00, 0x1C, 0x00, 0x00, 0xE0, 0x00, 0x06, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, + 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, + 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, + 0x00, 0xFE, 0x00, 0x0F, 0xF0, 0x00, 0xEF, 0x00, 0x1E, 0x78, 0x01, 0xE3, + 0xE0, 0x7C, 0x1F, 0xFF, 0x80, 0xFF, 0xE0, 0x01, 0xF8, 0x00, 0x00, 0x3C, + 0x00, 0x07, 0x80, 0x00, 0x70, 0x00, 0x0E, 0x00, 0x01, 0xC0, 0x00, 0x00, + 0x00, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, + 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, + 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, + 0xFE, 0x00, 0x0F, 0xF0, 0x00, 0xEF, 0x00, 0x1E, 0x78, 0x01, 0xE3, 0xE0, + 0x7C, 0x1F, 0xFF, 0x80, 0xFF, 0xE0, 0x01, 0xF8, 0x00, 0x00, 0xF0, 0x00, + 0x1F, 0x80, 0x03, 0x98, 0x00, 0x31, 0xC0, 0x06, 0x0E, 0x00, 0x00, 0x00, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, + 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, + 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, + 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, + 0x00, 0x0F, 0xF0, 0x00, 0xEF, 0x00, 0x1E, 0x78, 0x01, 0xE3, 0xE0, 0x7C, + 0x1F, 0xFF, 0x80, 0xFF, 0xE0, 0x01, 0xF8, 0x00, 0x07, 0x9E, 0x00, 0x79, + 0xE0, 0x07, 0x9E, 0x00, 0x79, 0xE0, 0x00, 0x00, 0x0E, 0x00, 0x0F, 0xE0, + 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, + 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, + 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, + 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFF, 0x00, + 0x0E, 0xF0, 0x01, 0xE7, 0x80, 0x1E, 0x3E, 0x07, 0xC1, 0xFF, 0xF8, 0x0F, + 0xFE, 0x00, 0x1F, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x70, + 0x00, 0x01, 0xC0, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x07, + 0xBC, 0x00, 0x0F, 0x3C, 0x00, 0x3C, 0x78, 0x00, 0xF0, 0x78, 0x01, 0xE0, + 0x78, 0x07, 0x80, 0xF0, 0x0E, 0x00, 0xF0, 0x3C, 0x00, 0xE0, 0x70, 0x01, + 0xE1, 0xE0, 0x01, 0xE7, 0x80, 0x03, 0xCE, 0x00, 0x03, 0xFC, 0x00, 0x03, + 0xF0, 0x00, 0x07, 0xC0, 0x00, 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x1E, + 0x00, 0x00, 0x3C, 0x00, 0x00, 0x78, 0x00, 0x00, 0xF0, 0x00, 0x01, 0xE0, + 0x00, 0x03, 0xC0, 0x00, 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x1E, 0x00, + 0xE0, 0x00, 0x1C, 0x00, 0x03, 0x80, 0x00, 0x70, 0x00, 0x0E, 0x00, 0x01, + 0xFF, 0xFC, 0x3F, 0xFF, 0xC7, 0xFF, 0xFC, 0xE0, 0x07, 0xDC, 0x00, 0x7B, + 0x80, 0x07, 0x70, 0x00, 0xFE, 0x00, 0x1F, 0xC0, 0x03, 0xB8, 0x00, 0xF7, + 0x00, 0x1E, 0xE0, 0x3F, 0x9F, 0xFF, 0xE3, 0xFF, 0xF8, 0x70, 0x00, 0x0E, + 0x00, 0x01, 0xC0, 0x00, 0x38, 0x00, 0x07, 0x00, 0x00, 0xE0, 0x00, 0x1C, + 0x00, 0x00, 0x0F, 0xF8, 0x0F, 0xFF, 0x87, 0xC1, 0xF1, 0xC0, 0x1C, 0x70, + 0x07, 0xBC, 0x00, 0xEE, 0x00, 0x3B, 0x80, 0x1E, 0xE0, 0x07, 0x38, 0x03, + 0xCE, 0x0F, 0xE3, 0x83, 0xF8, 0xE0, 0xFF, 0x38, 0x01, 0xEE, 0x00, 0x3B, + 0x80, 0x0F, 0xE0, 0x01, 0xF8, 0x00, 0x7E, 0x00, 0x1F, 0x80, 0x07, 0xE0, + 0x03, 0xB8, 0x01, 0xEE, 0x01, 0xF3, 0x87, 0xF8, 0xE1, 0xFC, 0x00, 0x10, + 0x00, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0x03, 0x00, 0x00, 0x60, + 0x00, 0x00, 0x00, 0x3F, 0x00, 0x7F, 0xF0, 0x3F, 0xFE, 0x0F, 0x07, 0x87, + 0x80, 0xE1, 0xC0, 0x1C, 0x00, 0x07, 0x00, 0x03, 0xC0, 0x07, 0xF0, 0x3F, + 0xFC, 0x3F, 0xE7, 0x1F, 0x01, 0xC7, 0x00, 0x71, 0xC0, 0x1C, 0xF0, 0x0F, + 0x1C, 0x03, 0xC7, 0x03, 0xF1, 0xFF, 0xDF, 0x3F, 0xE7, 0xC3, 0xE0, 0xF0, + 0x00, 0x78, 0x00, 0x3C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, + 0x00, 0x00, 0x3F, 0x00, 0x7F, 0xF0, 0x3F, 0xFE, 0x0F, 0x07, 0x87, 0x80, + 0xE1, 0xC0, 0x1C, 0x00, 0x07, 0x00, 0x03, 0xC0, 0x07, 0xF0, 0x3F, 0xFC, + 0x3F, 0xE7, 0x1F, 0x01, 0xC7, 0x00, 0x71, 0xC0, 0x1C, 0xF0, 0x0F, 0x1C, + 0x03, 0xC7, 0x03, 0xF1, 0xFF, 0xDF, 0x3F, 0xE7, 0xC3, 0xE0, 0xF0, 0x03, + 0xE0, 0x00, 0xFC, 0x00, 0x73, 0x00, 0x38, 0xE0, 0x0C, 0x18, 0x00, 0x00, + 0x00, 0x3F, 0x00, 0x7F, 0xF0, 0x3F, 0xFE, 0x0F, 0x07, 0x87, 0x80, 0xE1, + 0xC0, 0x1C, 0x00, 0x07, 0x00, 0x03, 0xC0, 0x07, 0xF0, 0x3F, 0xFC, 0x3F, + 0xE7, 0x1F, 0x01, 0xC7, 0x00, 0x71, 0xC0, 0x1C, 0xF0, 0x0F, 0x1C, 0x03, + 0xC7, 0x03, 0xF1, 0xFF, 0xDF, 0x3F, 0xE7, 0xC3, 0xE0, 0xF0, 0x07, 0x0C, + 0x03, 0xFF, 0x01, 0xFF, 0x80, 0x61, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3F, 0x00, 0x7F, 0xF0, 0x3F, 0xFE, 0x0F, 0x07, 0x87, 0x80, 0xE1, 0xC0, + 0x1C, 0x00, 0x07, 0x00, 0x03, 0xC0, 0x07, 0xF0, 0x3F, 0xFC, 0x3F, 0xE7, + 0x1F, 0x01, 0xC7, 0x00, 0x71, 0xC0, 0x1C, 0xF0, 0x0F, 0x1C, 0x03, 0xC7, + 0x03, 0xF1, 0xFF, 0xDF, 0x3F, 0xE7, 0xC3, 0xE0, 0xF0, 0x0F, 0x3C, 0x03, + 0xCF, 0x00, 0xF3, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, + 0x00, 0x7F, 0xF0, 0x3F, 0xFE, 0x0F, 0x07, 0x87, 0x80, 0xE1, 0xC0, 0x1C, + 0x00, 0x07, 0x00, 0x03, 0xC0, 0x07, 0xF0, 0x3F, 0xFC, 0x3F, 0xE7, 0x1F, + 0x01, 0xC7, 0x00, 0x71, 0xC0, 0x1C, 0xF0, 0x0F, 0x1C, 0x03, 0xC7, 0x03, + 0xF1, 0xFF, 0xDF, 0x3F, 0xE7, 0xC3, 0xE0, 0xF0, 0x01, 0xE0, 0x00, 0xFC, + 0x00, 0x77, 0x00, 0x18, 0xC0, 0x06, 0x30, 0x01, 0xFC, 0x00, 0x3E, 0x00, + 0x00, 0x00, 0x03, 0xF0, 0x07, 0xFF, 0x03, 0xFF, 0xE0, 0xF0, 0x78, 0x78, + 0x0E, 0x1C, 0x01, 0xC0, 0x00, 0x70, 0x00, 0x3C, 0x00, 0x7F, 0x03, 0xFF, + 0xC3, 0xFE, 0x71, 0xF0, 0x1C, 0x70, 0x07, 0x1C, 0x01, 0xCF, 0x00, 0xF1, + 0xC0, 0x3C, 0x70, 0x3F, 0x1F, 0xFD, 0xF3, 0xFE, 0x7C, 0x3E, 0x0F, 0x03, + 0xE0, 0x3E, 0x00, 0xFF, 0xC7, 0xFC, 0x0F, 0xFF, 0x7F, 0xF8, 0x78, 0x1F, + 0x83, 0xC7, 0x80, 0xF8, 0x0F, 0x38, 0x03, 0x80, 0x38, 0x00, 0x1C, 0x01, + 0xE0, 0x01, 0xE0, 0x07, 0x00, 0x7F, 0xFF, 0xF8, 0x7F, 0xFF, 0xFF, 0xCF, + 0xF9, 0xFF, 0xFE, 0xF8, 0x0C, 0x00, 0x07, 0x00, 0x70, 0x00, 0x78, 0x03, + 0x80, 0x1B, 0xC0, 0x3C, 0x01, 0xCE, 0x03, 0xF0, 0x1E, 0x78, 0x3B, 0xC1, + 0xE3, 0xFF, 0x8F, 0xFF, 0x0F, 0xF8, 0x3F, 0xE0, 0x1F, 0x00, 0x7C, 0x00, + 0x03, 0xE0, 0x0F, 0xF8, 0x1F, 0xFC, 0x3C, 0x1E, 0x78, 0x0E, 0x70, 0x0E, + 0xF0, 0x0E, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xF0, 0x07, 0x70, 0x0E, 0x78, 0x0E, 0x3C, 0x1E, 0x1F, 0xFC, + 0x0F, 0xF8, 0x03, 0xC0, 0x01, 0x00, 0x03, 0xE0, 0x00, 0xE0, 0x00, 0x70, + 0x18, 0xE0, 0x1F, 0xE0, 0x0F, 0x00, 0x03, 0xC0, 0x00, 0xE0, 0x00, 0x38, + 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x0F, 0xF8, 0x0F, + 0xFF, 0x0F, 0x07, 0x87, 0x01, 0xE7, 0x00, 0x73, 0x80, 0x1D, 0xC0, 0x0F, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x0E, 0x00, 0x07, 0x00, + 0x3B, 0x80, 0x39, 0xE0, 0x1C, 0x78, 0x3C, 0x1F, 0xFE, 0x07, 0xFC, 0x00, + 0xF8, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x1C, 0x00, 0x1C, + 0x00, 0x1C, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x0F, 0xF8, 0x0F, 0xFF, 0x0F, + 0x07, 0x87, 0x01, 0xE7, 0x00, 0x73, 0x80, 0x1D, 0xC0, 0x0F, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x3B, 0x80, + 0x39, 0xE0, 0x1C, 0x78, 0x3C, 0x1F, 0xFE, 0x07, 0xFC, 0x00, 0xF8, 0x00, + 0x01, 0xE0, 0x01, 0xF8, 0x01, 0xCE, 0x00, 0xC3, 0x00, 0xE0, 0xC0, 0x00, + 0x00, 0x0F, 0x80, 0x1F, 0xF0, 0x1F, 0xFE, 0x1E, 0x0F, 0x0E, 0x03, 0xCE, + 0x00, 0xE7, 0x00, 0x3B, 0x80, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xF0, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x77, 0x00, 0x73, 0xC0, 0x38, 0xF0, + 0x78, 0x3F, 0xFC, 0x0F, 0xF8, 0x01, 0xF0, 0x00, 0x0F, 0x3C, 0x07, 0x9E, + 0x03, 0xCF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x80, 0x1F, + 0xF0, 0x1F, 0xFE, 0x1E, 0x0F, 0x0E, 0x03, 0xCE, 0x00, 0xE7, 0x00, 0x3B, + 0x80, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x1C, 0x00, + 0x0E, 0x00, 0x77, 0x00, 0x73, 0xC0, 0x38, 0xF0, 0x78, 0x3F, 0xFC, 0x0F, + 0xF8, 0x01, 0xF0, 0x00, 0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0xC0, 0x00, 0x1C, + 0x38, 0x70, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3, 0x87, + 0x0E, 0x1C, 0x38, 0x0F, 0x1E, 0x3C, 0x38, 0x70, 0x60, 0x00, 0x00, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x38, 0x1C, 0x0F, 0x83, 0xF1, 0xCC, 0x61, 0xB0, + 0x70, 0x00, 0x00, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, + 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, + 0x07, 0x00, 0xE3, 0xF1, 0xF8, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x38, 0x1C, + 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, + 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x00, 0x18, 0x00, 0x1E, 0x38, 0x03, + 0xF8, 0x00, 0xF0, 0x01, 0xFE, 0x00, 0xC7, 0x80, 0x01, 0xE0, 0x07, 0x78, + 0x0F, 0xFC, 0x0F, 0xFF, 0x0F, 0x07, 0x8F, 0x01, 0xE7, 0x00, 0x73, 0x80, + 0x3B, 0xC0, 0x0F, 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFE, + 0x00, 0x77, 0x00, 0x73, 0x80, 0x39, 0xE0, 0x3C, 0x78, 0x3C, 0x1F, 0xFC, + 0x07, 0xFC, 0x00, 0xF8, 0x00, 0x0C, 0x18, 0x3F, 0x70, 0x7F, 0xE1, 0x87, + 0x80, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x73, 0xFC, 0xEF, 0xFD, 0xF8, 0x3F, + 0xE0, 0x3F, 0x80, 0x7F, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, + 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, + 0xF0, 0x07, 0xE0, 0x0E, 0x0F, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x30, + 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x0F, 0xF8, 0x0F, + 0xFE, 0x0F, 0x07, 0x8F, 0x01, 0xE7, 0x00, 0x73, 0x80, 0x3B, 0xC0, 0x0F, + 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFE, 0x00, 0x77, 0x00, + 0x73, 0x80, 0x39, 0xE0, 0x3C, 0x78, 0x3C, 0x1F, 0xFC, 0x07, 0xFC, 0x00, + 0xF8, 0x00, 0x00, 0x78, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x18, + 0x00, 0x18, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x0F, 0xF8, 0x0F, 0xFE, 0x0F, + 0x07, 0x8F, 0x01, 0xE7, 0x00, 0x73, 0x80, 0x3B, 0xC0, 0x0F, 0xC0, 0x07, + 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFE, 0x00, 0x77, 0x00, 0x73, 0x80, + 0x39, 0xE0, 0x3C, 0x78, 0x3C, 0x1F, 0xFC, 0x07, 0xFC, 0x00, 0xF8, 0x00, + 0x01, 0xC0, 0x01, 0xF0, 0x00, 0xDC, 0x00, 0xE6, 0x00, 0xE3, 0x80, 0x60, + 0xC0, 0x00, 0x00, 0x07, 0xC0, 0x0F, 0xF8, 0x0F, 0xFE, 0x0F, 0x07, 0x8F, + 0x01, 0xE7, 0x00, 0x73, 0x80, 0x3B, 0xC0, 0x0F, 0xC0, 0x07, 0xE0, 0x03, + 0xF0, 0x01, 0xF8, 0x00, 0xFE, 0x00, 0x77, 0x00, 0x73, 0x80, 0x39, 0xE0, + 0x3C, 0x78, 0x3C, 0x1F, 0xFC, 0x07, 0xFC, 0x00, 0xF8, 0x00, 0x06, 0x0C, + 0x07, 0xFE, 0x07, 0xFE, 0x03, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, + 0x80, 0x1F, 0xF0, 0x1F, 0xFC, 0x1E, 0x0F, 0x1E, 0x03, 0xCE, 0x00, 0xE7, + 0x00, 0x77, 0x80, 0x1F, 0x80, 0x0F, 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x01, + 0xFC, 0x00, 0xEE, 0x00, 0xE7, 0x00, 0x73, 0xC0, 0x78, 0xF0, 0x78, 0x3F, + 0xF8, 0x0F, 0xF8, 0x01, 0xF0, 0x00, 0x0E, 0x38, 0x07, 0x1C, 0x03, 0x8E, + 0x01, 0xC7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x0F, + 0xF8, 0x0F, 0xFE, 0x0F, 0x07, 0x8F, 0x01, 0xE7, 0x00, 0x73, 0x80, 0x3B, + 0xC0, 0x0F, 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFE, 0x00, + 0x77, 0x00, 0x73, 0x80, 0x39, 0xE0, 0x3C, 0x78, 0x3C, 0x1F, 0xFC, 0x07, + 0xFC, 0x00, 0xF8, 0x00, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0xF0, 0x00, 0x78, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, + 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x0F, 0x00, + 0x07, 0x80, 0x03, 0xC0, 0x00, 0x03, 0xE0, 0x83, 0xFE, 0x61, 0xFF, 0xF0, + 0xF0, 0x78, 0x78, 0x0F, 0x1C, 0x03, 0xC7, 0x01, 0xF3, 0xC0, 0xCE, 0xE0, + 0x63, 0xB8, 0x30, 0xEE, 0x18, 0x3B, 0x8C, 0x0E, 0xF6, 0x03, 0x9D, 0x81, + 0xC7, 0xC0, 0x71, 0xE0, 0x3C, 0x3C, 0x1E, 0x1F, 0xFF, 0x0C, 0xFF, 0x82, + 0x0F, 0x80, 0x1E, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x18, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, + 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, + 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x03, 0xFC, 0x07, 0xB8, 0x1F, 0x7F, + 0xEE, 0x7F, 0x9C, 0x3C, 0x00, 0x00, 0xF0, 0x01, 0xC0, 0x07, 0x00, 0x1C, + 0x00, 0x30, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0xC0, 0x1F, + 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, + 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x03, 0xFC, 0x07, + 0xB8, 0x1F, 0x7F, 0xEE, 0x7F, 0x9C, 0x3C, 0x00, 0x03, 0x80, 0x0F, 0x80, + 0x1B, 0x80, 0x73, 0x01, 0xC7, 0x03, 0x06, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, + 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, + 0x03, 0xFC, 0x07, 0xB8, 0x1F, 0x7F, 0xEE, 0x7F, 0x9C, 0x3C, 0x00, 0x1C, + 0x70, 0x38, 0xE0, 0x71, 0xC0, 0xE3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, + 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, + 0x7E, 0x00, 0xFC, 0x03, 0xFC, 0x07, 0xB8, 0x1F, 0x7F, 0xEE, 0x7F, 0x9C, + 0x3C, 0x00, 0x00, 0xF0, 0x00, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x03, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0E, 0xE0, 0x0E, 0x70, 0x0E, + 0x70, 0x1C, 0x70, 0x1C, 0x38, 0x3C, 0x38, 0x38, 0x38, 0x38, 0x1C, 0x70, + 0x1C, 0x70, 0x1C, 0x70, 0x0E, 0xE0, 0x0E, 0xE0, 0x0E, 0xE0, 0x07, 0xC0, + 0x07, 0xC0, 0x07, 0xC0, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00, + 0x07, 0x00, 0x1E, 0x00, 0x7E, 0x00, 0x7C, 0x00, 0x30, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE3, 0xE0, + 0xEF, 0xF8, 0xFF, 0xFC, 0xFC, 0x3E, 0xF0, 0x1E, 0xF0, 0x0F, 0xE0, 0x07, + 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, + 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x1E, 0xFC, 0x3E, 0xFF, 0xFC, 0xEF, 0xF8, + 0xE3, 0xE0, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, + 0xE0, 0x00, 0xE0, 0x00, 0x1E, 0x78, 0x1E, 0x78, 0x1E, 0x78, 0x1E, 0x78, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0E, 0xE0, 0x0E, + 0x70, 0x0E, 0x70, 0x1C, 0x70, 0x1C, 0x38, 0x3C, 0x38, 0x38, 0x38, 0x38, + 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x0E, 0xE0, 0x0E, 0xE0, 0x0E, 0xE0, + 0x07, 0xC0, 0x07, 0xC0, 0x07, 0xC0, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x1E, 0x00, 0x7E, 0x00, 0x7C, 0x00, 0x30, 0x00 }; + +const GFXglyph FreeSans18pt8bGlyphs[] PROGMEM = { + { 0, 1, 1, 10, 0, 0 }, // 0x20 ' ' U+0020 + { 1, 3, 26, 10, 4, -25 }, // 0x21 '!' U+0021 + { 11, 9, 9, 12, 2, -24 }, // 0x22 '"' U+0022 + { 22, 19, 25, 19, 0, -23 }, // 0x23 '#' U+0023 + { 82, 17, 31, 19, 1, -26 }, // 0x24 '$' U+0024 + { 148, 29, 26, 31, 1, -24 }, // 0x25 '%' U+0025 + { 243, 20, 26, 23, 2, -24 }, // 0x26 '&' U+0026 + { 308, 3, 9, 7, 2, -24 }, // 0x27 ''' U+0027 + { 312, 7, 33, 12, 3, -25 }, // 0x28 '(' U+0028 + { 341, 8, 33, 12, 1, -25 }, // 0x29 ')' U+0029 + { 374, 11, 11, 14, 1, -25 }, // 0x2a '*' U+002A + { 390, 17, 17, 20, 2, -16 }, // 0x2b '+' U+002B + { 427, 4, 9, 10, 3, -3 }, // 0x2c ',' U+002C + { 432, 8, 3, 12, 2, -10 }, // 0x2d '-' U+002D + { 435, 4, 4, 10, 3, -3 }, // 0x2e '.' U+002E + { 437, 10, 27, 10, 0, -25 }, // 0x2f '/' U+002F + { 471, 17, 26, 19, 1, -24 }, // 0x30 '0' U+0030 + { 527, 8, 25, 19, 4, -24 }, // 0x31 '1' U+0031 + { 552, 17, 25, 19, 1, -24 }, // 0x32 '2' U+0032 + { 606, 17, 26, 19, 1, -24 }, // 0x33 '3' U+0033 + { 662, 17, 25, 19, 1, -24 }, // 0x34 '4' U+0034 + { 716, 17, 26, 19, 1, -24 }, // 0x35 '5' U+0035 + { 772, 17, 26, 19, 1, -24 }, // 0x36 '6' U+0036 + { 828, 16, 25, 19, 2, -24 }, // 0x37 '7' U+0037 + { 878, 17, 26, 19, 1, -24 }, // 0x38 '8' U+0038 + { 934, 17, 26, 19, 1, -24 }, // 0x39 '9' U+0039 + { 990, 3, 18, 10, 4, -17 }, // 0x3a ':' U+003A + { 997, 4, 23, 10, 4, -17 }, // 0x3b ';' U+003B + { 1009, 17, 17, 20, 2, -16 }, // 0x3c '<' U+003C + { 1046, 17, 8, 20, 2, -11 }, // 0x3d '=' U+003D + { 1063, 17, 17, 20, 2, -16 }, // 0x3e '>' U+003E + { 1100, 15, 26, 19, 3, -25 }, // 0x3f '?' U+003F + { 1149, 32, 31, 36, 1, -25 }, // 0x40 '@' U+0040 + { 1273, 22, 26, 23, 1, -25 }, // 0x41 'A' U+0041 + { 1345, 19, 26, 23, 3, -25 }, // 0x42 'B' U+0042 + { 1407, 22, 27, 25, 2, -25 }, // 0x43 'C' U+0043 + { 1482, 20, 26, 25, 3, -25 }, // 0x44 'D' U+0044 + { 1547, 18, 26, 23, 3, -25 }, // 0x45 'E' U+0045 + { 1606, 17, 26, 21, 3, -25 }, // 0x46 'F' U+0046 + { 1662, 23, 27, 27, 2, -25 }, // 0x47 'G' U+0047 + { 1740, 20, 26, 25, 3, -25 }, // 0x48 'H' U+0048 + { 1805, 4, 26, 10, 3, -25 }, // 0x49 'I' U+0049 + { 1818, 14, 27, 18, 1, -25 }, // 0x4a 'J' U+004A + { 1866, 20, 26, 23, 3, -25 }, // 0x4b 'K' U+004B + { 1931, 16, 26, 19, 3, -25 }, // 0x4c 'L' U+004C + { 1983, 24, 26, 29, 3, -25 }, // 0x4d 'M' U+004D + { 2061, 20, 26, 25, 3, -25 }, // 0x4e 'N' U+004E + { 2126, 25, 27, 27, 1, -25 }, // 0x4f 'O' U+004F + { 2211, 19, 26, 23, 3, -25 }, // 0x50 'P' U+0050 + { 2273, 25, 28, 27, 1, -25 }, // 0x51 'Q' U+0051 + { 2361, 21, 26, 25, 3, -25 }, // 0x52 'R' U+0052 + { 2430, 20, 27, 23, 2, -25 }, // 0x53 'S' U+0053 + { 2498, 20, 26, 21, 1, -25 }, // 0x54 'T' U+0054 + { 2563, 20, 27, 25, 3, -25 }, // 0x55 'U' U+0055 + { 2631, 22, 26, 23, 1, -25 }, // 0x56 'V' U+0056 + { 2703, 32, 26, 33, 1, -25 }, // 0x57 'W' U+0057 + { 2807, 22, 26, 23, 1, -25 }, // 0x58 'X' U+0058 + { 2879, 23, 26, 23, 0, -25 }, // 0x59 'Y' U+0059 + { 2954, 19, 26, 21, 1, -25 }, // 0x5a 'Z' U+005A + { 3016, 7, 33, 10, 2, -25 }, // 0x5b '[' U+005B + { 3045, 10, 27, 10, 0, -25 }, // 0x5c '\' U+005C + { 3079, 6, 33, 10, 1, -25 }, // 0x5d ']' U+005D + { 3104, 13, 13, 16, 2, -24 }, // 0x5e '^' U+005E + { 3126, 21, 2, 19, -1, 5 }, // 0x5f '_' U+005F + { 3132, 7, 5, 12, 1, -25 }, // 0x60 '`' U+0060 + { 3137, 18, 20, 19, 1, -18 }, // 0x61 'a' U+0061 + { 3182, 16, 27, 19, 2, -25 }, // 0x62 'b' U+0062 + { 3236, 16, 20, 18, 1, -18 }, // 0x63 'c' U+0063 + { 3276, 16, 27, 19, 1, -25 }, // 0x64 'd' U+0064 + { 3330, 17, 20, 19, 1, -18 }, // 0x65 'e' U+0065 + { 3373, 8, 26, 10, 1, -25 }, // 0x66 'f' U+0066 + { 3399, 16, 27, 19, 1, -18 }, // 0x67 'g' U+0067 + { 3453, 15, 26, 19, 2, -25 }, // 0x68 'h' U+0068 + { 3502, 3, 26, 8, 2, -25 }, // 0x69 'i' U+0069 + { 3512, 6, 34, 8, -1, -25 }, // 0x6a 'j' U+006A + { 3538, 16, 26, 18, 2, -25 }, // 0x6b 'k' U+006B + { 3590, 3, 26, 8, 2, -25 }, // 0x6c 'l' U+006C + { 3600, 25, 19, 29, 2, -18 }, // 0x6d 'm' U+006D + { 3660, 15, 19, 19, 2, -18 }, // 0x6e 'n' U+006E + { 3696, 17, 20, 19, 1, -18 }, // 0x6f 'o' U+006F + { 3739, 16, 27, 19, 2, -18 }, // 0x70 'p' U+0070 + { 3793, 16, 27, 19, 1, -18 }, // 0x71 'q' U+0071 + { 3847, 9, 19, 12, 2, -18 }, // 0x72 'r' U+0072 + { 3869, 15, 20, 18, 1, -18 }, // 0x73 's' U+0073 + { 3907, 9, 24, 10, 0, -22 }, // 0x74 't' U+0074 + { 3934, 15, 19, 19, 2, -17 }, // 0x75 'u' U+0075 + { 3970, 17, 18, 18, 0, -17 }, // 0x76 'v' U+0076 + { 4009, 25, 18, 25, 0, -17 }, // 0x77 'w' U+0077 + { 4066, 16, 18, 18, 1, -17 }, // 0x78 'x' U+0078 + { 4102, 16, 26, 18, 1, -17 }, // 0x79 'y' U+0079 + { 4154, 15, 18, 18, 1, -17 }, // 0x7a 'z' U+007A + { 4188, 9, 33, 12, 1, -25 }, // 0x7b '{' U+007B + { 4226, 3, 33, 9, 3, -25 }, // 0x7c '|' U+007C + { 4239, 8, 33, 12, 1, -25 }, // 0x7d '}' U+007D + { 4272, 15, 6, 20, 3, -14 }, // 0x7e '~' U+007E + { 4284, 18, 26, 25, 3, -25 }, // 0x7f 'REPLACEMENT CHARACTER *' U+2370 + { 4343, 1, 1, 10, 0, 0 }, // 0x80 'NO-BREAK SPACE' U+00A0 + { 4344, 3, 26, 10, 5, -17 }, // 0x81 'INVERTED EXCLAMATION MARK' U+00A1 + { 4354, 16, 26, 19, 2, -21 }, // 0x82 'CENT SIGN' U+00A2 + { 4406, 18, 27, 19, 1, -25 }, // 0x83 'POUND SIGN' U+00A3 + { 4467, 21, 26, 23, 1, -24 }, // 0x84 'EURO SIGN *' U+20AC + { 4536, 19, 25, 19, 0, -24 }, // 0x85 'YEN SIGN' U+00A5 + { 4596, 20, 33, 23, 2, -31 }, // 0x86 'LATIN CAPITAL LETTER S WITH CARON *' U+0160 + { 4679, 17, 33, 19, 1, -25 }, // 0x87 'SECTION SIGN' U+00A7 + { 4750, 15, 27, 18, 1, -25 }, // 0x88 'LATIN SMALL LETTER S WITH CARON *' U+0161 + { 4801, 26, 27, 26, 0, -25 }, // 0x89 'COPYRIGHT SIGN' U+00A9 + { 4889, 11, 15, 13, 1, -25 }, // 0x8a 'FEMININE ORDINAL INDICATOR' U+00AA + { 4910, 12, 11, 16, 2, -14 }, // 0x8b 'LEFT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00AB + { 4927, 18, 10, 20, 1, -12 }, // 0x8c 'NOT SIGN' U+00AC + { 4950, 8, 3, 12, 2, -10 }, // 0x8d 'SOFT HYPHEN' U+00AD + { 4953, 26, 27, 26, 0, -25 }, // 0x8e 'REGISTERED SIGN' U+00AE + { 5041, 10, 3, 12, 1, -24 }, // 0x8f 'MACRON' U+00AF + { 5045, 11, 11, 21, 5, -23 }, // 0x90 'DEGREE SIGN' U+00B0 + { 5061, 17, 22, 20, 2, -21 }, // 0x91 'PLUS-MINUS SIGN' U+00B1 + { 5108, 10, 15, 12, 1, -24 }, // 0x92 'SUPERSCRIPT TWO' U+00B2 + { 5127, 10, 16, 12, 1, -24 }, // 0x93 'SUPERSCRIPT THREE' U+00B3 + { 5147, 19, 32, 21, 1, -31 }, // 0x94 'LATIN CAPITAL LETTER Z WITH CARON *' U+017D + { 5223, 17, 26, 19, 2, -17 }, // 0x95 'MICRO SIGN' U+00B5 + { 5279, 16, 32, 19, 2, -25 }, // 0x96 'PILCROW SIGN' U+00B6 + { 5343, 4, 4, 10, 3, -11 }, // 0x97 'MIDDLE DOT' U+00B7 + { 5345, 15, 26, 18, 1, -25 }, // 0x98 'LATIN SMALL LETTER Z WITH CARON *' U+017E + { 5394, 6, 15, 12, 2, -24 }, // 0x99 'SUPERSCRIPT ONE' U+00B9 + { 5406, 10, 15, 13, 1, -25 }, // 0x9a 'MASCULINE ORDINAL INDICATOR' U+00BA + { 5425, 12, 11, 16, 2, -14 }, // 0x9b 'RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00BB + { 5442, 33, 27, 35, 1, -25 }, // 0x9c 'LATIN CAPITAL LIGATURE OE *' U+0152 + { 5554, 30, 20, 33, 1, -18 }, // 0x9d 'LATIN SMALL LIGATURE OE *' U+0153 + { 5629, 23, 31, 23, 0, -30 }, // 0x9e 'LATIN CAPITAL LETTER Y WITH DIAERESIS *' U+0178 + { 5719, 15, 26, 19, 3, -17 }, // 0x9f 'INVERTED QUESTION MARK' U+00BF + { 5768, 22, 32, 23, 1, -31 }, // 0xa0 'LATIN CAPITAL LETTER A WITH GRAVE' U+00C0 + { 5856, 22, 32, 23, 1, -31 }, // 0xa1 'LATIN CAPITAL LETTER A WITH ACUTE' U+00C1 + { 5944, 22, 32, 23, 1, -31 }, // 0xa2 'LATIN CAPITAL LETTER A WITH CIRCUMFLEX' U+00C2 + { 6032, 22, 31, 23, 1, -30 }, // 0xa3 'LATIN CAPITAL LETTER A WITH TILDE' U+00C3 + { 6118, 22, 31, 23, 1, -30 }, // 0xa4 'LATIN CAPITAL LETTER A WITH DIAERESIS' U+00C4 + { 6204, 22, 34, 23, 1, -33 }, // 0xa5 'LATIN CAPITAL LETTER A WITH RING ABOVE' U+00C5 + { 6298, 33, 26, 35, 0, -25 }, // 0xa6 'LATIN CAPITAL LETTER AE' U+00C6 + { 6406, 22, 33, 25, 2, -25 }, // 0xa7 'LATIN CAPITAL LETTER C WITH CEDILLA' U+00C7 + { 6497, 18, 32, 23, 3, -31 }, // 0xa8 'LATIN CAPITAL LETTER E WITH GRAVE' U+00C8 + { 6569, 18, 32, 23, 3, -31 }, // 0xa9 'LATIN CAPITAL LETTER E WITH ACUTE' U+00C9 + { 6641, 18, 32, 23, 3, -31 }, // 0xaa 'LATIN CAPITAL LETTER E WITH CIRCUMFLEX' U+00CA + { 6713, 18, 31, 23, 3, -30 }, // 0xab 'LATIN CAPITAL LETTER E WITH DIAERESIS' U+00CB + { 6783, 7, 32, 10, 0, -31 }, // 0xac 'LATIN CAPITAL LETTER I WITH GRAVE' U+00CC + { 6811, 8, 32, 10, 2, -31 }, // 0xad 'LATIN CAPITAL LETTER I WITH ACUTE' U+00CD + { 6843, 10, 32, 10, 0, -31 }, // 0xae 'LATIN CAPITAL LETTER I WITH CIRCUMFLEX' U+00CE + { 6883, 10, 31, 10, 0, -30 }, // 0xaf 'LATIN CAPITAL LETTER I WITH DIAERESIS' U+00CF + { 6922, 22, 26, 25, 1, -25 }, // 0xb0 'LATIN CAPITAL LETTER ETH' U+00D0 + { 6994, 20, 30, 25, 3, -29 }, // 0xb1 'LATIN CAPITAL LETTER N WITH TILDE' U+00D1 + { 7069, 25, 33, 27, 1, -31 }, // 0xb2 'LATIN CAPITAL LETTER O WITH GRAVE' U+00D2 + { 7173, 25, 33, 27, 1, -31 }, // 0xb3 'LATIN CAPITAL LETTER O WITH ACUTE' U+00D3 + { 7277, 25, 33, 27, 1, -31 }, // 0xb4 'LATIN CAPITAL LETTER O WITH CIRCUMFLEX' U+00D4 + { 7381, 25, 32, 27, 1, -30 }, // 0xb5 'LATIN CAPITAL LETTER O WITH TILDE' U+00D5 + { 7481, 25, 32, 27, 1, -30 }, // 0xb6 'LATIN CAPITAL LETTER O WITH DIAERESIS' U+00D6 + { 7581, 14, 14, 20, 3, -14 }, // 0xb7 'MULTIPLICATION SIGN' U+00D7 + { 7606, 25, 27, 27, 1, -25 }, // 0xb8 'LATIN CAPITAL LETTER O WITH STROKE' U+00D8 + { 7691, 20, 33, 25, 3, -31 }, // 0xb9 'LATIN CAPITAL LETTER U WITH GRAVE' U+00D9 + { 7774, 20, 33, 25, 3, -31 }, // 0xba 'LATIN CAPITAL LETTER U WITH ACUTE' U+00DA + { 7857, 20, 33, 25, 3, -31 }, // 0xbb 'LATIN CAPITAL LETTER U WITH CIRCUMFLEX' U+00DB + { 7940, 20, 32, 25, 3, -30 }, // 0xbc 'LATIN CAPITAL LETTER U WITH DIAERESIS' U+00DC + { 8020, 23, 32, 23, 0, -31 }, // 0xbd 'LATIN CAPITAL LETTER Y WITH ACUTE' U+00DD + { 8112, 19, 26, 23, 3, -25 }, // 0xbe 'LATIN CAPITAL LETTER THORN' U+00DE + { 8174, 18, 26, 21, 2, -24 }, // 0xbf 'LATIN SMALL LETTER SHARP S' U+00DF + { 8233, 18, 26, 19, 1, -24 }, // 0xc0 'LATIN SMALL LETTER A WITH GRAVE' U+00E0 + { 8292, 18, 26, 19, 1, -24 }, // 0xc1 'LATIN SMALL LETTER A WITH ACUTE' U+00E1 + { 8351, 18, 26, 19, 1, -24 }, // 0xc2 'LATIN SMALL LETTER A WITH CIRCUMFLEX' U+00E2 + { 8410, 18, 26, 19, 1, -24 }, // 0xc3 'LATIN SMALL LETTER A WITH TILDE' U+00E3 + { 8469, 18, 26, 19, 1, -24 }, // 0xc4 'LATIN SMALL LETTER A WITH DIAERESIS' U+00E4 + { 8528, 18, 28, 19, 1, -26 }, // 0xc5 'LATIN SMALL LETTER A WITH RING ABOVE' U+00E5 + { 8591, 29, 20, 31, 1, -18 }, // 0xc6 'LATIN SMALL LETTER AE' U+00E6 + { 8664, 16, 26, 18, 1, -18 }, // 0xc7 'LATIN SMALL LETTER C WITH CEDILLA' U+00E7 + { 8716, 17, 27, 19, 1, -25 }, // 0xc8 'LATIN SMALL LETTER E WITH GRAVE' U+00E8 + { 8774, 17, 27, 19, 1, -25 }, // 0xc9 'LATIN SMALL LETTER E WITH ACUTE' U+00E9 + { 8832, 17, 26, 19, 1, -24 }, // 0xca 'LATIN SMALL LETTER E WITH CIRCUMFLEX' U+00EA + { 8888, 17, 26, 19, 1, -24 }, // 0xcb 'LATIN SMALL LETTER E WITH DIAERESIS' U+00EB + { 8944, 7, 26, 9, 0, -25 }, // 0xcc 'LATIN SMALL LETTER I WITH GRAVE' U+00EC + { 8967, 8, 26, 9, 1, -25 }, // 0xcd 'LATIN SMALL LETTER I WITH ACUTE' U+00ED + { 8993, 10, 26, 9, 0, -25 }, // 0xce 'LATIN SMALL LETTER I WITH CIRCUMFLEX' U+00EE + { 9026, 9, 25, 9, 0, -24 }, // 0xcf 'LATIN SMALL LETTER I WITH DIAERESIS' U+00EF + { 9055, 17, 27, 19, 1, -25 }, // 0xd0 'LATIN SMALL LETTER ETH' U+00F0 + { 9113, 15, 25, 19, 2, -24 }, // 0xd1 'LATIN SMALL LETTER N WITH TILDE' U+00F1 + { 9160, 17, 27, 19, 1, -25 }, // 0xd2 'LATIN SMALL LETTER O WITH GRAVE' U+00F2 + { 9218, 17, 27, 19, 1, -25 }, // 0xd3 'LATIN SMALL LETTER O WITH ACUTE' U+00F3 + { 9276, 17, 27, 19, 1, -25 }, // 0xd4 'LATIN SMALL LETTER O WITH CIRCUMFLEX' U+00F4 + { 9334, 17, 26, 19, 1, -24 }, // 0xd5 'LATIN SMALL LETTER O WITH TILDE' U+00F5 + { 9390, 17, 27, 19, 1, -25 }, // 0xd6 'LATIN SMALL LETTER O WITH DIAERESIS' U+00F6 + { 9448, 17, 17, 20, 2, -16 }, // 0xd7 'DIVISION SIGN' U+00F7 + { 9485, 18, 20, 21, 1, -18 }, // 0xd8 'LATIN SMALL LETTER O WITH STROKE' U+00F8 + { 9530, 15, 27, 19, 2, -25 }, // 0xd9 'LATIN SMALL LETTER U WITH GRAVE' U+00F9 + { 9581, 15, 27, 19, 2, -25 }, // 0xda 'LATIN SMALL LETTER U WITH ACUTE' U+00FA + { 9632, 15, 27, 19, 2, -25 }, // 0xdb 'LATIN SMALL LETTER U WITH CIRCUMFLEX' U+00FB + { 9683, 15, 27, 19, 2, -25 }, // 0xdc 'LATIN SMALL LETTER U WITH DIAERESIS' U+00FC + { 9734, 16, 34, 18, 1, -25 }, // 0xdd 'LATIN SMALL LETTER Y WITH ACUTE' U+00FD + { 9802, 16, 33, 19, 2, -24 }, // 0xde 'LATIN SMALL LETTER THORN' U+00FE + { 9868, 16, 34, 18, 1, -25 } }; // 0xdf 'LATIN SMALL LETTER Y WITH DIAERESIS' U+000FF + +const GFXfont FreeSans18pt8b PROGMEM = { + (uint8_t *)FreeSans18pt8bBitmaps, + (GFXglyph *)FreeSans18pt8bGlyphs, + 0x20, 0xDF, 49 }; + +// Approx. 11287 bytes diff --git a/RX_FSK/src/fonts/FreeSans9pt7b.h b/RX_FSK/src/fonts/FreeSans9pt7b.h new file mode 100644 index 0000000..1f006a1 --- /dev/null +++ b/RX_FSK/src/fonts/FreeSans9pt7b.h @@ -0,0 +1,201 @@ +const uint8_t FreeSans9pt7bBitmaps[] PROGMEM = { + 0xFF, 0xFF, 0xF8, 0xC0, 0xDE, 0xF7, 0x20, 0x09, 0x86, 0x41, 0x91, 0xFF, + 0x13, 0x04, 0xC3, 0x20, 0xC8, 0xFF, 0x89, 0x82, 0x61, 0x90, 0x10, 0x1F, + 0x14, 0xDA, 0x3D, 0x1E, 0x83, 0x40, 0x78, 0x17, 0x08, 0xF4, 0x7A, 0x35, + 0x33, 0xF0, 0x40, 0x20, 0x38, 0x10, 0xEC, 0x20, 0xC6, 0x20, 0xC6, 0x40, + 0xC6, 0x40, 0x6C, 0x80, 0x39, 0x00, 0x01, 0x3C, 0x02, 0x77, 0x02, 0x63, + 0x04, 0x63, 0x04, 0x77, 0x08, 0x3C, 0x0E, 0x06, 0x60, 0xCC, 0x19, 0x81, + 0xE0, 0x18, 0x0F, 0x03, 0x36, 0xC2, 0xD8, 0x73, 0x06, 0x31, 0xE3, 0xC4, + 0xFE, 0x13, 0x26, 0x6C, 0xCC, 0xCC, 0xC4, 0x66, 0x23, 0x10, 0x8C, 0x46, + 0x63, 0x33, 0x33, 0x32, 0x66, 0x4C, 0x80, 0x25, 0x7E, 0xA5, 0x00, 0x30, + 0xC3, 0x3F, 0x30, 0xC3, 0x0C, 0xD6, 0xF0, 0xC0, 0x08, 0x44, 0x21, 0x10, + 0x84, 0x42, 0x11, 0x08, 0x00, 0x3C, 0x66, 0x42, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0x11, 0x3F, 0x33, 0x33, 0x33, 0x33, + 0x30, 0x3E, 0x31, 0xB0, 0x78, 0x30, 0x18, 0x1C, 0x1C, 0x1C, 0x18, 0x18, + 0x10, 0x08, 0x07, 0xF8, 0x3C, 0x66, 0xC3, 0xC3, 0x03, 0x06, 0x1C, 0x07, + 0x03, 0xC3, 0xC3, 0x66, 0x3C, 0x0C, 0x18, 0x71, 0x62, 0xC9, 0xA3, 0x46, + 0xFE, 0x18, 0x30, 0x60, 0xC0, 0x7F, 0x20, 0x10, 0x08, 0x08, 0x07, 0xF3, + 0x8C, 0x03, 0x01, 0x80, 0xF0, 0x6C, 0x63, 0xE0, 0x1E, 0x31, 0x98, 0x78, + 0x0C, 0x06, 0xF3, 0x8D, 0x83, 0xC1, 0xE0, 0xD0, 0x6C, 0x63, 0xE0, 0xFF, + 0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x18, 0x18, 0x18, 0x10, 0x30, 0x30, + 0x3E, 0x31, 0xB0, 0x78, 0x3C, 0x1B, 0x18, 0xF8, 0xC6, 0xC1, 0xE0, 0xF0, + 0x6C, 0x63, 0xE0, 0x3C, 0x66, 0xC2, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x03, + 0x03, 0xC2, 0x66, 0x3C, 0xC0, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x64, 0xA0, + 0x00, 0x81, 0xC7, 0x8E, 0x0C, 0x07, 0x80, 0x70, 0x0E, 0x01, 0x80, 0xFF, + 0x80, 0x00, 0x1F, 0xF0, 0x00, 0x70, 0x0E, 0x01, 0xC0, 0x18, 0x38, 0x71, + 0xC0, 0x80, 0x00, 0x3E, 0x31, 0xB0, 0x78, 0x30, 0x18, 0x18, 0x38, 0x18, + 0x18, 0x0C, 0x00, 0x00, 0x01, 0x80, 0x03, 0xF0, 0x06, 0x0E, 0x06, 0x01, + 0x86, 0x00, 0x66, 0x1D, 0xBB, 0x31, 0xCF, 0x18, 0xC7, 0x98, 0x63, 0xCC, + 0x31, 0xE6, 0x11, 0xB3, 0x99, 0xCC, 0xF7, 0x86, 0x00, 0x01, 0x80, 0x00, + 0x70, 0x40, 0x0F, 0xE0, 0x06, 0x00, 0xF0, 0x0F, 0x00, 0x90, 0x19, 0x81, + 0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, 0x04, 0x60, 0x66, 0x06, 0xC0, 0x30, + 0xFF, 0x18, 0x33, 0x03, 0x60, 0x6C, 0x0D, 0x83, 0x3F, 0xC6, 0x06, 0xC0, + 0x78, 0x0F, 0x01, 0xE0, 0x6F, 0xF8, 0x1F, 0x86, 0x19, 0x81, 0xA0, 0x3C, + 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x68, 0x0D, 0x83, 0x18, 0x61, 0xF0, + 0xFF, 0x18, 0x33, 0x03, 0x60, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, + 0x78, 0x0F, 0x03, 0x60, 0xCF, 0xF0, 0xFF, 0xE0, 0x30, 0x18, 0x0C, 0x06, + 0x03, 0xFD, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0F, 0xF8, 0xFF, 0xC0, 0xC0, + 0xC0, 0xC0, 0xC0, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x0F, 0x83, + 0x0E, 0x60, 0x66, 0x03, 0xC0, 0x0C, 0x00, 0xC1, 0xFC, 0x03, 0xC0, 0x36, + 0x03, 0x60, 0x73, 0x0F, 0x0F, 0x10, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C, + 0x07, 0x80, 0xFF, 0xFE, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C, 0x06, + 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07, + 0x8F, 0x1E, 0x27, 0x80, 0xC0, 0xD8, 0x33, 0x0C, 0x63, 0x0C, 0xC1, 0xB8, + 0x3F, 0x07, 0x30, 0xC3, 0x18, 0x63, 0x06, 0x60, 0x6C, 0x0C, 0xC0, 0xC0, + 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xFF, 0xE0, + 0x3F, 0x01, 0xFC, 0x1F, 0xE0, 0xFD, 0x05, 0xEC, 0x6F, 0x63, 0x79, 0x13, + 0xCD, 0x9E, 0x6C, 0xF1, 0x47, 0x8E, 0x3C, 0x71, 0x80, 0xE0, 0x7C, 0x0F, + 0xC1, 0xE8, 0x3D, 0x87, 0x98, 0xF1, 0x1E, 0x33, 0xC3, 0x78, 0x6F, 0x07, + 0xE0, 0x7C, 0x0E, 0x0F, 0x81, 0x83, 0x18, 0x0C, 0xC0, 0x6C, 0x01, 0xE0, + 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1B, 0x01, 0x98, 0x0C, 0x60, 0xC0, 0xF8, + 0x00, 0xFF, 0x30, 0x6C, 0x0F, 0x03, 0xC0, 0xF0, 0x6F, 0xF3, 0x00, 0xC0, + 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x00, 0x0F, 0x81, 0x83, 0x18, 0x0C, 0xC0, + 0x6C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1B, 0x01, 0x98, 0x6C, + 0x60, 0xC0, 0xFB, 0x00, 0x08, 0xFF, 0x8C, 0x0E, 0xC0, 0x6C, 0x06, 0xC0, + 0x6C, 0x0C, 0xFF, 0x8C, 0x0E, 0xC0, 0x6C, 0x06, 0xC0, 0x6C, 0x06, 0xC0, + 0x70, 0x3F, 0x18, 0x6C, 0x0F, 0x03, 0xC0, 0x1E, 0x01, 0xF0, 0x0E, 0x00, + 0xF0, 0x3C, 0x0D, 0x86, 0x3F, 0x00, 0xFF, 0x86, 0x03, 0x01, 0x80, 0xC0, + 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0xC0, 0x78, 0x0F, + 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01, + 0xB0, 0x61, 0xF0, 0xC0, 0x6C, 0x0D, 0x81, 0x10, 0x63, 0x0C, 0x61, 0x04, + 0x60, 0xCC, 0x19, 0x01, 0x60, 0x3C, 0x07, 0x00, 0x60, 0xC1, 0x81, 0x30, + 0xE1, 0x98, 0x70, 0xCC, 0x28, 0x66, 0x26, 0x21, 0x13, 0x30, 0xC8, 0x98, + 0x6C, 0x4C, 0x14, 0x34, 0x0A, 0x1A, 0x07, 0x07, 0x03, 0x03, 0x80, 0x81, + 0x80, 0x60, 0x63, 0x0C, 0x30, 0xC1, 0x98, 0x0F, 0x00, 0xE0, 0x06, 0x00, + 0xF0, 0x19, 0x01, 0x98, 0x30, 0xC6, 0x0E, 0x60, 0x60, 0xC0, 0x36, 0x06, + 0x30, 0xC3, 0x0C, 0x19, 0x81, 0xD8, 0x0F, 0x00, 0x60, 0x06, 0x00, 0x60, + 0x06, 0x00, 0x60, 0x06, 0x00, 0xFF, 0xC0, 0x60, 0x30, 0x0C, 0x06, 0x03, + 0x01, 0xC0, 0x60, 0x30, 0x18, 0x06, 0x03, 0x00, 0xFF, 0xC0, 0xFB, 0x6D, + 0xB6, 0xDB, 0x6D, 0xB6, 0xE0, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, + 0x10, 0x80, 0xED, 0xB6, 0xDB, 0x6D, 0xB6, 0xDB, 0xE0, 0x30, 0x60, 0xA2, + 0x44, 0xD8, 0xA1, 0x80, 0xFF, 0xC0, 0xC6, 0x30, 0x7E, 0x71, 0xB0, 0xC0, + 0x60, 0xF3, 0xDB, 0x0D, 0x86, 0xC7, 0x3D, 0xC0, 0xC0, 0x60, 0x30, 0x1B, + 0xCE, 0x36, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x7C, 0x6D, 0xE0, 0x3C, + 0x66, 0xC3, 0xC0, 0xC0, 0xC0, 0xC0, 0xC3, 0x66, 0x3C, 0x03, 0x03, 0x03, + 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x3C, 0x66, + 0xC3, 0xC3, 0xFF, 0xC0, 0xC0, 0xC3, 0x66, 0x3C, 0x36, 0x6F, 0x66, 0x66, + 0x66, 0x66, 0x60, 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67, + 0x3B, 0x03, 0x03, 0xC6, 0x7C, 0xC0, 0xC0, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0x30, 0x03, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xE0, 0xC0, 0x60, 0x30, 0x18, 0x4C, + 0x46, 0x63, 0x61, 0xF0, 0xEC, 0x62, 0x31, 0x98, 0x6C, 0x30, 0xFF, 0xFF, + 0xFF, 0xC0, 0xDE, 0xF7, 0x1C, 0xF0, 0xC7, 0x86, 0x3C, 0x31, 0xE1, 0x8F, + 0x0C, 0x78, 0x63, 0xC3, 0x1E, 0x18, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0x66, 0x3C, 0xDE, 0x71, 0xB0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, + 0xE3, 0x6F, 0x30, 0x18, 0x0C, 0x00, 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0x67, 0x3B, 0x03, 0x03, 0x03, 0xDF, 0x31, 0x8C, 0x63, 0x18, + 0xC6, 0x00, 0x3E, 0xE3, 0xC0, 0xC0, 0xE0, 0x3C, 0x07, 0xC3, 0xE3, 0x7E, + 0x66, 0xF6, 0x66, 0x66, 0x66, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC7, 0x7B, 0xC1, 0xA0, 0x98, 0xCC, 0x42, 0x21, 0xB0, 0xD0, + 0x28, 0x1C, 0x0C, 0x00, 0xC6, 0x1E, 0x38, 0x91, 0xC4, 0xCA, 0x66, 0xD3, + 0x16, 0xD0, 0xA6, 0x87, 0x1C, 0x38, 0xC0, 0xC6, 0x00, 0x43, 0x62, 0x36, + 0x1C, 0x18, 0x1C, 0x3C, 0x26, 0x62, 0x43, 0xC1, 0x21, 0x98, 0xCC, 0x42, + 0x61, 0xB0, 0xD0, 0x38, 0x1C, 0x0C, 0x06, 0x03, 0x01, 0x03, 0x00, 0xFE, + 0x0C, 0x30, 0xC1, 0x86, 0x18, 0x20, 0xC1, 0xFC, 0x36, 0x66, 0x66, 0x6E, + 0xCE, 0x66, 0x66, 0x66, 0x30, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC6, 0x66, + 0x66, 0x67, 0x37, 0x66, 0x66, 0x66, 0xC0, 0x61, 0x24, 0x38 }; + +const GFXglyph FreeSans9pt7bGlyphs[] PROGMEM = { + { 0, 0, 0, 5, 0, 1 }, // 0x20 ' ' + { 0, 2, 13, 6, 2, -12 }, // 0x21 '!' + { 4, 5, 4, 6, 1, -12 }, // 0x22 '"' + { 7, 10, 12, 10, 0, -11 }, // 0x23 '#' + { 22, 9, 16, 10, 1, -13 }, // 0x24 '$' + { 40, 16, 13, 16, 1, -12 }, // 0x25 '%' + { 66, 11, 13, 12, 1, -12 }, // 0x26 '&' + { 84, 2, 4, 4, 1, -12 }, // 0x27 ''' + { 85, 4, 17, 6, 1, -12 }, // 0x28 '(' + { 94, 4, 17, 6, 1, -12 }, // 0x29 ')' + { 103, 5, 5, 7, 1, -12 }, // 0x2A '*' + { 107, 6, 8, 11, 3, -7 }, // 0x2B '+' + { 113, 2, 4, 5, 2, 0 }, // 0x2C ',' + { 114, 4, 1, 6, 1, -4 }, // 0x2D '-' + { 115, 2, 1, 5, 1, 0 }, // 0x2E '.' + { 116, 5, 13, 5, 0, -12 }, // 0x2F '/' + { 125, 8, 13, 10, 1, -12 }, // 0x30 '0' + { 138, 4, 13, 10, 3, -12 }, // 0x31 '1' + { 145, 9, 13, 10, 1, -12 }, // 0x32 '2' + { 160, 8, 13, 10, 1, -12 }, // 0x33 '3' + { 173, 7, 13, 10, 2, -12 }, // 0x34 '4' + { 185, 9, 13, 10, 1, -12 }, // 0x35 '5' + { 200, 9, 13, 10, 1, -12 }, // 0x36 '6' + { 215, 8, 13, 10, 0, -12 }, // 0x37 '7' + { 228, 9, 13, 10, 1, -12 }, // 0x38 '8' + { 243, 8, 13, 10, 1, -12 }, // 0x39 '9' + { 256, 2, 10, 5, 1, -9 }, // 0x3A ':' + { 259, 3, 12, 5, 1, -8 }, // 0x3B ';' + { 264, 9, 9, 11, 1, -8 }, // 0x3C '<' + { 275, 9, 4, 11, 1, -5 }, // 0x3D '=' + { 280, 9, 9, 11, 1, -8 }, // 0x3E '>' + { 291, 9, 13, 10, 1, -12 }, // 0x3F '?' + { 306, 17, 16, 18, 1, -12 }, // 0x40 '@' + { 340, 12, 13, 12, 0, -12 }, // 0x41 'A' + { 360, 11, 13, 12, 1, -12 }, // 0x42 'B' + { 378, 11, 13, 13, 1, -12 }, // 0x43 'C' + { 396, 11, 13, 13, 1, -12 }, // 0x44 'D' + { 414, 9, 13, 11, 1, -12 }, // 0x45 'E' + { 429, 8, 13, 11, 1, -12 }, // 0x46 'F' + { 442, 12, 13, 14, 1, -12 }, // 0x47 'G' + { 462, 11, 13, 13, 1, -12 }, // 0x48 'H' + { 480, 2, 13, 5, 2, -12 }, // 0x49 'I' + { 484, 7, 13, 10, 1, -12 }, // 0x4A 'J' + { 496, 11, 13, 12, 1, -12 }, // 0x4B 'K' + { 514, 8, 13, 10, 1, -12 }, // 0x4C 'L' + { 527, 13, 13, 15, 1, -12 }, // 0x4D 'M' + { 549, 11, 13, 13, 1, -12 }, // 0x4E 'N' + { 567, 13, 13, 14, 1, -12 }, // 0x4F 'O' + { 589, 10, 13, 12, 1, -12 }, // 0x50 'P' + { 606, 13, 14, 14, 1, -12 }, // 0x51 'Q' + { 629, 12, 13, 13, 1, -12 }, // 0x52 'R' + { 649, 10, 13, 12, 1, -12 }, // 0x53 'S' + { 666, 9, 13, 11, 1, -12 }, // 0x54 'T' + { 681, 11, 13, 13, 1, -12 }, // 0x55 'U' + { 699, 11, 13, 12, 0, -12 }, // 0x56 'V' + { 717, 17, 13, 17, 0, -12 }, // 0x57 'W' + { 745, 12, 13, 12, 0, -12 }, // 0x58 'X' + { 765, 12, 13, 12, 0, -12 }, // 0x59 'Y' + { 785, 10, 13, 11, 1, -12 }, // 0x5A 'Z' + { 802, 3, 17, 5, 1, -12 }, // 0x5B '[' + { 809, 5, 13, 5, 0, -12 }, // 0x5C '\' + { 818, 3, 17, 5, 0, -12 }, // 0x5D ']' + { 825, 7, 7, 8, 1, -12 }, // 0x5E '^' + { 832, 10, 1, 10, 0, 3 }, // 0x5F '_' + { 834, 4, 3, 5, 0, -12 }, // 0x60 '`' + { 836, 9, 10, 10, 1, -9 }, // 0x61 'a' + { 848, 9, 13, 10, 1, -12 }, // 0x62 'b' + { 863, 8, 10, 9, 1, -9 }, // 0x63 'c' + { 873, 8, 13, 10, 1, -12 }, // 0x64 'd' + { 886, 8, 10, 10, 1, -9 }, // 0x65 'e' + { 896, 4, 13, 5, 1, -12 }, // 0x66 'f' + { 903, 8, 14, 10, 1, -9 }, // 0x67 'g' + { 917, 8, 13, 10, 1, -12 }, // 0x68 'h' + { 930, 2, 13, 4, 1, -12 }, // 0x69 'i' + { 934, 4, 17, 4, 0, -12 }, // 0x6A 'j' + { 943, 9, 13, 9, 1, -12 }, // 0x6B 'k' + { 958, 2, 13, 4, 1, -12 }, // 0x6C 'l' + { 962, 13, 10, 15, 1, -9 }, // 0x6D 'm' + { 979, 8, 10, 10, 1, -9 }, // 0x6E 'n' + { 989, 8, 10, 10, 1, -9 }, // 0x6F 'o' + { 999, 9, 13, 10, 1, -9 }, // 0x70 'p' + { 1014, 8, 13, 10, 1, -9 }, // 0x71 'q' + { 1027, 5, 10, 6, 1, -9 }, // 0x72 'r' + { 1034, 8, 10, 9, 1, -9 }, // 0x73 's' + { 1044, 4, 12, 5, 1, -11 }, // 0x74 't' + { 1050, 8, 10, 10, 1, -9 }, // 0x75 'u' + { 1060, 9, 10, 9, 0, -9 }, // 0x76 'v' + { 1072, 13, 10, 13, 0, -9 }, // 0x77 'w' + { 1089, 8, 10, 9, 0, -9 }, // 0x78 'x' + { 1099, 9, 14, 9, 0, -9 }, // 0x79 'y' + { 1115, 7, 10, 9, 1, -9 }, // 0x7A 'z' + { 1124, 4, 17, 6, 1, -12 }, // 0x7B '{' + { 1133, 2, 17, 4, 2, -12 }, // 0x7C '|' + { 1138, 4, 17, 6, 1, -12 }, // 0x7D '}' + { 1147, 7, 3, 9, 1, -7 } }; // 0x7E '~' + +const GFXfont FreeSans9pt7b PROGMEM = { + (uint8_t *)FreeSans9pt7bBitmaps, + (GFXglyph *)FreeSans9pt7bGlyphs, + 0x20, 0x7E, 22 }; + +// Approx. 1822 bytes diff --git a/RX_FSK/src/fonts/FreeSans9pt8b.h b/RX_FSK/src/fonts/FreeSans9pt8b.h new file mode 100644 index 0000000..e1c87c5 --- /dev/null +++ b/RX_FSK/src/fonts/FreeSans9pt8b.h @@ -0,0 +1,421 @@ +const uint8_t FreeSans9pt8bBitmaps[] PROGMEM = { + 0x00, 0xFF, 0xFF, 0x83, 0xC0, 0xDD, 0xD9, 0x90, 0x09, 0x82, 0x61, 0x90, + 0x64, 0x7F, 0xC4, 0xC1, 0x30, 0xC8, 0xFF, 0xBF, 0xE2, 0x20, 0x98, 0x26, + 0x00, 0x10, 0x3C, 0x76, 0xD3, 0x93, 0xD0, 0xF0, 0x7C, 0x17, 0x13, 0x91, + 0x91, 0xD3, 0x7E, 0x10, 0x10, 0x00, 0x21, 0xE1, 0x08, 0x84, 0x23, 0x20, + 0x8C, 0x83, 0x64, 0x07, 0x10, 0x00, 0x8E, 0x06, 0x6C, 0x13, 0x10, 0xCC, + 0x42, 0x11, 0x18, 0x78, 0x1C, 0x0F, 0x86, 0x21, 0x88, 0x36, 0x0F, 0x03, + 0x81, 0xB2, 0xC6, 0xA0, 0xEC, 0x13, 0x1E, 0x7C, 0xC0, 0xFE, 0x80, 0x12, + 0x26, 0x44, 0xCC, 0xCC, 0x44, 0x46, 0x22, 0x10, 0x84, 0x46, 0x22, 0x23, + 0x33, 0x22, 0x26, 0x4C, 0x80, 0x25, 0x5C, 0xA5, 0x00, 0x08, 0x04, 0x02, + 0x01, 0x0F, 0xF8, 0x40, 0x20, 0x10, 0x08, 0x00, 0xF0, 0xFF, 0xC0, 0x08, + 0x44, 0x21, 0x10, 0x84, 0x42, 0x11, 0x08, 0x00, 0x18, 0x7E, 0x42, 0xC3, + 0xC3, 0x83, 0x83, 0x83, 0x83, 0xC3, 0xC3, 0x46, 0x7C, 0x11, 0x7F, 0x11, + 0x11, 0x11, 0x11, 0x10, 0x3C, 0x7E, 0xC3, 0xC1, 0x81, 0x03, 0x06, 0x1C, + 0x30, 0x60, 0xC0, 0xFF, 0xFF, 0x3C, 0x7E, 0xC3, 0xC3, 0x03, 0x06, 0x1C, + 0x03, 0x03, 0x83, 0x83, 0xC3, 0x7E, 0x02, 0x03, 0x01, 0x81, 0x41, 0xA1, + 0x90, 0x88, 0xC4, 0xC2, 0x7F, 0xC0, 0x80, 0x40, 0x20, 0x7F, 0x7F, 0x40, + 0x40, 0xC0, 0xFE, 0xC3, 0x03, 0x01, 0x01, 0x83, 0xC3, 0x7E, 0x1C, 0x7E, + 0x43, 0xC3, 0xC0, 0xBC, 0xFE, 0xC3, 0xC1, 0xC1, 0xC3, 0x63, 0x7E, 0xFF, + 0xFF, 0x03, 0x02, 0x04, 0x0C, 0x08, 0x18, 0x10, 0x30, 0x30, 0x20, 0x20, + 0x3C, 0x7E, 0xC3, 0xC3, 0xC3, 0x66, 0x7C, 0xC3, 0x83, 0x81, 0x83, 0xC3, + 0x7E, 0x38, 0x7E, 0xC2, 0x83, 0x83, 0x83, 0xC3, 0x7D, 0x13, 0x03, 0xC3, + 0xC6, 0x7C, 0xC0, 0x03, 0xC0, 0xC0, 0x03, 0xD6, 0x00, 0x01, 0xC3, 0x8F, + 0x0C, 0x07, 0x00, 0xF0, 0x0E, 0x01, 0x80, 0xFF, 0x80, 0x00, 0x1F, 0xF0, + 0x00, 0x60, 0x1E, 0x01, 0xC0, 0x38, 0x3C, 0x71, 0xE0, 0x80, 0x00, 0x3E, + 0x63, 0x43, 0xC1, 0x03, 0x06, 0x0C, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, + 0x07, 0xF0, 0x1C, 0x1C, 0x30, 0x0E, 0x60, 0x06, 0x43, 0xD3, 0xC6, 0x33, + 0x8C, 0x31, 0x8C, 0x23, 0x88, 0x23, 0x8C, 0x62, 0xCC, 0xEC, 0xC7, 0x38, + 0x60, 0x00, 0x38, 0x00, 0x0F, 0xF0, 0x01, 0x80, 0x06, 0x00, 0xF0, 0x0F, + 0x00, 0x90, 0x19, 0x81, 0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, 0x06, 0x60, + 0x66, 0x06, 0xC0, 0x30, 0xFF, 0x30, 0x6C, 0x0F, 0x03, 0xC0, 0xB0, 0xEF, + 0xFB, 0x03, 0xC0, 0xF0, 0x1C, 0x0F, 0x07, 0xFF, 0x00, 0x1F, 0x86, 0x19, + 0x81, 0xE0, 0x3C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x78, 0x0D, 0x81, + 0xB8, 0x63, 0xF8, 0xFE, 0x20, 0xC8, 0x1A, 0x03, 0x80, 0xE0, 0x38, 0x0E, + 0x03, 0x80, 0xE0, 0x38, 0x1A, 0x1C, 0xFE, 0x00, 0xFF, 0xC0, 0x20, 0x10, + 0x08, 0x04, 0x03, 0xFD, 0x00, 0x80, 0x40, 0x20, 0x10, 0x0F, 0xF8, 0xFF, + 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x1F, 0x83, 0x0E, 0x60, 0x6C, 0x03, 0xC0, 0x0C, 0x00, 0x83, 0xFC, 0x3F, + 0xC0, 0x3C, 0x03, 0x60, 0x77, 0x0F, 0x1F, 0x90, 0xC0, 0x78, 0x0F, 0x01, + 0xE0, 0x3C, 0x07, 0x80, 0xFF, 0xFE, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, + 0x3C, 0x06, 0xFF, 0xF8, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0xC3, 0xC3, 0x66, 0x7E, 0xC0, 0xD8, 0x33, 0x0C, 0x63, 0x0C, 0xC1, + 0xB8, 0x3F, 0x07, 0x30, 0xC3, 0x18, 0x63, 0x06, 0x60, 0x6C, 0x04, 0xC0, + 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, + 0x0F, 0xF8, 0xE0, 0x3F, 0x01, 0xFC, 0x1F, 0xE0, 0xFD, 0x05, 0xEC, 0x6F, + 0x63, 0x79, 0x13, 0xCD, 0x9E, 0x6C, 0xF1, 0x47, 0x8E, 0x3C, 0x71, 0x80, + 0xE0, 0x7C, 0x0F, 0xC1, 0xEC, 0x3D, 0x87, 0x98, 0xF1, 0x1E, 0x33, 0xC3, + 0x78, 0x2F, 0x07, 0xE0, 0x7C, 0x0E, 0x1F, 0x87, 0x0E, 0x60, 0x6C, 0x03, + 0xC0, 0x38, 0x01, 0x80, 0x18, 0x01, 0xC0, 0x3C, 0x03, 0x60, 0x67, 0x0E, + 0x1F, 0x80, 0xFF, 0x41, 0xE0, 0x70, 0x38, 0x1C, 0x0F, 0xFD, 0x00, 0x80, + 0x40, 0x20, 0x10, 0x08, 0x00, 0x1F, 0x87, 0x0E, 0x60, 0x6C, 0x03, 0xC0, + 0x38, 0x01, 0x80, 0x18, 0x01, 0xC0, 0x3C, 0x03, 0x61, 0xE7, 0x0E, 0x1F, + 0xF0, 0x01, 0xFF, 0x20, 0x68, 0x0E, 0x03, 0x80, 0xE0, 0x6F, 0xF2, 0x06, + 0x80, 0xA0, 0x28, 0x0A, 0x03, 0x80, 0xC0, 0x3F, 0x18, 0x6C, 0x0F, 0x03, + 0xC0, 0x1E, 0x01, 0xF0, 0x0F, 0x00, 0xF0, 0x3C, 0x0D, 0x87, 0x3F, 0x80, + 0xFF, 0xE0, 0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, + 0x00, 0x80, 0x10, 0x02, 0x00, 0x40, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, + 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3C, 0x0B, 0x86, 0x7F, 0x00, 0xC0, + 0x58, 0x1B, 0x03, 0x30, 0x46, 0x18, 0x43, 0x0C, 0x41, 0x98, 0x13, 0x03, + 0x40, 0x78, 0x07, 0x00, 0xC0, 0x41, 0xC1, 0xB0, 0xE1, 0x98, 0x50, 0xCC, + 0x28, 0x62, 0x36, 0x31, 0x9B, 0x10, 0xC8, 0x98, 0x64, 0x6C, 0x16, 0x36, + 0x0B, 0x0A, 0x07, 0x07, 0x03, 0x83, 0x80, 0xC1, 0xC0, 0x60, 0x63, 0x0C, + 0x30, 0xC1, 0x98, 0x0F, 0x00, 0x70, 0x06, 0x00, 0xF0, 0x09, 0x81, 0x98, + 0x30, 0xC6, 0x06, 0x60, 0x60, 0x60, 0x36, 0x06, 0x30, 0xC1, 0x0C, 0x19, + 0x80, 0xD0, 0x0F, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, + 0x00, 0x7F, 0xC0, 0x18, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x80, 0x60, + 0x18, 0x06, 0x01, 0x80, 0x30, 0x0F, 0xFE, 0xFC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xF0, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, + 0x80, 0xF3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xF0, 0x30, 0x60, + 0xA2, 0x44, 0xD8, 0xA1, 0x00, 0xFF, 0xC0, 0x63, 0x3C, 0x3F, 0x30, 0x80, + 0x60, 0x73, 0xFB, 0x0D, 0x06, 0xC7, 0x7D, 0xC0, 0x80, 0x80, 0x80, 0x9C, + 0xBE, 0xC3, 0xC1, 0xC1, 0x81, 0xC1, 0xC3, 0xE3, 0xBE, 0x38, 0x7E, 0xC2, + 0x82, 0x80, 0x80, 0x80, 0x82, 0xC6, 0x7C, 0x01, 0x80, 0xC0, 0x63, 0xB3, + 0xFB, 0x0D, 0x06, 0x83, 0xC1, 0xA0, 0xD0, 0x6C, 0x73, 0xE8, 0x18, 0x7E, + 0xC3, 0xC3, 0x81, 0xFF, 0x80, 0xC3, 0xC3, 0x7E, 0x39, 0x08, 0x4F, 0x90, + 0x84, 0x21, 0x08, 0x42, 0x00, 0x38, 0x7F, 0xC7, 0x83, 0x83, 0x83, 0x83, + 0x83, 0xC7, 0x7F, 0x03, 0x82, 0xE6, 0x7C, 0xC0, 0xC0, 0xC0, 0xDC, 0xFE, + 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xF0, 0xFF, 0xFF, 0xC0, + 0x6C, 0x06, 0xDB, 0x6D, 0xB6, 0xDB, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC6, + 0xCC, 0xD8, 0xF8, 0xD8, 0xCC, 0xC4, 0xC6, 0xC3, 0xFF, 0xFF, 0xFF, 0xC0, + 0x1C, 0x67, 0xFF, 0xB0, 0xC7, 0x84, 0x3C, 0x21, 0xE1, 0x0F, 0x08, 0x78, + 0x43, 0xC2, 0x1E, 0x10, 0xC0, 0x1C, 0xFE, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC3, 0x38, 0x7E, 0xC3, 0x83, 0x81, 0x81, 0x81, 0xC3, 0xC6, + 0x7E, 0x1C, 0xBE, 0xC3, 0xC1, 0xC1, 0x81, 0xC1, 0xC3, 0xE3, 0xBE, 0x80, + 0x80, 0x80, 0x80, 0x1C, 0x1F, 0x58, 0x68, 0x34, 0x1E, 0x0D, 0x06, 0x83, + 0x63, 0x9F, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x1F, 0xF9, 0x8C, 0x63, 0x18, + 0xC6, 0x00, 0x39, 0xFB, 0x1C, 0x0E, 0x07, 0x81, 0xC1, 0xC7, 0xF8, 0x21, + 0x09, 0xF2, 0x10, 0x84, 0x21, 0x08, 0x70, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC7, 0x7F, 0x41, 0x31, 0x98, 0xC4, 0x42, 0x61, 0xA0, 0x50, + 0x38, 0x18, 0x00, 0xC7, 0x12, 0x38, 0x99, 0x4C, 0xCA, 0x62, 0xDA, 0x14, + 0xD0, 0xE3, 0x87, 0x18, 0x18, 0xC0, 0x63, 0x13, 0x0D, 0x03, 0x81, 0xC0, + 0xE0, 0xD8, 0xC6, 0x43, 0x00, 0x41, 0x31, 0x98, 0xC4, 0x43, 0x61, 0xA0, + 0x50, 0x38, 0x18, 0x0C, 0x06, 0x0E, 0x06, 0x00, 0xFE, 0x08, 0x30, 0xC3, + 0x0C, 0x10, 0x60, 0xFE, 0x36, 0x66, 0x66, 0x4C, 0x84, 0x66, 0x66, 0x66, + 0x30, 0xFF, 0xFF, 0x80, 0xC4, 0x44, 0x44, 0x46, 0x36, 0x44, 0x44, 0x44, + 0x80, 0x60, 0x59, 0x8F, 0xFF, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, + 0x01, 0x80, 0xC0, 0x60, 0x30, 0x1F, 0xF8, 0x00, 0xF0, 0x7F, 0xFF, 0xC0, + 0x08, 0x1C, 0x7E, 0x4B, 0xC9, 0xC8, 0xC8, 0xC8, 0xCB, 0x6B, 0x3E, 0x08, + 0x08, 0x1F, 0x0C, 0xE6, 0x19, 0x82, 0x60, 0x08, 0x0F, 0xE0, 0x40, 0x10, + 0x04, 0x03, 0x01, 0xF2, 0x7F, 0xC0, 0x07, 0x07, 0xF3, 0x04, 0x80, 0x60, + 0x3F, 0xE6, 0x03, 0xFC, 0x60, 0x18, 0x03, 0x00, 0x61, 0x0F, 0xC0, 0xC0, + 0xD0, 0x22, 0x18, 0xCC, 0x12, 0x07, 0x80, 0xC1, 0xFE, 0x0C, 0x1F, 0xE0, + 0xC0, 0x30, 0x0C, 0x00, 0x12, 0x07, 0x80, 0xC0, 0x00, 0x3F, 0x18, 0x6C, + 0x0F, 0x03, 0xC0, 0x1E, 0x01, 0xF0, 0x0F, 0x00, 0xF0, 0x3C, 0x0D, 0x87, + 0x3F, 0x80, 0x3C, 0x66, 0x62, 0x62, 0x30, 0x5C, 0x8E, 0x83, 0xC1, 0x61, + 0x3B, 0x1E, 0x06, 0xC6, 0x46, 0x7E, 0x38, 0x6C, 0x70, 0x41, 0xCF, 0xD8, + 0xE0, 0x70, 0x3C, 0x0E, 0x0E, 0x3F, 0xC0, 0x1F, 0xC0, 0xC1, 0x86, 0x31, + 0x33, 0x66, 0x88, 0xCA, 0x60, 0x29, 0x80, 0xE6, 0x12, 0x88, 0xCB, 0x36, + 0x66, 0x71, 0x0C, 0x18, 0x1F, 0xC0, 0xF4, 0x9D, 0x29, 0x74, 0x1F, 0x21, + 0x99, 0xA6, 0x4C, 0x90, 0xFF, 0xFF, 0xC0, 0x20, 0x10, 0x08, 0xFF, 0x1F, + 0xC0, 0xC1, 0x86, 0xF1, 0x33, 0xF6, 0x88, 0x4A, 0x23, 0x28, 0xF8, 0xE2, + 0x32, 0x88, 0xCB, 0x23, 0x66, 0x01, 0x0C, 0x18, 0x1F, 0xC0, 0xFF, 0xC0, + 0xF4, 0x63, 0x17, 0x00, 0x08, 0x04, 0x02, 0x01, 0x0F, 0xF8, 0x40, 0x20, + 0x10, 0x08, 0x00, 0x3F, 0xE0, 0x39, 0x34, 0x43, 0x19, 0x84, 0x3F, 0x31, + 0x2C, 0xC6, 0x08, 0x1C, 0xDE, 0x11, 0x01, 0x60, 0x18, 0x00, 0x07, 0xFC, + 0x01, 0x80, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x38, 0x06, 0x01, 0x80, 0x60, + 0x18, 0x03, 0x00, 0xFF, 0xE0, 0xC3, 0x61, 0xB0, 0xD8, 0x6C, 0x36, 0x1B, + 0x0D, 0x8E, 0xFF, 0xE0, 0x30, 0x18, 0x0C, 0x00, 0x3F, 0x7A, 0xFA, 0xFA, + 0xFA, 0xFA, 0xFA, 0x7A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, + 0xC0, 0x6C, 0x50, 0x40, 0x0F, 0xE0, 0x83, 0x0C, 0x30, 0xC1, 0x06, 0x0F, + 0xE0, 0x27, 0x92, 0x49, 0xF4, 0x63, 0x19, 0x38, 0x1F, 0x93, 0x26, 0x59, + 0x98, 0x40, 0x3F, 0xFF, 0x71, 0xC0, 0x40, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, + 0x80, 0xC0, 0x80, 0xFF, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x40, 0xC0, + 0x61, 0xC0, 0x3F, 0xFF, 0x38, 0x30, 0xFD, 0xFB, 0x0E, 0x1C, 0x18, 0x38, + 0x10, 0x70, 0x3F, 0xE0, 0x40, 0x61, 0x83, 0xC7, 0x84, 0xFD, 0xF8, 0x19, + 0x81, 0x98, 0x00, 0x06, 0x03, 0x60, 0x63, 0x0C, 0x10, 0xC1, 0x98, 0x0D, + 0x00, 0xF0, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x18, + 0x18, 0x00, 0x00, 0x18, 0x18, 0x30, 0x60, 0xC0, 0x83, 0xC2, 0xC6, 0x7C, + 0x0C, 0x00, 0x40, 0x02, 0x00, 0x00, 0x06, 0x00, 0xF0, 0x0F, 0x00, 0x90, + 0x19, 0x81, 0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, 0x06, 0x60, 0x66, 0x06, + 0xC0, 0x30, 0x01, 0x80, 0x30, 0x06, 0x00, 0x00, 0x06, 0x00, 0xF0, 0x0F, + 0x00, 0x90, 0x19, 0x81, 0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, 0x06, 0x60, + 0x66, 0x06, 0xC0, 0x30, 0x06, 0x00, 0xF0, 0x09, 0x00, 0x00, 0x06, 0x00, + 0xF0, 0x0F, 0x00, 0x90, 0x19, 0x81, 0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, + 0x06, 0x60, 0x66, 0x06, 0xC0, 0x30, 0x0C, 0x81, 0x30, 0x00, 0x00, 0x60, + 0x0F, 0x00, 0xF0, 0x09, 0x01, 0x98, 0x19, 0x81, 0x08, 0x30, 0xC3, 0xFC, + 0x20, 0x66, 0x06, 0x60, 0x6C, 0x03, 0x19, 0x81, 0x98, 0x00, 0x00, 0x60, + 0x0F, 0x00, 0xF0, 0x09, 0x01, 0x98, 0x19, 0x81, 0x08, 0x30, 0xC3, 0xFC, + 0x20, 0x66, 0x06, 0x60, 0x6C, 0x03, 0x0F, 0x00, 0x90, 0x0F, 0x00, 0x00, + 0x06, 0x00, 0xF0, 0x0F, 0x00, 0x90, 0x19, 0x81, 0x98, 0x10, 0x83, 0x0C, + 0x3F, 0xC2, 0x06, 0x60, 0x66, 0x06, 0xC0, 0x30, 0x07, 0xFF, 0x83, 0x60, + 0x01, 0x30, 0x01, 0x98, 0x00, 0x8C, 0x00, 0xC6, 0x00, 0x63, 0xFC, 0x61, + 0x80, 0x3F, 0xC0, 0x10, 0x60, 0x18, 0x30, 0x0C, 0x18, 0x0C, 0x0F, 0xF8, + 0x1F, 0x86, 0x19, 0x81, 0xE0, 0x3C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, + 0x78, 0x0D, 0x81, 0xB8, 0x63, 0xF8, 0x08, 0x01, 0x80, 0x10, 0x0E, 0x00, + 0x30, 0x08, 0x02, 0x00, 0x0F, 0xFC, 0x02, 0x01, 0x00, 0x80, 0x40, 0x3F, + 0xD0, 0x08, 0x04, 0x02, 0x01, 0x00, 0xFF, 0x80, 0x04, 0x04, 0x04, 0x00, + 0x0F, 0xFC, 0x02, 0x01, 0x00, 0x80, 0x40, 0x3F, 0xD0, 0x08, 0x04, 0x02, + 0x01, 0x00, 0xFF, 0x80, 0x18, 0x0E, 0x09, 0x00, 0x0F, 0xFC, 0x02, 0x01, + 0x00, 0x80, 0x40, 0x3F, 0xD0, 0x08, 0x04, 0x02, 0x01, 0x00, 0xFF, 0x80, + 0x66, 0x33, 0x00, 0x1F, 0xF8, 0x04, 0x02, 0x01, 0x00, 0x80, 0x7F, 0xA0, + 0x10, 0x08, 0x04, 0x02, 0x01, 0xFF, 0xC6, 0x20, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x20, 0x36, 0x40, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x40, + 0x32, 0xB2, 0x02, 0x10, 0x84, 0x21, 0x08, 0x42, 0x10, 0x84, 0x20, 0xCF, + 0x30, 0x08, 0x20, 0x82, 0x08, 0x20, 0x82, 0x08, 0x20, 0x82, 0x08, 0x3F, + 0x82, 0x0C, 0x20, 0x62, 0x03, 0x20, 0x32, 0x03, 0xFC, 0x32, 0x03, 0x20, + 0x32, 0x03, 0x20, 0x62, 0x1C, 0x3F, 0x80, 0x09, 0x03, 0xE0, 0x00, 0x70, + 0x3E, 0x07, 0xE0, 0xF6, 0x1E, 0xC3, 0xCC, 0x78, 0x8F, 0x19, 0xE1, 0xBC, + 0x17, 0x83, 0xF0, 0x3E, 0x07, 0x0C, 0x00, 0x40, 0x02, 0x00, 0x00, 0x1F, + 0x87, 0x0E, 0x60, 0x6C, 0x03, 0xC0, 0x38, 0x01, 0x80, 0x18, 0x01, 0xC0, + 0x3C, 0x03, 0x60, 0x67, 0x0E, 0x1F, 0x80, 0x03, 0x00, 0x20, 0x04, 0x00, + 0x00, 0x1F, 0x87, 0x0E, 0x60, 0x6C, 0x03, 0xC0, 0x38, 0x01, 0x80, 0x18, + 0x01, 0xC0, 0x3C, 0x03, 0x60, 0x67, 0x0E, 0x1F, 0x80, 0x06, 0x00, 0xF0, + 0x09, 0x00, 0x00, 0x1F, 0x87, 0x0E, 0x60, 0x6C, 0x03, 0xC0, 0x38, 0x01, + 0x80, 0x18, 0x01, 0xC0, 0x3C, 0x03, 0x60, 0x67, 0x0E, 0x1F, 0x80, 0x0C, + 0x81, 0x30, 0x00, 0x01, 0xF8, 0x70, 0xE6, 0x06, 0xC0, 0x3C, 0x03, 0x80, + 0x18, 0x01, 0x80, 0x1C, 0x03, 0xC0, 0x36, 0x06, 0x70, 0xE1, 0xF8, 0x19, + 0x81, 0x98, 0x00, 0x01, 0xF8, 0x70, 0xE6, 0x06, 0xC0, 0x3C, 0x03, 0x80, + 0x18, 0x01, 0x80, 0x1C, 0x03, 0xC0, 0x36, 0x06, 0x70, 0xE1, 0xF8, 0x81, + 0x89, 0xA1, 0x83, 0x89, 0xA1, 0x80, 0x00, 0x01, 0xF9, 0x70, 0xE6, 0x06, + 0xC0, 0xBC, 0x13, 0x82, 0x18, 0x41, 0x8C, 0x1D, 0x83, 0xF0, 0x36, 0x06, + 0x70, 0xE9, 0xF8, 0x30, 0x06, 0x00, 0x80, 0x00, 0x80, 0xE0, 0x38, 0x0E, + 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3C, 0x0B, 0x86, 0x7F, + 0x00, 0x06, 0x03, 0x00, 0x80, 0x00, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, + 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3C, 0x0B, 0x86, 0x7F, 0x00, 0x0C, + 0x05, 0x03, 0x20, 0x00, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, + 0x0E, 0x03, 0x80, 0xE0, 0x3C, 0x0B, 0x86, 0x7F, 0x00, 0x33, 0x0C, 0xC0, + 0x02, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, + 0x80, 0xF0, 0x2E, 0x19, 0xFC, 0x01, 0x00, 0x20, 0x04, 0x00, 0x00, 0x60, + 0x36, 0x06, 0x30, 0xC1, 0x0C, 0x19, 0x80, 0xD0, 0x0F, 0x00, 0x60, 0x06, + 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x80, 0x40, 0x3F, 0x9F, 0xE8, + 0x1C, 0x0E, 0x07, 0x03, 0xFF, 0x7E, 0x20, 0x10, 0x08, 0x00, 0x3E, 0x31, + 0xB0, 0x78, 0x3C, 0x16, 0x7B, 0x3D, 0x83, 0xC0, 0xE0, 0x70, 0x78, 0x7C, + 0xF0, 0x30, 0x0C, 0x02, 0x07, 0x87, 0xE6, 0x10, 0x0C, 0x0E, 0x7F, 0x61, + 0xA0, 0xD8, 0xEF, 0xB8, 0x0C, 0x0C, 0x04, 0x07, 0x87, 0xE6, 0x10, 0x0C, + 0x0E, 0x7F, 0x61, 0xA0, 0xD8, 0xEF, 0xB8, 0x18, 0x16, 0x19, 0x07, 0x87, + 0xE6, 0x10, 0x0C, 0x0E, 0x7F, 0x61, 0xA0, 0xD8, 0xEF, 0xB8, 0x32, 0x3E, + 0x00, 0x07, 0x87, 0xE6, 0x10, 0x0C, 0x0E, 0x7F, 0x61, 0xA0, 0xD8, 0xEF, + 0xB8, 0x66, 0x33, 0x00, 0x07, 0x87, 0xE6, 0x10, 0x0C, 0x0E, 0x7F, 0x61, + 0xA0, 0xD8, 0xEF, 0xB8, 0x18, 0x12, 0x09, 0x03, 0x03, 0xC3, 0xF3, 0x08, + 0x06, 0x07, 0x3F, 0xB0, 0xD0, 0x6C, 0x77, 0xDC, 0x38, 0x71, 0xFF, 0xEC, + 0x30, 0xC0, 0xC1, 0x06, 0x05, 0xFF, 0xFC, 0x20, 0x20, 0xC1, 0xC7, 0x8F, + 0xE7, 0xE0, 0x38, 0x7E, 0xC2, 0x82, 0x80, 0x80, 0x80, 0x83, 0xC6, 0x7C, + 0x10, 0x18, 0x08, 0x78, 0x30, 0x18, 0x08, 0x18, 0x7E, 0xC3, 0xC3, 0x81, + 0xFF, 0x80, 0xC3, 0xC3, 0x7E, 0x0C, 0x18, 0x10, 0x18, 0x7E, 0xC3, 0xC3, + 0x81, 0xFF, 0x80, 0xC3, 0xC3, 0x7E, 0x18, 0x34, 0x22, 0x18, 0x7E, 0xC3, + 0xC3, 0x81, 0xFF, 0x80, 0xC3, 0xC3, 0x7E, 0x66, 0x66, 0x00, 0x18, 0x7E, + 0xC3, 0xC3, 0x81, 0xFF, 0x80, 0xC3, 0xC3, 0x7E, 0x42, 0x10, 0x22, 0x22, + 0x22, 0x22, 0x20, 0x6C, 0x80, 0x44, 0x44, 0x44, 0x44, 0x40, 0x72, 0xA2, + 0x02, 0x10, 0x84, 0x21, 0x08, 0x42, 0x00, 0xCF, 0x30, 0x00, 0x10, 0x41, + 0x04, 0x10, 0x41, 0x04, 0x10, 0x6C, 0x30, 0x4C, 0x3E, 0x7E, 0xC3, 0x83, + 0x81, 0x81, 0x81, 0xC3, 0xC6, 0x7E, 0x32, 0x7C, 0x00, 0x1C, 0xFE, 0xC3, + 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x30, 0x10, 0x08, 0x38, 0x7E, + 0xC3, 0x83, 0x81, 0x81, 0x81, 0xC3, 0xC6, 0x7E, 0x0C, 0x18, 0x10, 0x38, + 0x7E, 0xC3, 0x83, 0x81, 0x81, 0x81, 0xC3, 0xC6, 0x7E, 0x18, 0x2C, 0x64, + 0x38, 0x7E, 0xC3, 0x83, 0x81, 0x81, 0x81, 0xC3, 0xC6, 0x7E, 0x32, 0x5C, + 0x00, 0x38, 0x7E, 0xC3, 0x83, 0x81, 0x81, 0x81, 0xC3, 0xC6, 0x7E, 0x66, + 0x66, 0x00, 0x38, 0x7E, 0xC3, 0x83, 0x81, 0x81, 0x81, 0xC3, 0xC6, 0x7E, + 0x18, 0x0C, 0x00, 0x00, 0x0F, 0xF8, 0x00, 0x00, 0x30, 0x18, 0x00, 0x1C, + 0x0F, 0xE6, 0x19, 0x8E, 0x44, 0x92, 0x25, 0x09, 0xC6, 0x63, 0x1F, 0xC0, + 0x00, 0x30, 0x10, 0x08, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC7, 0x7F, 0x0C, 0x18, 0x10, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC7, 0x7F, 0x18, 0x2C, 0x64, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC7, 0x7F, 0x66, 0x66, 0x00, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC3, 0xC7, 0x7F, 0x0C, 0x04, 0x04, 0x00, 0x04, 0x13, 0x19, + 0x8C, 0x44, 0x36, 0x1A, 0x05, 0x03, 0x81, 0x80, 0xC0, 0x60, 0xE0, 0x60, + 0x00, 0x80, 0x80, 0x80, 0x9C, 0xBE, 0xC3, 0xC1, 0xC1, 0x81, 0xC1, 0xC3, + 0xE3, 0xBE, 0x80, 0x80, 0x80, 0x80, 0x22, 0x11, 0x00, 0x00, 0x04, 0x13, + 0x19, 0x8C, 0x44, 0x36, 0x1A, 0x05, 0x03, 0x81, 0x80, 0xC0, 0x60, 0xE0, + 0x60, 0x00 }; + +const GFXglyph FreeSans9pt8bGlyphs[] PROGMEM = { + { 0, 1, 1, 5, 0, 0 }, // 0x20 ' ' U+0020 + { 1, 2, 13, 5, 2, -12 }, // 0x21 '!' U+0021 + { 5, 4, 5, 6, 1, -12 }, // 0x22 '"' U+0022 + { 8, 10, 13, 10, 0, -12 }, // 0x23 '#' U+0023 + { 25, 8, 16, 10, 1, -13 }, // 0x24 '$' U+0024 + { 41, 14, 13, 16, 1, -12 }, // 0x25 '%' U+0025 + { 64, 10, 13, 12, 1, -12 }, // 0x26 '&' U+0026 + { 81, 2, 5, 3, 1, -12 }, // 0x27 ''' U+0027 + { 83, 4, 17, 6, 1, -12 }, // 0x28 '(' U+0028 + { 92, 4, 17, 6, 1, -12 }, // 0x29 ')' U+0029 + { 101, 5, 5, 7, 1, -12 }, // 0x2a '*' U+002A + { 105, 9, 9, 11, 1, -8 }, // 0x2b '+' U+002B + { 116, 1, 5, 5, 2, -1 }, // 0x2c ',' U+002C + { 117, 4, 2, 6, 1, -5 }, // 0x2d '-' U+002D + { 118, 1, 2, 5, 2, -1 }, // 0x2e '.' U+002E + { 119, 5, 13, 5, 0, -12 }, // 0x2f '/' U+002F + { 128, 8, 13, 10, 1, -12 }, // 0x30 '0' U+0030 + { 141, 4, 13, 10, 2, -12 }, // 0x31 '1' U+0031 + { 148, 8, 13, 10, 1, -12 }, // 0x32 '2' U+0032 + { 161, 8, 13, 10, 1, -12 }, // 0x33 '3' U+0033 + { 174, 9, 13, 10, 0, -12 }, // 0x34 '4' U+0034 + { 189, 8, 13, 10, 1, -12 }, // 0x35 '5' U+0035 + { 202, 8, 13, 10, 1, -12 }, // 0x36 '6' U+0036 + { 215, 8, 13, 10, 1, -12 }, // 0x37 '7' U+0037 + { 228, 8, 13, 10, 1, -12 }, // 0x38 '8' U+0038 + { 241, 8, 13, 10, 1, -12 }, // 0x39 '9' U+0039 + { 254, 2, 9, 5, 2, -8 }, // 0x3a ':' U+003A + { 257, 2, 12, 5, 2, -8 }, // 0x3b ';' U+003B + { 260, 9, 9, 11, 1, -8 }, // 0x3c '<' U+003C + { 271, 9, 4, 11, 1, -5 }, // 0x3d '=' U+003D + { 276, 9, 9, 11, 1, -8 }, // 0x3e '>' U+003E + { 287, 8, 13, 10, 1, -12 }, // 0x3f '?' U+003F + { 300, 16, 16, 18, 1, -12 }, // 0x40 '@' U+0040 + { 332, 12, 13, 12, 0, -12 }, // 0x41 'A' U+0041 + { 352, 10, 13, 12, 1, -12 }, // 0x42 'B' U+0042 + { 369, 11, 13, 13, 1, -12 }, // 0x43 'C' U+0043 + { 387, 10, 13, 13, 2, -12 }, // 0x44 'D' U+0044 + { 404, 9, 13, 12, 2, -12 }, // 0x45 'E' U+0045 + { 419, 8, 13, 11, 2, -12 }, // 0x46 'F' U+0046 + { 432, 12, 13, 14, 1, -12 }, // 0x47 'G' U+0047 + { 452, 11, 13, 13, 1, -12 }, // 0x48 'H' U+0048 + { 470, 1, 13, 5, 2, -12 }, // 0x49 'I' U+0049 + { 472, 8, 13, 9, 0, -12 }, // 0x4a 'J' U+004A + { 485, 11, 13, 12, 1, -12 }, // 0x4b 'K' U+004B + { 503, 9, 13, 10, 1, -12 }, // 0x4c 'L' U+004C + { 518, 13, 13, 15, 1, -12 }, // 0x4d 'M' U+004D + { 540, 11, 13, 13, 1, -12 }, // 0x4e 'N' U+004E + { 558, 12, 13, 14, 1, -12 }, // 0x4f 'O' U+004F + { 578, 9, 13, 12, 2, -12 }, // 0x50 'P' U+0050 + { 593, 12, 14, 14, 1, -12 }, // 0x51 'Q' U+0051 + { 614, 10, 13, 13, 2, -12 }, // 0x52 'R' U+0052 + { 631, 10, 13, 12, 1, -12 }, // 0x53 'S' U+0053 + { 648, 11, 13, 11, 0, -12 }, // 0x54 'T' U+0054 + { 666, 10, 13, 13, 2, -12 }, // 0x55 'U' U+0055 + { 683, 11, 13, 12, 1, -12 }, // 0x56 'V' U+0056 + { 701, 17, 13, 17, 0, -12 }, // 0x57 'W' U+0057 + { 729, 12, 13, 12, 0, -12 }, // 0x58 'X' U+0058 + { 749, 12, 13, 12, 0, -12 }, // 0x59 'Y' U+0059 + { 769, 11, 13, 11, 0, -12 }, // 0x5a 'Z' U+005A + { 787, 4, 17, 5, 1, -12 }, // 0x5b '[' U+005B + { 796, 5, 13, 5, 0, -12 }, // 0x5c '\' U+005C + { 805, 4, 17, 5, 0, -12 }, // 0x5d ']' U+005D + { 814, 7, 7, 8, 1, -12 }, // 0x5e '^' U+005E + { 821, 10, 1, 10, 0, 3 }, // 0x5f '_' U+005F + { 823, 4, 2, 6, 0, -12 }, // 0x60 '`' U+0060 + { 824, 9, 10, 10, 1, -9 }, // 0x61 'a' U+0061 + { 836, 8, 13, 10, 1, -12 }, // 0x62 'b' U+0062 + { 849, 8, 10, 9, 1, -9 }, // 0x63 'c' U+0063 + { 859, 9, 13, 10, 0, -12 }, // 0x64 'd' U+0064 + { 874, 8, 10, 10, 1, -9 }, // 0x65 'e' U+0065 + { 884, 5, 13, 5, 0, -12 }, // 0x66 'f' U+0066 + { 893, 8, 14, 10, 1, -9 }, // 0x67 'g' U+0067 + { 907, 8, 13, 10, 1, -12 }, // 0x68 'h' U+0068 + { 920, 2, 13, 4, 1, -12 }, // 0x69 'i' U+0069 + { 924, 3, 17, 4, 0, -12 }, // 0x6a 'j' U+006A + { 931, 8, 13, 9, 1, -12 }, // 0x6b 'k' U+006B + { 944, 2, 13, 4, 1, -12 }, // 0x6c 'l' U+006C + { 948, 13, 10, 15, 1, -9 }, // 0x6d 'm' U+006D + { 965, 8, 10, 10, 1, -9 }, // 0x6e 'n' U+006E + { 975, 8, 10, 10, 1, -9 }, // 0x6f 'o' U+006F + { 985, 8, 14, 10, 1, -9 }, // 0x70 'p' U+0070 + { 999, 9, 14, 10, 0, -9 }, // 0x71 'q' U+0071 + { 1015, 5, 10, 6, 1, -9 }, // 0x72 'r' U+0072 + { 1022, 7, 10, 9, 1, -9 }, // 0x73 's' U+0073 + { 1031, 5, 12, 5, 0, -11 }, // 0x74 't' U+0074 + { 1039, 8, 9, 10, 1, -8 }, // 0x75 'u' U+0075 + { 1048, 9, 9, 9, 0, -8 }, // 0x76 'v' U+0076 + { 1059, 13, 9, 13, 0, -8 }, // 0x77 'w' U+0077 + { 1074, 9, 9, 9, 0, -8 }, // 0x78 'x' U+0078 + { 1085, 9, 13, 9, 0, -8 }, // 0x79 'y' U+0079 + { 1100, 7, 9, 9, 1, -8 }, // 0x7a 'z' U+007A + { 1108, 4, 17, 6, 1, -12 }, // 0x7b '{' U+007B + { 1117, 1, 17, 5, 2, -12 }, // 0x7c '|' U+007C + { 1120, 4, 17, 6, 1, -12 }, // 0x7d '}' U+007D + { 1129, 8, 3, 11, 1, -7 }, // 0x7e '~' U+007E + { 1132, 9, 13, 13, 2, -12 }, // 0x7f 'REPLACEMENT CHARACTER *' U+2370 + { 1147, 1, 1, 5, 0, 0 }, // 0x80 'NO-BREAK SPACE' U+00A0 + { 1148, 2, 13, 5, 2, -8 }, // 0x81 'INVERTED EXCLAMATION MARK' U+00A1 + { 1152, 8, 13, 10, 1, -10 }, // 0x82 'CENT SIGN' U+00A2 + { 1165, 10, 13, 10, 0, -12 }, // 0x83 'POUND SIGN' U+00A3 + { 1182, 10, 13, 12, 1, -12 }, // 0x84 'EURO SIGN *' U+20AC + { 1199, 10, 13, 10, 0, -12 }, // 0x85 'YEN SIGN' U+00A5 + { 1216, 10, 17, 12, 1, -16 }, // 0x86 'LATIN CAPITAL LETTER S WITH CARON *' U+0160 + { 1238, 8, 17, 10, 1, -12 }, // 0x87 'SECTION SIGN' U+00A7 + { 1255, 7, 13, 9, 1, -12 }, // 0x88 'LATIN SMALL LETTER S WITH CARON *' U+0161 + { 1267, 14, 13, 13, 0, -12 }, // 0x89 'COPYRIGHT SIGN' U+00A9 + { 1290, 5, 8, 7, 1, -12 }, // 0x8a 'FEMININE ORDINAL INDICATOR' U+00AA + { 1295, 6, 6, 8, 1, -7 }, // 0x8b 'LEFT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00AB + { 1300, 9, 5, 11, 1, -6 }, // 0x8c 'NOT SIGN' U+00AC + { 1306, 4, 2, 6, 1, -5 }, // 0x8d 'SOFT HYPHEN' U+00AD + { 1307, 14, 13, 13, 0, -12 }, // 0x8e 'REGISTERED SIGN' U+00AE + { 1330, 5, 2, 6, 0, -12 }, // 0x8f 'MACRON' U+00AF + { 1332, 5, 5, 11, 3, -11 }, // 0x90 'DEGREE SIGN' U+00B0 + { 1336, 9, 11, 11, 1, -10 }, // 0x91 'PLUS-MINUS SIGN' U+00B1 + { 1349, 6, 8, 6, 0, -12 }, // 0x92 'SUPERSCRIPT TWO' U+00B2 + { 1355, 6, 8, 6, 0, -12 }, // 0x93 'SUPERSCRIPT THREE' U+00B3 + { 1361, 11, 17, 11, 0, -16 }, // 0x94 'LATIN CAPITAL LETTER Z WITH CARON *' U+017D + { 1385, 9, 13, 10, 1, -8 }, // 0x95 'MICRO SIGN' U+00B5 + { 1400, 8, 16, 10, 1, -12 }, // 0x96 'PILCROW SIGN' U+00B6 + { 1416, 1, 2, 5, 2, -5 }, // 0x97 'MIDDLE DOT' U+00B7 + { 1417, 7, 13, 9, 1, -12 }, // 0x98 'LATIN SMALL LETTER Z WITH CARON *' U+017E + { 1429, 3, 8, 6, 1, -12 }, // 0x99 'SUPERSCRIPT ONE' U+00B9 + { 1432, 5, 8, 7, 1, -12 }, // 0x9a 'MASCULINE ORDINAL INDICATOR' U+00BA + { 1437, 6, 6, 8, 1, -7 }, // 0x9b 'RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK' U+00BB + { 1442, 16, 13, 18, 1, -12 }, // 0x9c 'LATIN CAPITAL LIGATURE OE *' U+0152 + { 1468, 15, 10, 17, 1, -9 }, // 0x9d 'LATIN SMALL LIGATURE OE *' U+0153 + { 1487, 12, 16, 12, 0, -15 }, // 0x9e 'LATIN CAPITAL LETTER Y WITH DIAERESIS *' U+0178 + { 1511, 8, 13, 10, 2, -8 }, // 0x9f 'INVERTED QUESTION MARK' U+00BF + { 1524, 12, 17, 12, 0, -16 }, // 0xa0 'LATIN CAPITAL LETTER A WITH GRAVE' U+00C0 + { 1550, 12, 17, 12, 0, -16 }, // 0xa1 'LATIN CAPITAL LETTER A WITH ACUTE' U+00C1 + { 1576, 12, 17, 12, 0, -16 }, // 0xa2 'LATIN CAPITAL LETTER A WITH CIRCUMFLEX' U+00C2 + { 1602, 12, 16, 12, 0, -15 }, // 0xa3 'LATIN CAPITAL LETTER A WITH TILDE' U+00C3 + { 1626, 12, 16, 12, 0, -15 }, // 0xa4 'LATIN CAPITAL LETTER A WITH DIAERESIS' U+00C4 + { 1650, 12, 17, 12, 0, -16 }, // 0xa5 'LATIN CAPITAL LETTER A WITH RING ABOVE' U+00C5 + { 1676, 17, 13, 18, 0, -12 }, // 0xa6 'LATIN CAPITAL LETTER AE' U+00C6 + { 1704, 11, 17, 13, 1, -12 }, // 0xa7 'LATIN CAPITAL LETTER C WITH CEDILLA' U+00C7 + { 1728, 9, 17, 12, 2, -16 }, // 0xa8 'LATIN CAPITAL LETTER E WITH GRAVE' U+00C8 + { 1748, 9, 17, 12, 2, -16 }, // 0xa9 'LATIN CAPITAL LETTER E WITH ACUTE' U+00C9 + { 1768, 9, 17, 12, 2, -16 }, // 0xaa 'LATIN CAPITAL LETTER E WITH CIRCUMFLEX' U+00CA + { 1788, 9, 16, 12, 2, -15 }, // 0xab 'LATIN CAPITAL LETTER E WITH DIAERESIS' U+00CB + { 1806, 4, 17, 5, 0, -16 }, // 0xac 'LATIN CAPITAL LETTER I WITH GRAVE' U+00CC + { 1815, 4, 17, 5, 1, -16 }, // 0xad 'LATIN CAPITAL LETTER I WITH ACUTE' U+00CD + { 1824, 5, 17, 5, 0, -16 }, // 0xae 'LATIN CAPITAL LETTER I WITH CIRCUMFLEX' U+00CE + { 1835, 6, 16, 5, 0, -15 }, // 0xaf 'LATIN CAPITAL LETTER I WITH DIAERESIS' U+00CF + { 1847, 12, 13, 13, 0, -12 }, // 0xb0 'LATIN CAPITAL LETTER ETH' U+00D0 + { 1867, 11, 16, 13, 1, -15 }, // 0xb1 'LATIN CAPITAL LETTER N WITH TILDE' U+00D1 + { 1889, 12, 17, 14, 1, -16 }, // 0xb2 'LATIN CAPITAL LETTER O WITH GRAVE' U+00D2 + { 1915, 12, 17, 14, 1, -16 }, // 0xb3 'LATIN CAPITAL LETTER O WITH ACUTE' U+00D3 + { 1941, 12, 17, 14, 1, -16 }, // 0xb4 'LATIN CAPITAL LETTER O WITH CIRCUMFLEX' U+00D4 + { 1967, 12, 16, 14, 1, -15 }, // 0xb5 'LATIN CAPITAL LETTER O WITH TILDE' U+00D5 + { 1991, 12, 16, 14, 1, -15 }, // 0xb6 'LATIN CAPITAL LETTER O WITH DIAERESIS' U+00D6 + { 2015, 7, 7, 11, 2, -7 }, // 0xb7 'MULTIPLICATION SIGN' U+00D7 + { 2022, 12, 14, 14, 1, -13 }, // 0xb8 'LATIN CAPITAL LETTER O WITH STROKE' U+00D8 + { 2043, 10, 17, 13, 2, -16 }, // 0xb9 'LATIN CAPITAL LETTER U WITH GRAVE' U+00D9 + { 2065, 10, 17, 13, 2, -16 }, // 0xba 'LATIN CAPITAL LETTER U WITH ACUTE' U+00DA + { 2087, 10, 17, 13, 2, -16 }, // 0xbb 'LATIN CAPITAL LETTER U WITH CIRCUMFLEX' U+00DB + { 2109, 10, 16, 13, 2, -15 }, // 0xbc 'LATIN CAPITAL LETTER U WITH DIAERESIS' U+00DC + { 2129, 12, 17, 12, 0, -16 }, // 0xbd 'LATIN CAPITAL LETTER Y WITH ACUTE' U+00DD + { 2155, 9, 13, 12, 2, -12 }, // 0xbe 'LATIN CAPITAL LETTER THORN' U+00DE + { 2170, 9, 13, 11, 1, -12 }, // 0xbf 'LATIN SMALL LETTER SHARP S' U+00DF + { 2185, 9, 13, 10, 1, -12 }, // 0xc0 'LATIN SMALL LETTER A WITH GRAVE' U+00E0 + { 2200, 9, 13, 10, 1, -12 }, // 0xc1 'LATIN SMALL LETTER A WITH ACUTE' U+00E1 + { 2215, 9, 13, 10, 1, -12 }, // 0xc2 'LATIN SMALL LETTER A WITH CIRCUMFLEX' U+00E2 + { 2230, 9, 13, 10, 1, -12 }, // 0xc3 'LATIN SMALL LETTER A WITH TILDE' U+00E3 + { 2245, 9, 13, 10, 1, -12 }, // 0xc4 'LATIN SMALL LETTER A WITH DIAERESIS' U+00E4 + { 2260, 9, 14, 10, 1, -13 }, // 0xc5 'LATIN SMALL LETTER A WITH RING ABOVE' U+00E5 + { 2276, 14, 10, 16, 1, -9 }, // 0xc6 'LATIN SMALL LETTER AE' U+00E6 + { 2294, 8, 14, 9, 1, -9 }, // 0xc7 'LATIN SMALL LETTER C WITH CEDILLA' U+00E7 + { 2308, 8, 13, 10, 1, -12 }, // 0xc8 'LATIN SMALL LETTER E WITH GRAVE' U+00E8 + { 2321, 8, 13, 10, 1, -12 }, // 0xc9 'LATIN SMALL LETTER E WITH ACUTE' U+00E9 + { 2334, 8, 13, 10, 1, -12 }, // 0xca 'LATIN SMALL LETTER E WITH CIRCUMFLEX' U+00EA + { 2347, 8, 13, 10, 1, -12 }, // 0xcb 'LATIN SMALL LETTER E WITH DIAERESIS' U+00EB + { 2360, 4, 13, 5, 0, -12 }, // 0xcc 'LATIN SMALL LETTER I WITH GRAVE' U+00EC + { 2367, 4, 13, 5, 1, -12 }, // 0xcd 'LATIN SMALL LETTER I WITH ACUTE' U+00ED + { 2374, 5, 13, 5, 0, -12 }, // 0xce 'LATIN SMALL LETTER I WITH CIRCUMFLEX' U+00EE + { 2383, 6, 13, 5, -1, -12 }, // 0xcf 'LATIN SMALL LETTER I WITH DIAERESIS' U+00EF + { 2393, 8, 13, 10, 1, -12 }, // 0xd0 'LATIN SMALL LETTER ETH' U+00F0 + { 2406, 8, 13, 10, 1, -12 }, // 0xd1 'LATIN SMALL LETTER N WITH TILDE' U+00F1 + { 2419, 8, 13, 10, 1, -12 }, // 0xd2 'LATIN SMALL LETTER O WITH GRAVE' U+00F2 + { 2432, 8, 13, 10, 1, -12 }, // 0xd3 'LATIN SMALL LETTER O WITH ACUTE' U+00F3 + { 2445, 8, 13, 10, 1, -12 }, // 0xd4 'LATIN SMALL LETTER O WITH CIRCUMFLEX' U+00F4 + { 2458, 8, 13, 10, 1, -12 }, // 0xd5 'LATIN SMALL LETTER O WITH TILDE' U+00F5 + { 2471, 8, 13, 10, 1, -12 }, // 0xd6 'LATIN SMALL LETTER O WITH DIAERESIS' U+00F6 + { 2484, 9, 9, 11, 1, -8 }, // 0xd7 'DIVISION SIGN' U+00F7 + { 2495, 10, 11, 11, 0, -9 }, // 0xd8 'LATIN SMALL LETTER O WITH STROKE' U+00F8 + { 2509, 8, 13, 10, 1, -12 }, // 0xd9 'LATIN SMALL LETTER U WITH GRAVE' U+00F9 + { 2522, 8, 13, 10, 1, -12 }, // 0xda 'LATIN SMALL LETTER U WITH ACUTE' U+00FA + { 2535, 8, 13, 10, 1, -12 }, // 0xdb 'LATIN SMALL LETTER U WITH CIRCUMFLEX' U+00FB + { 2548, 8, 13, 10, 1, -12 }, // 0xdc 'LATIN SMALL LETTER U WITH DIAERESIS' U+00FC + { 2561, 9, 17, 9, 0, -12 }, // 0xdd 'LATIN SMALL LETTER Y WITH ACUTE' U+00FD + { 2581, 8, 17, 10, 1, -12 }, // 0xde 'LATIN SMALL LETTER THORN' U+00FE + { 2598, 9, 17, 9, 0, -12 } }; // 0xdf 'LATIN SMALL LETTER Y WITH DIAERESIS' U+000FF + +const GFXfont FreeSans9pt8b PROGMEM = { + (uint8_t *)FreeSans9pt8bBitmaps, + (GFXglyph *)FreeSans9pt8bGlyphs, + 0x20, 0xDF, 25 }; + +// Approx. 3969 bytes diff --git a/RX_FSK/src/fonts/Picopixel.h b/RX_FSK/src/fonts/Picopixel.h new file mode 100644 index 0000000..0ed6543 --- /dev/null +++ b/RX_FSK/src/fonts/Picopixel.h @@ -0,0 +1,123 @@ +// Picopixel by Sebastian Weber. A tiny font +// with all characters within a 6 pixel height. + +const uint8_t PicopixelBitmaps[] PROGMEM = { + 0xE8, 0xB4, 0x57, 0xD5, 0xF5, 0x00, 0x4E, 0x3E, 0x80, 0xA5, 0x4A, 0x4A, + 0x5A, 0x50, 0xC0, 0x6A, 0x40, 0x95, 0x80, 0xAA, 0x80, 0x5D, 0x00, 0x60, + 0xE0, 0x80, 0x25, 0x48, 0x56, 0xD4, 0x75, 0x40, 0xC5, 0x4E, 0xC5, 0x1C, + 0x97, 0x92, 0xF3, 0x1C, 0x53, 0x54, 0xE5, 0x48, 0x55, 0x54, 0x55, 0x94, + 0xA0, 0x46, 0x64, 0xE3, 0x80, 0x98, 0xC5, 0x04, 0x56, 0xC6, 0x57, 0xDA, + 0xD7, 0x5C, 0x72, 0x46, 0xD6, 0xDC, 0xF3, 0xCE, 0xF3, 0x48, 0x72, 0xD4, + 0xB7, 0xDA, 0xF8, 0x24, 0xD4, 0xBB, 0x5A, 0x92, 0x4E, 0x8E, 0xEB, 0x58, + 0x80, 0x9D, 0xB9, 0x90, 0x56, 0xD4, 0xD7, 0x48, 0x56, 0xD4, 0x40, 0xD7, + 0x5A, 0x71, 0x1C, 0xE9, 0x24, 0xB6, 0xD4, 0xB6, 0xA4, 0x8C, 0x6B, 0x55, + 0x00, 0xB5, 0x5A, 0xB5, 0x24, 0xE5, 0x4E, 0xEA, 0xC0, 0x91, 0x12, 0xD5, + 0xC0, 0x54, 0xF0, 0x90, 0xC7, 0xF0, 0x93, 0x5E, 0x71, 0x80, 0x25, 0xDE, + 0x5E, 0x30, 0x6E, 0x80, 0x77, 0x9C, 0x93, 0x5A, 0xB8, 0x45, 0x60, 0x92, + 0xEA, 0xAA, 0x40, 0xD5, 0x6A, 0xD6, 0x80, 0x55, 0x00, 0xD7, 0x40, 0x75, + 0x90, 0xE8, 0x71, 0xE0, 0xBA, 0x40, 0xB5, 0x80, 0xB5, 0x00, 0x8D, 0x54, + 0xAA, 0x80, 0xAC, 0xE0, 0xE5, 0x70, 0x6A, 0x26, 0xFC, 0xC8, 0xAC, 0x5A }; + +const GFXglyph PicopixelGlyphs[] PROGMEM = { + { 0, 0, 0, 2, 0, 1 }, // 0x20 ' ' + { 0, 1, 5, 2, 0, -4 }, // 0x21 '!' + { 1, 3, 2, 4, 0, -4 }, // 0x22 '"' + { 2, 5, 5, 6, 0, -4 }, // 0x23 '#' + { 6, 3, 6, 4, 0, -4 }, // 0x24 '$' + { 9, 3, 5, 4, 0, -4 }, // 0x25 '%' + { 11, 4, 5, 5, 0, -4 }, // 0x26 '&' + { 14, 1, 2, 2, 0, -4 }, // 0x27 ''' + { 15, 2, 5, 3, 0, -4 }, // 0x28 '(' + { 17, 2, 5, 3, 0, -4 }, // 0x29 ')' + { 19, 3, 3, 4, 0, -3 }, // 0x2A '*' + { 21, 3, 3, 4, 0, -3 }, // 0x2B '+' + { 23, 2, 2, 3, 0, 0 }, // 0x2C ',' + { 24, 3, 1, 4, 0, -2 }, // 0x2D '-' + { 25, 1, 1, 2, 0, 0 }, // 0x2E '.' + { 26, 3, 5, 4, 0, -4 }, // 0x2F '/' + { 28, 3, 5, 4, 0, -4 }, // 0x30 '0' + { 30, 2, 5, 3, 0, -4 }, // 0x31 '1' + { 32, 3, 5, 4, 0, -4 }, // 0x32 '2' + { 34, 3, 5, 4, 0, -4 }, // 0x33 '3' + { 36, 3, 5, 4, 0, -4 }, // 0x34 '4' + { 38, 3, 5, 4, 0, -4 }, // 0x35 '5' + { 40, 3, 5, 4, 0, -4 }, // 0x36 '6' + { 42, 3, 5, 4, 0, -4 }, // 0x37 '7' + { 44, 3, 5, 4, 0, -4 }, // 0x38 '8' + { 46, 3, 5, 4, 0, -4 }, // 0x39 '9' + { 48, 1, 3, 2, 0, -3 }, // 0x3A ':' + { 49, 2, 4, 3, 0, -3 }, // 0x3B ';' + { 50, 2, 3, 3, 0, -3 }, // 0x3C '<' + { 51, 3, 3, 4, 0, -3 }, // 0x3D '=' + { 53, 2, 3, 3, 0, -3 }, // 0x3E '>' + { 54, 3, 5, 4, 0, -4 }, // 0x3F '?' + { 56, 3, 5, 4, 0, -4 }, // 0x40 '@' + { 58, 3, 5, 4, 0, -4 }, // 0x41 'A' + { 60, 3, 5, 4, 0, -4 }, // 0x42 'B' + { 62, 3, 5, 4, 0, -4 }, // 0x43 'C' + { 64, 3, 5, 4, 0, -4 }, // 0x44 'D' + { 66, 3, 5, 4, 0, -4 }, // 0x45 'E' + { 68, 3, 5, 4, 0, -4 }, // 0x46 'F' + { 70, 3, 5, 4, 0, -4 }, // 0x47 'G' + { 72, 3, 5, 4, 0, -4 }, // 0x48 'H' + { 74, 1, 5, 2, 0, -4 }, // 0x49 'I' + { 75, 3, 5, 4, 0, -4 }, // 0x4A 'J' + { 77, 3, 5, 4, 0, -4 }, // 0x4B 'K' + { 79, 3, 5, 4, 0, -4 }, // 0x4C 'L' + { 81, 5, 5, 6, 0, -4 }, // 0x4D 'M' + { 85, 4, 5, 5, 0, -4 }, // 0x4E 'N' + { 88, 3, 5, 4, 0, -4 }, // 0x4F 'O' + { 90, 3, 5, 4, 0, -4 }, // 0x50 'P' + { 92, 3, 6, 4, 0, -4 }, // 0x51 'Q' + { 95, 3, 5, 4, 0, -4 }, // 0x52 'R' + { 97, 3, 5, 4, 0, -4 }, // 0x53 'S' + { 99, 3, 5, 4, 0, -4 }, // 0x54 'T' + { 101, 3, 5, 4, 0, -4 }, // 0x55 'U' + { 103, 3, 5, 4, 0, -4 }, // 0x56 'V' + { 105, 5, 5, 6, 0, -4 }, // 0x57 'W' + { 109, 3, 5, 4, 0, -4 }, // 0x58 'X' + { 111, 3, 5, 4, 0, -4 }, // 0x59 'Y' + { 113, 3, 5, 4, 0, -4 }, // 0x5A 'Z' + { 115, 2, 5, 3, 0, -4 }, // 0x5B '[' + { 117, 3, 5, 4, 0, -4 }, // 0x5C '\' + { 119, 2, 5, 3, 0, -4 }, // 0x5D ']' + { 121, 3, 2, 4, 0, -4 }, // 0x5E '^' + { 122, 4, 1, 4, 0, 1 }, // 0x5F '_' + { 123, 2, 2, 3, 0, -4 }, // 0x60 '`' + { 124, 3, 4, 4, 0, -3 }, // 0x61 'a' + { 126, 3, 5, 4, 0, -4 }, // 0x62 'b' + { 128, 3, 3, 4, 0, -2 }, // 0x63 'c' + { 130, 3, 5, 4, 0, -4 }, // 0x64 'd' + { 132, 3, 4, 4, 0, -3 }, // 0x65 'e' + { 134, 2, 5, 3, 0, -4 }, // 0x66 'f' + { 136, 3, 5, 4, 0, -3 }, // 0x67 'g' + { 138, 3, 5, 4, 0, -4 }, // 0x68 'h' + { 140, 1, 5, 2, 0, -4 }, // 0x69 'i' + { 141, 2, 6, 3, 0, -4 }, // 0x6A 'j' + { 143, 3, 5, 4, 0, -4 }, // 0x6B 'k' + { 145, 2, 5, 3, 0, -4 }, // 0x6C 'l' + { 147, 5, 3, 6, 0, -2 }, // 0x6D 'm' + { 149, 3, 3, 4, 0, -2 }, // 0x6E 'n' + { 151, 3, 3, 4, 0, -2 }, // 0x6F 'o' + { 153, 3, 4, 4, 0, -2 }, // 0x70 'p' + { 155, 3, 4, 4, 0, -2 }, // 0x71 'q' + { 157, 2, 3, 3, 0, -2 }, // 0x72 'r' + { 158, 3, 4, 4, 0, -3 }, // 0x73 's' + { 160, 2, 5, 3, 0, -4 }, // 0x74 't' + { 162, 3, 3, 4, 0, -2 }, // 0x75 'u' + { 164, 3, 3, 4, 0, -2 }, // 0x76 'v' + { 166, 5, 3, 6, 0, -2 }, // 0x77 'w' + { 168, 3, 3, 4, 0, -2 }, // 0x78 'x' + { 170, 3, 4, 4, 0, -2 }, // 0x79 'y' + { 172, 3, 4, 4, 0, -3 }, // 0x7A 'z' + { 174, 3, 5, 4, 0, -4 }, // 0x7B '{' + { 176, 1, 6, 2, 0, -4 }, // 0x7C '|' + { 177, 3, 5, 4, 0, -4 }, // 0x7D '}' + { 179, 4, 2, 5, 0, -3 } }; // 0x7E '~' + +const GFXfont Picopixel PROGMEM = { + (uint8_t *)PicopixelBitmaps, + (GFXglyph *)PicopixelGlyphs, + 0x20, 0x7E, 7 }; + +// Approx. 852 bytes diff --git a/RX_FSK/src/fonts/Terminal11x16.h b/RX_FSK/src/fonts/Terminal11x16.h new file mode 100644 index 0000000..2522cbe --- /dev/null +++ b/RX_FSK/src/fonts/Terminal11x16.h @@ -0,0 +1,221 @@ +const uint8_t Terminal11x16Bitmap[] = { + 0x0C, 0x18, 0x78, 0xF1, 0xE3, 0xC7, 0x86, 0x0C, 0x18, 0x00, 0x00, 0xC1, + 0x80, 0x33, 0x33, 0x33, 0x33, 0x0C, 0xC1, 0x98, 0x33, 0x3F, 0xF1, 0x98, + 0x33, 0x0C, 0xC1, 0x98, 0xFF, 0x8C, 0xC1, 0x98, 0x33, 0x00, 0x0C, 0x06, + 0x0F, 0xCF, 0xF6, 0xC3, 0x61, 0xFC, 0x7F, 0x0D, 0x86, 0xDF, 0xE7, 0xE0, + 0xC0, 0x60, 0x00, 0x2E, 0x0D, 0xC3, 0xB8, 0xE0, 0x38, 0x0E, 0x03, 0x80, + 0xE0, 0x38, 0x0E, 0x3B, 0x87, 0x60, 0xE0, 0x0E, 0x06, 0xC3, 0x30, 0xCC, + 0x36, 0x07, 0x03, 0xC1, 0xF0, 0x66, 0xD9, 0xE6, 0x31, 0xDE, 0x3C, 0xC0, + 0x1C, 0x71, 0xC3, 0x0C, 0x60, 0x07, 0x0C, 0x1C, 0x18, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x18, 0x1C, 0x0C, 0x07, 0x38, 0x0C, 0x0E, 0x06, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x0E, 0x0C, 0x38, 0x6D, 0xB6, 0xCF, + 0xC3, 0xC7, 0xF8, 0xF0, 0xFC, 0xDB, 0x6D, 0x80, 0x0C, 0x06, 0x03, 0x0F, + 0xF7, 0xF8, 0x60, 0x30, 0x18, 0x1C, 0x71, 0xC3, 0x18, 0x7F, 0xBF, 0xC0, + 0x1C, 0x71, 0xC0, 0x00, 0x20, 0x0C, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, + 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x60, 0x00, 0x1F, 0x0F, 0xF9, 0x83, + 0x60, 0x7C, 0x1F, 0x86, 0xF1, 0x9E, 0x63, 0xD8, 0x7E, 0x0F, 0x81, 0xB0, + 0x67, 0xFC, 0x3E, 0x00, 0x06, 0x03, 0x83, 0xE0, 0xF8, 0x06, 0x01, 0x80, + 0x60, 0x18, 0x06, 0x01, 0x80, 0x60, 0x18, 0x3F, 0xCF, 0xF0, 0x3F, 0x8F, + 0xFB, 0x83, 0xE0, 0x3C, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, + 0xE0, 0x38, 0x0F, 0xFF, 0xFF, 0xC0, 0x3F, 0x8F, 0xFB, 0x83, 0xE0, 0x30, + 0x06, 0x01, 0xC7, 0xF0, 0xFC, 0x00, 0xC0, 0x0F, 0x01, 0xF0, 0x77, 0xFC, + 0x7F, 0x00, 0x03, 0x80, 0xF0, 0x3E, 0x0E, 0xC3, 0x98, 0xE3, 0x38, 0x66, + 0x0C, 0xFF, 0xFF, 0xFC, 0x06, 0x00, 0xC0, 0x18, 0x03, 0x00, 0xFF, 0xFF, + 0xFF, 0x00, 0x60, 0x0C, 0x01, 0xFF, 0x1F, 0xF0, 0x07, 0x00, 0x60, 0x0F, + 0x01, 0xF0, 0x77, 0xFC, 0x7F, 0x00, 0x07, 0x81, 0xF0, 0x70, 0x1C, 0x07, + 0x00, 0xC0, 0x3F, 0xE7, 0xFE, 0xE0, 0xF8, 0x0F, 0x01, 0xF0, 0x77, 0xFC, + 0x7F, 0x00, 0xFF, 0xFF, 0xFC, 0x03, 0x00, 0x60, 0x18, 0x03, 0x00, 0xC0, + 0x18, 0x06, 0x00, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x30, 0x00, 0x1F, 0x07, + 0xF1, 0xC7, 0x30, 0x66, 0x0C, 0xE3, 0x8F, 0xE3, 0xFE, 0xE0, 0xF8, 0x0F, + 0x01, 0xF0, 0x77, 0xFC, 0x7F, 0x00, 0x3F, 0x8F, 0xFB, 0x83, 0xE0, 0x3C, + 0x07, 0xC1, 0xDF, 0xF9, 0xFF, 0x00, 0xC0, 0x38, 0x0E, 0x03, 0x83, 0xE0, + 0x78, 0x00, 0x1C, 0x71, 0xC0, 0x00, 0x01, 0xC7, 0x1C, 0x1C, 0x71, 0xC0, + 0x00, 0x01, 0xC7, 0x1C, 0x30, 0xC6, 0x01, 0x81, 0xC1, 0xC1, 0xC1, 0xC1, + 0xC1, 0xC0, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0C, 0x7F, 0xDF, + 0xF0, 0x00, 0x00, 0x7F, 0xDF, 0xF0, 0x60, 0x38, 0x0E, 0x03, 0x80, 0xE0, + 0x38, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x00, 0x3F, 0x1F, + 0xEE, 0x1F, 0x03, 0xC1, 0xC0, 0xE0, 0x70, 0x38, 0x0C, 0x03, 0x00, 0xC0, + 0x00, 0x0C, 0x03, 0x00, 0x3F, 0x8F, 0xF9, 0x83, 0x67, 0xBD, 0xF7, 0xB6, + 0xF6, 0xDE, 0xDB, 0xDB, 0x7B, 0xFB, 0x3E, 0x70, 0x07, 0xF8, 0x3F, 0x00, + 0x0C, 0x03, 0x01, 0xE0, 0x78, 0x1E, 0x0C, 0xC3, 0x30, 0xCC, 0x61, 0x9F, + 0xE7, 0xFB, 0x03, 0xC0, 0xF0, 0x30, 0xFE, 0x3F, 0xCC, 0x3B, 0x06, 0xC1, + 0xB0, 0xEF, 0xF3, 0xFE, 0xC1, 0xF0, 0x3C, 0x0F, 0x07, 0xFF, 0xBF, 0xC0, + 0x1F, 0x0F, 0xE7, 0x1D, 0x83, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, + 0x06, 0x0D, 0xC7, 0x3F, 0x87, 0xC0, 0xFE, 0x3F, 0xCC, 0x3B, 0x06, 0xC0, + 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x1B, 0x0E, 0xFF, 0x3F, 0x80, + 0xFF, 0xFF, 0xFC, 0x03, 0x00, 0xC0, 0x30, 0x0F, 0xF3, 0xFC, 0xC0, 0x30, + 0x0C, 0x03, 0x00, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFC, 0x03, 0x00, 0xC0, + 0x30, 0x0F, 0xF3, 0xFC, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x00, + 0x1F, 0x8F, 0xF7, 0x0D, 0x80, 0xC0, 0x30, 0x0C, 0x7F, 0x1F, 0xC0, 0xF0, + 0x36, 0x0D, 0xC3, 0x3F, 0xC7, 0xF0, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, + 0xF0, 0x3F, 0xFF, 0xFF, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x30, + 0x3F, 0x3F, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, + 0x3F, 0x3F, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, + 0x00, 0xF0, 0x3C, 0x0F, 0x86, 0x7F, 0x8F, 0xC0, 0xC0, 0xF0, 0x7C, 0x3B, + 0x1C, 0xCE, 0x37, 0x0F, 0x83, 0xE0, 0xDC, 0x33, 0x8C, 0x73, 0x0E, 0xC1, + 0xF0, 0x30, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, + 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xFF, 0xFF, 0xF0, 0xC0, 0xF8, 0x7E, 0x1F, + 0xCF, 0xF3, 0xF7, 0xBD, 0xEF, 0x33, 0xCC, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, + 0xF0, 0x30, 0xC0, 0xF8, 0x3E, 0x0F, 0xC3, 0xD8, 0xF6, 0x3C, 0xCF, 0x33, + 0xC6, 0xF1, 0xBC, 0x3F, 0x07, 0xC1, 0xF0, 0x30, 0x1E, 0x0F, 0xC7, 0x39, + 0x86, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x36, 0x19, 0xCE, 0x3F, + 0x07, 0x80, 0xFF, 0x3F, 0xEC, 0x1F, 0x03, 0xC0, 0xF0, 0x3C, 0x1F, 0xFE, + 0xFF, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x00, 0x1E, 0x0F, 0xC7, 0x39, + 0x86, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF1, 0xB6, 0x79, 0xCE, 0x3F, + 0xC7, 0xB0, 0xFF, 0x3F, 0xEC, 0x1F, 0x03, 0xC0, 0xF0, 0x3C, 0x1F, 0xFE, + 0xFF, 0x33, 0x8C, 0x73, 0x0E, 0xC1, 0xF0, 0x30, 0x3F, 0x1F, 0xEE, 0x1F, + 0x03, 0xC0, 0x38, 0x07, 0xF0, 0xFE, 0x01, 0xC0, 0x3C, 0x0F, 0x87, 0x7F, + 0x8F, 0xC0, 0x7F, 0xBF, 0xC3, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, + 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, + 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0D, 0x86, 0x7F, 0x8F, 0xC0, + 0xC0, 0xF0, 0x3C, 0x0D, 0x86, 0x61, 0x98, 0x63, 0x30, 0xCC, 0x33, 0x07, + 0x81, 0xE0, 0x78, 0x0C, 0x03, 0x00, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, + 0xF0, 0x3C, 0x0F, 0x33, 0xCC, 0xF7, 0xBF, 0x3F, 0x87, 0xE1, 0xF0, 0x30, + 0xC0, 0xF0, 0x36, 0x19, 0x86, 0x33, 0x07, 0x80, 0xC0, 0x30, 0x1E, 0x0C, + 0xC6, 0x19, 0x86, 0xC0, 0xF0, 0x30, 0xC0, 0xF0, 0x36, 0x19, 0x86, 0x33, + 0x0C, 0xC1, 0xE0, 0x78, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, + 0xFF, 0xFF, 0xF0, 0x18, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x30, 0x18, 0x0C, + 0x06, 0x01, 0x80, 0xFF, 0xFF, 0xF0, 0x3F, 0x3F, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F, 0x3F, 0x80, 0x18, 0x03, 0x80, + 0x38, 0x03, 0x80, 0x38, 0x03, 0x80, 0x38, 0x03, 0x80, 0x38, 0x03, 0x80, + 0x30, 0x3F, 0x3F, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x3F, 0x3F, 0x04, 0x01, 0xC0, 0x7C, 0x1D, 0xC7, 0x1D, 0xC1, 0xF0, + 0x18, 0xFF, 0xFF, 0xFC, 0x0E, 0x1C, 0x38, 0x60, 0xC0, 0xC0, 0x3F, 0x9F, + 0xF0, 0x0C, 0xFF, 0x7F, 0xF0, 0x3C, 0x0F, 0xFF, 0x7F, 0xC0, 0xC0, 0x30, + 0x0C, 0x03, 0x00, 0xC0, 0x37, 0xCF, 0xFB, 0x87, 0xC0, 0xF0, 0x3C, 0x0F, + 0x07, 0xFF, 0xBF, 0xC0, 0x3F, 0x1F, 0xEE, 0x0F, 0x00, 0xC0, 0x30, 0x0E, + 0x0D, 0xFE, 0x3F, 0x00, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xCF, 0xB7, + 0xFF, 0x8F, 0xC0, 0xF0, 0x3C, 0x0F, 0x83, 0x7F, 0xCF, 0xF0, 0x3F, 0x1F, + 0xEE, 0x0F, 0xFF, 0xFF, 0xB0, 0x0E, 0x01, 0xFE, 0x3F, 0x00, 0x0F, 0x1F, + 0x38, 0x30, 0x30, 0x30, 0xFE, 0xFE, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x3F, 0xDF, 0xFE, 0x0F, 0x03, 0xE1, 0xDF, 0xF3, 0xEC, 0x03, 0x01, 0xDF, + 0xE7, 0xF0, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0xF3, 0xFD, 0xC7, 0xC1, + 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0C, 0x0C, 0x0C, 0x00, 0x1C, 0x1C, 0x0C, + 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x3F, 0x03, 0x03, 0x00, 0x07, 0x07, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x33, 0x3F, 0x1E, 0x60, 0x30, 0x18, 0x0C, + 0x06, 0x03, 0x19, 0x9C, 0xDC, 0x7C, 0x3E, 0x1B, 0x8C, 0xE6, 0x3B, 0x0C, + 0x1C, 0x1C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, + 0x3F, 0x3F, 0xB3, 0x3F, 0xEF, 0xFF, 0x33, 0xCC, 0xF3, 0x3C, 0xCF, 0x33, + 0xCC, 0xC0, 0x7F, 0x1F, 0xE6, 0x1D, 0x83, 0x60, 0xD8, 0x36, 0x0D, 0x83, + 0x60, 0xC0, 0x3F, 0x1F, 0xEE, 0x1F, 0x03, 0xC0, 0xF0, 0x3E, 0x1D, 0xFE, + 0x3F, 0x00, 0xFF, 0x3F, 0xEC, 0x1F, 0x03, 0xC0, 0xF8, 0x7F, 0xFB, 0x7C, + 0xC0, 0x30, 0x0C, 0x00, 0x3F, 0xDF, 0xFE, 0x0F, 0x03, 0xC0, 0xF8, 0x77, + 0xFC, 0xFB, 0x00, 0xC0, 0x30, 0x0C, 0x6F, 0x9F, 0xF7, 0x0D, 0x80, 0x60, + 0x18, 0x06, 0x01, 0x80, 0x60, 0x00, 0x7E, 0xFF, 0xC0, 0xFE, 0x7F, 0x03, + 0x03, 0xFF, 0x7E, 0x30, 0x30, 0x30, 0x30, 0xFE, 0xFE, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x3F, 0x1F, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3E, + 0x1D, 0xFF, 0x3E, 0xC0, 0xC0, 0xF0, 0x36, 0x19, 0x86, 0x33, 0x0C, 0xC1, + 0xE0, 0x78, 0x0C, 0x00, 0xCC, 0xF3, 0x3C, 0xCF, 0x33, 0xCC, 0xF7, 0xB7, + 0xF9, 0xCE, 0x21, 0x00, 0xC1, 0xF1, 0xDD, 0xC7, 0xC1, 0xC1, 0xF1, 0xDD, + 0xC7, 0xC1, 0x80, 0x61, 0xB0, 0xCC, 0xC6, 0x61, 0xE0, 0xF0, 0x30, 0x18, + 0x18, 0x0C, 0x0C, 0x00, 0xFF, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0xFF, 0xFF, 0x80, 0x07, 0x87, 0xC7, 0x03, 0x01, 0x80, 0xC0, 0xE0, 0xE0, + 0x38, 0x0C, 0x06, 0x03, 0x01, 0xC0, 0x7C, 0x1E, 0x0C, 0x30, 0xC3, 0x0C, + 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0x78, 0x3E, 0x03, 0x80, 0xC0, + 0x60, 0x30, 0x1C, 0x07, 0x07, 0x03, 0x01, 0x80, 0xC0, 0xE3, 0xE1, 0xE0, + 0x38, 0xDB, 0x6C, 0x70, 0x0C, 0x07, 0x83, 0x31, 0x86, 0xC0, 0xF0, 0x3F, + 0xFF, 0xFF, +}; + +const GFXglyph Terminal11x16Glyphs[] = { + { 0, 6, 0, 7, 0, 4 }, // 0x20 ' ' + { 0, 7, 14, 8, 0, -12 }, // 0x21 '!' + { 13, 8, 4, 9, 0, -10 }, // 0x22 '"' + { 17, 11, 12, 12, 0, -11 }, // 0x23 '#' + { 34, 9, 14, 10, 0, -12 }, // 0x24 '$' + { 50, 11, 12, 12, 0, -10 }, // 0x25 '%' + { 67, 10, 13, 11, 0, -11 }, // 0x26 '&' + { 84, 6, 6, 7, 0, -12 }, // 0x27 ''' + { 89, 8, 14, 9, 0, -12 }, // 0x28 '(' + { 103, 8, 14, 9, 0, -12 }, // 0x29 ')' + { 117, 9, 9, 10, 0, -9 }, // 0x2a '*' + { 128, 9, 8, 10, 0, -8 }, // 0x2b '+' + { 137, 6, 5, 7, 0, -1 }, // 0x2c ',' + { 141, 9, 2, 10, 0, -5 }, // 0x2d '-' + { 144, 6, 3, 7, 0, -1 }, // 0x2e '.' + { 147, 11, 12, 12, 0, -11 }, // 0x2f '/' + { 164, 11, 14, 12, 0, -12 }, // 0x30 '0' + { 184, 10, 14, 11, 0, -12 }, // 0x31 '1' + { 202, 11, 14, 12, 0, -12 }, // 0x32 '2' + { 222, 11, 14, 12, 0, -12 }, // 0x33 '3' + { 242, 11, 14, 12, 0, -12 }, // 0x34 '4' + { 262, 11, 14, 12, 0, -12 }, // 0x35 '5' + { 282, 11, 14, 12, 0, -12 }, // 0x36 '6' + { 302, 11, 14, 12, 0, -12 }, // 0x37 '7' + { 322, 11, 14, 12, 0, -12 }, // 0x38 '8' + { 342, 11, 14, 12, 0, -12 }, // 0x39 '9' + { 362, 6, 9, 7, 0, -8 }, // 0x3a ':' + { 369, 6, 12, 7, 0, -8 }, // 0x3b ';' + { 378, 9, 14, 10, 0, -12 }, // 0x3c '<' + { 394, 10, 6, 11, 0, -7 }, // 0x3d '=' + { 402, 9, 14, 10, 0, -12 }, // 0x3e '>' + { 418, 10, 14, 11, 0, -12 }, // 0x3f '?' + { 436, 11, 14, 12, 0, -12 }, // 0x40 '@' + { 456, 10, 14, 11, 0, -12 }, // 0x41 'A' + { 474, 10, 14, 11, 0, -12 }, // 0x42 'B' + { 492, 10, 14, 11, 0, -12 }, // 0x43 'C' + { 510, 10, 14, 11, 0, -12 }, // 0x44 'D' + { 528, 10, 14, 11, 0, -12 }, // 0x45 'E' + { 546, 10, 14, 11, 0, -12 }, // 0x46 'F' + { 564, 10, 14, 11, 0, -12 }, // 0x47 'G' + { 582, 10, 14, 11, 0, -12 }, // 0x48 'H' + { 600, 8, 14, 9, 0, -12 }, // 0x49 'I' + { 614, 10, 14, 11, 0, -12 }, // 0x4a 'J' + { 632, 10, 14, 11, 0, -12 }, // 0x4b 'K' + { 650, 10, 14, 11, 0, -12 }, // 0x4c 'L' + { 668, 10, 14, 11, 0, -12 }, // 0x4d 'M' + { 686, 10, 14, 11, 0, -12 }, // 0x4e 'N' + { 704, 10, 14, 11, 0, -12 }, // 0x4f 'O' + { 722, 10, 14, 11, 0, -12 }, // 0x50 'P' + { 740, 10, 14, 11, 0, -12 }, // 0x51 'Q' + { 758, 10, 14, 11, 0, -12 }, // 0x52 'R' + { 776, 10, 14, 11, 0, -12 }, // 0x53 'S' + { 794, 9, 14, 10, 0, -12 }, // 0x54 'T' + { 810, 10, 14, 11, 0, -12 }, // 0x55 'U' + { 828, 10, 14, 11, 0, -12 }, // 0x56 'V' + { 846, 10, 14, 11, 0, -12 }, // 0x57 'W' + { 864, 10, 14, 11, 0, -12 }, // 0x58 'X' + { 882, 10, 14, 11, 0, -12 }, // 0x59 'Y' + { 900, 10, 14, 11, 0, -12 }, // 0x5a 'Z' + { 918, 8, 14, 9, 0, -12 }, // 0x5b '[' + { 932, 11, 12, 12, 0, -11 }, // 0x5c '\' + { 949, 8, 14, 9, 0, -12 }, // 0x5d ']' + { 963, 11, 7, 12, 0, -12 }, // 0x5e '^' + { 973, 11, 2, 12, 0, 2 }, // 0x5f '_' + { 976, 7, 6, 8, 0, -11 }, // 0x60 '`' + { 982, 10, 9, 11, 0, -7 }, // 0x61 'a' + { 994, 10, 14, 11, 0, -12 }, // 0x62 'b' + { 1012, 10, 9, 11, 0, -7 }, // 0x63 'c' + { 1024, 10, 14, 11, 0, -12 }, // 0x64 'd' + { 1042, 10, 9, 11, 0, -7 }, // 0x65 'e' + { 1054, 8, 14, 9, 0, -12 }, // 0x66 'f' + { 1068, 10, 11, 11, 0, -7 }, // 0x67 'g' + { 1082, 9, 14, 10, 0, -12 }, // 0x68 'h' + { 1098, 8, 12, 9, 0, -10 }, // 0x69 'i' + { 1110, 8, 14, 9, 0, -10 }, // 0x6a 'j' + { 1124, 9, 14, 10, 0, -12 }, // 0x6b 'k' + { 1140, 8, 14, 9, 0, -12 }, // 0x6c 'l' + { 1154, 10, 9, 11, 0, -7 }, // 0x6d 'm' + { 1166, 10, 9, 11, 0, -7 }, // 0x6e 'n' + { 1178, 10, 9, 11, 0, -7 }, // 0x6f 'o' + { 1190, 10, 11, 11, 0, -7 }, // 0x70 'p' + { 1204, 10, 11, 11, 0, -7 }, // 0x71 'q' + { 1218, 10, 9, 11, 0, -7 }, // 0x72 'r' + { 1230, 8, 9, 9, 0, -7 }, // 0x73 's' + { 1239, 8, 13, 9, 0, -11 }, // 0x74 't' + { 1252, 10, 9, 11, 0, -7 }, // 0x75 'u' + { 1264, 10, 9, 11, 0, -7 }, // 0x76 'v' + { 1276, 10, 9, 11, 0, -7 }, // 0x77 'w' + { 1288, 9, 9, 10, 0, -7 }, // 0x78 'x' + { 1299, 9, 11, 10, 0, -7 }, // 0x79 'y' + { 1312, 9, 9, 10, 0, -7 }, // 0x7a 'z' + { 1323, 9, 15, 10, 0, -12 }, // 0x7b '{' + { 1340, 6, 14, 7, 0, -12 }, // 0x7c '|' + { 1351, 9, 15, 10, 0, -12 }, // 0x7d '}' + { 1368, 10, 3, 11, 0, -10 }, // 0x7e '~' + { 1372, 10, 8, 11, 0, -8 }, // 0x7f '' + }; +const GFXfont Terminal11x16Font = { + (uint8_t *)Terminal11x16Bitmap, + (GFXglyph *)Terminal11x16Glyphs, + 0x20, 0x7F, 18 }; diff --git a/RX_FSK/src/fonts/fonts.cpp b/RX_FSK/src/fonts/fonts.cpp new file mode 100644 index 0000000..9459f82 --- /dev/null +++ b/RX_FSK/src/fonts/fonts.cpp @@ -0,0 +1,25 @@ +#include +#include "gfxfont.h" + +#define PROGMEM + +#include "FreeMono12pt8b.h" +#include "FreeMono9pt8b.h" +#include "FreeSans12pt8b.h" +#include "FreeSans18pt8b.h" +#include "FreeSans9pt8b.h" +#include "Picopixel.h" +#include "Terminal11x16.h" + +__attribute__((used)) const GFXfont * const allfonts[]={ + (const GFXfont *)0x544E4F46, + &Terminal11x16Font, + &Terminal11x16Font, + &FreeSans9pt8b, + &FreeSans12pt8b, + &Picopixel, + &FreeSans18pt8b, + &FreeMono9pt8b, + &FreeMono12pt8b, + 0, +}; diff --git a/RX_FSK/src/fonts/gfxfont.h b/RX_FSK/src/fonts/gfxfont.h new file mode 100644 index 0000000..42cfcfc --- /dev/null +++ b/RX_FSK/src/fonts/gfxfont.h @@ -0,0 +1,31 @@ +// Font structures for newer Adafruit_GFX (1.1 and later). +// Example fonts are included in 'Fonts' directory. +// To use a font in your Arduino sketch, #include the corresponding .h +// file and pass address of GFXfont struct to setFont(). Pass NULL to +// revert to 'classic' fixed-space bitmap font. + +#ifndef _GFXFONT_H_ +#define _GFXFONT_H_ + +/// Font data stored PER GLYPH +typedef struct +{ + uint16_t bitmapOffset; ///< Pointer into GFXfont->bitmap + uint8_t width; ///< Bitmap dimensions in pixels + uint8_t height; ///< Bitmap dimensions in pixels + uint8_t xAdvance; ///< Distance to advance cursor (x axis) + int8_t xOffset; ///< X dist from cursor pos to UL corner + int8_t yOffset; ///< Y dist from cursor pos to UL corner +} GFXglyph; + +/// Data stored for FONT AS A WHOLE +typedef struct +{ + uint8_t *bitmap; ///< Glyph bitmaps, concatenated + GFXglyph *glyph; ///< Glyph array + uint8_t first; ///< ASCII extents (first char) + uint8_t last; ///< ASCII extents (last char) + uint8_t yAdvance; ///< Newline distance (y axis) +} GFXfont; + +#endif // _GFXFONT_H_ diff --git a/RX_FSK/src/geteph.cpp b/RX_FSK/src/geteph.cpp new file mode 100644 index 0000000..c6f1d86 --- /dev/null +++ b/RX_FSK/src/geteph.cpp @@ -0,0 +1,238 @@ +#include "time.h" +#include "geteph.h" +#include +#include +#include +#include +#include +#include "Display.h" +#include "Sonde.h" + +extern WiFiClient client; + +//static const char *ftpserver = "www.ngs.noaa.gov"; +char outbuf[128]; +uint8_t ephstate = EPH_NOTUSED; +//enum EPHSTATE { EPH_NOTUSED, EPH_PENDING, EPH_TIMEERR, EPH_ERROR, EPH_EPHERROR, EPH_GOOD }; +const char *ephtxt[] = { "Disabled", "Pending", "Time error", "Fetch error", "Read error", "Good" }; + +uint8_t getreply() { + String s = client.readStringUntil('\n'); + Serial.println(s); + const char *str = s.c_str(); + if(strlen(str)<4) return 255; // something unusual... + if(str[3]=='-') { // multi-line resonse... + String s2; + const char *str2; + do { + s2 = client.readStringUntil('\n'); + Serial.println(s2); + str2 = s2.c_str(); + if(strlen(str2)<4) return 255; // something is wrong + } while( str[0]!=str2[0] || str[1]!=str2[1] || str[2]!=str2[2] || str2[3]!=' ' ); + } + return str[0]; +} + +void writeFully(File &file, uint8_t *buf, size_t len) +{ + size_t olen; + + while(len) { + olen = file.write(buf, len); + Serial.printf("written: %d of %d\n", olen, len); + len -= olen; + buf += olen; + } +} + +void geteph() { + // Set current time via network... + ephstate = EPH_PENDING; + struct tm tinfo; + configTime(0, 0, "pool.ntp.org"); + bool ok = getLocalTime(&tinfo, 2000); // wait max 2 seconds to get current time via ntp + if(!ok) { + ephstate = EPH_TIMEERR; + Serial.println("Failed to get current date/time"); + return; + } + + // Check time of last update + int year = tinfo.tm_year + 1900; + int day = tinfo.tm_yday + 1; + Serial.printf("year %d, day %d\n", year, day); + char nowstr[20]; + snprintf(nowstr, 20, "%04d%03d%02d", year, day, tinfo.tm_hour); + File status = SPIFFS.open("/brdc.time", "r"); + if(status) { + String ts = status.readStringUntil('\n'); + const char *tsstr = ts.c_str(); + if(tsstr && strlen(tsstr)>=9) { + if(strcmp(nowstr, ts.c_str())<=0) { + Serial.println("local brdc is up to date\n"); + ephstate = EPH_GOOD; + return; + } + } + Serial.printf("now: %s, existing: %s => updating\n", nowstr, tsstr); + } + status.close(); + File fh = SPIFFS.open("/brdc.gz","w"); + if(!fh) { + Serial.println("cannot open file\n"); + return; + } + char host[252]; + strcpy(host, sonde.config.ephftp); + char *buf = strchr(host, '/'); + if(!buf) { Serial.println("Invalid FTP host config"); return; } + *buf = 0; + buf++; + uint8_t dispw, disph, dispxs, dispys; + disp.rdis->getDispSize(&disph, &dispw, &dispxs, &dispys); + disp.rdis->clear(); + disp.rdis->setFont(FONT_SMALL); + disp.rdis->drawString(0, 0, host); + // fetch rinex from server + char *ptr = buf + strlen(buf); + snprintf(ptr, 128, "%04d/%03d/brdc%03d0.%02dn.gz", year, day, day, year-2000); + Serial.println("running geteph\n"); + disp.rdis->drawString(0, 1*dispys, ptr+9); + + if(!client.connect(host, 21)) { + Serial.printf("FTP connection to %s failed\n", host); + return; + } + if(getreply()>='4') { Serial.println("connected failed"); return; } + client.print("USER anonymous\r\n"); + if(getreply()>='4') { Serial.println("USER failed"); return; } + client.print("PASS anonymous\r\n"); + if(getreply()>='4') { Serial.println("PASS failed"); return; } + client.print("TYPE I\r\n"); + if(getreply()>='4') { Serial.println("TYPE I failed"); return; } + client.print("PASV\r\n"); + String s = client.readStringUntil('\n'); + Serial.println(s); + if(s.c_str()[0]>='4') { Serial.println("PASV failed"); return; } + int array_pasv[6]; + char *tStr = strtok((char *)s.c_str(), "(,"); + for(int i=0; i<6; i++) { + tStr = strtok(NULL, "(,"); + if(tStr==NULL) { + Serial.println("strange response to PASV"); + return; + } + array_pasv[i] = atoi(tStr); + Serial.println(array_pasv[i]); + } + uint16_t port = (array_pasv[4]<<8) | (array_pasv[5]&0xff); + WiFiClient dclient; + Serial.printf("connecting to %s:%d\n", host, port); + dclient.connect(host, port); + if(!dclient) { + Serial.println("data connection failed"); + return; + } + client.print("RETR "); + Serial.printf("fetching %s with FTP...\n", buf); + client.println(buf); + s = client.readStringUntil('\n'); + Serial.println(s); + if(s.c_str()[0]>='4') { Serial.println("RETR failed"); return; } + int len=0; + while(dclient.connected()) { + while(dclient.available()) { + int c = dclient.read(); + if(c==-1) { + Serial.println("dclient.read() returned -1 inspite of available() being true?!"); + } else { + fh.write(c); + len++; + } + } + } + Serial.printf("fetched %d bytes\n", len); + fh.close(); + snprintf(buf, 16, "Fetched %d B ",len); + buf[16]=0; + disp.rdis->drawString(0,2*dispys,buf); + + disp.rdis->drawString(0,4*dispys,"Decompressing..."); + // decompression + tinfl_decompressor *decomp = (tinfl_decompressor *)malloc(sizeof(tinfl_decompressor)); + tinfl_init(decomp); + File file = SPIFFS.open("/brdc.gz","r"); + if(!file) { + Serial.println("cannot open file\n"); + return; + } + File ofile = SPIFFS.open("/brdc", "w"); + if(!ofile) { + Serial.println("cannot open file /brdc for writing"); + return; + } + file.readBytes(buf, 10); // skip gzip header + char flags = buf[3]; + if(flags&0x07) { + Serial.println("Unsupported flags in gzip header, may or may not cause a problem"); + } + if(flags&0x08) { // skip file name extra header + do { + int res=file.readBytes(buf, 1); + if(res!=1) return; + } while(*buf); + } + if(flags&0x10) { // skip file name extra header + do { + int res=file.readBytes(buf, 1); + if(res!=1) return; + } while(*buf); + } + int opos = 0; + int total = 0; + Serial.println("Decompressing ephemeris data...\n"); + char *obuf =(char *)malloc(32768); + char *ibuf =(char *)malloc(8192); + while(file.available()) { + size_t len = file.readBytes(ibuf, 8192); + size_t inofs = 0; + size_t inlen = len; + while(inofs=32768) { + Serial.printf("... decompressed %d bytes\n", total); + opos=0; + } + } + } + // maybe todo: check crc?!? + Serial.printf("done extracing content (total length: %d)\n", total); + status = SPIFFS.open("/brdc.time","w"); + status.println(nowstr); + status.close(); + snprintf(buf, 16, "Done: %d B ",total); + buf[16]=0; + disp.rdis->drawString(0,5*dispys,buf); + ephstate = EPH_GOOD; + delay(1000); + + free(obuf); + free(ibuf); + free(decomp); + file.close(); + ofile.close(); +} diff --git a/RX_FSK/src/geteph.h b/RX_FSK/src/geteph.h new file mode 100644 index 0000000..eca58f0 --- /dev/null +++ b/RX_FSK/src/geteph.h @@ -0,0 +1,11 @@ +#include + +#ifndef GETEPH_H +#define GETEPH_H +void geteph(); + +enum EPHSTATE { EPH_NOTUSED, EPH_PENDING, EPH_TIMEERR, EPH_ERROR, EPH_EPHERROR, EPH_GOOD }; + +extern uint8_t ephstate; +extern const char *ephtxt[]; +#endif diff --git a/RX_FSK/src/gfxfont.h b/RX_FSK/src/gfxfont.h new file mode 100644 index 0000000..f99a757 --- /dev/null +++ b/RX_FSK/src/gfxfont.h @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-3.0 +// original source: https://github.com/Nkawu/TFT_22_ILI9225 + +// Font structures like Adafruit_GFX (1.1 and later). +// Example fonts are included in 'fonts' directory. +// To use a font in your Arduino sketch, #include the corresponding .h +// file and pass address of GFXfont struct to setFont(). + +#ifndef _GFFFONT_H_ +#define _GFFFONT_H_ + +typedef struct { // Data stored PER GLYPH + uint16_t bitmapOffset; // Pointer into GFXfont->bitmap + uint8_t width, height; // Bitmap dimensions in pixels + uint8_t xAdvance; // Distance to advance cursor (x axis) + int8_t xOffset, yOffset; // Dist from cursor pos to UL corner +} GFXglyph; + +typedef struct { // Data stored for FONT AS A WHOLE: + uint8_t *bitmap; // Glyph bitmaps, concatenated + GFXglyph *glyph; // Glyph array + uint8_t first, last; // ASCII extents + uint8_t yAdvance; // Newline distance (y axis) +} GFXfont; + +#endif // _GFFFONT_H_ diff --git a/RX_FSK/src/json.cpp b/RX_FSK/src/json.cpp new file mode 100644 index 0000000..010ae89 --- /dev/null +++ b/RX_FSK/src/json.cpp @@ -0,0 +1,106 @@ +#include "json.h" +#include "RS41.h" + +extern const char *sondeTypeStrSH[]; +extern const char *dfmSubtypeStrSH[]; + +static char typestr[11]; + +const char *getType(SondeInfo *si) { + if( si->type == STYPE_RS41 ) { + if ( RS41::getSubtype(typestr, 11, si) == 0 ) return typestr; + } else if ( TYPE_IS_DFM(si->type) && si->d.subtype > 0 && si->d.subtype < 16 ) { + const char *t = dfmSubtypeStrSH[si->d.subtype]; + if(t) return t; + sprintf(typestr, "DFMx%X", si->d.subtype); + return typestr; + } + return sondeTypeStrSH[sonde.realType(si)]; +} + +int float2json(char **buf, int *maxlen, const char *fmt, float value) { + if(isnan(value)) return 0; + int n = snprintf(*buf, *maxlen, fmt, value); + if(n>*maxlen) return -1; + *buf += n; *maxlen -= n; + return n; +} + +// To be used by +// - MQTT +// - rdzJSON (for Android app) +// - Web map +int sonde2json(char *buf, int maxlen, SondeInfo *si) +{ + SondeData *s = &(si->d); + int n; + + n = float2json(&buf, &maxlen, "\"lat\": %.5f,", s->lat); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"lon\": %.5f,", s->lon); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"alt\": %.1f,", s->alt); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"vs\": %.1f,", s->vs); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"hs\": %.1f,", s->hs); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"climb\": %.1f,", s->vs); // used by HTML map, to be removed (-> vs) + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"speed\": %.1f,", s->hs); // used by HTML map, to be removed (-> hs) + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"dir\": %.1f,", s->dir); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"temp\": %.1f,", s->temperature ); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"humidity\": %.1f,", s->relativeHumidity); + if(n<0) return -1; + n = float2json(&buf, &maxlen, "\"pressure\": %.1f,", s->pressure); + if(n<0) return -1; + n = snprintf(buf, maxlen, + "\"type\":\"%s\"," + "\"id\": \"%s\"," // TODO: maybe remove in the future, ser is enough, client can calculate APRS id if needed + "\"ser\": \"%s\"," + "\"frame\": %u," // raw frame, from sonde, can be 0. (TODO: add virtual frame # as in sondehub?) + "\"vframe\": %d," + "\"time\": %u," + "\"sats\": %d," + "\"freq\": %.2f," + "\"rssi\": %d," + "\"afc\": %d," + "\"launchKT\": %d," + "\"burstKT\": %d," + "\"countKT\": %d," + "\"crefKT\": %d," + "\"launchsite\": \"%s\"," + "\"res\": %d", + getType(si), + s->id, + s->ser, + s->frame, + s->vframe, + s->time, + s->sats, + si->freq, + si->rssi, + si->afc, + s->launchKT, + s->burstKT, + s->countKT, + s->crefKT, + si->launchsite, + (int)si->rxStat[0] + ); + if(n>=maxlen) return -1; + buf += n; maxlen -= n; + + // add only if available + if(s->batteryVoltage > 0) { + n = snprintf(buf, maxlen, ",\"batt\": %.1f", s->batteryVoltage); + if(n>=maxlen) return -1; + buf += n; maxlen -= n; + } + return 0; +} + + diff --git a/RX_FSK/src/json.h b/RX_FSK/src/json.h new file mode 100644 index 0000000..608e924 --- /dev/null +++ b/RX_FSK/src/json.h @@ -0,0 +1,8 @@ +#ifndef _JSON_H +#define _JSON_H + +#include "Sonde.h" + +int sonde2json(char *buf, int maxlen, SondeInfo *si); + +#endif diff --git a/RX_FSK/src/library.json b/RX_FSK/src/library.json new file mode 100644 index 0000000..7e25074 --- /dev/null +++ b/RX_FSK/src/library.json @@ -0,0 +1,11 @@ +{ + + "dependencies": +[ + { + "owner": "olikraus", + "name": "U8g2", + "version": "^2.28.8" + } +] +} \ No newline at end of file diff --git a/RX_FSK/src/mqtt.cpp b/RX_FSK/src/mqtt.cpp new file mode 100644 index 0000000..de2e701 --- /dev/null +++ b/RX_FSK/src/mqtt.cpp @@ -0,0 +1,165 @@ +#include +#include "mqtt.h" +#include +//#include +#include +#include +#include "RS41.h" +#include "json.h" + +extern const char *version_name; +extern const char *version_id; + +TimerHandle_t mqttReconnectTimer; + +void mqttCallback(char* topic, byte* payload, unsigned int length) { + Serial.print("Message arrived ["); + Serial.print(topic); + Serial.print("] "); + for (int i=0;iip); + this->port = port; + this->username = username; + this->password = password; + this->prefix = prefix; + + Serial.println("[MQTT] pubsub client"); + mqttClient.setServer(ip, port); + snprintf(buffer, 20, "%s%04d", id, (int)random(0, 1000)); + buffer[20] = 0; + Serial.print(buffer); + mqttClient.setClientId(buffer); + if (strlen(password) > 0) { + mqttClient.setCredentials(username, password); + } +} + +void MQTT::connectToMqtt() { + Serial.println("Connecting to MQTT..."); + mqttClient.connect(); +} + +void MQTT::publishUptime() +{ + mqttClient.connect(); // ensure we've got connection + + Serial.println("[MQTT] writing"); + char payload[256]; + // maybe TODO: Use dynamic position if GPS is available? + // rxlat, rxlon only if not empty + snprintf(payload, 256, "{\"uptime\": %lu, \"user\": \"%s\", ", millis(), username); + if( !isnan(sonde.config.rxlat) && !isnan(sonde.config.rxlon) ) { + snprintf(payload, 256, "%s\"rxlat\": %.5f, \"rxlon\": %.5f, ", payload, sonde.config.rxlat, sonde.config.rxlon); + } + snprintf(payload, 256, "%s\"SW\": \"%s\", \"VER\": \"%s\"}", payload, version_name, version_id); + Serial.println(payload); + char topic[128]; + snprintf(topic, 128, "%s%s", this->prefix, "uptime"); + mqttClient.publish(topic, 1, 1, payload); +} + +void MQTT::publishPacket(SondeInfo *si) +{ + SondeData *s = &(si->d); + mqttClient.connect(); // ensure we've got connection + + char payload[1024]; + payload[0] = '{'; + int n = sonde2json(payload+1, 1023, si); + if(n<0) { + // ERROR + Serial.println("publishPacket: sonde2json failed, string too long"); + } + +#if 0 + snprintf(payload, 1024, "{" + "\"active\": %d," + "\"freq\": %.2f," + "\"id\": \"%s\"," + "\"ser\": \"%s\"," + "\"validId\": %d," + "\"launchsite\": \"%s\"," + "\"lat\": %.5f," + "\"lon\": %.5f," + "\"alt\": %.1f," + "\"vs\": %.1f," + "\"hs\": %.1f," + "\"dir\": %.1f," + "\"sats\": %d," + "\"validPos\": %d," + "\"time\": %u," + "\"frame\": %u," + "\"validTime\": %d," + "\"rssi\": %d," + "\"afc\": %d," + "\"rxStat\": \"%s\"," + "\"rxStart\": %u," + "\"norxStart\": %u," + "\"viewStart\": %u," + "\"lastState\": %d," + "\"launchKT\": %d," + "\"burstKT\": %d," + "\"countKT\": %d," + "\"crefKT\": %d", + (int)si->active, + si->freq, + s->id, + s->ser, + (int)s->validID, + si->launchsite, + s->lat, + s->lon, + s->alt, + s->vs, + s->hs, + s->dir, + s->sats, + s->validPos, + s->time, + s->frame, + (int)s->validTime, + si->rssi, + si->afc, + si->rxStat, + si->rxStart, + si->norxStart, + si->viewStart, + si->lastState, + s->launchKT, + s->burstKT, + s->countKT, + s->crefKT + ); + if ( !isnan( s->temperature ) ) { + snprintf(payload, 1024, "%s%s%.1f", payload, ",\"temp\": ", s->temperature ); + } + if ( !isnan( s->relativeHumidity ) ) { + snprintf(payload, 1024, "%s%s%.1f", payload, ",\"humidity\": ", s->relativeHumidity ); + } + if ( !isnan( s->pressure ) ) { + snprintf(payload, 1024, "%s%s%.1f", payload, ",\"pressure\": ", s->pressure ); + } + if ( !isnan( s->batteryVoltage && s->batteryVoltage > 0 ) ) { + snprintf(payload, 1024, "%s%s%.1f", payload, ",\"batt\": ", s->batteryVoltage ); + } + char subtype[11]; + if ( RS41::getSubtype( subtype, 11, si) == 0 ) { + snprintf(payload, 1024, "%s%s%s%s", payload, ",\"subtype\": \"", subtype, "\"" ); + } + snprintf(payload, 1024, "%s%s", payload, "}" ); // terminate payload string +#endif + strcat(payload, "}"); // terminate payload string + + char topic[128]; + snprintf(topic, 128, "%s%s", this->prefix, "packet"); + Serial.print(payload); + mqttClient.publish(topic, 1, 1, payload); +} diff --git a/RX_FSK/src/mqtt.h b/RX_FSK/src/mqtt.h new file mode 100644 index 0000000..0e6eb9b --- /dev/null +++ b/RX_FSK/src/mqtt.h @@ -0,0 +1,29 @@ +#ifndef MQTT_h +#define MQTT_h + +#include +//#include +#include +#include "Sonde.h" +#include "RS41.h" + +class MQTT +{ +public: + WiFiClient mqttWifiClient; + AsyncMqttClient mqttClient; + TimerHandle_t mqttReconnectTimer; + IPAddress ip; + uint16_t port; + const char *username; + const char *password; + const char *prefix; + + void init(const char *host, uint16_t port, const char *id, const char *username, const char *password, const char *prefix); + void publishPacket(SondeInfo *s); + void publishUptime(); +private: + void connectToMqtt(); +}; + +#endif diff --git a/RX_FSK/src/nav_gps_vel.cpp b/RX_FSK/src/nav_gps_vel.cpp new file mode 100644 index 0000000..174ec5b --- /dev/null +++ b/RX_FSK/src/nav_gps_vel.cpp @@ -0,0 +1,1715 @@ +/* SPDX-License-Identifier: GPL-3.0 + * based on https://github.com/rs1729/RS/blob/master/rs92/nav_gps_vel.c + * + Quellen: + - IS-GPS-200H (bis C: ICD-GPS-200): + http://www.gps.gov/technical/icwg/ + - Borre: http://kom.aau.dk/~borre + - Essential GNSS Project (hier und da etwas unklar) +*/ +#include +#include +#include +#include +#include + +#include "nav_gps_vel.h" + +#ifndef PI +#define PI (3.1415926535897932384626433832795) +#endif + +#define RELATIVISTIC_CLOCK_CORRECTION (-4.442807633e-10) // combined constant defined in IS-GPS-200 [s]/[sqrt(m)] +#define GRAVITY_CONSTANT (3.986005e14) // gravity constant defined on IS-GPS-200 [m^3/s^2] +#define EARTH_ROTATION_RATE (7.2921151467e-05) // IS-GPS-200 [rad/s] +#define SECONDS_IN_WEEK (604800.0) // [s] +#define LIGHTSPEED (299792458.0) // light speed constant defined in IS-GPS-200 [m/s] + +#define RANGE_ESTIMATE (0.072) // approx. GPS-Sat range 0.072s*299792458m/s=21585057m +#define RANGERATE_ESTIMATE (0.000) // + +#define EARTH_a (6378137.0) +#define EARTH_b (6356752.31424518) +#define EARTH_a2_b2 (EARTH_a*EARTH_a - EARTH_b*EARTH_b) + +/* ---------------------------------------------------------------------------------------------------- */ + + +void ecef2elli(double X, double Y, double Z, double *lat, double *lon, double *alt) { + double ea2 = EARTH_a2_b2 / (EARTH_a*EARTH_a), + eb2 = EARTH_a2_b2 / (EARTH_b*EARTH_b); + double phi, lam, R, p, t; + double sint, cost; + + lam = atan2( Y , X ); + + p = sqrt( X*X + Y*Y ); + t = atan2( Z*EARTH_a , p*EARTH_b ); + + sint = sin(t); + cost = cos(t); + + phi = atan2( Z + eb2 * EARTH_b * sint*sint*sint , + p - ea2 * EARTH_a * cost*cost*cost ); + + R = EARTH_a / sqrt( 1 - ea2*sin(phi)*sin(phi) ); + *alt = p / cos(phi) - R; + + *lat = phi*180.0/PI; + *lon = lam*180.0/PI; +} + + +double dist(double X1, double Y1, double Z1, double X2, double Y2, double Z2) { + return sqrt( (X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1) ); +} + + +void rotZ(double x1, double y1, double z1, double angle, double *x2, double *y2, double *z2) { + double cosa = cos(angle); + double sina = sin(angle); + *x2 = cosa * x1 + sina * y1; + *y2 = -sina * x1 + cosa * y1; + *z2 = z1; +} + + +/* ---------------------------------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------------------------------------- */ + + +static EPHEM_t *te; + +#define fgets(buffer, siz, file) file.read((uint8_t *)buffer, siz) +#define fread(buffer, siz, els, file) (file.read((uint8_t *)buffer, (siz)*(els))/siz) +#define fgetc(file) (char)file.read() + +int readDbl(File *fp, double *dbl) { + uint8_t buf[20]; + int l = fp->read(buf, 19); + if(l!=19) return -1; + if (buf[15] == 'D') buf[15] = 'E'; + buf[19] = 0; + sscanf((char *)buf, "%lf", dbl); + return 0; +} + +EPHEM_t *read_RNXpephs(const char *file) { + int l, i; + char buf[64], str[20]; + unsigned ui; + double dbl; + int c; + EPHEM_t ephem = {}; + + File fp = SPIFFS.open(file, "r"); + if(!fp) { Serial.printf("Error opening %s\n", file); } + + String line; + do { // header-Zeilen: 80 Zeichen + line = fp.readStringUntil('\n'); + //pbuf = fgets(buffer, 84, fp); // max 82-1 Zeichen + //buffer[82] = '\0'; + Serial.printf("Skipping header: %s\n", line.c_str()); + } while ( fp.available() && !strstr((const char *)line.c_str(), "END OF HEADER") ); + if (!fp.available()) return NULL; + + if(te) free(te); + te = (EPHEM_t *)calloc( 34, sizeof(ephem) ); // calloc( 1, sizeof(ephem) ); + if (te == NULL) return NULL; + + //int n = 0; + + + while (true) { // brdc/hour-rinex sollte nur Daten von einem Tag enthalten + + //memset(&ephem, 0, sizeof(ephem)); + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; sscanf(buf, "%d", &ui); + ephem.prn = ui; + + for (i = 0; i < 16; i++) ephem.epoch[i] = '0'; + ephem.epoch[16] = '\0'; + + l = fread(buf, 19, 1, fp); if (l != 1) break; buf[19] = 0; + + for (i = 0; i < 6; i++) { + c = buf[3*i ]; if (c == ' ') c = '0'; str[2*i ] = c; + c = buf[3*i+1]; if (c == ' ') c = '0'; str[2*i+1] = c; + } + str[12] = buf[17]; + str[13] = buf[18]; + str[14] = '\0'; + + strncpy(ephem.epoch , "20", 2); // vorausgesetzt 21.Jhd; Datum steht auch im Header + strncpy(ephem.epoch+2, str, 15); + ephem.epoch[16] = '\0'; + + if(readDbl(&fp, &dbl)<0) break; ephem.af0 = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.af1 = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.af2 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af0 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af1 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af2 = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; //ephem.iode = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.crs = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.delta_n = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.M0 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iode = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.crs = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.delta_n = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.M0 = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; ephem.cuc = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.e = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.cus = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.sqrta = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cuc = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.e = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cus = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.sqrta = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; ephem.toe = dbl; ephem.toc = ephem.toe; + if(readDbl(&fp, &dbl)<0) break; ephem.cic = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.Omega0 = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.cis = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.toe = dbl; + // ephem.toc = ephem.toe; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cic = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.Omega0 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cis = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; ephem.i0 = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.crc = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.w = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.OmegaDot = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.i0 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.crc = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.w = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.OmegaDot = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; ephem.idot = dbl; + if(readDbl(&fp, &dbl)<0) break; //ephem.codeL2 = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.gpsweek = (int)dbl; + if(readDbl(&fp, &dbl)<0) break; //ephem.iodc = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.idot = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.codeL2 = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.gpsweek = (int)dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iodc = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; //ephem.sva = dbl; + if(readDbl(&fp, &dbl)<0) break; ephem.health = (uint8_t)(dbl+0.1); + if(readDbl(&fp, &dbl)<0) break; ephem.tgd = dbl; + if(readDbl(&fp, &dbl)<0) break; //ephem.iodc = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.sva = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.health = (uint8_t)(dbl+0.1); + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.tgd = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iodc = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } + + l = fread(buf, 3, 1, fp); if (l != 1) break; buf[ 3] = 0; + if(readDbl(&fp, &dbl)<0) break; //ephem.ttom = dbl; + //l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.ttom = dbl; + String l = fp.readStringUntil('\n'); + /* // die letzten beiden Felder (spare) sind manchmal leer (statt 0.00); manchmal fehlt sogar das drittletzte Feld + l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.fit = dbl; + l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.spare1 = dbl; + l = fread(buf, 19, 1, fp); if (l != 1) break; if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.spare2 = dbl; + while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; } */ + + ephem.week = 1; // ephem.gpsweek + //Serial.printf("Reading ephem for prn %d\n", ui); + if(ui<33) { +#if 0 + // no need to do it the difficult way, most recent data is at end of file :-) + double tdiff; + if(te[ui].prn!=ui) { + tdiff = WEEKSEC; + } else { + tdiff = now - te[ui].toe; + if(tdiff>WEEKSEC/2) tdiff -= WEEKSEC; + if(tdiff<-WEEKSEC/2) tdiff += WEEKSEC; + } + double td = now - ephem.toe; + if(td>WEEKSEC/2) td -= WEEKSEC; + if(td<-WEEKSEC/2) td += WEEKSEC; +#endif + te[ui] = ephem; + } else { + Serial.printf("bad prn: %d\n", ui); + } + //if (pbuf == NULL) break; + if(!fp.available()) break; + } + te[33].prn=0; + return te; +} + +/* ---------------------------------------------------------------------------------------------------- */ +// +// Satellite Position +// + +void GPS_SatelliteClockCorrection( + const unsigned short transmission_gpsweek, // GPS week when signal was transmit (0-1024+) [weeks] + const double transmission_gpstow, // GPS time of week when signal was transmit [s] + const unsigned short ephem_week, // ephemeris: GPS week (0-1024+) [weeks] + const double toe, // ephemeris: time of week [s] + const double toc, // ephemeris: clock reference time of week [s] + const double af0, // ephemeris: polynomial clock correction coefficient [s], + const double af1, // ephemeris: polynomial clock correction coefficient [s/s], + const double af2, // ephemeris: polynomial clock correction coefficient [s/s^2] + const double ecc, // ephemeris: eccentricity of satellite orbit [] + const double sqrta, // ephemeris: square root of the semi-major axis of orbit [m^(1/2)] + const double delta_n, // ephemeris: mean motion difference from computed value [rad] + const double m0, // ephemeris: mean anomaly at reference time [rad] + const double tgd, // ephemeris: group delay differential between L1 and L2 [s] + double* clock_correction ) // ephemeris: satellite clock correction [m] +{ + int j; + + double tot; // time of transmission (including gps week) [s] + double tk; // time from ephemeris reference epoch [s] + double tc; // time from clock reference epoch [s] + double d_tr; // relativistic correction term [s] + double d_tsv; // SV PRN code phase time offset [s] + double a; // semi-major axis of orbit [m] + double n; // corrected mean motion [rad/s] + double M; // mean anomaly, [rad] + double E; // eccentric anomaly [rad] + + // compute the times from the reference epochs + tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow; + tk = tot - (ephem_week*SECONDS_IN_WEEK + toe); + tc = tot - (ephem_week*SECONDS_IN_WEEK + toc); + + // compute the corrected mean motion term + a = sqrta*sqrta; + n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); // mean motion + n += delta_n; // corrected mean motion + + // Kepler-Gleichung M = E - e sin(E) + M = m0 + n*tk; // mean anomaly + E = M; // f(E) = M + e sin(E) hat Fixpunkt fuer e < 1, + for( j = 0; j < 7; j++ ) { // da |f'(E)|=|e cos(E)|<1. + E = M + ecc * sin(E); // waehle Startwert E_1 = M, E_{k+1} = f(E_k) + } // konvergiert langsam gegen E_0 = f(E_0) + + // relativistic correction + d_tr = RELATIVISTIC_CLOCK_CORRECTION * ecc * sqrta * sin(E); // [s] + d_tr *= LIGHTSPEED; + + // clock correction + d_tsv = af0 + af1*tc + af2*tc*tc; // [s] + + // L1 only + d_tsv -= tgd; // [s] + + // clock correction + *clock_correction = d_tsv*LIGHTSPEED + d_tr; // [m] + +} + +void GPS_ComputeSatellitePosition( + const unsigned short transmission_gpsweek, // GPS week when signal was transmit (0-1024+) [weeks] + const double transmission_gpstow, // GPS time of week when signal was transmit [s] + const unsigned short ephem_week, // ephemeris: GPS week (0-1024+) [weeks] + const double toe, // ephemeris: time of week [s] + const double m0, // ephemeris: mean anomaly at reference time [rad] + const double delta_n, // ephemeris: mean motion difference from computed value [rad] + const double ecc, // ephemeris: eccentricity [] + const double sqrta, // ephemeris: square root of the semi-major axis [m^(1/2)] + const double omega0, // ephemeris: longitude of ascending node of orbit plane at weekly epoch [rad] + const double i0, // ephemeris: inclination angle at reference time [rad] + const double w, // ephemeris: argument of perigee [rad] + const double omegadot, // ephemeris: rate of right ascension [rad/s] + const double idot, // ephemeris: rate of inclination angle [rad/s] + const double cuc, // ephemeris: cos harmonic correction term to the argument of latitude [rad] + const double cus, // ephemeris: sin harmonic correction term to the argument of latitude [rad] + const double crc, // ephemeris: cos harmonic correction term to the orbit radius [m] + const double crs, // ephemeris: sin harmonic correction term to the orbit radius [m] + const double cic, // ephemeris: cos harmonic correction term to the angle of inclination [rad] + const double cis, // ephemeris: sin harmonic correction term to the angle of inclination [rad] + double* x, // satellite x [m] + double* y, // satellite y [m] + double* z ) // satellite z [m] +{ + int j; + + double tot; // time of transmission (including gps week) [s] + double tk; // time from ephemeris reference epoch [s] + double a; // semi-major axis of orbit [m] + double n; // corrected mean motion [rad/s] + double M; // mean anomaly, [rad] + double E; // eccentric anomaly [rad] + double v; // true anomaly [rad] + double u; // argument of latitude, corrected [rad] + double r; // radius in the orbital plane [m] + double i; // orbital inclination [rad] + double cos2u; // cos(2*u) [] + double sin2u; // sin(2*u) [] + double d_u; // argument of latitude correction [rad] + double d_r; // radius correction [m] + double d_i; // inclination correction [rad] + double x_op; // x position in the orbital plane [m] + double y_op; // y position in the orbital plane [m] + double omegak; // corrected longitude of the ascending node [rad] + double cos_omegak; // cos(omegak) + double sin_omegak; // sin(omegak) + double cosu; // cos(u) + double sinu; // sin(u) + double cosi; // cos(i) + double sini; // sin(i) + double cosE; // cos(E) + double sinE; // sin(E) + + + // compute the times from the reference epochs + tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow; + tk = tot - (ephem_week*SECONDS_IN_WEEK + toe); + + // compute the corrected mean motion term + a = sqrta*sqrta; + n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); // computed mean motion + n += delta_n; // corrected mean motion + + // Kepler-Gleichung M = E - e sin(E) + M = m0 + n*tk; // mean anomaly + E = M; // f(E) = M + e sin(E) hat Fixpunkt fuer e < 1, + for( j = 0; j < 7; j++ ) { // da |f'(E)|=|e cos(E)|<1. + E = M + ecc * sin(E); // waehle Startwert E_1 = M, E_{k+1} = f(E_k) + } // konvergiert langsam gegen E_0 = f(E_0) + + cosE = cos(E); + sinE = sin(E); + + // true anomaly + v = atan2( (sqrt(1.0 - ecc*ecc)*sinE), (cosE - ecc) ); + // argument of latitude + u = v + w; + // radius in orbital plane + r = a * (1.0 - ecc * cos(E)); + // orbital inclination + i = i0; + + // second harmonic perturbations + // + cos2u = cos(2.0*u); + sin2u = sin(2.0*u); + // argument of latitude correction + d_u = cuc * cos2u + cus * sin2u; + // radius correction + d_r = crc * cos2u + crs * sin2u; + // correction to inclination + d_i = cic * cos2u + cis * sin2u; + + // corrected argument of latitude + u += d_u; + // corrected radius + r += d_r; + // corrected inclination + i += d_i + idot * tk; + + // positions in orbital plane + cosu = cos(u); + sinu = sin(u); + x_op = r * cosu; + y_op = r * sinu; + + + omegak = omega0 + omegadot*tk - EARTH_ROTATION_RATE*(tk + toe); + // fuer Bestimmung der Satellitenposition in ECEF, range=0; + // fuer GPS-Loesung (Sats in ECI) Erdrotation hinzuziehen: + // rotZ(EARTH_ROTATION_RATE*0.072), 0.072s*299792458m/s=21585057m + + // compute the WGS84 ECEF coordinates, + // vector r with components x & y is now rotated using, R3(-omegak)*R1(-i) + cos_omegak = cos(omegak); + sin_omegak = sin(omegak); + cosi = cos(i); + sini = sin(i); + + *x = x_op * cos_omegak - y_op * sin_omegak * cosi; + *y = x_op * sin_omegak + y_op * cos_omegak * cosi; + *z = y_op * sini; + +} + +void GPS_SatellitePosition_Ephem( + const unsigned short gpsweek, // gps week of signal transmission (0-1024+) [week] + const double gpstow, // time of week of signal transmission (gpstow-psr/c) [s] + EPHEM_t ephem, + double* clock_correction, // clock correction for this satellite for this epoch [m] + double* satX, // satellite X position WGS84 ECEF [m] + double* satY, // satellite Y position WGS84 ECEF [m] + double* satZ // satellite Z position WGS84 ECEF [m] + ) +{ + double tow; // user time of week adjusted with the clock corrections [s] + double x; // sat X position [m] + double y; // sat Y position [m] + double z; // sat Z position [m] + unsigned short week; // user week adjusted with the clock correction if needed [week] + + + x = y = z = 0.0; + + GPS_SatelliteClockCorrection( gpsweek, gpstow, + ephem.week, ephem.toe, ephem.toc, ephem.af0, + ephem.af1, ephem.af2, ephem.e, ephem.sqrta, + ephem.delta_n, ephem.M0, ephem.tgd, clock_correction ); + + + // adjust for week rollover + week = gpsweek; + tow = gpstow + (*clock_correction)/LIGHTSPEED; + if ( tow < 0.0 ) { + tow += SECONDS_IN_WEEK; + week--; + } + if ( tow > SECONDS_IN_WEEK ) { + tow -= SECONDS_IN_WEEK; + week++; + } + + //range = 0.072s*299792458m/s=21585057m + GPS_ComputeSatellitePosition( week, tow, + ephem.week, ephem.toe, ephem.M0, ephem.delta_n, ephem.e, ephem.sqrta, + ephem.Omega0, ephem.i0, ephem.w, ephem.OmegaDot, ephem.idot, + ephem.cuc, ephem.cus, ephem.crc, ephem.crs, ephem.cic, ephem.cis, + &x, &y, &z ); + + *satX = x; + *satY = y; + *satZ = z; + +} + +/* ---------------------------------------------------------------------------------------------------- */ + + +int NAV_ClosedFormSolution_FromPseudorange( + SAT_t sats[4], // input: satellite position and pseudorange + double* latitude, // output: ellipsoid latitude [rad] + double* longitude, // ellipsoid longitude [rad] + double* height, // ellipsoid height [m] + double* rx_clock_bias, // receiver clock bias [m] + double pos_ecef[3] ) // ECEF coordinates [m] +{ + + double p1 = sats[0].pseudorange + sats[0].clock_corr; // pseudorange measurement + clock correction [m] + double p2 = sats[1].pseudorange + sats[1].clock_corr; + double p3 = sats[2].pseudorange + sats[2].clock_corr; + double p4 = sats[3].pseudorange + sats[3].clock_corr; + + double x1, y1, z1; // Sat1 ECEF + double x2, y2, z2; // Sat2 ECEF + double x3, y3, z3; // Sat3 ECEF + double x4, y4, z4; // Sat4 ECEF + + // Erdrotation ECEF-ECI, 0.070s*299792458m/s=20985472m, 0.072s*299792458m/s=21585057m + rotZ(sats[0].X, sats[0].Y, sats[0].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x1, &y1, &z1); + rotZ(sats[1].X, sats[1].Y, sats[1].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x2, &y2, &z2); + rotZ(sats[2].X, sats[2].Y, sats[2].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x3, &y3, &z3); + rotZ(sats[3].X, sats[3].Y, sats[3].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x4, &y4, &z4); + + + double x12, x13, x14; // 'xij' = 'xi' - 'xj' [m] + double y12, y13, y14; + double z12, z13, z14; + double p21, p31, p41; // 'pij' = 'pi' - 'pj' [m] + + double k1, k2, k3; // coefficients + double c1, c2, c3; + double f1, f2, f3; + double m1, m2, m3; + + double d1; // clock bias, solution 1 [m] + double d2; // clock bias, solution 2 [m] + double detA; // determinant of A + double tmp1; + double tmp2; + double tmp3; + + double A[3][3]; + double D[3][3]; // D is A^-1 * detA + + typedef struct { + double x; + double y; + double z; + } struct_SOLN; + + struct_SOLN s1; + struct_SOLN s2; + + struct_SOLN stmp; + double dtmp; + double x0, y0, z0; + double latS, lonS, altS, + lat1, lon1, alt1, + lat2, lon2, alt2; + double d2_1, d2_2; + + + x12 = x1 - x2; + x13 = x1 - x3; + x14 = x1 - x4; + + y12 = y1 - y2; + y13 = y1 - y3; + y14 = y1 - y4; + + z12 = z1 - z2; + z13 = z1 - z3; + z14 = z1 - z4; + + p21 = p2 - p1; + p31 = p3 - p1; + p41 = p4 - p1; + + k1 = x12*x12 + y12*y12 + z12*z12 - p21*p21; + k2 = x13*x13 + y13*y13 + z13*z13 - p31*p31; + k3 = x14*x14 + y14*y14 + z14*z14 - p41*p41; + + A[0][0] = 2.0*x12; + A[1][0] = 2.0*x13; + A[2][0] = 2.0*x14; + + A[0][1] = 2.0*y12; + A[1][1] = 2.0*y13; + A[2][1] = 2.0*y14; + + A[0][2] = 2.0*z12; + A[1][2] = 2.0*z13; + A[2][2] = 2.0*z14; + + tmp1 = A[1][1]*A[2][2] - A[2][1]*A[1][2]; + tmp2 = A[1][0]*A[2][2] - A[2][0]*A[1][2]; + tmp3 = A[1][0]*A[2][1] - A[2][0]*A[1][1]; + + detA = A[0][0]*tmp1 - A[0][1]*tmp2 + A[0][2]*tmp3; + + D[0][0] = tmp1; + D[1][0] = -tmp2; + D[2][0] = tmp3; + + D[0][1] = -A[0][1]*A[2][2] + A[2][1]*A[0][2]; + D[1][1] = A[0][0]*A[2][2] - A[2][0]*A[0][2]; + D[2][1] = -A[0][0]*A[2][1] + A[2][0]*A[0][1]; + + D[0][2] = A[0][1]*A[1][2] - A[1][1]*A[0][2]; + D[1][2] = -A[0][0]*A[1][2] + A[1][0]*A[0][2]; + D[2][2] = A[0][0]*A[1][1] - A[1][0]*A[0][1]; + + c1 = (D[0][0]*p21 + D[0][1]*p31 + D[0][2]*p41) * 2.0 / detA; + c2 = (D[1][0]*p21 + D[1][1]*p31 + D[1][2]*p41) * 2.0 / detA; + c3 = (D[2][0]*p21 + D[2][1]*p31 + D[2][2]*p41) * 2.0 / detA; + + f1 = (D[0][0]*k1 + D[0][1]*k2 + D[0][2]*k3) / detA; + f2 = (D[1][0]*k1 + D[1][1]*k2 + D[1][2]*k3) / detA; + f3 = (D[2][0]*k1 + D[2][1]*k2 + D[2][2]*k3) / detA; + + m1 = c1*c1 + c2*c2 + c3*c3 - 1.0; + m2 = -2.0*( c1*f1 + c2*f2 + c3*f3 ); + m3 = f1*f1 + f2*f2 + f3*f3; + + tmp1 = m2*m2 - 4.0*m1*m3; + if ( tmp1 < 0 ) { // not good, there is no solution + return -1; //FALSE + } + + d1 = ( -m2 - sqrt( tmp1 ) ) * 0.5 / m1; // +-Reihenfolge vertauscht + d2 = ( -m2 + sqrt( tmp1 ) ) * 0.5 / m1; + + // two solutions + s1.x = c1*d1 - f1 + x1; + s1.y = c2*d1 - f2 + y1; + s1.z = c3*d1 - f3 + z1; + + s2.x = c1*d2 - f1 + x1; + s2.y = c2*d2 - f2 + y1; + s2.z = c3*d2 - f3 + z1; + + tmp1 = sqrt( s1.x*s1.x + s1.y*s1.y + s1.z*s1.z ); + tmp2 = sqrt( s2.x*s2.x + s2.y*s2.y + s2.z*s2.z ); + + // choose the correct solution based + // on whichever solution is closest to + // the Earth's surface + tmp1 = fabs( tmp1 - 6371000.0 ); + tmp2 = fabs( tmp2 - 6371000.0 ); + + // nur (tmp2 < tmp1) geht manchmal schief + if ( tmp2 < tmp1 && tmp1 >= 60000 ) { // swap solutions + stmp = s1; s1 = s2; s2 = stmp; // s1 = s2; + dtmp = d1; d1 = d2; d2 = dtmp; // d1 = d2; + } + else if ( tmp2 < 60000 ) { // interessant wenn tmp1 50000.0 ) { + return -2; + } + + return 0; +} + + +/* ---------------------------------------------------------------------------------------------------- */ + + +int trace_invert(double mat[4][4], double trinv[4]) // trace-invert +/* selected elements from 4x4 matrix inversion */ +{ + // Find all NECESSARY 2x2 subdeterminants + double Det2_12_01 = mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]; + double Det2_12_02 = mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]; + //double Det2_12_03 = mat[1][0]*mat[2][3] - mat[1][3]*mat[2][0]; + double Det2_12_12 = mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1]; + //double Det2_12_13 = mat[1][1]*mat[2][3] - mat[1][3]*mat[2][1]; + //double Det2_12_23 = mat[1][2]*mat[2][3] - mat[1][3]*mat[2][2]; + double Det2_13_01 = mat[1][0] * mat[3][1] - mat[1][1] * mat[3][0]; + //double Det2_13_02 = mat[1][0]*mat[3][2] - mat[1][2]*mat[3][0]; + double Det2_13_03 = mat[1][0] * mat[3][3] - mat[1][3] * mat[3][0]; + //double Det2_13_12 = mat[1][1]*mat[3][2] - mat[1][2]*mat[3][1]; + double Det2_13_13 = mat[1][1] * mat[3][3] - mat[1][3] * mat[3][1]; + //double Det2_13_23 = mat[1][2]*mat[3][3] - mat[1][3]*mat[3][2]; + double Det2_23_01 = mat[2][0] * mat[3][1] - mat[2][1] * mat[3][0]; + double Det2_23_02 = mat[2][0] * mat[3][2] - mat[2][2] * mat[3][0]; + double Det2_23_03 = mat[2][0] * mat[3][3] - mat[2][3] * mat[3][0]; + double Det2_23_12 = mat[2][1] * mat[3][2] - mat[2][2] * mat[3][1]; + double Det2_23_13 = mat[2][1] * mat[3][3] - mat[2][3] * mat[3][1]; + double Det2_23_23 = mat[2][2] * mat[3][3] - mat[2][3] * mat[3][2]; + + // Find all NECESSARY 3x3 subdeterminants + double Det3_012_012 = mat[0][0] * Det2_12_12 - mat[0][1] * Det2_12_02 + mat[0][2] * Det2_12_01; + //double Det3_012_013 = mat[0][0]*Det2_12_13 - mat[0][1]*Det2_12_03 + mat[0][3]*Det2_12_01; + //double Det3_012_023 = mat[0][0]*Det2_12_23 - mat[0][2]*Det2_12_03 + mat[0][3]*Det2_12_02; + //double Det3_012_123 = mat[0][1]*Det2_12_23 - mat[0][2]*Det2_12_13 + mat[0][3]*Det2_12_12; + //double Det3_013_012 = mat[0][0]*Det2_13_12 - mat[0][1]*Det2_13_02 + mat[0][2]*Det2_13_01; + double Det3_013_013 = mat[0][0] * Det2_13_13 - mat[0][1] * Det2_13_03 + mat[0][3] * Det2_13_01; + //double Det3_013_023 = mat[0][0]*Det2_13_23 - mat[0][2]*Det2_13_03 + mat[0][3]*Det2_13_02; + //double Det3_013_123 = mat[0][1]*Det2_13_23 - mat[0][2]*Det2_13_13 + mat[0][3]*Det2_13_12; + //double Det3_023_012 = mat[0][0]*Det2_23_12 - mat[0][1]*Det2_23_02 + mat[0][2]*Det2_23_01; + //double Det3_023_013 = mat[0][0]*Det2_23_13 - mat[0][1]*Det2_23_03 + mat[0][3]*Det2_23_01; + double Det3_023_023 = mat[0][0] * Det2_23_23 - mat[0][2] * Det2_23_03 + mat[0][3] * Det2_23_02; + //double Det3_023_123 = mat[0][1]*Det2_23_23 - mat[0][2]*Det2_23_13 + mat[0][3]*Det2_23_12; + double Det3_123_012 = mat[1][0] * Det2_23_12 - mat[1][1] * Det2_23_02 + mat[1][2] * Det2_23_01; + double Det3_123_013 = mat[1][0] * Det2_23_13 - mat[1][1] * Det2_23_03 + mat[1][3] * Det2_23_01; + double Det3_123_023 = mat[1][0] * Det2_23_23 - mat[1][2] * Det2_23_03 + mat[1][3] * Det2_23_02; + double Det3_123_123 = mat[1][1] * Det2_23_23 - mat[1][2] * Det2_23_13 + mat[1][3] * Det2_23_12; + + // Find the 4x4 determinant + static double det; + det = mat[0][0] * Det3_123_123 + - mat[0][1] * Det3_123_023 + + mat[0][2] * Det3_123_013 + - mat[0][3] * Det3_123_012; + + // Very small determinants probably reflect floating-point fuzz near zero + if (fabs(det) < 0.0001) + return -1; + + //inv[0][0] = Det3_123_123 / det; + //inv[0][1] = -Det3_023_123 / det; + //inv[0][2] = Det3_013_123 / det; + //inv[0][3] = -Det3_012_123 / det; + + //inv[1][0] = -Det3_123_023 / det; + //inv[1][1] = Det3_023_023 / det; + //inv[1][2] = -Det3_013_023 / det; + //inv[1][3] = Det3_012_023 / det; + + //inv[2][0] = Det3_123_013 / det; + //inv[2][1] = -Det3_023_013 / det; + //inv[2][2] = Det3_013_013 / det; + //inv[2][3] = -Det3_012_013 / det; + + //inv[3][0] = -Det3_123_012 / det; + //inv[3][1] = Det3_023_012 / det; + //inv[3][2] = -Det3_013_012 / det; + //inv[3][3] = Det3_012_012 / det; + + trinv[0] = Det3_123_123 / det; + + trinv[1] = Det3_023_023 / det; + trinv[2] = Det3_013_013 / det; + trinv[3] = Det3_012_012 / det; + + return 0; +} + +int calc_DOPn(int n, SAT_t satss[], double pos_ecef[3], double DOP[4]) { + int i, j, k; + double norm[n], satpos[n][3]; + double SATS[n][4], AtA[4][4]; + + for (i = 0; i < n; i++) { + satpos[i][0] = satss[i].X-pos_ecef[0]; + satpos[i][1] = satss[i].Y-pos_ecef[1]; + satpos[i][2] = satss[i].Z-pos_ecef[2]; + } + + + for (i = 0; i < n; i++) { + norm[i] = sqrt( satpos[i][0]*satpos[i][0] + satpos[i][1]*satpos[i][1] + satpos[i][2]*satpos[i][2] ); + for (j = 0; j < 3; j++) { + SATS[i][j] = satpos[i][j] / norm[i]; + } + SATS[i][3] = 1; + } + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + AtA[i][j] = 0.0; + for (k = 0; k < n; k++) { + AtA[i][j] += SATS[k][i]*SATS[k][j]; + } + } + } + + return trace_invert(AtA, DOP); +} + +/* ---------------------------------------------------------------------------------------------------- */ + +int rotE(SAT_t sat, double *x, double *y, double *z) { + // Erdrotation ECEF-ECI, 0.070s*299792458m/s=20985472m, 0.072s*299792458m/s=21585057m + double range = sat.PR/LIGHTSPEED; + if (range < 19e6 || range > 30e6) range = 21e6; + rotZ(sat.X, sat.Y, sat.Z, EARTH_ROTATION_RATE*(range/LIGHTSPEED), x, y, z); + return 0; +} + + +double lorentz(double a[4], double b[4]) { + return a[0]*b[0] + a[1]*b[1] +a[2]*b[2] - a[3]*b[3]; +} + +int matrix_invert(double mat[4][4], double inv[4][4]) +{ + // 2x2 subdeterminants + double Det2_12_01 = mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]; + double Det2_12_02 = mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]; + double Det2_12_03 = mat[1][0] * mat[2][3] - mat[1][3] * mat[2][0]; + double Det2_12_12 = mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1]; + double Det2_12_13 = mat[1][1] * mat[2][3] - mat[1][3] * mat[2][1]; + double Det2_12_23 = mat[1][2] * mat[2][3] - mat[1][3] * mat[2][2]; + double Det2_13_01 = mat[1][0] * mat[3][1] - mat[1][1] * mat[3][0]; + double Det2_13_02 = mat[1][0] * mat[3][2] - mat[1][2] * mat[3][0]; + double Det2_13_03 = mat[1][0] * mat[3][3] - mat[1][3] * mat[3][0]; + double Det2_13_12 = mat[1][1] * mat[3][2] - mat[1][2] * mat[3][1]; + double Det2_13_13 = mat[1][1] * mat[3][3] - mat[1][3] * mat[3][1]; + double Det2_13_23 = mat[1][2] * mat[3][3] - mat[1][3] * mat[3][2]; + double Det2_23_01 = mat[2][0] * mat[3][1] - mat[2][1] * mat[3][0]; + double Det2_23_02 = mat[2][0] * mat[3][2] - mat[2][2] * mat[3][0]; + double Det2_23_03 = mat[2][0] * mat[3][3] - mat[2][3] * mat[3][0]; + double Det2_23_12 = mat[2][1] * mat[3][2] - mat[2][2] * mat[3][1]; + double Det2_23_13 = mat[2][1] * mat[3][3] - mat[2][3] * mat[3][1]; + double Det2_23_23 = mat[2][2] * mat[3][3] - mat[2][3] * mat[3][2]; + + // 3x3 subdeterminants + double Det3_012_012 = mat[0][0] * Det2_12_12 - mat[0][1] * Det2_12_02 + mat[0][2] * Det2_12_01; + double Det3_012_013 = mat[0][0] * Det2_12_13 - mat[0][1] * Det2_12_03 + mat[0][3] * Det2_12_01; + double Det3_012_023 = mat[0][0] * Det2_12_23 - mat[0][2] * Det2_12_03 + mat[0][3] * Det2_12_02; + double Det3_012_123 = mat[0][1] * Det2_12_23 - mat[0][2] * Det2_12_13 + mat[0][3] * Det2_12_12; + double Det3_013_012 = mat[0][0] * Det2_13_12 - mat[0][1] * Det2_13_02 + mat[0][2] * Det2_13_01; + double Det3_013_013 = mat[0][0] * Det2_13_13 - mat[0][1] * Det2_13_03 + mat[0][3] * Det2_13_01; + double Det3_013_023 = mat[0][0] * Det2_13_23 - mat[0][2] * Det2_13_03 + mat[0][3] * Det2_13_02; + double Det3_013_123 = mat[0][1] * Det2_13_23 - mat[0][2] * Det2_13_13 + mat[0][3] * Det2_13_12; + double Det3_023_012 = mat[0][0] * Det2_23_12 - mat[0][1] * Det2_23_02 + mat[0][2] * Det2_23_01; + double Det3_023_013 = mat[0][0] * Det2_23_13 - mat[0][1] * Det2_23_03 + mat[0][3] * Det2_23_01; + double Det3_023_023 = mat[0][0] * Det2_23_23 - mat[0][2] * Det2_23_03 + mat[0][3] * Det2_23_02; + double Det3_023_123 = mat[0][1] * Det2_23_23 - mat[0][2] * Det2_23_13 + mat[0][3] * Det2_23_12; + double Det3_123_012 = mat[1][0] * Det2_23_12 - mat[1][1] * Det2_23_02 + mat[1][2] * Det2_23_01; + double Det3_123_013 = mat[1][0] * Det2_23_13 - mat[1][1] * Det2_23_03 + mat[1][3] * Det2_23_01; + double Det3_123_023 = mat[1][0] * Det2_23_23 - mat[1][2] * Det2_23_03 + mat[1][3] * Det2_23_02; + double Det3_123_123 = mat[1][1] * Det2_23_23 - mat[1][2] * Det2_23_13 + mat[1][3] * Det2_23_12; + + // 4x4 determinant + static double det; + det = mat[0][0] * Det3_123_123 + - mat[0][1] * Det3_123_023 + + mat[0][2] * Det3_123_013 + - mat[0][3] * Det3_123_012; + + // Very small determinants probably reflect floating-point fuzz near zero + if (fabs(det) < 0.0001) + return -1; + + inv[0][0] = Det3_123_123 / det; + inv[0][1] = -Det3_023_123 / det; + inv[0][2] = Det3_013_123 / det; + inv[0][3] = -Det3_012_123 / det; + + inv[1][0] = -Det3_123_023 / det; + inv[1][1] = Det3_023_023 / det; + inv[1][2] = -Det3_013_023 / det; + inv[1][3] = Det3_012_023 / det; + + inv[2][0] = Det3_123_013 / det; + inv[2][1] = -Det3_023_013 / det; + inv[2][2] = Det3_013_013 / det; + inv[2][3] = -Det3_012_013 / det; + + inv[3][0] = -Det3_123_012 / det; + inv[3][1] = Det3_023_012 / det; + inv[3][2] = -Det3_013_012 / det; + inv[3][3] = Det3_012_012 / det; + + return 0; +} + +int NAV_bancroft1(int N, SAT_t sats[], double pos_ecef[3], double *cc) { + + int i, j, k; + double B[N][4], BtB[4][4], BBinv[4][4], BBB[4][N]; + double a[N], Be[4], Ba[4]; + + double q0, q1, q2, p, q, sq, x1, x2; + double Lsg1[4], Lsg2[4]; + + double tmp1, tmp2; + double X, Y, Z; + + + if (N < 4 || N > 12) return -1; + + for (i = 0; i < N; i++) { + rotZ(sats[i].X, sats[i].Y, sats[i].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, B[i], B[i]+1, B[i]+2); + B[i][3] = sats[i].pseudorange + sats[i].clock_corr; + } + + if (N == 4) { + matrix_invert(B, (double (*)[4]) BBB); + } + else { + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + BtB[i][j] = 0.0; + for (k = 0; k < N; k++) { + BtB[i][j] += B[k][i]*B[k][j]; + } + } + } + matrix_invert(BtB, BBinv); + for (i = 0; i < 4; i++) { + for (j = 0; j < N; j++) { + BBB[i][j] = 0.0; + for (k = 0; k < 4; k++) { + BBB[i][j] += BBinv[i][k]*B[j][k]; + } + } + } + } + + for (i = 0; i < 4; i++) { + Be[i] = 0.0; + for (k = 0; k < N; k++) { + Be[i] += BBB[i][k]*1.0; + } + } + + for (i = 0; i < N; i++) { + a[i] = 0.5 * lorentz(B[i], B[i]); + } + + for (i = 0; i < 4; i++) { + Ba[i] = 0.0; + for (k = 0; k < N; k++) { + Ba[i] += BBB[i][k]*a[k]; + } + } + + q2 = lorentz(Be, Be); + q1 = lorentz(Ba, Be)-1; + q0 = lorentz(Ba, Ba); + + if (q2 == 0) return -2; + + p = q1/q2; + q = q0/q2; + + sq = p*p - q; + if (sq < 0) return -2; + + x1 = -p + sqrt(sq); + x2 = -p - sqrt(sq); + + for (i = 0; i < 4; i++) { + Lsg1[i] = x1*Be[i]+Ba[i]; + Lsg2[i] = x2*Be[i]+Ba[i]; + } + Lsg1[3] = -Lsg1[3]; + Lsg2[3] = -Lsg2[3]; + + + tmp1 = sqrt( Lsg1[0]*Lsg1[0] + Lsg1[1]*Lsg1[1] + Lsg1[2]*Lsg1[2] ); + tmp2 = sqrt( Lsg2[0]*Lsg2[0] + Lsg2[1]*Lsg2[1] + Lsg2[2]*Lsg2[2] ); + + tmp1 = fabs( tmp1 - 6371000.0 ); + tmp2 = fabs( tmp2 - 6371000.0 ); + + if (tmp1 < tmp2) { + X = Lsg1[0]; Y = Lsg1[1]; Z = Lsg1[2]; *cc = Lsg1[3]; + } else { + X = Lsg2[0]; Y = Lsg2[1]; Z = Lsg2[2]; *cc = Lsg2[3]; + } + pos_ecef[0] = X; + pos_ecef[1] = Y; + pos_ecef[2] = Z; + + return 0; +} + +int NAV_bancroft2(int N, SAT_t sats[], double pos_ecef[3], double *cc) { + + int i, j, k; + double B[N][4], BtB[4][4], BBinv[4][4], BBB[4][N]; + double a[N], Be[4], Ba[4]; + + double q0, q1, q2, p, q, sq, x1, x2; + double Lsg1[4], Lsg2[4]; + + double tmp1, tmp2; + double X, Y, Z; + + + if (N < 4 || N > 12) return -1; + + for (i = 0; i < N; i++) { + rotE(sats[i], B[i], B[i]+1, B[i]+2); + B[i][3] = sats[i].PR; + } + + if (N == 4) { + matrix_invert(B, (double (*)[4])BBB); + } + else { + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + BtB[i][j] = 0.0; + for (k = 0; k < N; k++) { + BtB[i][j] += B[k][i]*B[k][j]; + } + } + } + matrix_invert(BtB, BBinv); + for (i = 0; i < 4; i++) { + for (j = 0; j < N; j++) { + BBB[i][j] = 0.0; + for (k = 0; k < 4; k++) { + BBB[i][j] += BBinv[i][k]*B[j][k]; + } + } + } + } + + for (i = 0; i < 4; i++) { + Be[i] = 0.0; + for (k = 0; k < N; k++) { + Be[i] += BBB[i][k]*1.0; + } + } + + for (i = 0; i < N; i++) { + a[i] = 0.5 * lorentz(B[i], B[i]); + } + + for (i = 0; i < 4; i++) { + Ba[i] = 0.0; + for (k = 0; k < N; k++) { + Ba[i] += BBB[i][k]*a[k]; + } + } + + q2 = lorentz(Be, Be); + q1 = lorentz(Ba, Be)-1; + q0 = lorentz(Ba, Ba); + + if (q2 == 0) return -2; + + p = q1/q2; + q = q0/q2; + + sq = p*p - q; + if (sq < 0) return -2; + + x1 = -p + sqrt(sq); + x2 = -p - sqrt(sq); + + for (i = 0; i < 4; i++) { + Lsg1[i] = x1*Be[i]+Ba[i]; + Lsg2[i] = x2*Be[i]+Ba[i]; + } + Lsg1[3] = -Lsg1[3]; + Lsg2[3] = -Lsg2[3]; + + + tmp1 = sqrt( Lsg1[0]*Lsg1[0] + Lsg1[1]*Lsg1[1] + Lsg1[2]*Lsg1[2] ); + tmp2 = sqrt( Lsg2[0]*Lsg2[0] + Lsg2[1]*Lsg2[1] + Lsg2[2]*Lsg2[2] ); + + tmp1 = fabs( tmp1 - 6371000.0 ); + tmp2 = fabs( tmp2 - 6371000.0 ); + + if (tmp1 < tmp2) { + X = Lsg1[0]; Y = Lsg1[1]; Z = Lsg1[2]; *cc = Lsg1[3]; + } else { + X = Lsg2[0]; Y = Lsg2[1]; Z = Lsg2[2]; *cc = Lsg2[3]; + } + pos_ecef[0] = X; + pos_ecef[1] = Y; + pos_ecef[2] = Z; + + return 0; +} + +/* ---------------------------------------------------------------------------------------------------- */ + +int NAV_bancroft3(int N, SAT_t sats[], double pos_ecef1[3], double *cc1 , double pos_ecef2[3], double *cc2) { + + int i, j, k; + double B[N][4], BtB[4][4], BBinv[4][4], BBB[4][N]; + double a[N], Be[4], Ba[4]; + + double q0, q1, q2, p, q, sq, x1, x2; + double Lsg1[4], Lsg2[4]; + + double tmp1, tmp2; + double X1, Y1, Z1; + double X2, Y2, Z2; + + + if (N < 4 || N > 12) return -1; + + for (i = 0; i < N; i++) { // Test: nicht hier rotieren, sondern spaeter Lsg rotieren... + rotZ(sats[i].X, sats[i].Y, sats[i].Z, 0.0, B[i], B[i]+1, B[i]+2); + //B[i][3] = sats[i].PR; + B[i][3] = sats[i].pseudorange + sats[i].clock_corr; + } + + if (N == 4) { + matrix_invert(B, (double (*)[4])BBB); + } + else { + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + BtB[i][j] = 0.0; + for (k = 0; k < N; k++) { + BtB[i][j] += B[k][i]*B[k][j]; + } + } + } + matrix_invert(BtB, BBinv); + for (i = 0; i < 4; i++) { + for (j = 0; j < N; j++) { + BBB[i][j] = 0.0; + for (k = 0; k < 4; k++) { + BBB[i][j] += BBinv[i][k]*B[j][k]; + } + } + } + } + + for (i = 0; i < 4; i++) { + Be[i] = 0.0; + for (k = 0; k < N; k++) { + Be[i] += BBB[i][k]*1.0; + } + } + + for (i = 0; i < N; i++) { + a[i] = 0.5 * lorentz(B[i], B[i]); + } + + for (i = 0; i < 4; i++) { + Ba[i] = 0.0; + for (k = 0; k < N; k++) { + Ba[i] += BBB[i][k]*a[k]; + } + } + + q2 = lorentz(Be, Be); + q1 = lorentz(Ba, Be)-1; + q0 = lorentz(Ba, Ba); + + if (q2 == 0) return -2; + + p = q1/q2; + q = q0/q2; + + sq = p*p - q; + if (sq < 0) return -2; + + x1 = -p + sqrt(sq); + x2 = -p - sqrt(sq); + + for (i = 0; i < 4; i++) { + Lsg1[i] = x1*Be[i]+Ba[i]; + Lsg2[i] = x2*Be[i]+Ba[i]; + } + Lsg1[3] = -Lsg1[3]; + Lsg2[3] = -Lsg2[3]; + + + tmp1 = sqrt( Lsg1[0]*Lsg1[0] + Lsg1[1]*Lsg1[1] + Lsg1[2]*Lsg1[2] ); + tmp2 = sqrt( Lsg2[0]*Lsg2[0] + Lsg2[1]*Lsg2[1] + Lsg2[2]*Lsg2[2] ); + + tmp1 = tmp1 - 6371000.0; + tmp2 = tmp2 - 6371000.0; + + if ( fabs(tmp1) < fabs(tmp2) ) { + X1 = Lsg1[0]; Y1 = Lsg1[1]; Z1 = Lsg1[2]; *cc1 = Lsg1[3]; + X2 = Lsg2[0]; Y2 = Lsg2[1]; Z2 = Lsg2[2]; *cc2 = Lsg2[3]; + } else { + X1 = Lsg2[0]; Y1 = Lsg2[1]; Z1 = Lsg2[2]; *cc1 = Lsg2[3]; + X2 = Lsg1[0]; Y2 = Lsg1[1]; Z2 = Lsg1[2]; *cc2 = Lsg1[3]; + } + + rotZ(X1, Y1, Z1, EARTH_ROTATION_RATE*RANGE_ESTIMATE, pos_ecef1, pos_ecef1+1, pos_ecef1+2); + rotZ(X2, Y2, Z2, EARTH_ROTATION_RATE*RANGE_ESTIMATE, pos_ecef2, pos_ecef2+1, pos_ecef2+2); + + return 0; +} + + +/* ---------------------------------------------------------------------------------------------------- */ +/* ---------------------------------------------------------------------------------------------------- */ +// +// Satellite Position and Velocity +// + +void GPS_SatelliteClockDriftCorrection( + const unsigned short transmission_gpsweek, // GPS week when signal was transmit (0-1024+) [weeks] + const double transmission_gpstow, // GPS time of week when signal was transmit [s] + const unsigned short ephem_week, // ephemeris: GPS week (0-1024+) [weeks] + const double toe, // ephemeris: time of week [s] + const double toc, // ephemeris: clock reference time of week [s] + const double af0, // ephemeris: polynomial clock correction coefficient [s], + const double af1, // ephemeris: polynomial clock correction coefficient [s/s], + const double af2, // ephemeris: polynomial clock correction coefficient [s/s^2] + const double ecc, // ephemeris: eccentricity of satellite orbit [] + const double sqrta, // ephemeris: square root of the semi-major axis of orbit [m^(1/2)] + const double delta_n, // ephemeris: mean motion difference from computed value [rad] + const double m0, // ephemeris: mean anomaly at reference time [rad] + const double tgd, // ephemeris: group delay differential between L1 and L2 [s] + double* clock_correction, // ephemeris: satellite clock correction [m] + double* clock_drift ) // ephemeris: satellite clock drift correction [m/s] +{ + int j; + + double tot; // time of transmission (including gps week) [s] + double tk; // time from ephemeris reference epoch [s] + double tc; // time from clock reference epoch [s] + double d_tr; // relativistic correction term [s] + double d_tsv; // SV PRN code phase time offset [s] + double a; // semi-major axis of orbit [m] + double n; // corrected mean motion [rad/s] + double M; // mean anomaly, [rad] + double E; // eccentric anomaly [rad] + + // compute the times from the reference epochs + tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow; + tk = tot - (ephem_week*SECONDS_IN_WEEK + toe); + tc = tot - (ephem_week*SECONDS_IN_WEEK + toc); + + // compute the corrected mean motion term + a = sqrta*sqrta; + n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); // mean motion + n += delta_n; // corrected mean motion + + // Kepler-Gleichung M = E - e sin(E) + M = m0 + n*tk; // mean anomaly + E = M; // f(E) = M + e sin(E) hat Fixpunkt fuer e < 1, + for( j = 0; j < 7; j++ ) { // da |f'(E)|=|e cos(E)|<1. + E = M + ecc * sin(E); // waehle Startwert E_1 = M, E_{k+1} = f(E_k) + } // konvergiert langsam gegen E_0 = f(E_0) + + // relativistic correction + d_tr = RELATIVISTIC_CLOCK_CORRECTION * ecc * sqrta * sin(E); // [s] + d_tr *= LIGHTSPEED; + + // clock correction + d_tsv = af0 + af1*tc + af2*tc*tc; // [s] + + // L1 only + d_tsv -= tgd; // [s] + + // clock correction + *clock_correction = d_tsv*LIGHTSPEED + d_tr; // [m] + + // clock drift + *clock_drift = (af1 + 2.0*af2*tc) * LIGHTSPEED; // [m/s] + +} + +void GPS_ComputeSatellitePositionVelocity( + const unsigned short transmission_gpsweek, // GPS week when signal was transmit (0-1024+) [weeks] + const double transmission_gpstow, // GPS time of week when signal was transmit [s] + const unsigned short ephem_week, // ephemeris: GPS week (0-1024+) [weeks] + const double toe, // ephemeris: time of week [s] + const double m0, // ephemeris: mean anomaly at reference time [rad] + const double delta_n, // ephemeris: mean motion difference from computed value [rad] + const double ecc, // ephemeris: eccentricity [] + const double sqrta, // ephemeris: square root of the semi-major axis [m^(1/2)] + const double omega0, // ephemeris: longitude of ascending node of orbit plane at weekly epoch [rad] + const double i0, // ephemeris: inclination angle at reference time [rad] + const double w, // ephemeris: argument of perigee [rad] + const double omegadot, // ephemeris: rate of right ascension [rad/s] + const double idot, // ephemeris: rate of inclination angle [rad/s] + const double cuc, // ephemeris: cos harmonic correction term to the argument of latitude [rad] + const double cus, // ephemeris: sin harmonic correction term to the argument of latitude [rad] + const double crc, // ephemeris: cos harmonic correction term to the orbit radius [m] + const double crs, // ephemeris: sin harmonic correction term to the orbit radius [m] + const double cic, // ephemeris: cos harmonic correction term to the angle of inclination [rad] + const double cis, // ephemeris: sin harmonic correction term to the angle of inclination [rad] + double* x, // satellite x [m] + double* y, // satellite y [m] + double* z, // satellite z [m] + double* vx, // satellite velocity x [m/s] + double* vy, // satellite velocity y [m/s] + double* vz ) // satellite velocity z [m/s] +{ + int j; + + double tot; // time of transmission (including gps week) [s] + double tk; // time from ephemeris reference epoch [s] + double a; // semi-major axis of orbit [m] + double n; // corrected mean motion [rad/s] + double M; // mean anomaly, [rad] + double E; // eccentric anomaly [rad] + double v; // true anomaly [rad] + double u; // argument of latitude, corrected [rad] + double r; // radius in the orbital plane [m] + double i; // orbital inclination [rad] + double cos2u; // cos(2*u) [] + double sin2u; // sin(2*u) [] + double d_u; // argument of latitude correction [rad] + double d_r; // radius correction [m] + double d_i; // inclination correction [rad] + double x_op; // x position in the orbital plane [m] + double y_op; // y position in the orbital plane [m] + double omegak; // corrected longitude of the ascending node [rad] + double cos_omegak; // cos(omegak) + double sin_omegak; // sin(omegak) + double cosu; // cos(u) + double sinu; // sin(u) + double cosi; // cos(i) + double sini; // sin(i) + double cosE; // cos(E) + double sinE; // sin(E) + + + // compute the times from the reference epochs + tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow; + tk = tot - (ephem_week*SECONDS_IN_WEEK + toe); + + // compute the corrected mean motion term + a = sqrta*sqrta; + n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); // computed mean motion + n += delta_n; // corrected mean motion + + // Kepler-Gleichung M = E - e sin(E) + M = m0 + n*tk; // mean anomaly + E = M; // f(E) = M + e sin(E) hat Fixpunkt fuer e < 1, + for( j = 0; j < 7; j++ ) { // da |f'(E)|=|e cos(E)|<1. + E = M + ecc * sin(E); // waehle Startwert E_1 = M, E_{k+1} = f(E_k) + } // konvergiert langsam gegen E_0 = f(E_0) + + cosE = cos(E); + sinE = sin(E); + + // true anomaly + v = atan2( (sqrt(1.0 - ecc*ecc)*sinE), (cosE - ecc) ); + // argument of latitude + u = v + w; + // radius in orbital plane + r = a * (1.0 - ecc * cos(E)); + // orbital inclination + i = i0; + + // second harmonic perturbations + // + cos2u = cos(2.0*u); + sin2u = sin(2.0*u); + // argument of latitude correction + d_u = cuc * cos2u + cus * sin2u; + // radius correction + d_r = crc * cos2u + crs * sin2u; + // correction to inclination + d_i = cic * cos2u + cis * sin2u; + + // corrected argument of latitude + u += d_u; + // corrected radius + r += d_r; + // corrected inclination + i += d_i + idot * tk; + + // positions in orbital plane + cosu = cos(u); + sinu = sin(u); + x_op = r * cosu; + y_op = r * sinu; + + + omegak = omega0 + omegadot*tk - EARTH_ROTATION_RATE*(tk + toe); + // fuer Bestimmung der Satellitenposition in ECEF, range=0; + // fuer GPS-Loesung (Sats in ECI) Erdrotation hinzuziehen: + // rotZ(EARTH_ROTATION_RATE*0.072), 0.072s*299792458m/s=21585057m + + // compute the WGS84 ECEF coordinates, + // vector r with components x & y is now rotated using, R3(-omegak)*R1(-i) + cos_omegak = cos(omegak); + sin_omegak = sin(omegak); + cosi = cos(i); + sini = sin(i); + + *x = x_op * cos_omegak - y_op * sin_omegak * cosi; + *y = x_op * sin_omegak + y_op * cos_omegak * cosi; + *z = y_op * sini; + + + // Satellite Velocity Computations are below + // see Reference + // Remodi, B. M (2004). GPS Tool Box: Computing satellite velocities using the broadcast ephemeris. + // GPS Solutions. Volume 8(3), 2004. pp. 181-183 + // + // example source code was available at [http://www.ngs.noaa.gov/gps-toolbox/bc_velo/bc_velo.c] + + // recomputed the cos and sin of the corrected argument of latitude + + double omegadotk; // corrected rate of right ascension [rad/s] + double edot; // edot = n/(1.0 - ecc*cos(E)), [rad/s] + double vdot; // d/dt of true anomaly [rad/s] + double udot; // d/dt of argument of latitude [rad/s] + double idotdot; // d/dt of the rate of the inclination angle [rad/s^2] + double rdot; // d/dt of the radius in the orbital plane [m/s] + double tmpa; // temp + double tmpb; // temp + double vx_op; // x velocity in the orbital plane [m/s] + double vy_op; // y velocity in the orbital plane [m/s] + + cos2u = cos(2.0*u); + sin2u = sin(2.0*u); + + edot = n / (1.0 - ecc*cosE); + vdot = sinE*edot*(1.0 + ecc*cos(v)) / ( sin(v)*(1.0-ecc*cosE) ); + udot = vdot + 2.0*(cus*cos2u - cuc*sin2u)*vdot; + rdot = a*ecc*sinE*n/(1.0-ecc*cosE) + 2.0*(crs*cos2u - crc*sin2u)*vdot; + idotdot = idot + (cis*cos2u - cic*sin2u)*2.0*vdot; + + vx_op = rdot*cosu - y_op*udot; + vy_op = rdot*sinu + x_op*udot; + + // corrected rate of right ascension including similarily as above, + // for omegak, compensation for the Sagnac effect + omegadotk = omegadot - EARTH_ROTATION_RATE /* - EARTH_ROTATION_RATE*RANGERATE_ESTIMATE/LIGHTSPEED */ ; + + tmpa = vx_op - y_op*cosi*omegadotk; + tmpb = x_op*omegadotk + vy_op*cosi - y_op*sini*idotdot; + + *vx = tmpa * cos_omegak - tmpb * sin_omegak; + *vy = tmpa * sin_omegak + tmpb * cos_omegak; + *vz = vy_op*sini + y_op*cosi*idotdot; +} + +void GPS_SatellitePositionVelocity_Ephem( + const unsigned short gpsweek, // gps week of signal transmission (0-1024+) [week] + const double gpstow, // time of week of signal transmission (gpstow-psr/c) [s] + EPHEM_t ephem, + double* clock_correction, // clock correction for this satellite for this epoch [m] + double* clock_drift, // clock correction for this satellite for this epoch [m] + double* satX, // satellite X position WGS84 ECEF [m] + double* satY, // satellite Y position WGS84 ECEF [m] + double* satZ, // satellite Z position WGS84 ECEF [m] + double* satvX, // satellite X velocity WGS84 ECEF [m] + double* satvY, // satellite Y velocity WGS84 ECEF [m] + double* satvZ // satellite Z velocity WGS84 ECEF [m] + ) +{ + double tow; // user time of week adjusted with the clock corrections [s] + double x; // sat X position [m] + double y; // sat Y position [m] + double z; // sat Z position [m] + double vx; // sat vX velocity [m] + double vy; // sat VY velocity [m] + double vz; // sat VZ velocity [m] + unsigned short week; // user week adjusted with the clock correction if needed [week] + + + x = y = z = 0.0; + + GPS_SatelliteClockDriftCorrection( gpsweek, gpstow, + ephem.week, ephem.toe, ephem.toc, ephem.af0, + ephem.af1, ephem.af2, ephem.e, ephem.sqrta, + ephem.delta_n, ephem.M0, ephem.tgd, clock_correction, clock_drift ); + + + // adjust for week rollover + week = gpsweek; + tow = gpstow + (*clock_correction)/LIGHTSPEED; + if ( tow < 0.0 ) { + tow += SECONDS_IN_WEEK; + week--; + } + if ( tow > SECONDS_IN_WEEK ) { + tow -= SECONDS_IN_WEEK; + week++; + } + + //range = 0.072s*299792458m/s=21585057m + GPS_ComputeSatellitePositionVelocity( week, tow, + ephem.week, ephem.toe, ephem.M0, ephem.delta_n, ephem.e, ephem.sqrta, + ephem.Omega0, ephem.i0, ephem.w, ephem.OmegaDot, ephem.idot, + ephem.cuc, ephem.cus, ephem.crc, ephem.crs, ephem.cic, ephem.cis, + &x, &y, &z, &vx, &vy, &vz ); + + *satX = x; + *satY = y; + *satZ = z; + *satvX = vx; + *satvY = vy; + *satvZ = vz; + +} + +/* ---------------------------------------------------------------------------------------------------- */ + + +double NAV_relVel(LOC_t loc, VEL_t vel) { + double d; + double x,y,z; + double norm; + + x = vel.X-loc.X; + y = vel.Y-loc.Y; + z = vel.Z-loc.Z; + norm = sqrt(x*x+y*y+z*z); + x /= norm; + y /= norm; + z /= norm; + + d = vel.vX*x + vel.vY*y + vel.vZ*z; + + return d; +} + +int NAV_LinP(int N, SAT_t satv[], double pos_ecef[3], double dt, + double dpos_ecef[3], double *cc) { + + int i, j, k; + double B[N][4], Binv[4][N], BtB[4][4], BBinv[4][4]; + double a[N], Ba[N]; + + double X, Y, Z; + double norm[N]; + double range, obs_range, prox_range; + + if (N < 4 || N > 12) return -1; + + for (i = 0; i < N; i++) { + + range = dist( pos_ecef[0], pos_ecef[1], pos_ecef[2], satv[i].X, satv[i].Y, satv[i].Z ); + range /= LIGHTSPEED; + if (range < 0.06 || range > 0.1) range = RANGE_ESTIMATE; + rotZ(satv[i].X, satv[i].Y, satv[i].Z, EARTH_ROTATION_RATE*range, B[i], B[i]+1, B[i]+2); + //rotZ(satv[i].X, satv[i].Y, satv[i].Z, 0.0, B[i], B[i]+1, B[i]+2); // est. RANGE_RATE = 0.0 + + X = B[i][0]-pos_ecef[0]; + Y = B[i][1]-pos_ecef[1]; + Z = B[i][2]-pos_ecef[2]; + norm[i] = sqrt(X*X+Y*Y+Z*Z); + + B[i][0] = X/norm[i]; + B[i][1] = Y/norm[i]; + B[i][2] = Z/norm[i]; + + B[i][3] = 1; + } + + if (N == 4) { + matrix_invert(B, (double (*)[4])Binv); + } + else { + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + BtB[i][j] = 0.0; + for (k = 0; k < N; k++) { + BtB[i][j] += B[k][i]*B[k][j]; + } + } + } + matrix_invert(BtB, BBinv); + for (i = 0; i < 4; i++) { + for (j = 0; j < N; j++) { + Binv[i][j] = 0.0; + for (k = 0; k < 4; k++) { + Binv[i][j] += BBinv[i][k]*B[j][k]; + } + } + } + + } + + + for (i = 0; i < N; i++) { + obs_range = satv[i].pseudorange + satv[i].clock_corr; //satv[i].PR; + prox_range = norm[i] - dt; + a[i] = prox_range - obs_range; + } + + for (i = 0; i < 4; i++) { + Ba[i] = 0.0; + for (k = 0; k < N; k++) { + Ba[i] += Binv[i][k]*a[k]; + } + } + + dpos_ecef[0] = Ba[0]; + dpos_ecef[1] = Ba[1]; + dpos_ecef[2] = Ba[2]; + + *cc = Ba[3]; + + return 0; +} + +int NAV_LinV(int N, SAT_t satv[], double pos_ecef[3], + double vel_ecef[3], double dt, + double dvel_ecef[3], double *cc) { + + int i, j, k; + double B[N][4], Binv[4][N], BtB[4][4], BBinv[4][4]; + double a[N], Ba[N]; + + double X, Y, Z; + double norm[N]; + double v_proj; + double obs_rate, prox_rate; + LOC_t loc; + VEL_t vel; + + if (N < 4 || N > 12) return -1; + + loc.X = pos_ecef[0]; + loc.Y = pos_ecef[1]; + loc.Z = pos_ecef[2]; + + if (N < 4 || N > 12) return -1; + + for (i = 0; i < N; i++) { + rotZ(satv[i].X, satv[i].Y, satv[i].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, B[i], B[i]+1, B[i]+2); + //rotZ(satv[i].X, satv[i].Y, satv[i].Z, 0.0, B[i], B[i]+1, B[i]+2); // est. RANGE_RATE = 0.0 + + X = B[i][0]-pos_ecef[0]; + Y = B[i][1]-pos_ecef[1]; + Z = B[i][2]-pos_ecef[2]; + norm[i] = sqrt(X*X+Y*Y+Z*Z); + B[i][0] = X/norm[i]; + B[i][1] = Y/norm[i]; + B[i][2] = Z/norm[i]; + + // SatSpeed = sqrt( satv[i].vX*satv[i].vX + satv[i].vY*satv[i].vY + satv[i].vZ*satv[i].vZ ); + + B[i][3] = 1; + } + + if (N == 4) { + matrix_invert(B, (double (*)[4])Binv); + } + else { + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + BtB[i][j] = 0.0; + for (k = 0; k < N; k++) { + BtB[i][j] += B[k][i]*B[k][j]; + } + } + } + matrix_invert(BtB, BBinv); + for (i = 0; i < 4; i++) { + for (j = 0; j < N; j++) { + Binv[i][j] = 0.0; + for (k = 0; k < 4; k++) { + Binv[i][j] += BBinv[i][k]*B[j][k]; + } + } + } + + } + + + for (i = 0; i < N; i++) { + obs_rate = satv[i].pseudorate; // + satv[i].clock_drift; + vel.X = satv[i].X; + vel.Y = satv[i].Y; + vel.Z = satv[i].Z; + vel.vX = satv[i].vX - vel_ecef[0]; + vel.vY = satv[i].vY - vel_ecef[1]; + vel.vZ = satv[i].vZ - vel_ecef[2]; + v_proj = NAV_relVel(loc, vel); + prox_rate = v_proj - dt; + a[i] = prox_rate - obs_rate; + } + + for (i = 0; i < 4; i++) { + Ba[i] = 0.0; + for (k = 0; k < N; k++) { + Ba[i] += Binv[i][k]*a[k]; + } + } + + dvel_ecef[0] = Ba[0]; + dvel_ecef[1] = Ba[1]; + dvel_ecef[2] = Ba[2]; + + *cc = Ba[3]; + + return 0; +} + diff --git a/RX_FSK/src/nav_gps_vel.h b/RX_FSK/src/nav_gps_vel.h new file mode 100644 index 0000000..6bfcd7a --- /dev/null +++ b/RX_FSK/src/nav_gps_vel.h @@ -0,0 +1,148 @@ + + +typedef struct { + uint16_t prn; + uint16_t week; + uint32_t toa; + char epoch[20]; + double toe; + double toc; + double e; + double delta_n; + double delta_i; + double i0; + double OmegaDot; + double sqrta; + double Omega0; + double w; + double M0; + double tgd; + double idot; + double cuc; + double cus; + double crc; + double crs; + double cic; + double cis; + double af0; + double af1; + double af2; + int gpsweek; + uint16_t svn; + uint8_t ura; + uint8_t health; + uint8_t conf; +} EPHEM_t; + + +typedef struct { + uint32_t t; + double pseudorange; + double pseudorate; + double clock_corr; + double clock_drift; + double X; + double Y; + double Z; + double vX; + double vY; + double vZ; + int ephhr; + double PR; + double ephtime; + int prn; +} SAT_t; + + +typedef struct {double X; double Y; double Z;} LOC_t; + +typedef struct {double X; double Y; double Z; + double vX; double vY; double vZ;} VEL_t; + + +double dist(double X1, double Y1, double Z1, double X2, double Y2, double Z2); + +void GPS_SatelliteClockCorrection( + const unsigned short transmission_gpsweek, // GPS week when signal was transmit (0-1024+) [weeks] + const double transmission_gpstow, // GPS time of week when signal was transmit [s] + const unsigned short ephem_week, // ephemeris: GPS week (0-1024+) [weeks] + const double toe, // ephemeris: time of week [s] + const double toc, // ephemeris: clock reference time of week [s] + const double af0, // ephemeris: polynomial clock correction coefficient [s], + const double af1, // ephemeris: polynomial clock correction coefficient [s/s], + const double af2, // ephemeris: polynomial clock correction coefficient [s/s^2] + const double ecc, // ephemeris: eccentricity of satellite orbit [] + const double sqrta, // ephemeris: square root of the semi-major axis of orbit [m^(1/2)] + const double delta_n, // ephemeris: mean motion difference from computed value [rad] + const double m0, // ephemeris: mean anomaly at reference time [rad] + const double tgd, // ephemeris: group delay differential between L1 and L2 [s] + double* clock_correction ); + +void GPS_SatellitePosition_Ephem( + const unsigned short gpsweek, // gps week of signal transmission (0-1024+) [week] + const double gpstow, // time of week of signal transmission (gpstow-psr/c) [s] + EPHEM_t ephem, + double* clock_correction, // clock correction for this satellite for this epoch [m] + double* satX, // satellite X position WGS84 ECEF [m] + double* satY, // satellite Y position WGS84 ECEF [m] + double* satZ // satellite Z position WGS84 ECEF [m] + ); + +void GPS_SatelliteClockDriftCorrection( + const unsigned short transmission_gpsweek, // GPS week when signal was transmit (0-1024+) [weeks] + const double transmission_gpstow, // GPS time of week when signal was transmit [s] + const unsigned short ephem_week, // ephemeris: GPS week (0-1024+) [weeks] + const double toe, // ephemeris: time of week [s] + const double toc, // ephemeris: clock reference time of week [s] + const double af0, // ephemeris: polynomial clock correction coefficient [s], + const double af1, // ephemeris: polynomial clock correction coefficient [s/s], + const double af2, // ephemeris: polynomial clock correction coefficient [s/s^2] + const double ecc, // ephemeris: eccentricity of satellite orbit [] + const double sqrta, // ephemeris: square root of the semi-major axis of orbit [m^(1/2)] + const double delta_n, // ephemeris: mean motion difference from computed value [rad] + const double m0, // ephemeris: mean anomaly at reference time [rad] + const double tgd, // ephemeris: group delay differential between L1 and L2 [s] + double* clock_correction, // ephemeris: satellite clock correction [m] + double* clock_drift ) ; + +void GPS_SatellitePositionVelocity_Ephem( + const unsigned short gpsweek, // gps week of signal transmission (0-1024+) [week] + const double gpstow, // time of week of signal transmission (gpstow-psr/c) [s] + EPHEM_t ephem, + double* clock_correction, // clock correction for this satellite for this epoch [m] + double* clock_drift, // clock correction for this satellite for this epoch [m] + double* satX, // satellite X position WGS84 ECEF [m] + double* satY, // satellite Y position WGS84 ECEF [m] + double* satZ, // satellite Z position WGS84 ECEF [m] + double* satvX, // satellite X velocity WGS84 ECEF [m] + double* satvY, // satellite Y velocity WGS84 ECEF [m] + double* satvZ // satellite Z velocity WGS84 ECEF [m] + ); + + + int NAV_ClosedFormSolution_FromPseudorange( + SAT_t sats[4], // input: satellite position and pseudorange + double* latitude, // output: ellipsoid latitude [rad] + double* longitude, // ellipsoid longitude [rad] + double* height, // ellipsoid height [m] + double* rx_clock_bias, // receiver clock bias [m] + double pos_ecef[3] ); + +int calc_DOPn(int n, SAT_t satss[], double pos_ecef[3], double DOP[4]); + +int NAV_LinP(int N, SAT_t satv[], double pos_ecef[3], double dt, + double dpos_ecef[3], double *cc); +void ecef2elli(double X, double Y, double Z, double *lat, double *lon, double *alt); + +int NAV_LinP(int N, SAT_t satv[], double pos_ecef[3], double dt, + double dpos_ecef[3], double *cc); + +int NAV_LinV(int N, SAT_t satv[], double pos_ecef[3], + double vel_ecef[3], double dt, + double dvel_ecef[3], double *cc); + +int NAV_bancroft1(int N, SAT_t sats[], double pos_ecef[3], double *cc); + +EPHEM_t *read_RNXpephs(const char *file); + + diff --git a/RX_FSK/src/rs92gps.cpp b/RX_FSK/src/rs92gps.cpp new file mode 100644 index 0000000..4c31707 --- /dev/null +++ b/RX_FSK/src/rs92gps.cpp @@ -0,0 +1,1204 @@ +/* SPDX-License-Identifier: GPL-3.0 + * based on https://github.com/rs1729/RS/blob/master/rs92/rs92gps.c + * + * radiosonde RS92 + * + * + * broadcast ephemeris: + * http://cddis.gsfc.nasa.gov/Data_and_Derived_Products/GNSS/broadcast_ephemeris_data.html + * ftp://cddis.gsfc.nasa.gov/gnss/data/daily/YYYY/DDD/YYn/brdcDDD0.YYn.Z (updated) + * ftp://cddis.gsfc.nasa.gov/gnss/data/daily/YYYY/brdc/brdcDDD0.YYn.Z (final) + * + * SEM almanac: + * https://celestrak.com/GPS/almanac/SEM/ + * + * GPS calendar: + * http://adn.agi.com/GNSSWeb/ + * + * GPS-Hoehe ueber Ellipsoid, Geoid-Hoehe: + * http://geographiclib.sourceforge.net/cgi-bin/GeoidEval + */ + +/* + gcc rs92gps.c -lm -o rs92gps + (includes nav_gps_vel.c) + + examples: + + sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | ./rs92gps -e brdc3050.15n + + ./rs92gps -r 2015_11_01.wav > raw1.out + sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | stdbuf -oL ./rs92gps -r > raw2.out + ./rs92gps --dop 5 -gg -e brdc3050.15n --rawin1 raw.out + + sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | tee audio.wav | ./rs92gps -e brdc3050.15n + ./rs92gps -g1 -e brdc3050.15n 2015_11_01-14.wav | tee out1.txt + ./rs92gps -g2 -e brdc3050.15n 2015_11_01-14.wav | tee out2.txt + sox 2015_11_01.wav -t wav - lowpass 2600 2>/dev/null | ./rs92gps -gg -e brdc3050.15n | tee out3.txt + + sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | stdbuf -oL ./rs92gps -e brdc3050.15n > out1.txt + sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | stdbuf -oL ./rs92gps -e brdc3050.15n | tee out2.txt + +*/ + +#include +#include +#include +#include +#include + +#include +#include "nav_gps_vel.h" +#include "rs92gps.h" +#include "geteph.h" +#include "Sonde.h" + + + +gpx_t gpx; + +const int option_verbose = 0, // ausfuehrliche Anzeige + option_raw = 1, // rohe Frames + option_inv = 0, // invertiert Signal + option_res = 0, // genauere Bitmessung + option_crc = 0, // check CRC + option_avg = 0, // moving average + option_b = 0, + fileloaded = 0, + option_vergps = 0, + option_iter = 0, + option_vel = 0, // velocity + option_aux = 0, // Aux/Ozon + option_der = 0, // linErr + rawin = 0; +double dop_limit = 9.9; +double d_err = 10000; + +int rollover = 0, + err_gps = 0; + +int almanac = 0, + ephem = 0; + +int exSat = -1; + + +int bufpos = -1; + +#define FRAME_LEN 240 +uint8_t frame[FRAME_LEN] = { 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x10}; +/* --- RS92-SGP ------------------- */ + + +char buffer_rawin[3*FRAME_LEN+8]; //## rawin1: buffer_rawin[2*FRAME_LEN+4]; +int frameofs = 0; + +#define MASK_LEN 64 +uint8_t mask[MASK_LEN] = { 0x96, 0x83, 0x3E, 0x51, 0xB1, 0x49, 0x08, 0x98, + 0x32, 0x05, 0x59, 0x0E, 0xF9, 0x44, 0xC6, 0x26, + 0x21, 0x60, 0xC2, 0xEA, 0x79, 0x5D, 0x6D, 0xA1, + 0x54, 0x69, 0x47, 0x0C, 0xDC, 0xE8, 0x5C, 0xF1, + 0xF7, 0x76, 0x82, 0x7F, 0x07, 0x99, 0xA2, 0x2C, + 0x93, 0x7C, 0x30, 0x63, 0xF5, 0x10, 0x2E, 0x61, + 0xD0, 0xBC, 0xB4, 0xB6, 0x06, 0xAA, 0xF4, 0x23, + 0x78, 0x6E, 0x3B, 0xAE, 0xBF, 0x7B, 0x4C, 0xC1}; +/* LFSR: ab i=8 (mod 64): + * m[16+i] = m[i] ^ m[i+2] ^ m[i+4] ^ m[i+6] + * ________________3205590EF944C6262160C2EA795D6DA15469470CDCE85CF1 + * F776827F0799A22C937C3063F5102E61D0BCB4B606AAF423786E3BAEBF7B4CC196833E51B1490898 + */ + +/* ------------------------------------------------------------------------------------ */ + +#define BAUD_RATE 4800 + +int sample_rate = 0, bits_sample = 0, channels = 0; +float samples_per_bit = 0; + +int findstr(char *buff, char *str, int pos) { + int i; + for (i = 0; i < 4; i++) { + if (buff[(pos+i)%4] != str[i]) break; + } + return i; +} + + +uint8_t framebyte(int pos) { + return frame[pos]; +} + + +/* ------------------------------------------------------------------------------------ */ + +#define GPS_WEEK1024 1 +#define WEEKSEC 604800 + +/* + * Convert GPS Week and Seconds to Modified Julian Day. + * - Adapted from sci.astro FAQ. + * - Ignores UTC leap seconds. + */ + +void Gps2Date(long GpsWeek, long GpsSeconds, int *Year, int *Month, int *Day) { + + long GpsDays, Mjd; + long J, C, Y, M; + + GpsDays = GpsWeek * 7 + (GpsSeconds / 86400); + Mjd = 44244 + GpsDays; + + J = Mjd + 2468570; + C = 4 * J / 146097; + J = J - (146097 * C + 3) / 4; + Y = 4000 * (J + 1) / 1461001; + J = J - 1461 * Y / 4 + 31; + M = 80 * J / 2447; + *Day = J - 2447 * M / 80; + J = M / 11; + *Month = M + 2 - (12 * J); + *Year = 100 * (C - 49) + Y + J; +} + +/* ------------------------------------------------------------------------------------ */ + +#define pos_FrameNb 0x08 // 2 byte +#define pos_SondeID 0x0C // 8 byte // oder: 0x0A, 10 byte? +#define pos_CalData 0x17 // 1 byte, counter 0x00..0x1f +#define pos_Calfreq 0x1A // 2 byte, calfr 0x00 + +#define posGPS_TOW 0x48 // 4 byte +#define posGPS_PRN 0x4E // 12*5 bit in 8 byte +#define posGPS_STATUS 0x56 // 12 byte +#define posGPS_DATA 0x62 // 12*8 byte + +#define pos_PTU 0x2C // 24 byte +#define pos_AuxData 0xC8 // 8 byte + + +#define BLOCK_CFG 0x6510 // frame[pos_FrameNb-2], frame[pos_FrameNb-1] +#define BLOCK_PTU 0x690C +#define BLOCK_GPS 0x673D // frame[posGPS_TOW-2], frame[posGPS_TOW-1] +#define BLOCK_AUX 0x6805 + +#define LEN_CFG (2*(BLOCK_CFG & 0xFF)) +#define LEN_GPS (2*(BLOCK_GPS & 0xFF)) +#define LEN_PTU (2*(BLOCK_PTU & 0xFF)) + + +int crc16(int start, int len) { + int crc16poly = 0x1021; + int rem = 0xFFFF, i, j; + int byte; + + if (start+len >= FRAME_LEN) return -1; + + for (i = 0; i < len; i++) { + byte = framebyte(start+i); + rem = rem ^ (byte << 8); + for (j = 0; j < 8; j++) { + if (rem & 0x8000) { + rem = (rem << 1) ^ crc16poly; + } + else { + rem = (rem << 1); + } + rem &= 0xFFFF; + } + } + return rem; +} + +int get_FrameNb() { + int i; + unsigned byte; + uint8_t frnr_bytes[2]; + int frnr; + + for (i = 0; i < 2; i++) { + byte = framebyte(pos_FrameNb + i); + frnr_bytes[i] = byte; + } + + frnr = frnr_bytes[0] + (frnr_bytes[1] << 8); + gpx.frnr = frnr; + + return 0; +} + +int get_SondeID() { + int i, ret=0; + unsigned byte; + uint8_t sondeid_bytes[10]; + int crc_frame, crc; + + // BLOCK_CFG == frame[pos_FrameNb-2 .. pos_FrameNb-1] ? + crc_frame = framebyte(pos_FrameNb+LEN_CFG) | (framebyte(pos_FrameNb+LEN_CFG+1) << 8); + crc = crc16(pos_FrameNb, LEN_CFG); +/* + if (option_crc) { + //fprintf(stdout, " (%04X:%02X%02X) ", BLOCK_CFG, frame[pos_FrameNb-2], frame[pos_FrameNb-1]); + fprintf(stdout, " [%04X:%04X] ", crc_frame, crc); + } +*/ + ret = 0; + if ( 0 && option_crc && crc != crc_frame) { + ret = -2; // erst wichtig, wenn Cal/Cfg-Data + } + + for (i = 0; i < 8; i++) { + byte = framebyte(pos_SondeID + i); + if ((byte < 0x20) || (byte > 0x7E)) return -1; + sondeid_bytes[i] = byte; + } + + for (i = 0; i < 8; i++) { + gpx.id[i] = sondeid_bytes[i]; + } + gpx.id[8] = '\0'; + + return ret; +} + +char weekday[7][3] = { "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"}; + +int get_GPStime() { + int i, ret=0; + unsigned byte; + uint8_t gpstime_bytes[4]; + int gpstime = 0, // 32bit + day; + int ms; + int crc_frame, crc; + + // BLOCK_GPS == frame[posGPS_TOW-2 .. posGPS_TOW-1] ? + crc_frame = framebyte(posGPS_TOW+LEN_GPS) | (framebyte(posGPS_TOW+LEN_GPS+1) << 8); + crc = crc16(posGPS_TOW, LEN_GPS); +/* + if (option_crc) { + //fprintf(stdout, " (%04X:%02X%02X) ", BLOCK_GPS, frame[posGPS_TOW-2], frame[posGPS_TOW-1]); + fprintf(stdout, " [%04X:%04X] ", crc_frame, crc); + } +*/ + ret = 0; + if (option_crc && crc != crc_frame) { + ret = -2; + } + + for (i = 0; i < 4; i++) { + byte = framebyte(posGPS_TOW + i); + gpstime_bytes[i] = byte; + } + + memcpy(&gpstime, gpstime_bytes, 4); + ms = gpstime % 1000; + gpstime /= 1000; + + gpx.gpssec = gpstime; + Serial.printf("GPS time is %04x (%d)\n", gpstime, gpstime); + + day = (gpstime / (24 * 3600)) % 7; // besser CRC-check, da auch + //if ((day < 0) || (day > 6)) return -1; // gpssec=604800,604801 beobachtet + + gpstime %= (24*3600); + + gpx.wday = day; + gpx.std = gpstime / 3600; + gpx.min = (gpstime % 3600) / 60; + gpx.sek = gpstime % 60 + ms/1000.0; + + return ret; +} + +int get_Aux() { + int i; + unsigned short byte; + + for (i = 0; i < 4; i++) { + byte = framebyte(pos_AuxData+2*i)+(framebyte(pos_AuxData+2*i+1)<<8); + gpx.aux[i] = byte; + } + + return 0; +} + +int get_Cal() { + int i; + unsigned byte; + uint8_t calfr = 0; + //uint8_t burst = 0; + int freq = 0; + uint8_t freq_bytes[2]; + + byte = framebyte(pos_CalData); + calfr = byte; + + if (option_verbose == 4) { + fprintf(stdout, "\n"); + fprintf(stdout, "[%5d] ", gpx.frnr); + fprintf(stdout, " 0x%02x:", calfr); + } + for (i = 0; i < 16; i++) { + byte = framebyte(pos_CalData+1+i); + if (option_verbose == 4) { + fprintf(stdout, " %02x", byte); + } + } + if (option_aux) { + get_Aux(); + if (option_verbose == 4) { + fprintf(stdout, " # "); + for (i = 0; i < 8; i++) { + byte = framebyte(pos_AuxData+i); + fprintf(stdout, "%02x ", byte); + } + } + else { + if (gpx.aux[0] != 0 || gpx.aux[1] != 0 || gpx.aux[2] != 0 || gpx.aux[3] != 0) { + fprintf(stdout, " # %04x %04x %04x %04x", gpx.aux[0], gpx.aux[1], gpx.aux[2], gpx.aux[3]); + } + } + } + + if (calfr == 0x00) { + for (i = 0; i < 2; i++) { + byte = framebyte(pos_Calfreq + i); + freq_bytes[i] = byte; + } + byte = freq_bytes[0] + (freq_bytes[1] << 8); + //fprintf(stdout, ":%04x ", byte); + freq = 400000 + 10*byte; // kHz; + gpx.freq = freq; + fprintf(stdout, " : fq %d kHz", freq); + } + + return 0; +} + + +/* ---------------------------------------------------------------------------------------------------- */ + + + +//we only use ephs EPHEM_t alm[33]; +//EPHEM_t eph[33][24]; +EPHEM_t *ephs = NULL; + +SAT_t sat[33], + sat1s[33]; + + +uint8_t prn_le[12*5+4]; +/* le - little endian */ +int prnbits_le(uint16_t byte16, uint8_t bits[64], int block) { + int i; /* letztes bit Ueberlauf, wenn 3. PRN = 32 */ + for (i = 0; i < 15; i++) { + bits[15*block+i] = byte16 & 1; + byte16 >>= 1; + } + bits[60+block] = byte16 & 1; + return byte16 & 1; +} +uint8_t prns[12], // PRNs in data + sat_status[12]; +int prn32toggle = 0x1, ind_prn32, prn32next; +void prn12(uint8_t *prn_le, uint8_t prns[12]) { + int i, j, d; + for (i = 0; i < 12; i++) { + prns[i] = 0; + d = 1; + for (j = 0; j < 5; j++) { + if (prn_le[5*i+j]) prns[i] += d; + d <<= 1; + } + } + ind_prn32 = 32; + for (i = 0; i < 12; i++) { + // PRN-32 overflow + if ( (prns[i] == 0) && (sat_status[i] & 0x0F) ) { // 5 bit: 0..31 + if ( ((i % 3 == 2) && (prn_le[60+i/3] & 1)) // Spalte 2 + || ((i % 3 != 2) && (prn_le[5*(i+1)] & 1)) ) { // Spalte 0,1 + prns[i] = 32; ind_prn32 = i; + } + } + else if ((sat_status[i] & 0x0F) == 0) { // erste beiden bits: 0x03 ? + prns[i] = 0; + } + } + + prn32next = 0; + if (ind_prn32 < 12) { + // PRN-32 overflow + if (ind_prn32 % 3 != 2) { // -> ind_prn32<11 // vorausgesetzt im Block folgt auf PRN-32 + if ((sat_status[ind_prn32+1] & 0x0F) && prns[ind_prn32+1] > 1) { // entweder PRN-1 oder PRN-gerade + // && prns[ind_prn32+1] != 3 ? + for (j = 0; j < ind_prn32; j++) { + if (prns[j] == (prns[ind_prn32+1]^prn32toggle) && (sat_status[j] & 0x0F)) break; + } + if (j < ind_prn32) { prn32toggle ^= 0x1; } + else { + for (j = ind_prn32+2; j < 12; j++) { + if (prns[j] == (prns[ind_prn32+1]^prn32toggle) && (sat_status[j] & 0x0F)) break; + } + if (j < 12) { prn32toggle ^= 0x1; } + } + prns[ind_prn32+1] ^= prn32toggle; + /* + // nochmal testen + for (j = 0; j < ind_prn32; j++) { if (prns[j] == prns[ind_prn32+1]) break; } + if (j < ind_prn32) prns[ind_prn32+1] = 0; + else { + for (j = ind_prn32+2; j < 12; j++) { if (prns[j] == prns[ind_prn32+1]) break; } + if (j < 12) prns[ind_prn32+1] = 0; + } + if (prns[ind_prn32+1] == 0) { prn32toggle ^= 0x1; } + */ + } + prn32next = prns[ind_prn32+1]; // -> ind_prn32<11 && ind_prn32 % 3 != 2 + } + } +} + + +int calc_satpos_rnx(EPHEM_t eph[][24], double t, SAT_t *satp) { + double X, Y, Z, vX, vY, vZ; + int j, i, ti; + int week = 0; + double cl_corr, cl_drift; + double tdiff, td; + + for (j = 1; j < 33; j++) { + + // Woche hat 604800 sec + tdiff = WEEKSEC; + ti = 0; + for (i = 0; i < 24; i++) { + if (eph[j][i].prn > 0) { + if (t-eph[j][i].toe > WEEKSEC/2) rollover = +1; + else if (t-eph[j][i].toe < -WEEKSEC/2) rollover = -1; + else rollover = 0; + td = t-eph[j][i].toe - rollover*WEEKSEC; + if (td < 0) td *= -1; + + if ( td < tdiff ) { + tdiff = td; + ti = i; + week = eph[j][ti].week - rollover; + gpx.week = eph[j][ti].gpsweek - rollover; + } + } + } + + if (option_vel >= 2) { + GPS_SatellitePositionVelocity_Ephem( + week, t, eph[j][ti], + &cl_corr, &cl_drift, &X, &Y, &Z, &vX, &vY, &vZ + ); + satp[eph[j][ti].prn].clock_drift = cl_drift; + satp[eph[j][ti].prn].vX = vX; + satp[eph[j][ti].prn].vY = vY; + satp[eph[j][ti].prn].vZ = vZ; + } + else { + GPS_SatellitePosition_Ephem( + week, t, eph[j][ti], + &cl_corr, &X, &Y, &Z + ); + } + + satp[eph[j][ti].prn].X = X; + satp[eph[j][ti].prn].Y = Y; + satp[eph[j][ti].prn].Z = Z; + satp[eph[j][ti].prn].clock_corr = cl_corr; + + } + + return 0; +} + +int calc_satpos_rnx2(EPHEM_t *eph, double t, SAT_t *satp) { + double X, Y, Z, vX, vY, vZ; + int j; + int week = 0; + double cl_corr, cl_drift; + double tdiff, td; + int count, count0, satfound; + + for (j = 1; j < 33; j++) { + + count = count0 = 1; + satfound = 0; + + // Woche hat 604800 sec + tdiff = WEEKSEC; + while (eph[count].prn > 0) { + if (eph[count].prn == j) { + + satfound += 1; + + if (t - eph[count].toe > WEEKSEC/2) rollover = +1; + else if (t - eph[count].toe < -WEEKSEC/2) rollover = -1; + else rollover = 0; + td = fabs( t - eph[count].toe - rollover*WEEKSEC); + + if ( td < tdiff ) { + tdiff = td; + week = eph[count].week - rollover; + gpx.week = eph[count].gpsweek - rollover; + count0 = count; + } + } + count += 1; + } + + if ( satfound ) + { + if (option_vel >= 2) { + GPS_SatellitePositionVelocity_Ephem( + week, t, eph[count0], + &cl_corr, &cl_drift, &X, &Y, &Z, &vX, &vY, &vZ + ); + satp[j].clock_drift = cl_drift; + satp[j].vX = vX; + satp[j].vY = vY; + satp[j].vZ = vZ; + } + else { + GPS_SatellitePosition_Ephem( + week, t, eph[count0], + &cl_corr, &X, &Y, &Z + ); + } + + satp[j].X = X; + satp[j].Y = Y; + satp[j].Z = Z; + satp[j].clock_corr = cl_corr; + satp[j].ephtime = eph[count0].toe; + } + + } + + return 0; +} + + +typedef struct { + uint32_t tow; + uint8_t status; + int chips; + int deltachips; +} RANGE_t; +RANGE_t range[33]; + +int prn[12]; // valide PRN 0,..,k-1 + + +// pseudo.range = -df*pseudo.chips +// df = lightspeed/(chips/sec)/2^10 +const double df = 299792.458/1023.0/1024.0; //0.286183844 // c=299792458m/s, 1023000chips/s +// dl = L1/(chips/sec)/4 +const double dl = 1575.42/1.023/4.0; //385.0 // GPS L1 1575.42MHz=154*10.23MHz, dl=154*10/4 + +double pr_ofs; +double GPSsatAlt = 20200e3; + +int get_pseudorange() { + uint32_t gpstime; + uint8_t gpstime_bytes[4]; + uint8_t pseudobytes[4]; + uint32_t chipbytes, deltabytes; + int i, j, k; + uint8_t bytes[4]; + uint16_t byte16; + double pr0, prj; + + // GPS-TOW in ms + for (i = 0; i < 4; i++) { + gpstime_bytes[i] = framebyte(posGPS_TOW + i); + } + memcpy(&gpstime, gpstime_bytes, 4); + + // Sat Status + Serial.print("Sat status: "); + for (i = 0; i < 12; i++) { + sat_status[i] = framebyte(posGPS_STATUS + i); + Serial.printf("%d:%d ", i, sat_status[i]); + } + Serial.print("\n"); + + // PRN-Nummern + for (i = 0; i < 4; i++) { + for (j = 0; j < 2; j++) { + bytes[j] = frame[posGPS_PRN+2*i+j]; + } + memcpy(&byte16, bytes, 2); + prnbits_le(byte16, prn_le, i); + } + prn12(prn_le, prns); + + + // GPS Sat Pos (& Vel) + if (ephem) calc_satpos_rnx2(ephs, gpstime/1000.0, sat); + + // GPS Sat Pos t -= 1s + if (option_vel == 1) { + if (ephem) calc_satpos_rnx2(ephs, gpstime/1000.0-1, sat1s); + } + + k = 0; + for (j = 0; j < 12; j++) { + + // Pseudorange/chips + for (i = 0; i < 4; i++) { + pseudobytes[i] = frame[posGPS_DATA+8*j+i]; + } + memcpy(&chipbytes, pseudobytes, 4); + //Serial.printf("Chipbytes(%d): %04x\n",j, chipbytes); + + // delta_pseudochips / 385 + for (i = 0; i < 3; i++) { + pseudobytes[i] = frame[posGPS_DATA+8*j+4+i]; + } + deltabytes = 0; // bzw. pseudobytes[3]=0 (24 bit); deltabytes & (0xFF<<24) als + memcpy(&deltabytes, pseudobytes, 3); // gemeinsamer offset relevant in --vel1 ! + + //if ( (prns[j] == 0) && (sat_status[j] & 0x0F) ) prns[j] = 32; + range[prns[j]].tow = gpstime; + range[prns[j]].status = sat_status[j]; + + if ( chipbytes == 0x7FFFFFFF || chipbytes == 0x55555555 ) { + range[prns[j]].chips = 0; + continue; + } + if (option_vergps != 8) { + if ( chipbytes > 0x10000000 && chipbytes < 0xF0000000 ) { + range[prns[j]].chips = 0; + continue; + }} + + range[prns[j]].chips = chipbytes; + range[prns[j]].deltachips = deltabytes; + +/* + if (range[prns[j]].deltachips == 0x555555) { + range[prns[j]].deltachips = 0; + continue; + } +*/ + Serial.printf("j=%d: prns=%d status=%d dist=%f\n ", j, prns[j], sat_status[j], dist(sat[prns[j]].X, sat[prns[j]].Y, sat[prns[j]].Z, 0, 0, 0)); + //int o=prns[j]; + //Serial.printf("x=%f y=%f z=%f\n", sat[o].X, sat[o].Y, sat[o].Z); + if ( (prns[j] > 0) && ((sat_status[j] & 0x0F) == 0xF) + && (dist(sat[prns[j]].X, sat[prns[j]].Y, sat[prns[j]].Z, 0, 0, 0) > 6700000) ) + { + for (i = 0; i < k; i++) { if (prn[i] == prns[j]) break; } + if (i == k && prns[j] != exSat) { + //if ( range[prns[j]].status & 0xF0 ) // Signalstaerke > 0 ? + { + prn[k] = prns[j]; + k++; + } + } + } + + } + + + for (j = 0; j < 12; j++) { // 0x013FB0A4 + sat[prns[j]].pseudorange = /*0x01400000*/ - range[prns[j]].chips * df; + sat1s[prns[j]].pseudorange = -(range[prns[j]].chips - range[prns[j]].deltachips/dl)*df; + //+ sat[prns[j]].clock_corr - sat1s[prns[j]].clock_corr + sat[prns[j]].pseudorate = - range[prns[j]].deltachips * df / dl; + + sat[prns[j]].prn = prns[j]; + sat1s[prns[j]].prn = prns[j]; + } + + + pr0 = (double)0x01400000; + for (j = 0; j < k; j++) { + prj = sat[prn[j]].pseudorange + sat[prn[j]].clock_corr; + if (prj < pr0) pr0 = prj; + } + for (j = 0; j < k; j++) sat[prn[j]].PR = sat[prn[j]].pseudorange + sat[prn[j]].clock_corr - pr0 + GPSsatAlt; + // es kann PRNs geben, die zeitweise stark abweichende PR liefern; + // eventuell Standardabweichung ermitteln und fehlerhafte Sats weglassen + for (j = 0; j < k; j++) { // sat/sat1s... PR-check + sat1s[prn[j]].PR = sat1s[prn[j]].pseudorange + sat[prn[j]].clock_corr - pr0 + GPSsatAlt; + } + pr_ofs = pr0; + + return k; +} + +int get_GPSvel(double lat, double lon, double vel_ecef[3], + double *vH, double *vD, double *vU) { + // ECEF-Velocities + // ECEF-Vel -> NorthEastUp + double phi = lat*M_PI/180.0; + double lam = lon*M_PI/180.0; + double vN = -vel_ecef[0]*sin(phi)*cos(lam) - vel_ecef[1]*sin(phi)*sin(lam) + vel_ecef[2]*cos(phi); + double vE = -vel_ecef[0]*sin(lam) + vel_ecef[1]*cos(lam); + *vU = vel_ecef[0]*cos(phi)*cos(lam) + vel_ecef[1]*cos(phi)*sin(lam) + vel_ecef[2]*sin(phi); + // NEU -> HorDirVer + *vH = sqrt(vN*vN+vE*vE); + *vD = atan2(vE, vN) * 180 / M_PI; + if (*vD < 0) *vD += 360; + + return 0; +} + +double DOP[4]; + +int naiv_2Dfix(int N, SAT_t sats[], double alt) { +// simple 2D fix: 3 Sats & Alt above ellipsoid +// +// - fuer 3 unbekannte lat, lon, t braucht man mind. 3 Satelliten +// - fuer Iteration braucht man jedoch einen Startwert +// - es gibt direkte Methoden +// - hier werden die vorhandenen Funktionen benutzt: +// - der 4. Satellit im Erdmittelpunkt +// - seine pseudorange(+clock) wird grob geschaetzt +// (pseudochips liefern erst Rueckschluesse, wenn man Position kennt) +// - dann approximieren, bis Hoehe stimmt +// - bei 3-4 Satelliten ist die DOP-Konstellation oft schlecht +// - moeglicherweise ist in einigen Faellen die 2. Loesung besser + + double radius = 6371e3 + alt; // wird dann approximiert + double lat2d, lon2d, alt2d, + pos_ecef[3], rx_cl_bias, + dpos_ecef[3]; + //double d; + double rofs = 200000.0, rdiff = 0.0; + int k, k_limit; + double gdop = -1; + + + sats[3].X = sats[3].Y = sats[3].Z = 0; + + k = 0; + k_limit = 100; + + if (N >= 3) { + + do + { + // PR = pseudorange + clock_corr - pr_ofs + GPSsatAlt + sats[3].X = sats[3].Y = sats[3].Z = 0; + sats[3].PR = radius - rofs; + sats[3].pseudorange = sats[3].PR + pr_ofs - GPSsatAlt; + + + NAV_bancroft1(4, sats, pos_ecef, &rx_cl_bias); + //NAV_bancroft3(4, sats, pos_ecef1, &rx_cl_bias1, pos_ecef2, &rx_cl_bias2); + + ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat2d, &lon2d, &alt2d); + rdiff = alt-alt2d; + + rofs -= rdiff*1.2; + k += 1; + + } while (k < k_limit && fabs(rdiff) > 1.0); + + NAV_LinP(4, sats, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias); + // for (j=0;j<3;j++) pos_ecef[j] += dpos_ecef[j]; + // NAV_LinP(4, sats, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias); + // d = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]); + + } + + if (calc_DOPn(4, sats, pos_ecef, DOP) == 0) { + gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]); + } + //if (gdop > 2*dop_limit) gdop = -1; + //if (gdop < 0) gdop = -1; + + gpx.lat = lat2d; + gpx.lon = lon2d; + gpx.alt = alt2d; + gpx.dop = gdop; + + if ( fabs(alt2d-alt) > 1000.0 ) return -1; + if ( k == k_limit ) return 0; + return 1; +} + + +int get_GPSkoord(int N) { + double lat, lon, alt, rx_cl_bias; + double vH, vD, vU; + double pos_ecef[3], dpos_ecef[3], + vel_ecef[3], dvel_ecef[3]; + double gdop, gdop0 = 1000.0; + //double hdop, vdop, pdop; + int i0, i1, i2, i3, j; + int nav_ret = 0; + int num = 0; + SAT_t Sat_A[4]; +#if 0 + int k, n; + double lat1s, lon1s, alt1s, + lat0 , lon0 , alt0 , pos0_ecef[3]; + double pos1s_ecef[3]; + SAT_t Sat_B[12]; // N <= 12 + SAT_t Sat_B1s[12]; + SAT_t Sat_C[12]; // 11 + int exN = -1; +#endif + double diter = 0; + +#if 0 + if (option_vergps == 8) { + fprintf(stdout, " sats: "); + for (j = 0; j < N; j++) fprintf(stdout, "%02d ", prn[j]); + fprintf(stdout, "\n"); + } +#endif + + gpx.lat = gpx.lon = gpx.alt = 0; + + if (option_vergps != 2) { + for (i0=0;i0 0 && gdop < gdop0) { // wenn fehlerhafter Sat, diter wohl besserer Indikator + gpx.lat = lat; + gpx.lon = lon; + gpx.alt = alt; + gpx.dop = gdop; + gpx.diter = diter; + gpx.sats[0] = prn[i0]; gpx.sats[1] = prn[i1]; gpx.sats[2] = prn[i2]; gpx.sats[3] = prn[i3]; + gdop0 = gdop; + + if (option_vel == 4) { + gpx.vH = vH; + gpx.vD = vD; + gpx.vU = vU; + } + } + } + + }}}} + } + +#if 0 + if (option_vergps == 8 || option_vergps == 2) { + + for (j = 0; j < N; j++) Sat_B[j] = sat[prn[j]]; + for (j = 0; j < N; j++) Sat_B1s[j] = sat1s[prn[j]]; + + NAV_bancroft1(N, Sat_B, pos_ecef, &rx_cl_bias); + ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat, &lon, &alt); + gdop = -1; + if (calc_DOPn(N, Sat_B, pos_ecef, DOP) == 0) { + gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]); + } + + NAV_LinP(N, Sat_B, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias); + if (option_iter) { + for (j = 0; j < 3; j++) pos_ecef[j] += dpos_ecef[j]; + ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat, &lon, &alt); + } + gpx.diter = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]); + + // Sat mit schlechten Daten suchen + if (gpx.diter > d_err) { + if (N > 5) { // N > 4 kann auch funktionieren + for (n = 0; n < N; n++) { + k = 0; + for (j = 0; j < N; j++) { + if (j != n) { + Sat_C[k] = Sat_B[j]; + k++; + } + } + for (j = 0; j < 3; j++) pos0_ecef[j] = 0; + NAV_bancroft1(N-1, Sat_C, pos0_ecef, &rx_cl_bias); + NAV_LinP(N-1, Sat_C, pos0_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias); + diter = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]); + ecef2elli(pos0_ecef[0], pos0_ecef[1], pos0_ecef[2], &lat0, &lon0, &alt0); + if (diter < gpx.diter) { + gpx.diter = diter; + for (j = 0; j < 3; j++) pos_ecef[j] = pos0_ecef[j]; + lat = lat0; + lon = lon0; + alt = alt0; + exN = n; + } + } + if (exN >= 0) { + if (prn[exN] == prn32next) prn32toggle ^= 0x1; + for (k = exN; k < N-1; k++) { + Sat_B[k] = Sat_B[k+1]; + prn[k] = prn[k+1]; + if (option_vel == 1) { + Sat_B1s[k] = Sat_B1s[k+1]; + } + } + N = N-1; + if (calc_DOPn(N, Sat_B, pos_ecef, DOP) == 0) { + gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]); + } + } + } +/* + if (exN < 0 && prn32next > 0) { + //prn32next used in pre-fix? prn32toggle ^= 0x1; + } +*/ + } + + if (option_vel == 1) { + NAV_bancroft1(N, Sat_B1s, pos1s_ecef, &rx_cl_bias); + if (option_iter) { + NAV_LinP(N, Sat_B1s, pos1s_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias); + for (j = 0; j < 3; j++) pos1s_ecef[j] += dpos_ecef[j]; + } + for (j = 0; j < 3; j++) vel_ecef[j] = pos_ecef[j] - pos1s_ecef[j]; + get_GPSvel(lat, lon, vel_ecef, &vH, &vD, &vU); + ecef2elli(pos1s_ecef[0], pos1s_ecef[1], pos1s_ecef[2], &lat1s, &lon1s, &alt1s); + if (option_vergps == 8) { + fprintf(stdout, "\ndeltachips1s lat: %.6f , lon: %.6f , alt: %.2f ", lat1s, lon1s, alt1s); + fprintf(stdout, " vH: %4.1f D: %5.1f° vV: %3.1f ", vH, vD, vU); + fprintf(stdout, "\n"); + } + } + if (option_vel >= 2) { + //fprintf(stdout, "\nP(%.1f,%.1f,%.1f) \n", pos_ecef[0], pos_ecef[1], pos_ecef[2]); + vel_ecef[0] = vel_ecef[1] = vel_ecef[2] = 0; + NAV_LinV(N, Sat_B, pos_ecef, vel_ecef, 0.0, dvel_ecef, &rx_cl_bias); + for (j=0; j<3; j++) vel_ecef[j] += dvel_ecef[j]; + //fprintf(stdout, " V(%.1f,%.1f,%.1f) ", vel_ecef[0], vel_ecef[1], vel_ecef[2]); + //fprintf(stdout, " rx_vel_bias: %.1f \n", rx_cl_bias); + /* 2. Iteration: + NAV_LinV(N, Sat_B, pos_ecef, vel_ecef, rx_cl_bias, dvel_ecef, &rx_cl_bias); + for (j=0; j<3; j++) vel_ecef[j] += dvel_ecef[j]; + //fprintf(stdout, " V(%.1f,%.1f,%.1f) ", vel_ecef[0], vel_ecef[1], vel_ecef[2]); + //fprintf(stdout, " rx_vel_bias: %.1f \n", rx_cl_bias); + */ + get_GPSvel(lat, lon, vel_ecef, &vH, &vD, &vU); + } + + if (option_vergps == 8) { + fprintf(stdout, "bancroft[%2d] lat: %.6f , lon: %.6f , alt: %.2f ", N, lat, lon, alt); + fprintf(stdout, " (d:%.1f)", gpx.diter); + if (option_vel) { + fprintf(stdout, " vH: %4.1f D: %5.1f° vV: %3.1f ", vH, vD, vU); + } + fprintf(stdout, " DOP["); + for (j = 0; j < N; j++) { + fprintf(stdout, "%d", prn[j]); + if (j < N-1) fprintf(stdout, ","); else fprintf(stdout, "] %.1f ", gdop); + } + fprintf(stdout, "\n"); + } + + if (option_vergps == 2) { + gpx.lat = lat; + gpx.lon = lon; + gpx.alt = alt; + gpx.dop = gdop; + num = N; + + if (option_vel) { + gpx.vH = vH; + gpx.vD = vD; + gpx.vU = vU; + } + } + + } +#endif + + return num; +} + + +/* ------------------------------------------------------------------------------------ */ + + +int print_position() { // GPS-Hoehe ueber Ellipsoid + int j, k = 0, n = 0; + int err1, err2, fix2d = 0; + + err1 = 0; + if (!option_verbose) err1 = err_gps; + err1 |= get_FrameNb(); + err1 |= get_SondeID(); + + err2 = err1 | err_gps; + //err2 |= get_GPSweek(); + err2 |= get_GPStime(); + +#if 0 + Serial.printf("ephem=%d\n",ephem); + Serial.printf("print_position: ephs is %p\n", ephs); +#endif + + if (!err2 && (almanac || ephem)) { + k = get_pseudorange(); + gpx.k = k; + Serial.printf("k=%d\n", k); + if (k >= 4) { + n = get_GPSkoord(k); + } + if (k == 3) { + SAT_t Sat_A[4]; + for (j = 0; j < 3; j++) { Sat_A[j] = sat[prn[j]]; } + fix2d = naiv_2Dfix( 3, Sat_A, sonde.config.rs92.alt2d); + } + } + + if (!err1) { + fprintf(stdout, "[%5d] ", gpx.frnr); + fprintf(stdout, "(%s) ", gpx.id); + } + + if (!err2) { + if (option_verbose) { + Gps2Date(gpx.week, gpx.gpssec, &gpx.jahr, &gpx.monat, &gpx.tag); + //fprintf(stdout, "(W %d) ", gpx.week); + fprintf(stdout, "(%04d-%02d-%02d) ", gpx.jahr, gpx.monat, gpx.tag); + } + fprintf(stdout, "%s ", weekday[gpx.wday]); // %04.1f: wenn sek >= 59.950, wird auf 60.0 gerundet + fprintf(stdout, "%02d:%02d:%06.3f", gpx.std, gpx.min, gpx.sek); + + if (k == 3 && fix2d > 0 && gpx.dop > 0 && gpx.dop < 2*dop_limit) { + fprintf(stdout, " 2D lat: %.5f lon: %.5f alt: %.1f ", gpx.lat, gpx.lon, gpx.alt); + fprintf(stdout, " DOP[%02d,%02d,%02d,0] %.1f ", prn[0], prn[1], prn[2], gpx.dop); + } + else if (n > 0) { + fprintf(stdout, " "); + + if (almanac) fprintf(stdout, " lat: %.4f lon: %.4f alt: %.1f ", gpx.lat, gpx.lon, gpx.alt); + else fprintf(stdout, " lat: %.5f lon: %.5f alt: %.1f ", gpx.lat, gpx.lon, gpx.alt); + + if (option_verbose && option_vergps != 8) { + fprintf(stdout, " (d:%.1f)", gpx.diter); + } + if (option_vel /*&& option_vergps >= 2*/) { + fprintf(stdout," vH: %4.1f D: %5.1f° vV: %3.1f ", gpx.vH, gpx.vD, gpx.vU); + } + if (option_verbose) { + if (option_vergps != 2) { + fprintf(stdout, " DOP[%02d,%02d,%02d,%02d] %.1f", + gpx.sats[0], gpx.sats[1], gpx.sats[2], gpx.sats[3], gpx.dop); + } + else { // wenn option_vergps=2, dann n=N=k(-1) + fprintf(stdout, " DOP["); + for (j = 0; j < n; j++) { + fprintf(stdout, "%d", prn[j]); + if (j < n-1) fprintf(stdout, ","); else fprintf(stdout, "] %.1f ", gpx.dop); + } + } + } + } + + get_Cal(); + + if (option_vergps == 8 /*|| option_vergps == 2*/) + { + fprintf(stdout, "\n"); + for (j = 0; j < 60; j++) { fprintf(stdout, "%d", prn_le[j]); if (j % 5 == 4) fprintf(stdout, " "); } + fprintf(stdout, ": "); + for (j = 0; j < 12; j++) fprintf(stdout, "%2d ", prns[j]); + fprintf(stdout, "\n"); + fprintf(stdout, " status: "); + for (j = 0; j < 12; j++) fprintf(stdout, "%02X ", sat_status[j]); //range[prns[j]].status + fprintf(stdout, "\n"); + } + + } + + if (!err1) { + fprintf(stdout, "\n"); + //if (option_vergps == 8) fprintf(stdout, "\n"); + } + + return err2; +} + +void print_frame(uint8_t *data, int len) { + int i; + uint8_t byte; + + for (i = 0; i + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef inttypes_h + #include +#endif + +#define N 255 +#define R 24 +#define K (N-R) + +void *init_rs_char(int symsize,int gfpoly,int fcr,int prim,int nroots,int pad); +int decode_rs_char(void *arg, + unsigned char *data, int *eras_pos, int no_eras); + +void *rs; + +void initrsc() +{ + rs = init_rs_char( 8, 0x11d, 0, 1, R, 0); +} + + +int decodersc(char *data, uint32_t *eras_pos, uint32_t no_eras) +{ + return decode_rs_char(rs, (unsigned char *)data, (int *)eras_pos, no_eras); +} diff --git a/RX_FSK/src/rsc.h b/RX_FSK/src/rsc.h new file mode 100644 index 0000000..a73575c --- /dev/null +++ b/RX_FSK/src/rsc.h @@ -0,0 +1,17 @@ +/* + * dxlAPRS toolchain + * + * Copyright (C) Christian Rabler + * + * SPDX-License-Identifier: GPL-2.0+ + */ +#ifndef rsc_H_ +#define rsc_H_ + + +long decodersc(char [], uint32_t [], uint32_t); + +void initrsc(void); + + +#endif /* rsc_H_ */ diff --git a/RX_FSK/src/rsc_decode.cpp b/RX_FSK/src/rsc_decode.cpp new file mode 100644 index 0000000..eb102b4 --- /dev/null +++ b/RX_FSK/src/rsc_decode.cpp @@ -0,0 +1,436 @@ +/* + * Copyright 2016 Hannes Schmelzer, OE5HPM + * doing several cleanups and architecture changes, no functional change yet + * + * General purpose Reed-Solomon decoder for 8-bit symbols or less + * Copyright 2003 Phil Karn, KA9Q + * May be used under the terms of the GNU Lesser General Public License (LGPL) + * + * The guts of the Reed-Solomon decoder, meant to be #included + * into a function body with the following typedefs, macros and variables supplied + * according to the code parameters: + + * data_t - a typedef for the data symbol + * data_t data[] - array of rs->nn data and parity symbols to be corrected in place + * retval - an integer lvalue into which the decoder's return code is written + * NROOTS - the number of roots in the RS code generator polynomial, + * which is the same as the number of parity symbols in a block. + Integer variable or literal. + * rs->nn - the total number of symbols in a RS block. Integer variable or literal. + * rs->pad - the number of pad symbols in a block. Integer variable or literal. + * rs->alpha_to - The address of an array of rs->nn elements to convert Galois field + * elements in index (log) form to polynomial form. Read only. + * rs->index_of - The address of an array of rs->nn elements to convert Galois field + * elements in polynomial form to index (log) form. Read only. + * MODNN - a function to reduce its argument modulo rs->nn. May be inline or a macro. + * rs->fcr - An integer literal or variable specifying the first consecutive root of the + * Reed-Solomon generator polynomial. Integer variable or literal. + * rs->prim - The primitive root of the generator poly. Integer variable or literal. + * DEBUG - If set to 1 or more, do various internal consistency checking. Leave this + * undefined for production code + + * The memset(), memmove(), and memcpy() functions are used. The appropriate header + * file declaring these functions (usually ) must be included by the calling + * program. + */ +#include +#include +#include + +struct rs { + unsigned int magic; /* struct magic */ + int mm; /* Bits per symbol */ + int nn; /* Symbols per block (= (1<= rs->nn) { + x -= rs->nn; + x = (x >> rs->mm) + (x & rs->nn); + } + return x; +} + +#define MODNN(x) modnn(rs, x) +#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MAGIC 0xABCD6722 + +void free_rs_char(void *arg) +{ + struct rs *rs = (struct rs *)arg; + + if (rs == NULL) + return; + if (rs->magic != MAGIC) + return; + + if (rs->alpha_to != NULL) + free(rs->alpha_to); + if (rs->index_of != NULL) + free(rs->index_of); + if (rs->genpoly != NULL) + free(rs->genpoly); + free(rs); +} + +/* Initialize a Reed-Solomon codec + * symsize = symbol size, bits + * gfpoly = Field generator polynomial coefficients + * fcr = first root of RS code generator polynomial, index form + * prim = primitive element to generate polynomial roots + * nroots = RS code generator polynomial degree (number of roots) + * pad = padding bytes at front of shortened block + */ +void *init_rs_char(int symsize, int gfpoly, int fcr, int prim, + int nroots, int pad) +{ + struct rs *rs; + + int i, j, sr,root,iprim; + + /* Check parameter ranges */ + if (symsize < 0 || symsize > 8*sizeof(unsigned char)) + return NULL; + if (fcr < 0 || fcr >= (1<= (1<= (1<= ((1<magic = MAGIC; + + rs->mm = symsize; + rs->nn = (1<pad = pad; + + rs->alpha_to = (unsigned char *)malloc(sizeof(unsigned char)*(rs->nn+1)); + if (rs->alpha_to == NULL) { + free(rs); + return NULL; + } + rs->index_of = (unsigned char *)malloc(sizeof(unsigned char)*(rs->nn+1)); + if (rs->index_of == NULL) { + free(rs->alpha_to); + free(rs); + return NULL; + } + + /* Generate Galois field lookup tables */ + rs->index_of[0] = rs->nn; /* log(zero) = -inf */ + rs->alpha_to[rs->nn] = 0; /* alpha**-inf = 0 */ + sr = 1; + for (i = 0; i < rs->nn; i++) { + rs->index_of[sr] = i; + rs->alpha_to[i] = sr; + sr <<= 1; + if (sr & (1<nn; + } + if (sr != 1) { + /* field generator polynomial is not primitive! */ + free(rs->alpha_to); + free(rs->index_of); + free(rs); + return NULL; + } + + /* Form RS code generator polynomial from its roots */ + rs->genpoly = (unsigned char *)malloc(sizeof(unsigned char)*(nroots+1)); + if(rs->genpoly == NULL) { + free(rs->alpha_to); + free(rs->index_of); + free(rs); + return NULL; + } + rs->fcr = fcr; + rs->prim = prim; + rs->nroots = nroots; + + /* Find prim-th root of 1, used in decoding */ + for (iprim = 1; (iprim % prim) != 0; iprim += rs->nn) + ; + rs->iprim = iprim / prim; + + rs->genpoly[0] = 1; + for (i = 0, root = fcr*prim; i < nroots; i++, root += prim) { + rs->genpoly[i+1] = 1; + + /* Multiply rs->genpoly[] by @**(root + x) */ + for (j = i; j > 0; j--) { + if (rs->genpoly[j] != 0) + rs->genpoly[j] = rs->genpoly[j-1] ^ rs->alpha_to[modnn(rs,rs->index_of[rs->genpoly[j]] + root)]; + else + rs->genpoly[j] = rs->genpoly[j-1]; + } + /* rs->genpoly[0] can never be zero */ + rs->genpoly[0] = rs->alpha_to[modnn(rs,rs->index_of[rs->genpoly[0]] + root)]; + } + /* convert rs->genpoly[] to index form for quicker encoding */ + for (i = 0; i <= nroots; i++) + rs->genpoly[i] = rs->index_of[rs->genpoly[i]]; + + return rs; +} + +int decode_rs_char(void *arg, + unsigned char *data, int *eras_pos, int no_eras) +{ + struct rs *rs = (struct rs *)arg; + + if (rs == NULL) + return -1; + if (rs->magic != MAGIC) + return -1; + + int retval; + int deg_lambda, el, deg_omega; + int i, j, r,k; + + unsigned char u,q,tmp,num1,num2,den,discr_r; + unsigned char lambda[rs->nroots+1], s[rs->nroots]; /* Err+Eras Locator poly + * and syndrome poly */ + unsigned char b[rs->nroots+1], t[rs->nroots+1], omega[rs->nroots+1]; + unsigned char root[rs->nroots], reg[rs->nroots+1], loc[rs->nroots]; + int syn_error, count; + + /* form the syndromes; i.e., evaluate data(x) at roots of g(x) */ + for (i = 0; i < rs->nroots; i++) + s[i] = data[0]; + + for (j = 1; j < rs->nn-rs->pad; j++) { + for(i=0;inroots;i++) { + if(s[i] == 0) { + s[i] = data[j]; + } else { + s[i] = data[j] ^ rs->alpha_to[MODNN(rs->index_of[s[i]] + (rs->fcr+i)*rs->prim)]; + } + } + } + + /* Convert syndromes to index form, checking for nonzero condition */ + syn_error = 0; + for (i = 0; i < rs->nroots; i++) { + syn_error |= s[i]; + s[i] = rs->index_of[s[i]]; + } + + if (!syn_error) { + /* if syndrome is zero, data[] is a codeword and there are no + * errors to correct. So return data[] unmodified + */ + count = 0; + goto finish; + } + memset(&lambda[1], 0, rs->nroots*sizeof(lambda[0])); + lambda[0] = 1; + + if (no_eras > 0) { + /* Init lambda to be the erasure locator polynomial */ + lambda[1] = rs->alpha_to[MODNN(rs->prim*(rs->nn-1-eras_pos[0]))]; + for (i = 1; i < no_eras; i++) { + u = MODNN(rs->prim*(rs->nn-1-eras_pos[i])); + for (j = i+1; j > 0; j--) { + tmp = rs->index_of[lambda[j - 1]]; + if(tmp != rs->nn) + lambda[j] ^= rs->alpha_to[MODNN(u + tmp)]; + } + } + + #if DEBUG >= 1 + /* Test code that verifies the erasure locator polynomial just constructed + Needed only for decoder debugging. */ + + /* find roots of the erasure location polynomial */ + for(i=1;i<=no_eras;i++) + reg[i] = rs->index_of[lambda[i]]; + + count = 0; + for (i = 1,k=rs->iprim-1; i <= rs->nn; i++,k = MODNN(k+rs->iprim)) { + q = 1; + for (j = 1; j <= no_eras; j++) + if (reg[j] != rs->nn) { + reg[j] = MODNN(reg[j] + j); + q ^= rs->alpha_to[reg[j]]; + } + if (q != 0) + continue; + /* store root and error location number indices */ + root[count] = i; + loc[count] = k; + count++; + } + if (count != no_eras) { + printf("count = %d no_eras = %d\n lambda(x) is WRONG\n",count,no_eras); + count = -1; + goto finish; + } + #if DEBUG >= 2 + printf("\n Erasure positions as determined by roots of Eras Loc Poly:\n"); + for (i = 0; i < count; i++) + printf("%d ", loc[i]); + printf("\n"); + #endif + #endif + } + for (i = 0; i < rs->nroots+1; i++) + b[i] = rs->index_of[lambda[i]]; + + /* + * Begin Berlekamp-Massey algorithm to determine error+erasure + * locator polynomial + */ + r = no_eras; + el = no_eras; + while (++r <= rs->nroots) { /* r is the step number */ + /* Compute discrepancy at the r-th step in poly-form */ + discr_r = 0; + for (i = 0; i < r; i++) { + if ((lambda[i] != 0) && (s[r-i-1] != rs->nn)) { + discr_r ^= rs->alpha_to[MODNN(rs->index_of[lambda[i]] + s[r-i-1])]; + } + } + discr_r = rs->index_of[discr_r]; /* Index form */ + if (discr_r == rs->nn) { + /* 2 lines below: B(x) <-- x*B(x) */ + memmove(&b[1],b,rs->nroots*sizeof(b[0])); + b[0] = rs->nn; + } else { + /* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */ + t[0] = lambda[0]; + for (i = 0 ; i < rs->nroots; i++) { + if(b[i] != rs->nn) + t[i+1] = lambda[i+1] ^ rs->alpha_to[MODNN(discr_r + b[i])]; + else + t[i+1] = lambda[i+1]; + } + if (2 * el <= r + no_eras - 1) { + el = r + no_eras - el; + /* + * 2 lines below: B(x) <-- inv(discr_r) * + * lambda(x) + */ + for (i = 0; i <= rs->nroots; i++) + b[i] = (lambda[i] == 0) ? rs->nn : MODNN(rs->index_of[lambda[i]] - discr_r + rs->nn); + } else { + /* 2 lines below: B(x) <-- x*B(x) */ + memmove(&b[1],b,rs->nroots*sizeof(b[0])); + b[0] = rs->nn; + } + memcpy(lambda,t,(rs->nroots+1)*sizeof(t[0])); + } + } + + /* Convert lambda to index form and compute deg(lambda(x)) */ + deg_lambda = 0; + for (i = 0;i < rs->nroots+1; i++){ + lambda[i] = rs->index_of[lambda[i]]; + if(lambda[i] != rs->nn) + deg_lambda = i; + } + /* Find roots of the error+erasure locator polynomial by Chien search */ + memcpy(®[1], &lambda[1], rs->nroots*sizeof(reg[0])); + count = 0; /* Number of roots of lambda(x) */ + for (i = 1,k=rs->iprim-1; i <= rs->nn; i++,k = MODNN(k+rs->iprim)) { + q = 1; /* lambda[0] is always 0 */ + for (j = deg_lambda; j > 0; j--) { + if (reg[j] != rs->nn) { + reg[j] = MODNN(reg[j] + j); + q ^= rs->alpha_to[reg[j]]; + } + } + if (q != 0) + continue; /* Not a root */ + /* store root (index-form) and error location number */ + #if DEBUG>=2 + printf("count %d root %d loc %d\n",count,i,k); + #endif + root[count] = i; + loc[count] = k; + /* If we've already found max possible roots, + * abort the search to save time + */ + if(++count == deg_lambda) + break; + } + if (deg_lambda != count) { + /* + * deg(lambda) unequal to number of roots => uncorrectable + * error detected + */ + count = -1; + goto finish; + } + /* + * Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo + * x**rs->nroots). in index form. Also find deg(omega). + */ + deg_omega = deg_lambda-1; + for (i = 0; i <= deg_omega;i++) { + tmp = 0; + for (j = i; j >= 0; j--) { + if ((s[i - j] != rs->nn) && (lambda[j] != rs->nn)) + tmp ^= rs->alpha_to[MODNN(s[i - j] + lambda[j])]; + } + omega[i] = rs->index_of[tmp]; + } + /* + * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 = + * inv(X(l))**(rs->fcr-1) and den = lambda_pr(inv(X(l))) all in poly-form + */ + for (j = count-1; j >=0; j--) { + num1 = 0; + for (i = deg_omega; i >= 0; i--) { + if (omega[i] != rs->nn) + num1 ^= rs->alpha_to[MODNN(omega[i] + i * root[j])]; + } + num2 = rs->alpha_to[MODNN(root[j] * (rs->fcr - 1) + rs->nn)]; + den = 0; + + /* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */ + for (i = MIN(deg_lambda, rs->nroots-1) & ~1; i >= 0; i -=2) { + if(lambda[i+1] != rs->nn) + den ^= rs->alpha_to[MODNN(lambda[i+1] + i * root[j])]; + } + #if DEBUG >= 1 + if (den == 0) { + printf("\n ERROR: denominator = 0\n"); + count = -1; + goto finish; + } + #endif + /* Apply error to data */ + if (num1 != 0 && loc[j] >= rs->pad) { + data[loc[j]-rs->pad] ^= rs->alpha_to[MODNN(rs->index_of[num1] + rs->index_of[num2] + rs->nn - rs->index_of[den])]; + } + } + finish: + if(eras_pos != NULL) { + for (i = 0; i < count; i++) + eras_pos[i] = loc[i]; + } + retval = count; + + return retval; +} diff --git a/RX_FSK/update.ino.bin b/RX_FSK/update.ino.bin new file mode 100644 index 0000000..18dea71 Binary files /dev/null and b/RX_FSK/update.ino.bin differ diff --git a/RX_FSK/version.h b/RX_FSK/version.h new file mode 100644 index 0000000..3281d33 --- /dev/null +++ b/RX_FSK/version.h @@ -0,0 +1,4 @@ +const char *version_name = "RadioSonde"; +const char *version_id = "1.0.0"; +const int SPIFFS_MAJOR=1; +const int SPIFFS_MINOR=0; diff --git a/Setup.md b/Setup.md new file mode 100755 index 0000000..919703f --- /dev/null +++ b/Setup.md @@ -0,0 +1,99 @@ +# Près-requis +

+ + +## Arduino IDE + +Avoir une version à jour exemple 1.8.13(juillet2020) + +## ESP32 support + +Fichier -> Préférences + +en bas dans la case "URL de gestionnaire de cartes supplémentaires" + +Ajouter *https://dl.espressif.com/dl/package_esp32_index.json* et appuier sur oK + +Puis dans Outils +Outils -> type de cartes -> Gestionnaire de cartes + +dans la case de recherche taper "esp32" + +Installer "esp32 by Espressif Systems" + +Puis après + +## ESP32 Flash Filesystem Upload support + +Télécharger le fichier zip de la dernière version +https://github.com/me-no-dev/arduino-esp32fs-plugin/releases/ + +Décompresser l'archive dans le répértoire tools de votre Arduino IDE + +## Ajouter les bibliothèques + +Séléctionner Outils -> Gestionnaire de bibliothèques + +Installer "U8g2" + +Installer "MicroNMEA" + +mais pour les fonts, car le TTGO fonctionne avec OLED SSD1306 par défaut! + +## Ajouter les bibliothèques, parties 2 + +Depuis https://github.com/me-no-dev/ESPAsyncWebServer télécharger le ZIP , l'extraire dans "libraries" +, renommer le répertoire en ESPAsyncWebServer (supprimer juste "-master") + +Depuis https://github.com/me-no-dev/AsyncTCP télécharger le ZIP, l'extraire dans "libraries", et renommer le répertoire en AsyncTCP + +de même pour https://github.com/lewisxhe/AXP202X_Library télécharger le ZIP, l'extraire dans "libraries", et renommer le répertoire en AXP202X_Library + + +## Ajouter les bibliothèques, parties 3 + +Copier libraries/SX1278FSK +et libraries/SondeLib +et libraries/fonts + +fourni dans libraries + + +``` +ou sous Linux un lien symbolique est aussi possible mais pas obligatoire! +cd ~/Arduino/libraries +ln -s /radiosonde/libraries/SondeLib/ . +ln -s /radiosonde/libraries/SX1278FSK/ . +``` +Redémarrer Arduino IDE + +## Ajout carte esp32 + +Allez dans Outils-> type de cartes -> gestionnaire de cartes + +puis dans la case taper esp32 et Installer. + +## Dernière parties + +Dans Outils -> Esp32 arduino: -> +Séléctionner "TTGO LoRa32-OLED v1" + +Puis il vous faut ouvrir le fichier +RadioSonde_FSK.ino + +Compiler et Téléverser le dans votre TTGO + +puis il faut téléverser maintenant les DATA! + +Dans Outils +cliquer sur ESP32 Sketch Data Upload + +voila le TTGO est prêt! + +Pour les futur mise à jour, +j'ai prévue une mise à jour directe via OTA depuis le TTGO donc +s'il est connecté à internet depuis votre Smartphone ou votre Box. +Cela se fera depuis le menu de la page Web. +73 +Xavier +