/* -------------------------------------------------------- eventb_ctrl6.ino Eventbasierendes System, hier ganz bewusst ohne Interrupts 11.05.2026 R. Seelig -------------------------------------------------------- */ #include #include #include #include #include "sn74hc595.h" #include "eventsources.h" #include "my_printf.h" #include "colpos.h" #ifdef CH32V00x #include "HardwareSerial_v003.h" // CH32V003-spezifische Instanz HardwareSerial_v003 mySerial; #else // alle anderen Cores HardwareSerial &mySerial = Serial; #endif #define printf my_printf // "Umleiten" des originalen printf auf eigenes my_printf // sodass innerhalb dieses Programms dieses abgespeckte printf verwendet // werden kann /* ---------------------------------------------------------------------- Objektinstanz von shiftreg595 erstellen Usage: shiftreg595::shiftreg595(uint8_t clk, uint8_t dat, uint8_t stb) ---------------------------------------------------------------------- */ shiftreg595 sr(2, 3, 15); // stm32 r3-board (PB7, PB6, PB13) // shiftreg595 sr(5, 3, A2); // V003-Board // shiftreg595 sr(5, 7, 6); // Board 1 // shiftreg595 sr(7, 5, 6); // Board 2 /* ---------------------------------------------------------------------- Dip-Schalter an Pin xx und Pin xx angeschlossen --------------------------------------------------------------------- */ constexpr int dipkey_0= 4; constexpr int dipkey_1= 5; /* ---------------------------------------------------------------------- Trimmer an A0 angeschlossen ---------------------------------------------------------------------- */ constexpr int TimerA_adcpin= A0; constexpr int ntcpin = A1; /* ---------------------------------------------------------------------- LED angeschlossen an Pin xx (onboard LED) ---------------------------------------------------------------------- */ // constexpr int blinkLed = A5; // Build-In LED Eigenbau constexpr int blinkLed = 13; // Build-In LED UNO / Nano / Mega2650 / Due /* ---------------------------------------------------------------------- Eventcodes grundsaetzlich koennen hier frei Codes vergeben werden, einzig sie duerfen nicht doppelt auftreten, da sonst der Event-Handler nicht korrekt arbeiten kann. ---------------------------------------------------------------------- */ constexpr uint8_t TimerA_event = 0x80; // Event TimerA mit ADC fuer abgelaufene Zeit constexpr uint8_t TimerB_event = 0x40; // Event TimerB abgelaufene Zeit constexpr uint8_t AppTimer_event = 0x35; // Intervalltimer mittels dem ausgabemachende // Funktionen aufgerufen werden constexpr uint8_t MyDate_event = 0x31; constexpr uint8_t SysTick_event = 0x30; constexpr uint8_t Dipkey1Change_event = 0x21; // Event fuer einen Pinchange an dipkey_1 constexpr uint8_t Dipkey0Change_event = 0x20; // Event fuer einen Pinchange an dipkey_0 constexpr uint8_t UartChar_event = 0x10; // Event Zeichen auf UART eingetroffen constexpr uint8_t UartCr_event = 0x0d; // Event Cr auf UART eingetroffen /* ---------------------------------------------------------------------- Befehle der Kommandozeile ---------------------------------------------------------------------- */ constexpr char uhrset_cmd[] = {"clockset"}; constexpr char uhrrun_cmd[] = {"clockrun"}; constexpr char runlight_cmd[] = {"runlight"}; constexpr char blktime_cmd[] = {"ledinterval"}; constexpr char gettemp_cmd[] = {"temp"}; constexpr char nrguess_cmd[] = {"numberguess"}; constexpr char dice_cmd[] = {"dice"}; constexpr char list_cmd[] = {"list"}; enum { idle, clockset, clockrun, runlight, ledinterval, temp, numberguess, diceing, list }; /* ---------------------------------------------------------------------- globale Eventvariable ---------------------------------------------------------------------- */ uint8_t event = 0; // nimmt eingegangene Events nach event_scan auf uint8_t uart_readenable= 0; // Eingabefunktion auf der Konsole // 0: keine Eingabe moeglich // 1: Eingabe moeglich uint8_t uart_outputenable= 1; // Ausgabefunktion auf der Konsole // 1: Ausgabe moeglich // 0: Ausgabe nicht moeglich uint8_t uart_promptenable= 1; // 1: Ausgabe eines Prompts bei Eingabekorrektur // 0: keine Ausgabe /* ---------------------------------------------------------------------- Ojektinstanzen fuer Event-Methoden ---------------------------------------------------------------------- */ TIMERADC TimerA(TimerA_adcpin, TimerA_event); // TimerA stellt Zeit über eingelesenen ADC-Wert ein TIMERSOFT TimerB(500, TimerB_event); // TimerB erzeugt Intervall mit 500 ms TIMERSOFT AppTimer(100, AppTimer_event); // Timerintervall, mit der Funktionen aufgerufen werden, // die I/O Aktionen auf dem UART vornehmen, hier 100 ms GPIOCHANGE dipkey0(dipkey_0, Dipkey0Change_event); // PinChange auf dipkey_0 GPIOCHANGE dipkey1(dipkey_1, Dipkey1Change_event); // dto. dipkey_1 SYSTICKER systick(SysTick_event); DATETIME mydate(MyDate_event); /* -------------------------------------------------- Struct der ESC-Sequenzen fuer Farben -------------------------------------------------- */ _ANSICOLORS acolor; /* ---------------------------------------------------------------------- String des Systemprompts ---------------------------------------------------------------------- */ constexpr char sysprompt[] = {"\033[36mArduino > \033[37m"}; /* ---------------------------------------------------------------------- globales fuer Lauflicht ---------------------------------------------------------------------- */ uint8_t *ll_muster; uint8_t ll_len; uint8_t ll_index; /* ---------------------------------------------------------------------- globaler String, der die eingehenden Zeichen auf der UART entgegen nimmt. ---------------------------------------------------------------------- */ constexpr uint8_t uart_maxeventbuf = 80; char uart_eventbuf[uart_maxeventbuf] = {"\0"}; uint8_t strreadln_ready = 0; uint8_t prog_run = idle; // idle= 0 : es laueft kein Programm mit Ausgaben ueber UART /* ---------------------------------------------------------------------- Lauflichtmuster / -programme. Element 0 ist Laengenbyte und beinhaltet die Anzahl der abzuspielenden Leuchtmuster ---------------------------------------------------------------------- */ constexpr uint8_t ll_maxprogs = 4; uint8_t lauf_bmp0[] = {14, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02 }; uint8_t lauf_bmp1[] = {16, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 }; uint8_t lauf_bmp2[] = { 4, 0x33, 0x66, 0xcc, 0x99 }; uint8_t lauf_bmp3[] = { 8, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x81 }; /* -------------------------------------------------- my_putchar wird von my_printf benoetigt und hier wird die Funktion aufgerufen, auf die my_printf ein Zeichen streamt -------------------------------------------------- */ void my_putchar(char ch) { mySerial.print(ch); } /* ---------------------------------------------------------------------- dipkey_get liest die 2 GPIO-Pins ein, an denen der DIP-Schalter angeschlossen ist ---------------------------------------------------------------------- */ uint8_t dipkey_get(void) { return ((digitalRead(dipkey_1) << 1) | (digitalRead(dipkey_0))); } /* ---------------------------------------------------------------------- str_addbufch fuegt dem Eingangsbuffer auf der UART ein Zeichen hinten an. Im Falle eines Backspace / Del loescht es das letzte Zeichen aus dem Buffer ---------------------------------------------------------------------- */ void str_addbufch(char *s, char ch) { uint8_t len = strlen(s); // CR und LF NICHT in den String aufnehmen if (ch== 0x0d || ch== 0x0a) return; // DEL - Backspacezeichen => letztes Zeichen loeschen if (ch == 0x08 || ch == 0x7F) { if (len > 0) s[len - 1] = '\0'; return; } // alle anderen Zeichen hinten anhaengen, so lange der Eingabebuffer // nicht voll ist. if (len < (uart_maxeventbuf - 1)) { s[len] = ch; s[len + 1] = '\0'; } } /* ---------------------------------------------------------------------- ll_pointerget (LaufLichtMuster-PointerGet) liefert einen Zeiger auf das entsprechende Lauflichtmuster ---------------------------------------------------------------------- */ uint8_t *ll_pointerget(uint8_t mode) { switch (mode) { case 0: { return lauf_bmp0; } case 1: { return lauf_bmp1; } case 2: { return lauf_bmp2; } case 3: { return lauf_bmp3; } default: { return lauf_bmp0; } } } /* ---------------------------------------------------------------------- ll_setmusterseq setzt ein Lauflichtmuster entsprechend den angegebenen Arrays. Ein Pointer auf ein Muster wird gesetzt, die Laenge des Musters erfasst und ein Index auf das 1. Zeichen des Musters gesetzt und dieses auch ausgegeben. ---------------------------------------------------------------------- */ void ll_setmusterseq(uint8_t ll_seq) { ll_muster = ll_pointerget(ll_seq); ll_len = *ll_muster; ll_index = 1; sr.setvalue(*(ll_muster + ll_index), 1); } /* ---------------------------------------------------------------------- ll_step das naechstge Lauflichtbitmuster anzeigen ---------------------------------------------------------------------- */ void ll_step(void) { if (ll_index < ll_len) ll_index++; else ll_index = 1; sr.setvalue(*(ll_muster + ll_index), 1); } /* --------------------------------------------------------- ------------- blinkLed_toggle togglet LED an Pin ---------------------------------------------------------------------- */ void blinkLed_toggle(void) { static uint8_t led = 0x01; led ^= 0xff; digitalWrite(blinkLed, led & 0x01); } /* ---------------------------------------------------------------------- dectoa konvertiert einen Dezimalwert in einen String (als Ersatz fuer einen evtl. nicht vorhandenen itoa) Usage: char s[5]; dectoa(23, s, 4); // "0023" ---------------------------------------------------------------------- */ char* dectoa(uint16_t value, char* buf, uint8_t width) { buf[width] = '\0'; while (width) { buf[--width] = '0' + (value % 10); value /= 10; } return buf; } #define MAX_ARGS 10 /* ---------------------------------------------------------------------- parse_cmd zerlegt ein String in Kommando und nummerische Argumente Uebergabe: input : Zeiger auf Originalstring command : Zeiger, auf Stringspeicherbereich, der das Kommando aufnimmt args : Zeiger auf ein uint16_t Array, das die nummerischen Argumente aufnimmt Rueckgabe: Anzahl der vorhandenen Argumente ---------------------------------------------------------------------- */ uint8_t parse_cmd(char *input, char *command, uint16_t *args) { char *ptr; char *arg_ptr; char *end_ptr; uint8_t cmd_len = 0; uint8_t arg_count = 0; if(input == NULL || command == NULL || args == NULL) return 0; ptr = input; // Führende Leerzeichen ignorieren while(*ptr != '\0' && isspace((uint8_t)*ptr)) { ptr++; } // Befehl kopieren while(*ptr != '\0' && !isspace((uint8_t)*ptr)) { command[cmd_len++] = *ptr; ptr++; } command[cmd_len] = '\0'; // Leerzeichen zwischen Befehl und Argumenten überspringen while(*ptr != '\0' && isspace((uint8_t)*ptr)) { ptr++; } // Keine Argumente vorhanden ? if(*ptr == '\0') return 0; arg_ptr = ptr; while(*arg_ptr != '\0' && arg_count < MAX_ARGS) { // Führende Leerzeichen vor den Argumenten entfernen while(*arg_ptr != '\0' && isspace((unsigned char)*arg_ptr)) { arg_ptr++; } args[arg_count] = (uint16_t)strtoul(arg_ptr, &end_ptr, 10); arg_count++; if(arg_ptr == end_ptr) { break; } arg_ptr = end_ptr; // Leerzeichen nach Zahl entfernen while(*arg_ptr != '\0' && isspace((unsigned char)*arg_ptr)) { arg_ptr++; } if(*arg_ptr == ',') { arg_ptr++; } else { break; } } return arg_count; } /* ------------------------------------------------- Lookup-table fuer NTC-Widerstand R25-Wert: 10.00 kOhm Pullup-Widerstand: 22.00 kOhm Materialkonstante beta: 3950 Aufloesung des ADC: 10 Bit Einheit eines Tabellenwertes: 0.1 Grad Celcius Temperaturfehler der Tabelle: 0.5 Grad Celcius -------------------------------------------------*/ const int ntctable[] = { 1233, 994, 755, 625, 535, 467, 411, 363, 321, 284, 250, 218, 189, 161, 134, 108, 83, 58, 33, 8, -16, -41, -67, -94, -122, -151, -184, -219, -260, -309, -373, -471, -569 }; /* ------------------------------------------------- ntc_gettemp zuordnen des Temperaturwertes aus gegebenem ADC-Wert. ------------------------------------------------- */ int ntc_gettemp(uint16_t adc_value) { int p1,p2; // Stuetzpunkt vor und nach dem ADC Wert ermitteln. p1 = ntctable[ (adc_value >> 5) ]; p2 = ntctable[ (adc_value >> 5) + 1]; // zwischen beiden Punkten interpolieren. return p1 - ( (p1-p2) * (adc_value & 0x001f) ) / 32; } /* ---------------------------------------------------------------------- printtemp gibt die Temperatur auf dem UART aus ---------------------------------------------------------------------- */ void printtemp(uint16_t temp) { printfkomma= 1; settextattr(0x0e); printf(" %k oC ", temp); settextattr(0x07); } /* ---------------------------------------------------------------------- printdatum gibt einen Datumstext auf dem UART aus ---------------------------------------------------------------------- */ void printdatum(void) { const char wtag[][3] = {"So","Mo","Di","Mi","Do","Fr","Sa"}; int wt; wt= mydate.getwtag(); printf(" %s%s:%s %d.%d.%d %d.%d:%d ", acolor.fg_white, wtag[wt], acolor.fg_blue, mydate.day, mydate.month, mydate.year, mydate.hour, mydate.minute, mydate.second ); settextattr(0x07); } /* ---------------------------------------------------------------------- my_date_setdefault stellt ein Defaultdatum ein, hier: 01.01.2026 00.00:00 Uhr ---------------------------------------------------------------------- */ void mydate_setdefault(void) { // ein Datum vorgeben mydate.year= 2026; mydate.month= 1; mydate.day= 1; mydate.hour= 0; mydate.minute= 0; mydate.second= 0; mydate.date2stamp(); // Umrechnung Datum => Zeitstempel systick.seconds= mydate.stamp; // Zeitstempel zu Sekundensystemticker uebernehmen } /* ---------------------------------------------------------------------- cmdlist gibt die moeglichen Kommandobefehle auf dem Terminal aus ---------------------------------------------------------------------- */ void cmdlist(void) { printf("\n\r%s", uhrset_cmd); printf("\n\r%s", uhrrun_cmd); printf("\n\r%s", runlight_cmd); printf("\n\r%s", blktime_cmd); printf("\n\r%s", gettemp_cmd); printf("\n\r%s", nrguess_cmd); printf("\n\r%s", dice_cmd); printf("\n\r%s", list_cmd); printf("\n\n\r"); } /* ---------------------------------------------------------------------- zahlenraten einfache Demofunktion fuer Einbinden einer Funktion mit Konsolen- eingabe. Uebergabe: value : zu vergleichende Zahl mit der "gedachten" Zahl start : Erstaufruf (1) oder Zahlensuchspiel (0) ---------------------------------------------------------------------- */ uint8_t zahlenraten(uint8_t value, uint8_t start) { static int versuch; static int toguess; if (start) { versuch= 1; settextattr(0x0a); printf("\n\rNumber-Guess / Zahlenraten\n\r"); printf("mit 'exit' beenden\n\n\r"); settextattr(0x07); printf("Errate die vom Arduino gewaehlte Zahl (1..99)\n\n\r"); randomSeed(millis()); toguess= random(1,100); printf("%s%d. Versuch: ", acolor.fg_yellow, versuch); settextattr(0x0f); return 0; } else { if (value== toguess) { settextattr(0x0b); printf("\n\rTreffer und Gratulation, du hast die gesuchte Zahl gefunden\n\r"); printf("Du hattest: %s%d%s Versuche ! \n\r", acolor.fg_ired, versuch, acolor.fg_icyan); settextattr(0x07); return 1; } settextattr(0x0a); if (value< toguess) { printf("\n\r Die gesuchte Zahl ist %sGROESSER !\n\n\r", acolor.fg_imagenta); } else { printf("\n\r Die gesuchte Zahl ist %skleiner !\n\n\r", acolor.fg_iblue); } versuch++; settextattr(0x0b); printf("%s%d. Versuch: ", acolor.fg_yellow, versuch); settextattr(0x0f); } return 0; } /* ---------------------------------------------------------------------- diceint: Bitmuster fuer Wuerfelaugen ---------------------------------------------------------------------- */ static const uint16_t diceint[6] = { 0b0000000100000000, // 1 0b1000000000000010, // 2 0b1000000100000010, // 3 0b1000100000100010, // 4 0b1000100100100010, // 5 0b1000110001100010 // 6 }; /* ---------------------------------------------------------------------- dice_show zeigt Wuerfelaugen an ---------------------------------------------------------------------- */ void dice_show(uint8_t v) { uint16_t m = diceint[v - 1]; textcolor(v+8); for (int i = 0; i < 15; i++) { if (m & (1<<(15-i))) printf("o"); else printf(" "); if (i % 5 == 4) printf("\n\r"); } textcolor(7); printf("\n\r"); } /* ---------------------------------------------------------------------- dice wuerfeln ---------------------------------------------------------------------- */ void dice(void) { uint8_t diceval; randomSeed(millis()); diceval= random(1,7); dice_show(diceval); } /* --------------------------------------------------------- ------------- event_scan ersetzt hier im Prinzip Interrupts, in dem jegliche Quelle, die ein Event "erzeugen" kann, abgefragt wird. ---------------------------------------------------------------------- */ uint8_t event_scan(void) { uint8_t event; if (mySerial.available() > 0) return UartChar_event; if (strreadln_ready== 1) return UartCr_event; event= systick.getstate(); if (event) return event; event = TimerA.getstate(); if (event) return event; event = TimerB.getstate(); if (event) return event; event = AppTimer.getstate(); if (event) return event; event = dipkey0.getChange(); if (event) return event; event = dipkey1.getChange(); if (event) return event; return 0; } /* ---------------------------------------------------------------------- event_handler stellt eingegangene "Events" fest und startet den Events zuge- ordneten Funktionen. ---------------------------------------------------------------------- */ void event_handler(void) { uint8_t event; char ch; char concmd[40]; uint16_t cmdargs[10]; uint8_t arganz; uint8_t i; do { event = event_scan(); switch (event) { // ---------------------------------------------------- // Event fuer ueber ADC einstellbaren Timer (TimerA) // ---------------------------------------------------- case TimerA_event: { ll_step(); event= 0; TimerA.setstarttime(); break; } // ---------------------------------------------------- // Event fuer TimerB, hier blinkende LED // ---------------------------------------------------- case TimerB_event: { blinkLed_toggle(); event= 0; TimerB.setstarttime(); break; } case AppTimer_event: { break; } // ---------------------------------------------------- // Event System-Sekundenticker (1 Sekunde) // nach Abarbeitung ist zwingend das // systick.secondsflag= 0 zu setzen, da sonst das // Event-System blockiert wird. // // Zudem werden, hier Funktionen eingehaengt, die // Ausgaben ueber UART machen koennen, jede Sekunde // aufgerufen: // prog_run== clockrun / Systemdatum anzeigen // == temp / Temperatur anzeigen // ---------------------------------------------------- case SysTick_event: { if (uart_outputenable) { mydate.stamp= systick.seconds; // Systemsekunden als Zeitstempel umrechnen mydate.stamp2date(); // und diesen zu einem Datum umrechnen printf("\r"); // an Anfang der Terminalzeile springen switch (prog_run) { case clockrun : { printdatum(); // Datum ausgeben break; } case temp : { int adc= analogRead(ntcpin); int temp= ntc_gettemp(adc); printtemp(temp); break; } default : { break; } } } systick.secondsflag= 0; // Event quittieren break; } // ---------------------------------------------------- // Event fuer Aenderung an Dip-Schaltern // beide Pins des Schalters koennen einen Event // ausloesen. Beide Pins werden hier gelesen, unabhaengig // davon, welcher Pin das Event ausgeloest hat // ---------------------------------------------------- case Dipkey0Change_event: case Dipkey1Change_event: { event= 0; ll_setmusterseq(dipkey_get()); break; } // ---------------------------------------------------- // Event fuer eingegangenes Zeichen auf dem UART // ---------------------------------------------------- case UartChar_event: { // evtl. laufende Programme, die mit einfachem Tastendruck // beendet werden koennen, beenden if ((prog_run== clockrun) || (prog_run== temp)) // Datums- / Temperaturanzeige beenden { prog_run= idle; ch= mySerial.read(); // Dummy-Read um Zeichen vom Eingangspuffer zu nehmen printf("\n\r\n\r%s",sysprompt); // Prompt ausgeben uart_outputenable= 0; // Ausgabemodus auf UART beenden uart_readenable= 1; // und Eingabemodus wieder aktivieren event= 0; break; } // Wuerfelprogramm if (prog_run== diceing) { ch= mySerial.read(); if (ch== 27) // ESC = Wuerfelende { // Wuerfelprogramm beenden prog_run= idle; // Diceing aus Eventhandler herausnehmen printf("\n\r\n\r%s",sysprompt); // Prompt ausgeben uart_outputenable= 0; // Ausgabemodus auf UART beenden uart_readenable= 1; // und Eingabemodus wieder aktivieren uart_promptenable= 1; // Systemprompt in Zeile aktivieren break; } else { dice(); } event= 0; break; } // Zeichen dem Buffer nur dann hinzufuegen, wenn noch kein // Returnzeichen gesendet wurde if (!strreadln_ready) { ch= mySerial.read(); // Zeichen lesen if (!uart_readenable) break; // String einlesen und Echo nur dann, wenn Uart-lesen aktiv. // Hiermit kann verhindert werden, dass sich Ausgaben und // Eingaben auf der Konsole gegenseitig in ihrer Darstellung // "stoeren" printf("%c",ch); // und als Echo ausgeben str_addbufch(&uart_eventbuf[0], ch); // Zeichen im Buffer ablegen // bei Backspace / Delete gesamten String inkl. Prompt neu ausgeben // erforderlich, weil unterschiedliche Terminalemulationen das Echo // untrschiedlich bewerten if ((ch== 0x08) || (ch== 0x7f)) { printf("\b \r"); // am Ende der Zeile garantiert Leerzeichen im // Terminal zum Anzeigeloeschen anfuegen if (uart_promptenable) mySerial.print(sysprompt); printf("%s",uart_eventbuf); } // fuer CR oder LF Eingabezeile Flag fuer eingegangenen String setzen, // wird in event_scan ausgewertet if ((ch== 0x0d) || (ch== 0x0a)) { mySerial.println(""); strreadln_ready= 1; } } event= 0; break; } // ---------------------------------------------------- // Event fuer received string // ein kompletter C-String ist in uart_eventbuf // verfuegbar. // // Innerhalb dieses Events wird ein Kommandoparser // realisiert // ---------------------------------------------------- case UartCr_event: { if (strreadln_ready) { // ---------------------------------------------------- // Programme mit UART-Eingaben hier einhaengen // ---------------------------------------------------- // numberguess // ---------------------------------------------------- if (prog_run== numberguess) { arganz = parse_cmd(uart_eventbuf, concmd, cmdargs); if (strcmp(concmd, "exit") == 0) { prog_run= idle; // laufende Funktion beenden printf("\n\r%s",sysprompt); uart_promptenable= 1; uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // CR-Flag zuruecknehmen break; } else { int guess= atoi(uart_eventbuf); // uart-eingabe nach Integer umrechnen // Programm wird beendet if (zahlenraten(guess, 0)) { prog_run= idle; // laufende Funktion beenden printf("\n\r%s",sysprompt); uart_promptenable= 1; } uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // CR-Flag zuruecknehmen break; } } // ---------------------------------------------------- // Kommandoparser hier eingehaengen // ---------------------------------------------------- arganz = parse_cmd(uart_eventbuf, concmd, cmdargs); // cmd== dice // ---------------------------------------------------- if (strcmp(concmd, dice_cmd) == 0) { uart_promptenable= 0; printf("\n\r Diceing\n\r"); printf("\n\r Hit a key to dice, ESC to stop diceing\n\r"); prog_run= diceing; uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // und lesen wieder freigeben dice(); break; } // cmd== nrguess // ---------------------------------------------------- if (strcmp(concmd, nrguess_cmd) == 0) { uart_promptenable= 0; zahlenraten(0,1); // Zahlenraten starten prog_run= numberguess; uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // und lesen wieder freigeben break; } // cmd== list // ---------------------------------------------------- if (strcmp(concmd, list_cmd) == 0) { uart_promptenable= 0; cmdlist(); uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // und lesen wieder freigeben prog_run= idle; // laufende Funktion beenden printf("%s",sysprompt); uart_promptenable= 1; break; } // cmd== ledinterval // ---------------------------------------------------- else if (strcmp(concmd, blktime_cmd) == 0) { if (arganz == 0) { printf("\n\r wrong number of arguments\n\r"); printf("\n\r Syntax: ledinterval delaytime\n\r"); } else { printf("\n\r new LED interval running: %d", cmdargs[0]); TimerB.setoverflow(cmdargs[0]); // Intervallzeit TimerB (LED) TimerB.setstarttime(); // die erste Ablaufzeit TimerB setzen } } // cmd== runlight // ---------------------------------------------------- else if (strcmp(concmd, runlight_cmd) == 0) { if (arganz == 0) { printf("\n\r wrong number of arguments\n\r"); printf("\n\r Syntax: runlight prognr\n\r"); } else { printf("\n\r runlight program running: %d\n\r", cmdargs[0] % ll_maxprogs); ll_setmusterseq(cmdargs[0] % ll_maxprogs); } } // cmd== clockrun // ---------------------------------------------------- else if (strcmp(concmd, uhrrun_cmd) == 0) { printf("Hit any key to stop viewing system time\r\n\n"); uart_readenable= 0; // Eingabepuffer UART fuer die Dauer der Systemuhranzeige sperren uart_outputenable= 1; // Uart-Anzeige zulassen prog_run= clockrun; uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // CR-Flag zuruecknehmen break; } // cmd== temp // ---------------------------------------------------- else if (strcmp(concmd, gettemp_cmd) == 0) { printf("Hit any key to stop temperature measurement\r\n\n"); uart_readenable= 0; // Eingabepuffer UART fuer die Dauer der Temperaturanzeige sperren uart_outputenable= 1; // Uart-Anzeige zulassen prog_run= temp; uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // CR-Flag zuruecknehmen break; } // cmd== clockset // ---------------------------------------------------- else if (strcmp(concmd, uhrset_cmd) == 0) { if (arganz != 6) { printf("\n\r wrong number of arguments\n\r"); printf("\n\r Syntax: clockset day,month,year,hour,minute,second\n\r"); } else { mydate.day= cmdargs[0]; mydate.month= cmdargs[1]; mydate.year= cmdargs[2]; mydate.hour= cmdargs[3]; mydate.minute= cmdargs[4]; mydate.second= cmdargs[5]; mydate.date2stamp(); // Umrechnung Datum => Zeitstempel systick.seconds= mydate.stamp; // Zeitstempel zu Sekundensystemticker uebernehmen printf(" "); printdatum(); printf(" \n\r"); } } else { if (uart_eventbuf[0] != '\0') { mySerial.print("cmd not found: "); mySerial.println(uart_eventbuf); } } printf("\n\r%s", sysprompt); uart_eventbuf[0]= '\0'; // Eingabebuffer loeschen strreadln_ready= 0; // und lesen wieder freigeben } break; } default : { break; } } } while (event); } /* ---------------------------------------------------------------------- setup ---------------------------------------------------------------------- */ void setup() { mySerial.begin(115200); settextattr(0x07); clrscr(); settextattr(0x2e); printf("\n\r---------------------------------\n\r"); printf(" Event-Handler mit Arduino: Demo \n\r"); printf("---------------------------------\n\n\r"); settextattr(0x07); printf("Type in the command you want to run, available commands are:"); cmdlist(); printf("%s", sysprompt); pinMode(blinkLed, OUTPUT); // Blink-Led Anschluss als Ausgang pinMode(ntcpin, INPUT); // Anschluss NTC-Temperatursensor sr.begin(); // Schieberegister "starten" dipkey0.begin(); dipkey1.begin(); ll_setmusterseq(dipkey_get()); // Lauflichtmuster entspr. der Schalterstellung setzen TimerA.begin(); // mit ADC einstellbarer Timer TimerA.setstarttime(); // die erste Ablaufzeit TimerA setzen TimerB.setoverflow(500); // Intervallzeit TimerB TimerB.setstarttime(); // die erste Ablaufzeit TimerB setzen AppTimer.setstarttime(); systick.seconds= 0; uart_readenable= 1; uart_outputenable= 0; mydate_setdefault(); } /* ---------------------------------------------------------------------- loop ---------------------------------------------------------------------- */ void loop() { event_handler(); // hier alle dem Event-Handler nachgeordneten Funktionen einfuegen }