muwerk Scheduler Library
A low-resource cooperative scheduler with MQTT-like queues for Arduinos, ATtiny up to ESP32
Loading...
Searching...
No Matches
console.h
1// console.h - the muwerk simple console
2
3#pragma once
4
5#include "ustd_platform.h"
6#include "ustd_array.h"
7#include "muwerk.h"
8#include "scheduler.h"
9
10#ifdef USTD_FEATURE_FILESYSTEM
11#include "filesystem.h"
12#include "jsonfile.h"
13#endif
14
15namespace ustd {
16
22#if defined(__ESP__) || defined(__UNIXOID__)
23typedef std::function<void(String command, String args, Print *printer)> T_COMMANDFN;
24#else
25typedef ustd::function<void(String command, String args, Print *printer)> T_COMMANDFN;
26#endif
27
88class Console {
89 protected:
90#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
91 typedef struct {
92 int id;
93 char *command;
94 T_COMMANDFN fn;
95 } T_COMMAND;
96 ustd::array<T_COMMAND> commands;
97 int commandHandle = 0;
98#endif
99 Print *printer;
100 Scheduler *pSched;
101 int tID;
102 String name;
103 String args = "";
104 ustd::array<int> subsub;
105 bool suball = false;
106 bool debug = false;
107
108 public:
109 Console(String name, Print *printer)
110 : printer(printer), name(name) {
115 }
116
117 virtual ~Console() {
118#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
119 for (unsigned int i = 0; i < commands.length(); i++) {
120 free(commands[i].command);
121 }
122 commands.erase();
123#endif
124 }
125
126 bool execute(String command) {
131 args = command;
132 return execute();
133 }
134
135#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
136 int extend(String command, T_COMMANDFN handler) {
145 T_COMMAND cmd = {};
146 cmd.id = ++commandHandle;
147 cmd.fn = handler;
148 cmd.command = (char *)malloc(command.length() + 1);
149 strcpy(cmd.command, command.c_str());
150 return commands.add(cmd) != -1 ? commandHandle : -1;
151 }
152
153 bool unextend(String command) {
158 for (unsigned int i = 0; i < commands.length(); i++) {
159 if (command == (const char *)commands[i].command) {
160 return commands.erase(i);
161 }
162 }
163 return false;
164 }
165
166 bool unextend(int commandHandle) {
171 for (unsigned int i = 0; i < commands.length(); i++) {
172 if (commands[i].id == commandHandle) {
173 return commands.erase(i);
174 }
175 }
176 return false;
177 }
178#endif
179
180 protected:
181 virtual void prompt() {
182 printer->print("\rmuwerk> ");
183 printer->print(args);
184 }
185
186 size_t outputf(const char *format, ...) {
187 va_list arg;
188 va_start(arg, format);
189 char temp[64];
190 char *buffer = temp;
191 size_t len = vsnprintf(temp, sizeof(temp), format, arg);
192 va_end(arg);
193 if (len > sizeof(temp) - 1) {
194 buffer = new char[len + 1];
195 if (!buffer) {
196 return 0;
197 }
198 va_start(arg, format);
199 vsnprintf(buffer, len + 1, format, arg);
200 va_end(arg);
201 }
202 len = printer->write((const uint8_t *)buffer, len);
203 if (buffer != temp) {
204 delete[] buffer;
205 }
206 return len;
207 }
208
209 bool execute() {
210 args.trim();
211 if (args.length()) {
212 commandparser();
213 args = "";
214 return true;
215 }
216 return false;
217 }
218
219 void commandparser() {
220 String cmd = pullArg();
221 if (cmd == "help") {
222 cmd_help();
223#ifdef __ESP__
224 } else if (cmd == "reboot") {
225 cmd_reboot();
226 } else if (cmd == "wifi") {
227 cmd_wifi();
228#endif
229 } else if (cmd == "uname") {
230 cmd_uname();
231 } else if (cmd == "uptime") {
232 cmd_uptime();
233 } else if (cmd == "info") {
234 cmd_info();
235#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
236 } else if (cmd == "mem") {
237 cmd_mem();
238#endif
239#ifdef USTD_FEATURE_CLK_READ
240 } else if (cmd == "date") {
241 cmd_date();
242#endif
243 } else if (cmd == "sub") {
244 cmd_sub();
245 } else if (cmd == "pub") {
246 cmd_pub();
247#ifdef USTD_FEATURE_FILESYSTEM
248 } else if (cmd == "ls") {
249 cmd_ls();
250 } else if (cmd == "rm") {
251 cmd_rm();
252 } else if (cmd == "cat") {
253 cmd_cat();
254 } else if (cmd == "jf") {
255 cmd_jf();
256#endif
257 } else if (!cmd_custom(cmd)) {
258 printer->println("-mush: " + cmd + ": command not found");
259 }
260 }
261
262 void cmd_help() {
263 String help = "commands: help, pub, sub, uname, uptime, info";
264#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
265 help += ", mem";
266#endif
267#ifdef USTD_FEATURE_CLK_READ
268 help += ", date";
269#endif
270#ifdef USTD_FEATURE_FILESYSTEM
271 help += ", ls, rm, cat, jf";
272#endif
273#ifdef __ESP__
274 help += ", debug, wifi, reboot";
275#endif
276#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
277 for (unsigned int i = 0; i < commands.length(); i++) {
278 help += ", ";
279 help += commands[i].command;
280 }
281#endif
282 printer->println(help);
283 }
284
285 void cmd_sub() {
286 String arg = pullArg();
287 if (arg == "-h" || arg == "-H") {
288 printer->println("usage: sub [all | none]");
289 printer->println("usage: sub topic [topic [..]]");
290 return;
291 } else if (arg == "none") {
292 clearsub();
293 } else if (arg == "all") {
294 addsub("#");
295 } else if (arg.length()) {
296 do {
297 if (addsub(arg)) {
298 arg = pullArg();
299 } else {
300 arg = "";
301 }
302 } while (arg.length());
303 }
304 if (subsub.length()) {
305 if (suball) {
306 printer->println("All topics subscribed");
307 } else {
308 outputf("%i subscriptions\r\n", subsub.length());
309 }
310 } else {
311 printer->println("No subscriptions");
312 }
313 }
314
315 void cmd_pub() {
316 String arg = pullArg();
317 if (arg == "-h" || arg == "-H" || arg == "") {
318 printer->println("usage: pub <topic> <message>");
319 return;
320 }
321 pSched->publish(arg, args, name);
322 }
323
324#ifdef __ESP__
325 void cmd_reboot() {
326 printer->println("Restarting...");
327 ESP.restart();
328 }
329
330 void cmd_wifi() {
331 printer->println("WiFi Information:");
332 printer->println("-----------------");
333 WiFi.printDiag(*printer);
334 printer->println();
335 }
336#endif
337 void cmd_uptime() {
338 unsigned long uptime = pSched->getUptime();
339 unsigned long days = uptime / 86400;
340 unsigned long hours = (uptime % 86400) / 3600;
341 unsigned long minutes = (uptime % 3600) / 60;
342 unsigned long seconds = uptime % 60;
343
344 printer->print("up ");
345 if (days) {
346 printer->print(days);
347 if (days > 1) {
348 printer->print(" days, ");
349 } else {
350 printer->print(" day, ");
351 }
352 }
353 outputf("%2.2lu:%2.2lu:%2.2lu\r\n", hours, minutes, seconds);
354 }
355
356#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
357 void cmd_mem() {
358 printer->println();
359#ifdef __ESP__
360#if defined(__ESP32__) || defined(__ESP32_RISC__)
361 printer->println("Internal Ram:");
362 printer->println("-------------");
363 outputf("Size: %u B\r\n", (unsigned int)ESP.getHeapSize());
364 outputf("Free: %u B\r\n", (unsigned int)ESP.getFreeHeap());
365 outputf("Used: %u B\r\n", (unsigned int)ESP.getHeapSize() - ESP.getFreeHeap());
366 outputf("Peak: %u B\r\n", (unsigned int)ESP.getHeapSize() - ESP.getMinFreeHeap());
367 outputf("MaxB: %u B\r\n", (unsigned int)ESP.getMaxAllocHeap());
368 printer->println();
369
370 printer->println("SPI Ram:");
371 printer->println("--------");
372 outputf("Size: %u B\r\n", (unsigned int)ESP.getPsramSize());
373 outputf("Free: %u B\r\n", (unsigned int)ESP.getFreePsram());
374 outputf("Used: %u B\r\n", (unsigned int)ESP.getPsramSize() - ESP.getFreePsram());
375 outputf("Peak: %u B\r\n", (unsigned int)ESP.getPsramSize() - ESP.getMinFreePsram());
376 outputf("MaxB: %u B\r\n", (unsigned int)ESP.getMaxAllocPsram());
377 printer->println();
378#else
379 printer->println("Internal Ram:");
380 printer->println("-------------");
381 outputf("Free: %u B\r\n", (unsigned int)ESP.getFreeHeap());
382 outputf("Fragmentation: %u%%\r\n", (unsigned int)ESP.getHeapFragmentation());
383 outputf("Largest Free Block: %u B\r\n", (unsigned int)ESP.getMaxFreeBlockSize());
384 printer->println();
385#endif // __ESP32__ || __ESP32_RISC__
386#else
387#ifdef __ARDUINO__
388 printer->println("Memory:");
389 printer->println("-------");
390 printer->print("Free: ");
391 printer->print(freeMemory());
392 printer->println(" B");
393 printer->println();
394#else
395 printer->println("No information available");
396 printer->println();
397#endif // __ARDUINO__
398#endif // __ESP__
399 }
400#endif
401
402 void cmd_info() {
403 printer->println();
404#ifdef __ESP__
405#if defined(__ESP32__) || defined(__ESP32_RISC__)
406 printer->println("ESP32 Information:");
407 printer->println("------------------");
408#ifdef __ESP32_RISC__
409 outputf("Silicon type: RISC-V");
410#else
411 outputf("Silicon type: Tensilica");
412#endif
413 outputf("Chip Verion: %u\r\n", (unsigned int)ESP.getChipRevision());
414 outputf("CPU Frequency: %u MHz\r\n", (unsigned int)ESP.getCpuFreqMHz());
415 outputf("SDK Version: %s\r\n", ESP.getSdkVersion());
416 outputf("Program Size: %u B\r\n", (unsigned int)ESP.getSketchSize());
417 outputf("Program Free: %u B\r\n", (unsigned int)ESP.getFreeSketchSpace());
418 outputf("Flash Chip Size: %u B\r\n", (unsigned int)ESP.getFlashChipSize());
419 outputf("Flash Chip Speed: %.2f MHz\r\n", (float)ESP.getFlashChipSpeed() / 1000000.0);
420 printer->println();
421#else
422 printer->println("ESP Information:");
423 printer->println("----------------");
424 outputf("Chip ID: %u\r\n", (unsigned int)ESP.getChipId());
425 outputf("Chip Version: %s\r\n", ESP.getCoreVersion().c_str());
426 outputf("SDK Version: %s\r\n", ESP.getSdkVersion());
427 outputf("CPU Frequency: %u MHz\r\n", (unsigned int)ESP.getCpuFreqMHz());
428 outputf("Program Size: %u B\r\n", (unsigned int)ESP.getSketchSize());
429 outputf("Program Free: %u B\r\n", (unsigned int)ESP.getFreeSketchSpace());
430 outputf("Flash Chip ID: %u\r\n", (unsigned int)ESP.getFlashChipId());
431 outputf("Flash Chip Size: %u B\r\n", (unsigned int)ESP.getFlashChipSize());
432 outputf("Flash Chip Real Size: %u B\r\n", (unsigned int)ESP.getFlashChipRealSize());
433 outputf("Flash Chip Speed: %.2f MHz\r\n", (float)ESP.getFlashChipSpeed() / 1000000.0);
434 outputf("Last Reset Reason: %s\r\n", ESP.getResetReason().c_str());
435 printer->println();
436#endif // __ESP32__ || __ESP32_RISC__
437#else
438#ifdef __ARDUINO__
439#if USTD_FEATURE_MEMORY < USTD_FEATURE_MEM_8K
440 printer->print("mem ");
441 printer->print(freeMemory());
442 printer->print(", ");
443 printer->print((float)(F_CPU) / 1000000.0, 2);
444 printer->println(" MHz");
445 printer->println();
446#else
447 printer->print("CPU Frequency: ");
448 printer->print((float)(F_CPU) / 1000000.0, 2);
449 printer->println(" MHz");
450 outputf("Free Memory: %u B\r\n", (unsigned int)freeMemory());
451 printer->println();
452#endif // __LOWMEM
453#else
454#if USTD_FEATURE_MEMORY < USTD_FEATURE_MEM_8K
455 printer->println("No info");
456#else
457 printer->println("No information available");
458#endif
459 printer->println();
460#endif // __ARDUINO__
461#endif // __ESP__
462 }
463
464 void cmd_uname(char opt = '\0', bool crlf = true) {
465 String arg;
466 switch (opt) {
467 case '\0':
468 arg = pullArg();
469 switch (arg.length()) {
470 case 0:
471 break;
472 case 2:
473 if (arg[0] == '-') {
474 cmd_uname(arg[1]);
475 return;
476 }
477 // intended fallthrough
478 default:
479 cmd_uname('h');
480 return;
481 }
482 // intended fallthrough
483 case 's':
484 printer->print("munix");
485 break;
486 case 'a':
487 // all
488 cmd_uname('s', false);
489 printer->print(" ");
490 cmd_uname('n', false);
491 printer->print(" ");
492 cmd_uname('v', false);
493 break;
494 case 'n':
495#ifdef __ESP__
496#if defined(__ESP32__) || defined(__ESP32_RISC__)
497 printer->print(WiFi.getHostname());
498#else
499 printer->print(WiFi.hostname());
500#endif
501#else
502 printer->print("localhost");
503#endif
504 break;
505 case 'r':
506#ifdef __ESP__
507 printer->print(ESP.getSdkVersion());
508#else
509 printer->print("unknown");
510#endif
511 break;
512 case 'p':
513#ifdef __ESP__
514#if defined(__ESP32__)
515 printer->print("ESP32 (Tensilica)");
516#elif defined(__ESP32_RISC__)
517 printer->print("ESP32 (RISC-V)");
518#else
519 printer->print("ESP");
520#endif
521#else
522#ifdef __ARDUINO__
523 printer->print("Arduino");
524#else
525 printer->print("Unknown");
526#endif
527#endif
528 break;
529 case 'v':
530 cmd_uname('p', false);
531 printer->print(" Version ");
532 cmd_uname('r', false);
533 printer->print(": " __DATE__ " " __TIME__);
534#ifdef PLATFORMIO
535 printer->print("; PlatformIO " + String(PLATFORMIO));
536#ifdef ARDUINO_VARIANT
537 printer->print(", " ARDUINO_VARIANT);
538#endif
539#endif
540 break;
541 case 'h':
542 default:
543 printer->println("usage: uname [-amnprsv]");
544 return;
545 }
546 if (crlf) {
547 printer->println();
548 }
549 }
550
551#ifdef USTD_FEATURE_CLK_READ
552 void cmd_date() {
553 String arg = pullArg();
554 arg.toLowerCase();
555 if (arg == "-h") {
556#ifdef USTD_FEATURE_CLK_SET
557 printer->println("usage: date [[YYYY-MM-DD] hh:mm:ss]");
558#else
559 printer->println("usage: date");
560#endif
561 return;
562 }
563 time_t t = time(nullptr);
564 struct tm *lt = localtime(&t);
565 if (!lt) {
566 printer->println("error: current time cannot be determined");
567 return;
568 }
569 if (arg == "") {
570 outputf("%4.4i-%2.2i-%2.2i %2.2i:%2.2i:%2.2i - epoch %lu\r\n", (int)lt->tm_year + 1900,
571 (int)lt->tm_mon + 1, (int)lt->tm_mday, (int)lt->tm_hour, (int)lt->tm_min,
572 (int)lt->tm_sec, t);
573 } else {
574#ifdef USTD_FEATURE_CLK_SET
575 if (args.length()) {
576 // we have 2 arguments - the first is a date
577 int i = sscanf(arg.c_str(), "%4i-%2i-%2i", &lt->tm_year, &lt->tm_mon, &lt->tm_mday);
578 if (i != 3 || lt->tm_year < 1970 || lt->tm_year > 2038 || lt->tm_mon < 1 ||
579 lt->tm_mon > 11 || lt->tm_mday < 1 || lt->tm_mday > 31) {
580 printer->println("error: " + arg + " is not a date");
581 return;
582 }
583 lt->tm_year -= 1900;
584 lt->tm_mon -= 1;
585 // fetch next
586 arg = pullArg();
587 }
588 int i = sscanf(arg.c_str(), "%2i:%2i:%2i", &lt->tm_hour, &lt->tm_min, &lt->tm_sec);
589 if (i != 3 || lt->tm_hour < 0 || lt->tm_hour > 23 || lt->tm_min < 0 ||
590 lt->tm_min > 59 || lt->tm_sec < 0 || lt->tm_sec > 59) {
591 printer->println("error: " + arg + " is not a time");
592 return;
593 }
594 time_t newt = mktime(lt);
595#ifdef __ESP__
596 DBGF("Setting date to: %4.4i-%2.2i-%2.2i %2.2i:%2.2i:%2.2i - epoch %lu\n",
597 lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday, lt->tm_hour, lt->tm_min,
598 lt->tm_sec, (unsigned long)newt);
599#endif
600 time(&newt);
601 // invoke myself to display resulting date
602 args = "";
603 printer->print("Date set to: ");
604 cmd_date();
605#endif // __ESP__
606 }
607 }
608#endif // USTD_FEATURE_CLK_READ
609
610#ifdef USTD_FEATURE_FILESYSTEM
611 void cmd_ls() {
612 ustd::array<String> paths;
613 bool extended = false;
614
615 for (String arg = pullArg(); arg.length(); arg = pullArg()) {
616 if (arg == "-h" || arg == "-H") {
617 printer->println("\rusage: ls [-l] <path> [<path> [...]]");
618 return;
619 } else if (arg == "-l" || arg == "-L" || arg == "-la") {
620 extended = true;
621 } else {
622 paths.add(arg);
623 }
624 }
625
626 if (paths.length() == 0) {
627 String root = "/";
628 paths.add(root);
629 }
630
631 for (unsigned int i = 0; i < paths.length(); i++) {
632 fs::Dir dir = fsOpenDir(paths[i]);
633 while (dir.next()) {
634 if (extended) {
635 outputf("%crw-rw-rw- root root %10u ", (dir.isDirectory() ? 'd' : '-'),
636 dir.fileSize());
637 time_t tt = dir.fileTime();
638 struct tm *lt = localtime(&tt);
639 if (lt) {
640 outputf("%4.4i-%2.2i-%2.2i %2.2i:%2.2i:%2.2i ", lt->tm_year + 1900,
641 lt->tm_mon + 1, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec);
642 }
643 }
644 printer->println(dir.fileName());
645 }
646 }
647 }
648
649 void cmd_rm() {
650 String arg = pullArg();
651 if (arg == "-h" || arg == "-H") {
652 printer->println("usage: rm <filename>");
653 return;
654 }
655 if (!fsDelete(arg)) {
656#ifndef USE_SERIAL_DBG
657 printer->println("error: File " + arg + " can't be deleted.");
658#endif
659 }
660 }
661
662 void cmd_cat() {
663 String arg = pullArg();
664 if (arg == "-h" || arg == "-H") {
665 printer->println("usage: cat <filename>");
666 return;
667 }
668
669 fs::File f = fsOpen(arg, "r");
670 if (!f) {
671#ifndef USE_SERIAL_DBG
672 printer->println("error: File " + arg + " can't be opened.");
673#endif
674 return;
675 }
676 if (!f.available()) {
677 f.close();
678 return;
679 }
680 while (f.available()) {
681 // Lets read line by line from the file
682 printer->println(f.readStringUntil('\n'));
683 }
684 f.close();
685 }
686
687 void cmd_jf() {
688 String arg = pullArg();
689 arg.toLowerCase();
690
691 if (arg == "-h" || arg == "") {
692 cmd_jf_help();
693 } else if (arg == "get") {
694 cmd_jf_get();
695 } else if (arg == "set") {
696 cmd_jf_set();
697 } else if (arg == "del") {
698 cmd_jf_del();
699 } else {
700 printer->println("error: bad command " + arg + "specified.");
701 cmd_jf_help();
702 }
703 }
704
705 void cmd_jf_help() {
706 printer->println("usage: jf get <jsonpath>");
707 printer->println("usage: jf set <jsonpath> <jsonvalue>");
708 printer->println("usage: jf del <jsonpath>");
709 }
710
711 void cmd_jf_get() {
712 String arg = pullArg();
713
714 if (arg == "-h" || arg == "-H" || arg == "") {
715 cmd_jf_help();
716 return;
717 }
718
719 ustd::jsonfile jf;
720 JSONVar value;
721
722 if (!jf.readJsonVar(arg, value)) {
723#ifndef USE_SERIAL_DBG
724 printer->println("error: Cannot read value " + arg);
725#endif
726 return;
727 }
728 printer->print(arg);
729
730 String type = JSON.typeof(value);
731 printer->print(": " + type);
732 if (type == "unknown") {
733 printer->println("");
734 } else {
735 printer->println(", " + JSON.stringify(value));
736 }
737 }
738
739 void cmd_jf_set() {
740 String arg = pullArg();
741
742 if (arg == "-h" || arg == "-H" || arg == "" || args == "") {
743 cmd_jf_help();
744 return;
745 }
746
747 ustd::jsonfile jf;
748 JSONVar value = JSON.parse(args);
749 if (JSON.typeof(value) == "undefined") {
750 printer->println("error: Cannot parse value " + args);
751 return;
752 }
753 if (!jf.writeJsonVar(arg, value)) {
754#ifndef USE_SERIAL_DBG
755 printer->println("error: Failed to write value " + arg);
756#endif
757 }
758 }
759
760 void cmd_jf_del() {
761 String arg = pullArg();
762
763 if (arg == "-h" || arg == "-H" || arg == "") {
764 cmd_jf_help();
765 return;
766 }
767
768 ustd::jsonfile jf;
769 if (!jf.remove(arg)) {
770#ifndef USE_SERIAL_DBG
771 printer->println("error: Failed to delete value " + arg);
772#endif
773 }
774 }
775#endif
776
777 bool cmd_custom(String &cmd) {
778#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
779 for (unsigned int i = 0; i < commands.length(); i++) {
780 if (cmd == commands[i].command) {
781 commands[i].fn(cmd, args, printer);
782 return true;
783 }
784 }
785#endif
786 return false;
787 }
788
789 bool addsub(String topic) {
790 if (suball) {
791 return false;
792 } else if (topic == "#" && subsub.length()) {
793 clearsub();
794 }
795 int iSubId =
796 pSched->subscribe(tID, topic, [this](String topic, String msg, String originator) {
797 printer->print("\r>> ");
798#if USTD_FEATURE_MEMORY >= USTD_FEATURE_MEM_8K
799 if (originator.length()) {
800 printer->print("[");
801 printer->print(originator);
802 printer->print("] ");
803 }
804#endif
805 printer->print(topic);
806 printer->print(" ");
807 printer->println(msg);
808 prompt();
809 });
810 subsub.add(iSubId);
811 if (topic == "#") {
812 suball = true;
813 }
814 return true;
815 }
816
817 void clearsub() {
818 if (subsub.length()) {
819 for (unsigned int i = 0; i < subsub.length(); i++) {
820 pSched->unsubscribe(subsub[i]);
821 }
822 }
823 subsub.erase();
824 suball = false;
825 }
826
827 String pullArg(String defValue = "") {
828 return ustd::shift(args, ' ', defValue);
829 }
830};
831
874#if USTD_FEATURE_MEMORY < USTD_FEATURE_MEM_8K
875#define MU_SERIAL_BUF_SIZE 0
876#else
877#ifdef __ARDUINO__
878#define MU_SERIAL_BUF_SIZE 2
879#endif
880#endif
881
882#ifndef MU_SERIAL_BUF_SIZE
883#define MU_SERIAL_BUF_SIZE 16
884#endif
885#ifndef MU_SERIAL_CHUNK_SIZE
886#define MU_SERIAL_CHUNK_SIZE 32
887#endif
888
890class SerialConsole : public Console {
891 protected:
892#if MU_SERIAL_BUF_SIZE > 0
893 char buffer[MU_SERIAL_BUF_SIZE];
894 char *pcur;
895#endif
896
897 public:
898 SerialConsole()
899 : Console("serial", &Serial) {
902#if MU_SERIAL_BUF_SIZE > 0
903 pcur = buffer;
904 memset(buffer, 0, sizeof(buffer) / sizeof(char));
905#endif
906 }
907
908 void begin(Scheduler *_pSched, String initialCommand = "", unsigned long pollRate = 60) {
919 begin(_pSched, &Serial, initialCommand, pollRate);
920 }
921
922 void begin(Scheduler *_pSched, Stream *pSerial, String initialCommand = "",
923 unsigned long pollRate = 60) {
935 if (pollRate < 60) {
936 pollRate = 60000L;
937 } else if (pollRate > 1000) {
938 pollRate = 1000000L;
939 } else {
940 pollRate *= 1000;
941 }
942 pSched = _pSched;
943 printer = pSerial;
944 tID = pSched->add([this]() { this->loop(); }, name, 60000); // 60ms
945 printer->println();
946 execute(initialCommand);
947 prompt();
948 }
949
950 protected:
951#if MU_SERIAL_BUF_SIZE > 0
952 virtual void prompt() {
953 Console::prompt();
954 printer->print(buffer);
955 }
956#endif
957
958 void loop() {
959 int incomingByte;
960 bool changed = false;
961 int count = 0;
962
963 while ((incomingByte = ((Stream *)printer)->read()) != -1 && count < MU_SERIAL_CHUNK_SIZE) {
964 ++count; // limit reads per cycle
965 switch (incomingByte) {
966 case 0: // ignore
967 case 10: // ignore
968 break;
969 case 8: // backspace
970#if MU_SERIAL_BUF_SIZE > 0
971 if (pcur > buffer) {
972 --pcur;
973 *pcur = 0;
974 } else if (args.length()) {
975 args.remove(args.length() - 1, 1);
976 }
977#else
978 if (args.length()) {
979 args.remove(args.length() - 1, 1);
980 }
981#endif
982 changed = true;
983 break;
984 case 13: // enter
985 printer->println();
986#if MU_SERIAL_BUF_SIZE > 0
987 flush();
988#endif
989 execute();
990 changed = true;
991 break;
992 case 9: // tab
993 incomingByte = 32;
994 // treat like space
995 default:
996#if MU_SERIAL_BUF_SIZE > 0
997 *pcur = (char)incomingByte;
998 ++pcur;
999 if (pcur == buffer + (sizeof(buffer) / sizeof(char)) - 1) {
1000 // buffer full - flush it to args
1001 flush();
1002 }
1003#else
1004 args += (char)incomingByte;
1005#endif
1006 changed = true;
1007 break;
1008 }
1009 }
1010
1011 if (changed) {
1012 prompt();
1013 }
1014 }
1015
1016#if MU_SERIAL_BUF_SIZE > 0
1017 void flush() {
1018 *pcur = 0;
1019 args += buffer;
1020 // rewind
1021 pcur = buffer;
1022 memset(buffer, 0, sizeof(buffer) / sizeof(char));
1023 }
1024#endif
1025}; // class Console
1026
1027} // namespace ustd
ustd::Console
muwerk Console Class
Definition console.h:88
ustd::Console::unextend
bool unextend(int commandHandle)
Definition console.h:166
ustd::Console::unextend
bool unextend(String command)
Definition console.h:153
ustd::Console::extend
int extend(String command, T_COMMANDFN handler)
Definition console.h:136
ustd::Console::execute
bool execute(String command)
Definition console.h:126
ustd::Console::Console
Console(String name, Print *printer)
Definition console.h:109
ustd::Scheduler
muwerk Scheduler Class
Definition scheduler.h:199
ustd::Scheduler::add
int add(T_TASK task, String name, unsigned long minMicroSecs=100000L, T_PRIO prio=PRIO_NORMAL)
Definition scheduler.h:475
ustd::Scheduler::getUptime
unsigned long getUptime()
Definition scheduler.h:554
ustd::Scheduler::publish
bool publish(String topic, String msg="", String originator="")
Definition scheduler.h:367
ustd::Scheduler::subscribe
int subscribe(int taskID, String topic, T_SUBS subs, String originator="")
Definition scheduler.h:395
ustd::Scheduler::unsubscribe
bool unsubscribe(int subscriptionHandle)
Definition scheduler.h:428
ustd::SerialConsole
muwerk Serial Console Class
Definition console.h:890
ustd::SerialConsole::begin
void begin(Scheduler *_pSched, String initialCommand="", unsigned long pollRate=60)
Definition console.h:908
ustd::SerialConsole::begin
void begin(Scheduler *_pSched, Stream *pSerial, String initialCommand="", unsigned long pollRate=60)
Definition console.h:922
ustd::SerialConsole::SerialConsole
SerialConsole()
Definition console.h:898
ustd::jsonfile
muwerk JSON File Class
Definition jsonfile.h:67
ustd::jsonfile::remove
bool remove(String key)
Definition jsonfile.h:206
ustd::jsonfile::writeJsonVar
bool writeJsonVar(String key, JSONVar &value)
Definition jsonfile.h:685
ustd::jsonfile::readJsonVar
bool readJsonVar(String key, JSONVar &value)
Definition jsonfile.h:228
ustd
The muwerk namespace.
Definition console.h:15
ustd::fsOpen
fs::File fsOpen(String filename, String mode)
Definition filesystem.h:113
ustd::fsOpenDir
fs::Dir fsOpenDir(String path)
Definition filesystem.h:134
ustd::shift
String shift(String &src, char delimiter=' ', String defValue="")
Definition muwerk.h:94
ustd::fsDelete
bool fsDelete(String filename)
Definition filesystem.h:97
ustd::T_COMMANDFN
std::function< void(String command, String args, Print *printer)> T_COMMANDFN
Console Extension Function.
Definition console.h:23
Generated by doxygen 1.9.7