From 0a836ceceaa7a0d7bc4b27e34b769a2691b9dea6 Mon Sep 17 00:00:00 2001 From: Christian Chapman <1360262+enthdegree@users.noreply.github.com> Date: Sun, 16 Apr 2023 10:01:03 -0400 Subject: Morsecalc refactor (#229) * Added Morse code based RPN calculator * added manual and memory register * fixed morsecalc negative indicator, edited header comment * adjusted stack display controls * Fixed warnings. Added calculator token aliasing ability. Added binary shorthand for numeral entry. Extended morse code binary tree. * ui tweaks * Update movement_config.h * silence warning * Reorganized codebase and simplified morse code reading routines. * added 'quit if submission is empty' behavior * reverted rules.mk change for merge into main * corrected timeout behavior * consolidated morsecode lib into one file; deleted old mc.c mc.h * consolidated morsecode lib into one file; deleted old mc.c mc.h * removed specious null in morsecode bintree string --------- Co-authored-by: Christian Chapman Co-authored-by: joeycastillo --- movement/lib/morsecalc/calc.c | 8 +- movement/lib/morsecalc/calc_fns.c | 10 ++ movement/lib/morsecalc/calc_fns.h | 77 ++++++++------- movement/lib/morsecalc/mc.c | 66 ------------- movement/lib/morsecalc/mc.h | 51 ---------- movement/lib/morsecalc/morsecalc_display.c | 147 +++++++++++++++++++++++++++++ movement/lib/morsecalc/morsecalc_display.h | 35 +++++++ movement/lib/morsecalc/morsecode.c | 54 +++++++++++ movement/lib/morsecalc/test_morsecalc.c | 66 +++++++++++++ 9 files changed, 357 insertions(+), 157 deletions(-) delete mode 100644 movement/lib/morsecalc/mc.c delete mode 100644 movement/lib/morsecalc/mc.h create mode 100644 movement/lib/morsecalc/morsecalc_display.c create mode 100644 movement/lib/morsecalc/morsecalc_display.h create mode 100644 movement/lib/morsecalc/morsecode.c create mode 100644 movement/lib/morsecalc/test_morsecalc.c (limited to 'movement/lib') diff --git a/movement/lib/morsecalc/calc.c b/movement/lib/morsecalc/calc.c index 49b19a00..ed7eb25b 100644 --- a/movement/lib/morsecalc/calc.c +++ b/movement/lib/morsecalc/calc.c @@ -24,6 +24,7 @@ #include #include +#include #include "calc.h" #include "calc_fns.h" @@ -41,12 +42,11 @@ int calc_init(calc_state_t *cs) { } /* calc_input_function - * Try to execut the token as a calculator function - * TODO: Maybe replace this loop with binary search for token in a sorted calc_dict + * Try to execute the token as a calculator function */ int calc_input_function(calc_state_t *cs, char *token) { for(uint8_t idx=0; idxs--; return 0; } +int calc_torad(calc_state_t *cs) { + STACK_CHECK_1_IN_1_OUT; + cs->stack[cs->s-1] = cs->stack[cs->s-1]*to_rad; + return 0; +} +int calc_todeg(calc_state_t *cs) { + STACK_CHECK_1_IN_1_OUT; + cs->stack[cs->s-1] = cs->stack[cs->s-1]*to_deg; + return 0; +} diff --git a/movement/lib/morsecalc/calc_fns.h b/movement/lib/morsecalc/calc_fns.h index fd1d7aba..15f56b0e 100644 --- a/movement/lib/morsecalc/calc_fns.h +++ b/movement/lib/morsecalc/calc_fns.h @@ -67,57 +67,62 @@ int calc_asind(calc_state_t *cs); int calc_acosd(calc_state_t *cs); int calc_atand(calc_state_t *cs); int calc_atan2d(calc_state_t *cs); +int calc_torad(calc_state_t *cs); +int calc_todeg(calc_state_t *cs); // Dictionary definition typedef int (*calc_fn_t)(calc_state_t *cs); typedef struct { - char *names[3]; // Token to use to run this function + uint8_t n_names; // Number of aliases + const char ** names; // Token to use to run this function calc_fn_t fn; // Pointer to function } calc_dict_entry_t; static const calc_dict_entry_t calc_dict[] = { // Stack and register control - {{"x"}, &calc_delete}, - {{"xx"}, &calc_clear_stack}, - {{"xxx"}, &calc_init}, - {{"f"}, &calc_flip}, - {{"mc"}, &calc_mem_clear}, - {{"mr"}, &calc_mem_recall}, - {{"ma"}, &calc_mem_add}, - {{"ms"}, &calc_mem_subtract}, + {1, (const char*[]){"x"}, &calc_delete}, + {1, (const char*[]){"xx"}, &calc_clear_stack}, + {1, (const char*[]){"xxx"}, &calc_init}, + {1, (const char*[]){"f"}, &calc_flip}, + {1, (const char*[]){"mc"}, &calc_mem_clear}, + {1, (const char*[]){"mr"}, &calc_mem_recall}, + {1, (const char*[]){"ma"}, &calc_mem_add}, + {1, (const char*[]){"ms"}, &calc_mem_subtract}, // Basic operations - {{"a"}, &calc_add}, - {{"s"}, &calc_subtract}, - {{"n"}, &calc_negate}, - {{"m"}, &calc_multiply}, - {{"d"}, &calc_divide}, - {{"i"}, &calc_invert}, + {1, (const char*[]){"a"}, &calc_add}, + {1, (const char*[]){"s"}, &calc_subtract}, + {1, (const char*[]){"n"}, &calc_negate}, + {1, (const char*[]){"m"}, &calc_multiply}, + {1, (const char*[]){"d"}, &calc_divide}, + {1, (const char*[]){"i"}, &calc_invert}, // Constants - {{"e"}, &calc_e}, - {{"pi"}, &calc_pi}, + {1, (const char*[]){"e"}, &calc_e}, + {1, (const char*[]){"pi"}, &calc_pi}, // Exponential/logarithmic - {{"exp"}, &calc_exp}, - {{"pow"}, &calc_pow}, - {{"ln"}, &calc_ln}, - {{"log"}, &calc_log}, - {{"sqrt"}, &calc_sqrt}, + {1, (const char*[]){"exp"}, &calc_exp}, + {1, (const char*[]){"pow"}, &calc_pow}, + {1, (const char*[]){"ln"}, &calc_ln}, + {1, (const char*[]){"log"}, &calc_log}, + {1, (const char*[]){"sqrt"}, &calc_sqrt}, // Trigonometric - {{"sin", "sn"}, &calc_sin}, - {{"cos"}, &calc_cos}, - {{"tan"}, &calc_tan}, - {{"asin"}, &calc_asin}, - {{"acos"}, &calc_acos}, - {{"atan"}, &calc_atan}, - {{"atan2"}, &calc_atan2}, - {{"sind"}, &calc_sind}, - {{"cosd"}, &calc_cosd}, - {{"tand"}, &calc_tand}, - {{"asind"}, &calc_asind}, - {{"acosd"}, &calc_acosd}, - {{"atand"}, &calc_atand}, - {{"atan2d"}, &calc_atan2d}, + {2, (const char*[]){"sin", "sn"}, &calc_sin}, + {1, (const char*[]){"cos"}, &calc_cos}, + {1, (const char*[]){"tan"}, &calc_tan}, + {1, (const char*[]){"asin"}, &calc_asin}, + {1, (const char*[]){"acos"}, &calc_acos}, + {1, (const char*[]){"atan"}, &calc_atan}, + {1, (const char*[]){"atan2"}, &calc_atan2}, + {1, (const char*[]){"sind"}, &calc_sind}, + {1, (const char*[]){"cosd"}, &calc_cosd}, + {1, (const char*[]){"tand"}, &calc_tand}, + {1, (const char*[]){"asind"}, &calc_asind}, + {1, (const char*[]){"acosd"}, &calc_acosd}, + {1, (const char*[]){"atand"}, &calc_atand}, + {1, (const char*[]){"atan2d"}, &calc_atan2d}, + {1, (const char*[]){"tor"}, &calc_torad}, + {1, (const char*[]){"tod"}, &calc_todeg}, }; diff --git a/movement/lib/morsecalc/mc.c b/movement/lib/morsecalc/mc.c deleted file mode 100644 index 94f6511b..00000000 --- a/movement/lib/morsecalc/mc.c +++ /dev/null @@ -1,66 +0,0 @@ -/* - * MIT License - * - * Copyright (c) 2023 Christian Chapman - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - - -#include -#include "mc.h" - -/* mc_reset Initialize or reset an MC buffer - * Input: mc = location of buffer to reset - */ -void mc_reset(mc_state_t * mc) { - memset(mc->b, '\0', BUFFLEN*sizeof(mc->b[0])); - mc->bidx = 0; - return; - return; -} - -/* mc_input Read an input into a morse code buffer - * Input: mc = buffer to read into - * c = character to read into buffer ('.' or '-', ignored otherwise). - * If the buffer is full, reset it instead of entering the new character. - */ -void mc_input(mc_state_t * mc, char c) { - if(mc->bidx >= BUFFLEN) mc_reset(mc); - else if( ('.' == c) || ('-' == c) ) { - mc->b[mc->bidx] = c; - mc->bidx++; - } - return; -} - -/* mc_dec Decode a Morse code character (descend MC_DEC_KEY[]) - * Input: b = BUFFLEN-length char array with '.'s and '-'s - * Output: c = Character b represents, or '\0' if not a Morse code. - */ -char mc_dec(char b[BUFFLEN]) { - uint8_t pos = 1; // Binary tree position ('.'=0; '-'=1) - for(uint8_t idx=0; idx +#include + +#include "watch_private_display.h" +#include "morsecalc_display.h" + +// Display float on screen +void morsecalc_display_float(double d) { + // Special cases + if(d == 0) { + watch_display_string(" 0", 4); + return; + } + else if(isnan(d)) { + watch_display_string(" nan", 4); + return; + } + else if(d == (1.0)/(0.0)) { + watch_display_string(" inf", 4); + return; + } + else if(d == (-1.0)/(0.0)) { + watch_display_character('X', 1); + watch_display_string(" inf", 4); + return; + } + + // Record number properties + // Sign + int is_negative = d<0; + if(is_negative) d = -d; + + // Order of magnitude + int om = (int) floor(log(d)/log(10)); + int om_is_negative = (om<0); + + // Get the first 4 significant figures + int digits; + digits = round(d*pow(10.0, 3-om)); + if(digits>9999) { + digits = 1000; + om++; + } + + // Print signs + if(is_negative) { + // Xi; see https://joeycastillo.github.io/Sensor-Watch-Documentation/segmap + watch_set_pixel(0,11); + watch_set_pixel(2,12); + watch_set_pixel(2,11); + } + else watch_display_character(' ', 1); + if(om_is_negative) watch_set_pixel(1,9); + else watch_display_character(' ', 2); + + // Print first 4 significant figures + watch_display_character('0'+(digits/1000)%10, 4); + watch_display_character('0'+(digits/100 )%10, 5); + watch_display_character('0'+(digits/10 )%10, 6); + watch_display_character('0'+(digits/1 )%10, 7); + + // Prinat exponent + if(om_is_negative) om = -om; // Make exponent positive for display + if(om<=99) { + watch_display_character('0'+(om/10 )%10, 8); + watch_display_character('0'+(om/1 )%10, 9); + } else { // Over/underflow + if(om_is_negative) watch_display_string(" uf", 4); + else watch_display_string(" of", 4); + if(om<9999) { // Use main display to show order of magnitude + // (Should always succeed; max double is <2e308) + watch_display_character('0'+(om/1000)%10, 4); + watch_display_character('0'+(om/100 )%10, 5); + watch_display_character('0'+(om/10 )%10, 6); + watch_display_character('0'+(om/1 )%10, 7); + } + } + return; +} + +// Print current input token +void morsecalc_display_token(morsecalc_state_t *mcs) { + watch_display_string(" ", 0); // Clear display + + // Print morse code buffer + char c = MORSECODE_TREE[mcs->mc]; // Decode the morse code buffer's current contents + if('\0' == c) c = ' '; // Needed for watch_display_character + watch_display_character(c, 0); // Display current morse code char in mode position + + unsigned int v = mcs->mc+1; + char bidx = 0; while (v >>= 1) bidx++; + watch_display_character('0'+bidx, 3); // Display buffer position in top right + + // Print last 6 chars of current input line + uint8_t nlen = strlen(mcs->token); // number of characters in token + uint8_t nprint = min(nlen,6); // number of characters to print + watch_display_string(mcs->token+nlen-nprint, 10-nprint); // print right-aligned + return; +} + +// Print stack or memory register contents. +void morsecalc_display_stack(morsecalc_state_t * mcs) { + watch_display_string(" ", 0); // Clear display + + char c = MORSECODE_TREE[mcs->mc]; + if('m' == c) { // Display memory + morsecalc_display_float(mcs->cs->mem); + watch_display_character(c, 0); + } + else { + // If the morse code buffer has a numeral in it, print that stack item + // Otherwise print top of stack + uint8_t idx = 0; + if(c >= '0' && c <= '9') idx = c - '0'; + if(idx >= mcs->cs->s) watch_display_string(" empty", 4); // Stack empty + else morsecalc_display_float(mcs->cs->stack[mcs->cs->s-1-idx]); // Print stack item + + watch_display_character('0'+idx, 0); // Print which stack item this is top center + } + watch_display_character('0'+(mcs->cs->s), 3); // Print the # of stack items top right + return; +} + diff --git a/movement/lib/morsecalc/morsecalc_display.h b/movement/lib/morsecalc/morsecalc_display.h new file mode 100644 index 00000000..74f8b0cc --- /dev/null +++ b/movement/lib/morsecalc/morsecalc_display.h @@ -0,0 +1,35 @@ +/* + * MIT License + * + * Copyright (c) 2023 Christian Chapman + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "morsecalc_face.h" + +// Display float on screen +void morsecalc_display_float(double d); + +// Print current input token +void morsecalc_display_token(morsecalc_state_t *mcs); + +// Print stack or memory register contents. +void morsecalc_display_stack(morsecalc_state_t *mcs); + diff --git a/movement/lib/morsecalc/morsecode.c b/movement/lib/morsecalc/morsecode.c new file mode 100644 index 00000000..6b85e82c --- /dev/null +++ b/movement/lib/morsecalc/morsecode.c @@ -0,0 +1,54 @@ +/* + * MIT License + * + * Copyright (c) 2023 Christian Chapman + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef MORSECODE_ +#define MORSECODE_ + +/* + * MC International Morse Code binary tree + * Levels of the tree are concatenated. + * '.' = 0 and '-' = 1. + * + * Capitals denote special characters: + * C = Ch digraph + * V = VERIFY (ITU-R "UNDERSTOOD") + * R = REPEAT + * W = WAIT + * S = START TRANSMISSION + * E = END OF WORK + */ +static const char MORSECODE_TREE[] = " etianmsurwdkgohvf\0l\0pjbxcyzq\0C\x35\x34V\x33\0R\0\x32W\0+\0\0\0\0\x31\x36=/\0\0S(\0\x37\0\0\0\x38\0\x39\x30\0\0\0\0\0E\0\0\0\0\0\0?_\0\0\0\0\"\0\0.\0\0\0\0@\0\0\0'\0\0-\0\0\0\0\0\0\0\0;!\0)\0\0\0\0\0,\0\0\0\0:\0\0\0\0\0\0"; + +/* mc_input Read an input into a morse code buffer + * Input: mc = index of MORSECODE_TREE[] + * len = max morse code char length + * in = character to read into buffer (0='.', 1='-', ignored otherwise). + * If the buffer is full, reset it instead of entering the new character. + */ +static void morsecode_input(unsigned int *mc, unsigned int len, char in) { + if(*mc >= (unsigned int) ((1< +#include +#include +#include + +#include "calc.h" +#include "calc_fns.h" + +int main(void) { + calc_state_t cs; + calc_init(&cs); + + char * word = malloc(0); + unsigned int nword = 0; + char c; + int retval = 0; + for(unsigned int ii = 0; ii < 100; ii++) { + c = getchar(); + word = realloc(word, (++nword)*sizeof(char)); + word[nword-1] = c; + if((nword > 0) && isspace(c)) { // Word is finished + word[nword-1] = '\0'; + retval = calc_input(&cs, word); // Submit word + word = realloc(word, 0); nword = 0; // Clear word + + switch(retval) { + case 0: printf("Success.\n"); break; + case -1: printf("Bad command.\n"); break; + case -2: printf("Stack over/underflow.\n"); break; + case -3: printf("Error.\n"); break; + } + if(cs.s > 0) printf("[%i]: %.4f\n", cs.s, cs.stack[cs.s-1]); + else printf("[%i]\n", cs.s); + } + } + + free(word); + return 0; +} -- cgit v1.2.3