hueso/Sensor-Watch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

Morsecalc refactor (#229)

Browse Source 
* 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 <user@debian>
Co-authored-by: joeycastillo <joeycastillo@utexas.edu>
This commit is contained in:
Christian Chapman
2023-04-16 10:01:03 -04:00
committed by GitHub
parent 16a96d16b2
commit 0a836cecea
10 changed files with 360 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
movement/lib/morsecalc/calc.c
View File

@@ -24,6 +24,7 @@
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#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; idx<sizeof(calc_dict)/sizeof(calc_dict[0]); idx++) {
for(uint8_t idxn=0; idxn<sizeof(calc_dict[idx].names)/sizeof(calc_dict[idx].names[0]); idxn++) {
for(uint8_t idxn=0; idxn<calc_dict[idx].n_names; idxn++) {
if(0 == strcmp(calc_dict[idx].names[idxn], token)) { // Found a match
return (*calc_dict[idx].fn)(cs); // Run calculator function
}
@@ -108,6 +108,6 @@ int calc_input_float(calc_state_t *cs, char *token) {
*/
int calc_input(calc_state_t *cs, char *token) {
int retval = calc_input_function(cs, token);
if(retval == -1) retval = calc_input_float(cs, token);
if(-1 == retval) retval = calc_input_float(cs, token);
return retval;
}

10
movement/lib/morsecalc/calc_fns.c
View File

@@ -227,4 +227,14 @@ int calc_atan2d(calc_state_t *cs) {
cs->s--;
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;
}

77
movement/lib/morsecalc/calc_fns.h
View File

@@ -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},
};

147
movement/lib/morsecalc/morsecalc_display.c Normal file
View File

@@ -0,0 +1,147 @@
/*
* 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 <string.h>
#include <math.h>
#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;
}

30
movement/lib/morsecalc/mc.h → movement/lib/morsecalc/morsecalc_display.h
View File

@@ -22,30 +22,14 @@
* SOFTWARE.
*/
#include "morsecalc_face.h"
/* mc Morse code reading methods
*/
#include "stdint.h"
// Display float on screen
void morsecalc_display_float(double d);
#define BUFFLEN 5
typedef struct {
char b[BUFFLEN];
uint8_t bidx;
} mc_state_t;
// Print current input token
void morsecalc_display_token(morsecalc_state_t *mcs);
// MC_DEC_KEY represents a binary tree of International Morse Code.
// where '.' = 0 and '-' = 1. Levels of the tree are concatenated.
//
// 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 MC_DEC_KEY[] = " 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\0";
void mc_reset(mc_state_t * mcb);
void mc_input(mc_state_t * mc, char c);
char mc_dec(char b[BUFFLEN]);
// Print stack or memory register contents.
void morsecalc_display_stack(morsecalc_state_t *mcs);

58
movement/lib/morsecalc/mc.c → movement/lib/morsecalc/morsecode.c
View File

@@ -21,46 +21,34 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef MORSECODE_
#define MORSECODE_
#include <string.h>
#include "mc.h"
/* mc_reset Initialize or reset an MC buffer
* Input: mc = location of buffer to reset
/*
* 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
*/
void mc_reset(mc_state_t * mc) {
memset(mc->b, '\0', BUFFLEN*sizeof(mc->b[0]));
mc->bidx = 0;
return;
return;
}
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 = buffer to read into
* c = character to read into buffer ('.' or '-', ignored otherwise).
* 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.
*/
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++;
}
static void morsecode_input(unsigned int *mc, unsigned int len, char in) {
if(*mc >= (unsigned int) ((1<<len)-1)) *mc = 0;
else if((in == 0) | (in == 1)) *mc = (*mc)*2+in+1;
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<BUFFLEN; idx++) {
if('.' == b[idx]) pos = 2*pos; // Descend in . direction
else if('-' == b[idx]) pos = 2*pos+1; // Descend in - direction
else break; // End of morse code segment; finished descending
}
return MC_DEC_KEY[pos-1];
}
#endif

66
movement/lib/morsecalc/test_morsecalc.c Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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.
*/
// Computer console interface to calc and morsecode for testing without involving watch stuff.
// cc calc_strtof.c calc.c calc_fns.c test_morsecalc.c -lm
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#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;
}