eddy/stm32samples
1
0
Fork 0
mirror of https://github.com/eddyem/stm32samples.git synced 2026-03-20 08:40:57 +03:00
Code Issues Packages Projects Releases Wiki Activity

continue developing GPIO config; not tested yet

Browse Source
This commit is contained in:
Edward Emelianov
2026-03-09 01:24:02 +03:00
parent d39682b143
commit 9713b10cd4
10 changed files with 470 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
F0:F030,F042,F072/usbcan_gpio/hashparser.cpp
View File

@@ -16,6 +16,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// !!! Some commands could change icoming string, so don't try to use it after function call !!!
#include <stdint.h>
extern "C"{
@@ -23,20 +25,30 @@ extern "C"{
#include "can.h"
#include "flash.h"
#include "hashparser.h"
#include "gpio.h"
#include "gpioproto.h"
#define USBIF IGPIO
#include "strfunc.h"
}
static const char *const sOKn = "OK\n", *const sERRn = "ERR\n";
extern uint32_t Tms;
// list of all commands and handlers
#define COMMAND_TABLE \
COMMAND(canspeed, "CAN bus speed setter/getter (kBaud, 10..1000)") \
COMMAND(dumpflash, "flash config dump") \
COMMAND(time, "Current time (ms)") \
COMMAND(help, "Show this help")
COMMAND(help, "Show this help") \
COMMAND(PA, "GPIOA setter/getter (type PAx=help for further info)") \
COMMAND(PB, "GPIOB setter/getter") \
COMMAND(reinit, "apply pin config") \
COMMAND(storeconf, "save config to flash") \
COMMAND(time, "show current time (ms)")
// COMMAND(USART, "Read USART data or send (USART=hex)")
// COMMAND(usartconf, "set USART params (e.g. usartconf=115200 8N1)")
// COMMAND(SPI, "Read SPI data or send (SPI=hex)")
// COMMAND(spiconf, "set SPI params")
typedef struct {
const char *name;
@@ -54,6 +66,224 @@ static const CmdInfo cmdInfo[] = { // command name, description - for `help`
#undef COMMAND
};
// pin settings parser
struct Keyword {
const char *name;
uint8_t group;
uint8_t value;
};
enum KeywordGroup {
GROUP_MODE,
GROUP_PULL,
GROUP_OTYPE,
GROUP_FUNC,
GROUP_MISC
};
enum MiscValues{
MISC_MONITOR = 1,
};
static constexpr Keyword keywords[] = {
{"AIN", GROUP_MODE, MODE_ANALOG},
{"IN", GROUP_MODE, MODE_INPUT},
{"OUT", GROUP_MODE, MODE_OUTPUT},
{"AF", GROUP_MODE, MODE_AF},
{"PU", GROUP_PULL, PULL_UP},
{"PD", GROUP_PULL, PULL_DOWN},
{"FL", GROUP_PULL, PULL_NONE},
{"PP", GROUP_OTYPE, OUTPUT_PP},
{"OD", GROUP_OTYPE, OUTPUT_OD},
{"USART", GROUP_FUNC, FUNC_USART},
{"SPI", GROUP_FUNC, FUNC_SPI},
{"MONITOR",GROUP_MISC, MISC_MONITOR}, // monitor flag
};
#define NUM_KEYWORDS (sizeof(keywords)/sizeof(keywords[0]))
static const char* errtxt[ERR_AMOUNT] = {
[ERR_OK] = "OK",
[ERR_BADCMD] = "BADCMD",
[ERR_BADPAR] = "BADPAR",
[ERR_BADVAL] = "BADVAL",
[ERR_WRONGLEN] = "WRONGLEN",
[ERR_CANTRUN] = "CANTRUN",
};
static const char *EQ = " = "; // equal sign for getters
/**
* @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 NULL;
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 = NULL;
}
return next;
}
#if 0
/**
* @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 && parval){
*parval = I32;
return true;
}
return false;
}
#endif
// `port` and `pin` are checked in `parse_pin_command`
// `PAx = ` also printed there
static void pin_getter(uint8_t port, uint8_t pin){
pinconfig_t *pcfg = &the_conf.pinconfig[port][pin];
switch(pcfg->mode){
case MODE_INPUT:
case MODE_OUTPUT: {
uint32_t idr = (port == 0) ? GPIOA->IDR : GPIOB->IDR;
uint8_t bit = (idr >> pin) & 1;
PUTCHAR(bit ? '1' : '0');
NL();
}
break;
case MODE_ANALOG:
SENDn("TODO");
// TODO: read ADC channel #pin
//SENDn(u2str(get_adc_value(port, pin)));
break;
case MODE_AF:
SENDn("ERR: pin in AF mode, use USART/SPI commands");
break;
default:
break;
}
}
// `port` and `pin` are checked in `parse_pin_command`
// set GPIO values (if *setter is 0/1) or configure it
static errcodes_t pin_setter(uint8_t port, uint8_t pin, char *setter){
pinconfig_t *pcfg = &the_conf.pinconfig[port][pin];
char _1st = *setter;
if(_1st == '0' || _1st == '1'){ // just set/clear pin state; throw out all text after "1"/"0"
if(pcfg->mode != MODE_OUTPUT) return ERR_CANTRUN;
volatile GPIO_TypeDef * GPIOx = (port == 0) ? GPIOA : GPIOB;
if(_1st == '1') GPIOx->BSRR = (1 << pin);
else GPIOx->BRR = (1 << pin);
return ERR_OK;
}
// complex setter: parse properties
uint8_t mode_set = 0xFF, pull_set = 0xFF, otype_set = 0xFF, func_set = 0xFF;
bool monitor = false;
char *saveptr, *token = strtok_r(setter, " ,", &saveptr);
while(token){
size_t i = 0;
for(; i < NUM_KEYWORDS; i++){
if(strcmp(token, keywords[i].name) == 0){
switch(keywords[i].group){
case GROUP_MODE:
if(mode_set != 0xFF) return ERR_BADVAL; // repeated similar group parameter
mode_set = keywords[i].value;
break;
case GROUP_PULL:
if(pull_set != 0xFF) return ERR_BADVAL;
pull_set = keywords[i].value;
break;
case GROUP_OTYPE:
if(otype_set != 0xFF) return ERR_BADVAL;
otype_set = keywords[i].value;
break;
case GROUP_FUNC:
if(func_set != 0xFF) return ERR_BADVAL;
func_set = keywords[i].value;
break;
case GROUP_MISC:
if(keywords[i].value == MISC_MONITOR) monitor = true;
break;
}
break;
}
}
if(i == NUM_KEYWORDS) return ERR_BADVAL; // not found
token = strtok_r(NULL, " ,", &saveptr);
}
if(func_set != 0xFF) mode_set = MODE_AF;
if(mode_set == 0xFF) return ERR_BADVAL; // user forgot to set mode
// set defaults
if(pull_set == 0xFF) pull_set = PULL_NONE;
if(otype_set == 0xFF) otype_set = OUTPUT_PP;
// can also do something with `speed_set`, then remove SPEED_MEDIUM from `curconfig`
// check that current parameters combination is acceptable for current pin
pinconfig_t curconf;
curconf.mode = static_cast <pinmode_t> (mode_set);
curconf.pull = static_cast <pinpull_t> (pull_set);
curconf.otype = static_cast <pinout_t> (otype_set);
curconf.speed = SPEED_MEDIUM;
curconf.af = func_set;
curconf.monitor = monitor;
if(!is_func_allowed(port, pin, &curconf)) return ERR_BADVAL;
*pcfg = curconf;
return ERR_OK;
}
// PAx [= aa], PBx [= bb]
static errcodes_t parse_pin_command(const char *cmd, char *args){
if(!args) return ERR_BADPAR; // or maybe add list for all pins?
char port_char = cmd[1];
if(port_char != 'A' && port_char != 'B') return ERR_BADCMD;
uint8_t port = (port_char == 'A') ? 0 : 1;
int32_t pin = -1;
char *setter = splitargs(args, &pin);
if(pin < 0 || pin > 15) return ERR_BADPAR;
pinconfig_t *pcfg = &the_conf.pinconfig[port][pin]; // just to check if pin can be configured
if(!pcfg->enable) return ERR_CANTRUN; // prohibited pin
if(!setter){ // simple getter -> get value and return ERR_AMOUNT as silence
SEND(cmd); SEND(u2str((uint32_t)pin)); SEND(EQ);
pin_getter(port, pin);
return ERR_AMOUNT;
}
return pin_setter(port, pin, setter);
}
static errcodes_t cmd_PA(const char *cmd, char *args){
return parse_pin_command(cmd, args);
}
static errcodes_t cmd_PB(const char *cmd, char *args){
return parse_pin_command(cmd, args);
}
static errcodes_t cmd_reinit(const char _U_ *cmd, char _U_ *args){
if(gpio_reinit()) return ERR_OK;
SEND("Can't reinit: check your configuration!\n");
return ERR_AMOUNT;
}
static errcodes_t cmd_storeconf(const char _U_ *cmd, char _U_ *args){
if(!store_userconf()) return ERR_CANTRUN;
return ERR_OK;
}
// canspeed = baudrate (kBaud)
static errcodes_t cmd_canspeed(const char *cmd, char _U_ *args){
SEND(cmd); PUTCHAR('='); SENDn(u2str(CAN_getspeed()));
if(args && *args){SEND("You entered: "); SENDn(args);}
@@ -97,15 +327,6 @@ constexpr uint32_t hash(const char* str, uint32_t h = 0){
return *str ? hash(str + 1, h + ((h << 7) ^ *str)) : h;
}
static const char* errtxt[ERR_AMOUNT] = {
[ERR_OK] = "OK",
[ERR_BADPAR] = "BADPAR",
[ERR_BADVAL] = "BADVAL",
[ERR_WRONGLEN] = "WRONGLEN",
[ERR_CANTRUN] = "CANTRUN",
};
// TODO: add checking real command length!
void chk(char *str){
@@ -127,25 +348,3 @@ void chk(char *str){
if(ecode < ERR_AMOUNT) SENDn(errtxt[ecode]);
;
}
/*
if(*args){
const char *n = getnum(args, &N);
if(n != args){ // get parameter
if(N >= CANMESG_NOPAR){
USB_sendstr(errtxt[ERR_BADPAR]); newline();
return RET_GOOD;
}
par = (uint8_t) N;
}
n = strchr(n, '=');
if(n){
++n;
const char *nxt = getint(n, &val);
if(nxt != n){ // set setter flag
par |= SETTERFLAG;
}
}
}
*/