mirror of
https://github.com/eddyem/stm32samples.git
synced 2026-09-29 21:30:40 +03:00
426 lines
13 KiB
C++
426 lines
13 KiB
C++
/*
|
|
* This file is part of the cordic project.
|
|
* Copyright 2026 Edward V. Emelianov <edward.emelianoff@gmail.com>.
|
|
*
|
|
* 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <cstring>
|
|
|
|
extern "C"{
|
|
#include <math.h>
|
|
#include <stm32g4.h>
|
|
|
|
#include "astro.h"
|
|
#include "commproto.h"
|
|
#include "cordic.h"
|
|
#include "hardware.h"
|
|
#include "strfunc.h"
|
|
#include "test.h"
|
|
}
|
|
|
|
// sending function
|
|
static int (*SEND)(const char *str) = nullptr;
|
|
|
|
extern volatile uint32_t Tms;
|
|
|
|
// input coordinates (degrees) and meteo
|
|
static float phpa = 800.f, tc = 0.f, rh = 0.5f, az = 0.f, zd = 20.f, ra = 0.f, ha = 0.f, dec = 0.f;
|
|
// starting time parameters: UNIX-time value and Tms when setter called
|
|
static uint32_t unixt0 = 0, Tms0 = 0;
|
|
|
|
// get current UNIX time by Tms
|
|
static uint32_t curUNIXt(){
|
|
return unixt0 + (Tms - Tms0 + 500) / 1000;
|
|
}
|
|
|
|
constexpr uint32_t hash(const char* str, uint32_t h = 0){
|
|
return *str ? hash(str + 1, h + ((h << 7) ^ *str)) : h;
|
|
}
|
|
|
|
// structure for setters/getters of float parameters
|
|
typedef struct {
|
|
const char* name; // command name
|
|
uint32_t hash; // its hash
|
|
float* var; // pointer to variable
|
|
float min_val; // minimal and maximal values
|
|
float max_val;
|
|
} VarEntry;
|
|
|
|
// table for variables
|
|
static const VarEntry var_table[] = {
|
|
{"az", hash("az"), &az, -180.0f, 180.0f},
|
|
{"dec", hash("dec"), &dec, -90.0f, 90.0f},
|
|
{"ha", hash("ha"), &ha, -180.0f, 180.0f},
|
|
{"ra", hash("ra"), &ra, 0.0f, 360.0f},
|
|
{"zd", hash("zd"), &zd, 0.0f, 90.0f},
|
|
{"humid", hash("humid"), &rh, 0.0f, 1.0f},
|
|
{"press", hash("press"), &phpa, 0.0f, 1200.0f},
|
|
{"temp", hash("temp"), &tc, -273.15f, 100.0f},
|
|
};
|
|
static const size_t var_table_size = sizeof(var_table) / sizeof(var_table[0]);
|
|
|
|
//static uint8_t curbuf[MAXSTRLEN];
|
|
|
|
// COMMAND(USART, "Read USART data or send (USART=hex)")
|
|
|
|
#define STR_HELPER(x) #x
|
|
#define STR(x) STR_HELPER(x)
|
|
|
|
// text delimeter for help function
|
|
#define DELIMETER(text)
|
|
// setters/getters for common `find_var_by_hash` and `handle_var`
|
|
#define FLOATVAR(cmd, desc)
|
|
// list of all commands and handlers
|
|
#define COMMAND_TABLE \
|
|
COMMAND(help, "show this help") \
|
|
DELIMETER("Test functions") \
|
|
COMMAND(testc, "test CORDIC function: sincos, sin, cos, atan, sqrt, log") \
|
|
COMMAND(testm, "test math function: sin, cos, atan, sqrt, log") \
|
|
COMMAND(sincos, "calculate sin/cos for given angle in degrees") \
|
|
DELIMETER("Coordinates") \
|
|
FLOATVAR(az, "azimuth, deg (-180..180)") \
|
|
FLOATVAR(dec, "DEC, deg (-90..90)") \
|
|
FLOATVAR(ha, "HA, deg (-180..180)") \
|
|
FLOATVAR(ra, "RA, deg (0..360)") \
|
|
FLOATVAR(zd, "zenith distance, deg (0..90)") \
|
|
DELIMETER("Astro functions") \
|
|
COMMAND(sets, "sin-cos is cordic (1) or math (0)") \
|
|
COMMAND(time, "show MJD and LST for given UNIX-time (and set it as system)") \
|
|
COMMAND(azhd, "convert alt-az to ha-dec (0, default) or vise versa (1) and change input values") \
|
|
COMMAND(hara, "convert ha to ra (0, default) or vice versa (1) and change input values") \
|
|
COMMAND(refr, "calculate refraction for current zd") \
|
|
DELIMETER("Meteo conditions") \
|
|
FLOATVAR(humid, "rel. humidity, 0..1") \
|
|
FLOATVAR(press, "atm. pressure (hpa)") \
|
|
FLOATVAR(temp, "temperature, degC") \
|
|
|
|
typedef struct {
|
|
const char *name;
|
|
const char *desc;
|
|
} CmdInfo;
|
|
|
|
// prototypes
|
|
#define COMMAND(name, desc) static errcodes_t cmd_ ## name(const char*, char*);
|
|
COMMAND_TABLE
|
|
#undef COMMAND
|
|
|
|
static const CmdInfo cmdInfo[] = { // command name, description - for `help`
|
|
#undef DELIMETER
|
|
#undef FLOATVAR
|
|
#define DELIMETER(text) { nullptr, text },
|
|
#define FLOATVAR(name, desc) { #name, desc },
|
|
#define COMMAND(name, desc) { #name, desc },
|
|
COMMAND_TABLE
|
|
#undef COMMAND
|
|
#undef FLOATVAR
|
|
#undef DELIMETER
|
|
#define FLOATVAR(a, b)
|
|
#define DELIMETER(t)
|
|
};
|
|
|
|
static const char* errtxt[ERR_AMOUNT] = {
|
|
[ERR_OK] = "OK\n",
|
|
[ERR_BADCMD] = "BADCMD\n",
|
|
[ERR_BADPAR] = "BADPAR\n",
|
|
[ERR_BADVAL] = "BADVAL\n",
|
|
[ERR_WRONGLEN] = "WRONGLEN\n",
|
|
[ERR_CANTRUN] = "CANTRUN\n",
|
|
[ERR_BUSY] = "BUSY\n",
|
|
[ERR_OVERFLOW] = "OVERFLOW\n",
|
|
};
|
|
|
|
const char *EQ = " = "; // equal sign for getters
|
|
|
|
// send `command = `
|
|
#define CMDEQ() do{SEND(cmd); SEND(EQ);}while(0)
|
|
// send `commandXXX = `
|
|
#define CMDEQP(x) do{SEND(cmd); SEND(u2str((uint32_t)x)); SEND(EQ);}while(0)
|
|
// the same as last but with command as option and uint value
|
|
#define SHOWPARU(cmd, x, val) do{SEND(cmd); SEND(u2str((uint32_t)x)); SEND(EQ); SEND(u2str(val));}while(0)
|
|
|
|
/**
|
|
* @brief splitargs - get command parameter and setter from `args`
|
|
* @param args (i) - rest of string after command (like `1 = PU OD OUT`)
|
|
* @param parno (o) - parameter number or -1 if none
|
|
* @return setter (part after `=` without leading spaces) or NULL if none
|
|
*/
|
|
static char *splitargs(char *args, int32_t *parno){
|
|
if(!args) return nullptr;
|
|
uint32_t U32;
|
|
char *next = getnum(args, &U32);
|
|
int p = -1;
|
|
if(next != args && U32 <= MAXPARNO) p = U32;
|
|
if(parno) *parno = p;
|
|
next = strchr(next, '=');
|
|
if(next){
|
|
if(*(++next)) next = omit_spaces(next);
|
|
if(*next == 0) next = nullptr;
|
|
}
|
|
return next;
|
|
}
|
|
|
|
/**
|
|
* @brief argsvals - split `args` into `parno` and setter's value
|
|
* @param args - rest of string after command
|
|
* @param parno (o) - parameter number or -1 if none
|
|
* @param parval - integer setter's value
|
|
* @return false if no setter or it's not a number, true - got setter's num
|
|
*/
|
|
static bool argsvals(char *args, int32_t *parno, int32_t *parval){
|
|
char *setter = splitargs(args, parno);
|
|
if(!setter) return false;
|
|
int32_t I32;
|
|
char *next = getint(setter, &I32);
|
|
if(next != setter){
|
|
if(parval) *parval = I32;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static errcodes_t cmd_help(const char*, char*){
|
|
SEND(REPOURL);
|
|
for(size_t i = 0; i < sizeof(cmdInfo)/sizeof(cmdInfo[0]); i++){
|
|
if(cmdInfo[i].name){
|
|
SEND(cmdInfo[i].name);
|
|
SEND(" - ");
|
|
}else SEND(" ");
|
|
SEND(cmdInfo[i].desc); SEND("\n");
|
|
}
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
static const char* parse_func_name(char *args){
|
|
char *setter = splitargs(args, nullptr);
|
|
if(!setter) return nullptr;
|
|
// remove trailing spaces
|
|
char *p = setter;
|
|
while(*p && *p > ' ') ++p;
|
|
*p = 0;
|
|
return setter;
|
|
}
|
|
|
|
#if 0
|
|
static errcodes_t cmd_cordic(const char *cmd, char *args){
|
|
char *setter = splitargs(args, nullptr);
|
|
if(setter){
|
|
uint32_t u;
|
|
if(!getint(setter, &u)) return ERR_BADVAL;
|
|
set_sincos(u);
|
|
}
|
|
int i = get_sincos();
|
|
CMDEQ();
|
|
|
|
}
|
|
#endif
|
|
// calculate sin/cos
|
|
static errcodes_t cmd_sincos(const char *, char *args){
|
|
char *setter = splitargs(args, nullptr);
|
|
float f;
|
|
if(!setter || setter == getfloat(setter, &f)) return ERR_BADVAL;
|
|
f = f/180.f * M_PIf;
|
|
SEND("mathsin="); SEND(float2str(sinf(f), 7));
|
|
SEND("\nmathcos="); SEND(float2str(cosf(f), 7));
|
|
float s, c;
|
|
cordic_sincos(f, &s, &c);
|
|
SEND("\ncordicsin="); SEND(float2str(s, 7));
|
|
SEND("\ncordiccos="); SEND(float2str(c, 7));
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
// test math function
|
|
static errcodes_t cmd_testm(const char*, char *args){
|
|
const char *fname = parse_func_name(args);
|
|
if(!fname) return ERR_BADPAR;
|
|
uint32_t elapsed = 0;
|
|
bool ok = true;
|
|
if(strcmp(fname, "sin") == 0){
|
|
elapsed = test_math_sin();
|
|
}else if(strcmp(fname, "cos") == 0){
|
|
elapsed = test_math_cos();
|
|
}else if(strcmp(fname, "atan") == 0){
|
|
elapsed = test_math_atan();
|
|
}else if(strcmp(fname, "sqrt") == 0){
|
|
elapsed = test_math_sqrt();
|
|
}else if(strcmp(fname, "log") == 0){
|
|
elapsed = test_math_log();
|
|
}else{
|
|
ok = false;
|
|
}
|
|
if(!ok) return ERR_BADVAL;
|
|
SEND("TIMEus=");
|
|
SEND(u2str(elapsed));
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
|
|
// test CORDIC function
|
|
static errcodes_t cmd_testc(const char*, char *args){
|
|
const char *fname = parse_func_name(args);
|
|
if(!fname) return ERR_BADPAR;
|
|
uint32_t elapsed = 0;
|
|
bool ok = true;
|
|
if(strcmp(fname, "sincos") == 0){
|
|
elapsed = test_cordic_sincos();
|
|
}
|
|
else if(strcmp(fname, "sin") == 0){
|
|
elapsed = test_cordic_sin();
|
|
}else if(strcmp(fname, "cos") == 0){
|
|
elapsed = test_cordic_cos();
|
|
}else if(strcmp(fname, "atan") == 0){
|
|
elapsed = test_cordic_atan();
|
|
}else if(strcmp(fname, "sqrt") == 0){
|
|
elapsed = test_cordic_sqrt();
|
|
}else if(strcmp(fname, "log") == 0){
|
|
elapsed = test_cordic_log();
|
|
}else{
|
|
ok = false;
|
|
}
|
|
if(!ok) return ERR_BADVAL;
|
|
SEND("TIMEus=");
|
|
SEND(u2str(elapsed));
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
static errcodes_t cmd_time(const char *cmd, char *args){
|
|
char *setter = splitargs(args, nullptr);
|
|
if(setter){
|
|
if(setter == getnum(setter, &unixt0)) return ERR_BADVAL;
|
|
Tms0 = Tms;
|
|
}
|
|
CMDEQ();
|
|
uint32_t tnow = curUNIXt();
|
|
SEND(u2str(tnow));
|
|
float mjd = MJD_from_unix(tnow);
|
|
SEND("\nMJD="); SEND(float2str(mjd, 7));
|
|
SEND("\nLST="); SEND(float2str(LST_from_unix(tnow), 7));
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
static errcodes_t cmd_sets(const char *cmd, char *args){
|
|
int32_t val;
|
|
if(argsvals(args, nullptr, &val)) set_sincos(val);
|
|
CMDEQ();
|
|
if(get_sincos()) SEND("CORDIC\n");
|
|
else SEND("MATH\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
// get u32, return value or 0 in case of getter
|
|
static uint32_t getflag(char *args){
|
|
uint32_t val = 0;
|
|
char *setter = splitargs(args, nullptr);
|
|
if(setter) getnum(setter, &val);
|
|
return val;
|
|
}
|
|
|
|
static errcodes_t cmd_hara(const char *, char *args){
|
|
float lst_deg = HOURS2DEG(LST_from_unix(curUNIXt()));
|
|
if(getflag(args)){ // ra to ha
|
|
ha = ra_to_ha(ra, lst_deg);
|
|
SEND("ha = "); SEND(float2str(ha, 7));
|
|
}else{ // ha to ra
|
|
ra = ha_to_ra(ha, lst_deg);
|
|
SEND("ra = "); SEND(float2str(ra, 7));
|
|
}
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
static errcodes_t cmd_azhd(const char *, char *args){
|
|
float alt;
|
|
if(getflag(args)){ // hd to az
|
|
hadec_to_altaz(ha, dec, &alt, &az);
|
|
zd = 90.f - alt;
|
|
SEND("az = "); SEND(float2str(az, 7));
|
|
SEND("zd = "); SEND(float2str(zd, 7));
|
|
}else{ // az to hd
|
|
alt = 90.f - zd;
|
|
altaz_to_hadec(alt, az, &ha, &dec);
|
|
// and recalculate ra
|
|
float lst_deg = HOURS2DEG(LST_from_unix(curUNIXt()));
|
|
ra = ha_to_ra(ha, lst_deg);
|
|
SEND("ha = "); SEND(float2str(ha, 7));
|
|
SEND("\nra = "); SEND(float2str(ra, 7));
|
|
SEND("\ndec = "); SEND(float2str(dec, 7));
|
|
}
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
static errcodes_t cmd_refr(const char *cmd, char *){
|
|
float A, B;
|
|
refco_f32(phpa, tc, rh, 0.55, &A, &B);
|
|
SEND("coeffs a/b: "); SEND(float2str(A, 3)); SEND(", "); SEND(float2str(B, 3)); SEND("\n");
|
|
float refr = refraction(phpa, tc, rh, zd);
|
|
CMDEQ();
|
|
SEND(float2str(DEG2ARCSEC(refr), 2));
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
// setter/getter of floats
|
|
static errcodes_t handle_var(const VarEntry* entry, const char* cmd, char* setter){
|
|
if(setter){
|
|
float val;
|
|
if(setter == getfloat(setter, &val)) return ERR_BADPAR;
|
|
if(val < entry->min_val || val > entry->max_val) return ERR_BADVAL;
|
|
*entry->var = val;
|
|
}
|
|
CMDEQ();
|
|
SEND(float2str(*entry->var, 7));
|
|
SEND("\n");
|
|
return ERR_AMOUNT;
|
|
}
|
|
|
|
// linear search by hash for variable
|
|
static const VarEntry* find_var_by_hash(uint32_t h){
|
|
for(size_t i = 0; i < var_table_size; ++i){
|
|
if(var_table[i].hash == h)
|
|
return &var_table[i];
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const char *parse_cmd(int (*sendfun)(const char *), char *str){
|
|
SEND = sendfun;
|
|
char command[CMD_MAXLEN+1];
|
|
int i = 0;
|
|
while(*str > '@' && i < CMD_MAXLEN){ command[i++] = *str++; }
|
|
command[i] = 0;
|
|
while(*str && *str <= ' ') ++str;
|
|
char *restof = (char*) str;
|
|
uint32_t h = hash(command);
|
|
errcodes_t ecode = ERR_AMOUNT;
|
|
const VarEntry *entry = nullptr;
|
|
switch(h){
|
|
#define COMMAND(name, desc) case hash(#name): ecode = cmd_ ## name(command, restof); break;
|
|
COMMAND_TABLE
|
|
#undef COMMAND
|
|
default:
|
|
if((entry = find_var_by_hash(h))){
|
|
ecode = handle_var(entry, command, splitargs(restof, nullptr));
|
|
}else{
|
|
SEND("Unknown command, try 'help'\n");
|
|
}
|
|
}
|
|
if(ecode < ERR_AMOUNT) return errtxt[ecode];
|
|
return nullptr;
|
|
}
|