mirror of
https://github.com/eddyem/stm32samples.git
synced 2026-03-20 08:40:57 +03:00
1050 lines
35 KiB
C++
1050 lines
35 KiB
C++
/*
|
||
* This file is part of the usbcangpio 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/>.
|
||
*/
|
||
|
||
// !!! Some commands could change icoming string, so don't try to use it after function call !!!
|
||
|
||
#include <stdint.h>
|
||
|
||
extern "C"{
|
||
#include <stm32f0.h>
|
||
#include "adc.h"
|
||
#include "can.h"
|
||
#include "flash.h"
|
||
#include "gpio.h"
|
||
#include "gpioproto.h"
|
||
#include "i2c.h"
|
||
#include "pwm.h"
|
||
#include "spi.h"
|
||
#include "usart.h"
|
||
#undef USBIF
|
||
#define USBIF IGPIO
|
||
#include "strfunc.h"
|
||
}
|
||
|
||
extern volatile uint32_t Tms;
|
||
|
||
static uint8_t curbuf[MAXSTRLEN]; // buffer for receiving data from USART etc
|
||
|
||
static uint8_t usart_text = 0; // ==1 for text USART proto
|
||
static uint8_t hex_input_mode = 0; // ==0 for text input, 1 for HEX + text in quotes
|
||
|
||
// TODO: add analog threshold!
|
||
|
||
// list of all commands and handlers
|
||
#define COMMAND_TABLE \
|
||
COMMAND(canspeed, "CAN bus speed setter/getter (kBaud, 10..1000)") \
|
||
COMMAND(curcanspeed,"current CAN bus speed (interface speed, not settings)") \
|
||
COMMAND(curpinconf, "dump current (maybe wrong) pin configuration") \
|
||
COMMAND(dumpconf, "dump global configuration") \
|
||
COMMAND(eraseflash, "erase full flash storage") \
|
||
COMMAND(help, "show this help") \
|
||
COMMAND(hexinput, "input is text (0) or hex + text in quotes (1)") \
|
||
COMMAND(iic, "write data over I2C: I2C=addr data (hex)") \
|
||
COMMAND(iicread, "I2C read: I2Cread=addr nbytes (hex)") \
|
||
COMMAND(iicreadreg, "I2C read register: I2Creadreg=addr reg nbytes (hex)") \
|
||
COMMAND(iicscan, "Scan I2C bus for devices") \
|
||
COMMAND(mcutemp, "get MCU temperature (degC*10)") \
|
||
COMMAND(mcureset, "reset MCU") \
|
||
COMMAND(PA, "GPIOA setter/getter (type PA0=help for further info)") \
|
||
COMMAND(PB, "GPIOB setter/getter") \
|
||
COMMAND(pinout, "list pinout with all available functions (or selected in setter, like pinout=USART,AIN") \
|
||
COMMAND(pwmmap, "show pins with PWM ability") \
|
||
COMMAND(readconf, "re-read config from flash") \
|
||
COMMAND(reinit, "apply pin config") \
|
||
COMMAND(saveconf, "save current user configuration into flash") \
|
||
COMMAND(sendcan, "send all after '=' to CAN USB interface") \
|
||
COMMAND(setiface, "set/get name of interface x (0 - CAN, 1 - GPIO)") \
|
||
COMMAND(SPI, "transfer SPI data: SPI=data (hex); if RXONLY: SPI = size (size to read, bytes)") \
|
||
COMMAND(time, "show current time (ms)") \
|
||
COMMAND(USART, "Read USART data or send (USART=hex)") \
|
||
COMMAND(vdd, "get approx Vdd value (V*100)")
|
||
// COMMAND(SPI, "Read SPI data or send (SPI=hex)")
|
||
// COMMAND(spiconf, "set SPI params")
|
||
|
||
|
||
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`
|
||
#define COMMAND(name, desc) { #name, desc },
|
||
COMMAND_TABLE
|
||
#undef COMMAND
|
||
};
|
||
|
||
// pin settings parser
|
||
struct Keyword {
|
||
int index; // index in str_keywords
|
||
uint8_t group;
|
||
uint8_t value;
|
||
};
|
||
|
||
enum KeywordGroup {
|
||
GROUP_MODE,
|
||
GROUP_PULL,
|
||
GROUP_OTYPE,
|
||
GROUP_FUNC,
|
||
GROUP_MISC
|
||
};
|
||
|
||
enum MiscValues{
|
||
MISC_MONITOR = 1,
|
||
MISC_THRESHOLD,
|
||
MISC_SPEED,
|
||
MISC_TEXT,
|
||
MISC_HEX,
|
||
MISC_LSBFIRST,
|
||
MISC_CPOL,
|
||
MISC_CPHA,
|
||
};
|
||
|
||
// TODO: add HEX input?
|
||
|
||
#define KEYWORDS \
|
||
KW(AIN) \
|
||
KW(IN) \
|
||
KW(OUT) \
|
||
KW(AF) \
|
||
KW(PU)\
|
||
KW(PD) \
|
||
KW(FL) \
|
||
KW(PP) \
|
||
KW(OD) \
|
||
KW(USART) \
|
||
KW(SPI) \
|
||
KW(I2C) \
|
||
KW(MONITOR) \
|
||
KW(THRESHOLD) \
|
||
KW(SPEED) \
|
||
KW(TEXT) \
|
||
KW(HEX) \
|
||
KW(PWM) \
|
||
KW(LSBFIRST) \
|
||
KW(CPOL) \
|
||
KW(CPHA)
|
||
|
||
|
||
typedef enum{ // indexes of string keywords
|
||
#define KW(k) STR_ ## k,
|
||
KEYWORDS
|
||
#undef KW
|
||
} kwindex_t;
|
||
|
||
// strings for keywords
|
||
static const char *str_keywords[] = {
|
||
#define KW(x) [STR_ ## x] = #x,
|
||
KEYWORDS
|
||
#undef KW
|
||
};
|
||
|
||
static const Keyword keywords[] = {
|
||
#define KEY(x, g, v) { STR_ ## x, g, v},
|
||
KEY(AIN, GROUP_MODE, MODE_ANALOG)
|
||
KEY(IN, GROUP_MODE, MODE_INPUT)
|
||
KEY(OUT, GROUP_MODE, MODE_OUTPUT)
|
||
KEY(AF, GROUP_MODE, MODE_AF)
|
||
KEY(PU, GROUP_PULL, PULL_UP)
|
||
KEY(PD, GROUP_PULL, PULL_DOWN)
|
||
KEY(FL, GROUP_PULL, PULL_NONE)
|
||
KEY(PP, GROUP_OTYPE, OUTPUT_PP)
|
||
KEY(OD, GROUP_OTYPE, OUTPUT_OD)
|
||
KEY(USART, GROUP_FUNC, FUNC_USART)
|
||
KEY(SPI, GROUP_FUNC, FUNC_SPI)
|
||
KEY(I2C, GROUP_FUNC, FUNC_I2C)
|
||
KEY(PWM, GROUP_FUNC, FUNC_PWM)
|
||
KEY(MONITOR, GROUP_MISC, MISC_MONITOR)
|
||
KEY(THRESHOLD, GROUP_MISC, MISC_THRESHOLD)
|
||
KEY(SPEED, GROUP_MISC, MISC_SPEED)
|
||
KEY(TEXT, GROUP_MISC, MISC_TEXT)
|
||
KEY(HEX, GROUP_MISC, MISC_HEX)
|
||
KEY(LSBFIRST, GROUP_MISC, MISC_LSBFIRST)
|
||
KEY(CPOL, GROUP_MISC, MISC_CPOL)
|
||
KEY(CPHA, GROUP_MISC, MISC_CPHA)
|
||
#undef K
|
||
};
|
||
#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",
|
||
[ERR_BUSY] = "BUSY",
|
||
[ERR_OVERFLOW] = "OVERFLOW",
|
||
};
|
||
|
||
static const char *pinhelp =
|
||
"Pin settings: PXx = MODE PULL OTYPE FUNC MISC (in any sequence), where\n"
|
||
" MODE: AIN, IN or OUT (analog in, digital in, output), also AF (automatically set when AF selected)\n"
|
||
" PULL: PU, PD or FL (pullup, pulldown, no pull - floating)\n"
|
||
" OTYPE: PP or OD (push-pull or open-drain)\n"
|
||
" FUNC: USART, SPI, I2C or PWM (enable alternate function and configure peripheal)\n"
|
||
" MISC: MONITOR - send data by USB as only state changed\n"
|
||
" THRESHOLD val (ADC only) - monitoring threshold, ADU\n"
|
||
" SPEED val - interface speed/frequency\n"
|
||
" TEXT - USART means data as text ('\\n'-separated strings)\n"
|
||
" HEX - USART means data as binary (output: HEX)\n"
|
||
" CPHA - set SPI CPHA to 1\n"
|
||
" CPOL - set SPI CPOL to 1\n"
|
||
" LCBFIRST - SPI use lsb-first proto\n"
|
||
"\n"
|
||
;
|
||
|
||
static const char *EQ = " = "; // equal sign for getters
|
||
// token delimeters in setters
|
||
static const char *DELIM_ = " ,";
|
||
static const char *COMMA = ", "; // comma before next val in list
|
||
|
||
// 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)
|
||
|
||
/**
|
||
* @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){
|
||
DBG("next="); DBG(next); DBGNL();
|
||
if(*(++next)) next = omit_spaces(next);
|
||
if(*next == 0) next = NULL;
|
||
}
|
||
DBG("next="); DBG(next); DBGNL();
|
||
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 && parval){
|
||
*parval = I32;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief parse_hex_data - data parsing in case of `hex + text` input format
|
||
* @param input - input string
|
||
* @param output - output data
|
||
* @param max_len - length of `output`
|
||
* @return amount of parsed bytes or -1 in case of overflow or error
|
||
*/
|
||
static int parse_hex_data(char *input, uint8_t *output, int max_len){
|
||
if(!input || !*input || !output || max_len < 1) return 0;
|
||
char *p = input;
|
||
int out_idx = 0;
|
||
while(*p && out_idx < max_len){
|
||
while(*p == ' ' || *p == ',') ++p; // omit spaces and commas as delimeters
|
||
if(*p == '\0') break; // EOL
|
||
if(*p == '"'){ // TEXT (start/end)
|
||
++p;
|
||
while(*p && *p != '"'){
|
||
if(out_idx >= max_len) return -1;
|
||
output[out_idx++] = *p++;
|
||
}
|
||
if(*p == '"'){
|
||
++p; // go to next symbol after closing quotation mark
|
||
}else return -1; // no closing
|
||
}else{ // HEX number
|
||
char *start = p;
|
||
while(*p && *p != ' ' && *p != ',' && *p != '"') ++p;
|
||
char saved = *p;
|
||
*p = '\0'; // temporarily for `gethex`
|
||
uint32_t val;
|
||
const char *end = gethex(start, &val);
|
||
if(end != p || val > 0xFF){ // not a hex number or have more than 2 symbols
|
||
*p = saved;
|
||
return -1;
|
||
}
|
||
*p = saved;
|
||
output[out_idx++] = (uint8_t)val;
|
||
}
|
||
}
|
||
return out_idx;
|
||
}
|
||
|
||
// `port` and `pin` are checked in `parse_pin_command`
|
||
// `PAx = ` also printed there
|
||
static void pin_getter(uint8_t port, uint8_t pin){
|
||
int16_t val = pin_in(port, pin);
|
||
if(val < 0){
|
||
SENDn(errtxt[ERR_CANTRUN]);
|
||
return;
|
||
}
|
||
SEND(port == 0 ? "PA" : "PB"); SEND(u2str((uint32_t)pin)); SEND(EQ);
|
||
SENDn(u2str((uint32_t)val));
|
||
}
|
||
|
||
// `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){
|
||
if(strncmp(setter, "help", 4) == 0){ // send PIN help
|
||
SENDn(pinhelp);
|
||
return ERR_AMOUNT;
|
||
}
|
||
pinconfig_t curconf;
|
||
if(!get_curpinconf(port, pin, &curconf)) return ERR_BADVAL; // copy current config
|
||
uint32_t U32;
|
||
char *end = getnum(setter, &U32);
|
||
if(end != setter && *end == 0){ // number -> set pin/PWM value
|
||
if(U32 > 0xff) return ERR_BADVAL;
|
||
uint8_t val = (uint8_t) U32;
|
||
if(curconf.mode == MODE_OUTPUT){ // set/clear pin
|
||
if(U32 > 1) U32 = 1;
|
||
DBG("set pin\n");
|
||
if(pin_out(port, pin, val)) return ERR_OK;
|
||
return ERR_CANTRUN;
|
||
}else if(curconf.mode == MODE_AF && curconf.af == FUNC_PWM){
|
||
if(setPWM(port, pin, val)) return ERR_OK;
|
||
return ERR_CANTRUN;
|
||
}
|
||
}
|
||
// complex setter: parse properties
|
||
uint8_t mode_set = 0xFF, pull_set = 0xFF, otype_set = 0xFF, func_set = 0xFF;
|
||
bool monitor = false;
|
||
uint16_t *pending_u16 = NULL; // pointer to uint16_t value, if !NULL, next token should be a number
|
||
uint32_t *pending_u32 = NULL; // -//- for uint32_t
|
||
uint32_t wU32 = UINT32_MAX; // for pending
|
||
usartconf_t UsartConf;
|
||
spiconfig_t spiconf = {}; // for flags CPHA/CPOL/LSBFIRST
|
||
if(!get_curusartconf(&UsartConf)) return ERR_CANTRUN;
|
||
char *saveptr, *token = strtok_r(setter, DELIM_, &saveptr);
|
||
while(token){
|
||
if(pending_u16){
|
||
uint32_t val;
|
||
end = getnum(token, &val);
|
||
if(end == token || val > 0xFFFF) return ERR_BADVAL;
|
||
*pending_u16 = (uint16_t)val;
|
||
pending_u16 = NULL; // reset
|
||
token = strtok_r(NULL, DELIM_, &saveptr);
|
||
continue;
|
||
}
|
||
if(pending_u32){
|
||
uint32_t val;
|
||
end = getnum(token, &val);
|
||
if(end == token) return ERR_BADVAL;
|
||
*pending_u32 = val;
|
||
pending_u32 = NULL;
|
||
token = strtok_r(NULL, DELIM_, &saveptr);
|
||
continue;
|
||
}
|
||
size_t i = 0;
|
||
for(; i < NUM_KEYWORDS; i++){
|
||
if(strcmp(token, str_keywords[keywords[i].index]) == 0){
|
||
switch(keywords[i].group){
|
||
case GROUP_MODE:
|
||
DBG("GROUP_MODE\n");
|
||
if(mode_set != 0xFF) return ERR_BADVAL; // repeated similar group parameter
|
||
mode_set = keywords[i].value;
|
||
break;
|
||
case GROUP_PULL:
|
||
DBG("GROUP_PULL\n");
|
||
if(pull_set != 0xFF) return ERR_BADVAL;
|
||
pull_set = keywords[i].value;
|
||
break;
|
||
case GROUP_OTYPE:
|
||
DBG("GROUP_OTYPE\n");
|
||
if(otype_set != 0xFF) return ERR_BADVAL;
|
||
otype_set = keywords[i].value;
|
||
break;
|
||
case GROUP_FUNC:
|
||
DBG("GROUP_FUNC\n");
|
||
if(func_set != 0xFF) return ERR_BADVAL;
|
||
func_set = keywords[i].value;
|
||
break;
|
||
case GROUP_MISC:
|
||
DBG("GROUP_MISC\n");
|
||
switch(keywords[i].value){
|
||
case MISC_MONITOR:
|
||
monitor = true;
|
||
break;
|
||
case MISC_THRESHOLD:
|
||
pending_u16 = &curconf.threshold;
|
||
break;
|
||
case MISC_SPEED:
|
||
pending_u32 = &wU32;
|
||
break;
|
||
case MISC_TEXT: // what to do, if textproto is set, but user wants binary?
|
||
UsartConf.textproto = 1;
|
||
break;
|
||
case MISC_HEX: // clear text flag
|
||
UsartConf.textproto = 0;
|
||
break;
|
||
case MISC_CPHA:
|
||
spiconf.cpha = 1;
|
||
break;
|
||
case MISC_CPOL:
|
||
spiconf.cpol = 1;
|
||
break;
|
||
case MISC_LSBFIRST:
|
||
spiconf.lsbfirst = 1;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if(i == NUM_KEYWORDS) return ERR_BADVAL; // not found
|
||
token = strtok_r(NULL, DELIM_, &saveptr);
|
||
}
|
||
if(pending_u16 || pending_u32) return ERR_BADVAL; // no number that we waiting for
|
||
|
||
// check periferial settings before refresh pin data
|
||
// check current USART settings
|
||
if(func_set == FUNC_USART){
|
||
if(wU32 != UINT32_MAX) UsartConf.speed = wU32;
|
||
if(!chkusartconf(&UsartConf)) return ERR_BADVAL;
|
||
}else if(func_set == FUNC_I2C){ // check speed
|
||
if(wU32 != UINT32_MAX){
|
||
if(wU32 >= I2C_SPEED_AMOUNT) return ERR_BADVAL;
|
||
i2c_speed_t s = static_cast <i2c_speed_t> (wU32);
|
||
the_conf.I2Cspeed = static_cast <uint8_t> (s);
|
||
}
|
||
}else if(func_set == FUNC_SPI){
|
||
if(wU32 != UINT32_MAX) the_conf.spiconfig.speed = wU32;
|
||
the_conf.spiconfig.cpha = spiconf.cpha;
|
||
the_conf.spiconfig.cpol = spiconf.cpol;
|
||
the_conf.spiconfig.lsbfirst = spiconf.lsbfirst;
|
||
}
|
||
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
|
||
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 = static_cast <funcnames_t> (func_set);
|
||
curconf.monitor = monitor;
|
||
if(!set_pinfunc(port, pin, &curconf)) return ERR_BADVAL;
|
||
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);
|
||
DBG("args="); DBG(args); DBG(", pin="); DBG(i2str(pin)); DBG(", setter="); DBG(setter); DBGNL();
|
||
if(pin < 0 || pin > 15) return ERR_BADPAR;
|
||
if(is_disabled(port, pin)) return ERR_CANTRUN; // prohibited pin
|
||
if(!setter){ // simple getter -> get value and return ERR_AMOUNT as silence
|
||
DBG("Getter\n");
|
||
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()){
|
||
usartconf_t UC;
|
||
if(get_curusartconf(&UC)){
|
||
usart_text = UC.textproto;
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
SEND("Can't reinit: check your configuration!\n");
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
// canspeed = baudrate (kBaud)
|
||
static errcodes_t cmd_canspeed(const char *cmd, char *args){
|
||
int32_t S;
|
||
if(argsvals(args, NULL, &S)){
|
||
if(S < CAN_MIN_SPEED || S > CAN_MAX_SPEED) return ERR_BADVAL;
|
||
the_conf.CANspeed = S;
|
||
}
|
||
CMDEQ();
|
||
SENDn(u2str(the_conf.CANspeed));
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_curcanspeed(const char *cmd, char _U_ *args){
|
||
CMDEQ();
|
||
SENDn(u2str(CAN_getspeed()));
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
// dump global pin config (current == 0) or current (==1)
|
||
static void dumppinconf(int current){
|
||
if(current) SEND("Current p");
|
||
else PUTCHAR('P');
|
||
SEND("in configuration:\n");
|
||
#define S(k) SEND(str_keywords[STR_ ## k])
|
||
#define SP(k) do{PUTCHAR(' '); S(k);}while(0)
|
||
for(int port = 0; port < 2; port++){
|
||
char port_letter = (port == 0) ? 'A' : 'B';
|
||
for(int pin = 0; pin < 16; pin++){
|
||
pinconfig_t cur, *p = &cur;
|
||
if(current && !get_curpinconf(port, pin, &cur)) continue; // local
|
||
if(!current) p = &the_conf.pinconfig[port][pin]; // global
|
||
if(!p->enable) continue;
|
||
PUTCHAR('P'); PUTCHAR(port_letter); SEND(i2str(pin)); SEND(EQ);
|
||
switch(p->mode){
|
||
case MODE_INPUT:
|
||
S(IN);
|
||
if(p->pull == PULL_UP) SP(PU);
|
||
else if (p->pull == PULL_DOWN) SP(PD);
|
||
else SP(FL);
|
||
break;
|
||
case MODE_OUTPUT:
|
||
S(OUT);
|
||
if(p->otype == OUTPUT_PP) SP(PP);
|
||
else SP(OD);
|
||
if(p->pull == PULL_UP) SP(PU);
|
||
else if (p->pull == PULL_DOWN) SP(PD);
|
||
break;
|
||
case MODE_ANALOG:
|
||
S(AIN);
|
||
if(p->threshold){
|
||
SP(THRESHOLD);
|
||
PUTCHAR(' ');
|
||
SEND(u2str(p->threshold));
|
||
}
|
||
break;
|
||
case MODE_AF:
|
||
switch(p->af){
|
||
case FUNC_USART: S(USART); break;
|
||
case FUNC_SPI: S(SPI); break;
|
||
case FUNC_I2C: S(I2C); break;
|
||
case FUNC_PWM: S(PWM); break;
|
||
default: SEND("UNKNOWN_AF");
|
||
}
|
||
break;
|
||
}
|
||
/*
|
||
if(p->mode == MODE_OUTPUT || p->mode == MODE_AF){
|
||
switch(p->speed){
|
||
case SPEED_LOW: SEND(" LOWSPEED"); break;
|
||
case SPEED_MEDIUM: SEND(" MEDSPEED"); break;
|
||
case SPEED_HIGH: SEND(" HIGHSPEED"); break;
|
||
default: break;
|
||
}
|
||
}*/
|
||
// Monitor
|
||
if(p->monitor) SP(MONITOR);
|
||
NL();
|
||
}
|
||
}
|
||
#undef S
|
||
#undef SP
|
||
}
|
||
|
||
static errcodes_t cmd_curpinconf(const char _U_ *cmd, char _U_ *args){
|
||
dumppinconf(TRUE);
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_dumpconf(const char _U_ *cmd, char _U_ *args){
|
||
SEND("userconf_sz="); SEND(u2str(the_conf.userconf_sz));
|
||
SEND("\nstorage_capacity="); SEND(u2str(storage_capacity()));
|
||
SEND("\ncurrentconfidx="); SENDn(i2str(currentconfidx));
|
||
for(int i = 0; i < InterfacesAmount; ++i){
|
||
SEND("interface"); PUTCHAR('0' + i);
|
||
PUTCHAR('=');
|
||
int l = the_conf.iIlengths[i] / 2;
|
||
char *ptr = (char*) the_conf.iInterface[i];
|
||
for(int j = 0; j < l; ++j){
|
||
PUTCHAR(*ptr);
|
||
ptr += 2;
|
||
}
|
||
NL();
|
||
}
|
||
SEND("canspeed="); SENDn(u2str(the_conf.CANspeed));
|
||
dumppinconf(FALSE); // global pin config
|
||
#define S(k) SEND(str_keywords[STR_ ## k])
|
||
#define SP(k) do{PUTCHAR(' '); S(k);}while(0)
|
||
usartconf_t U = the_conf.usartconfig;
|
||
if(U.RXen || U.TXen){ // USART enabled -> tell config
|
||
S(USART); SEND(EQ);
|
||
S(SPEED); PUTCHAR(' '); SEND(u2str(U.speed));
|
||
if(U.textproto) SP(TEXT);
|
||
if(U.monitor) SP(MONITOR);
|
||
if(U.TXen && !U.RXen) SEND(" TXONLY");
|
||
else if(!U.TXen && U.RXen) SEND(" RXONLY");
|
||
NL();
|
||
}
|
||
if(I2C1->CR1 & I2C_CR1_PE){ // I2C active, show its speed
|
||
S(I2C); SEND(EQ); S(SPEED); PUTCHAR(' ');
|
||
switch(the_conf.I2Cspeed){
|
||
case 0: SEND("10kHz"); break;
|
||
case 1: SEND("100kHz"); break;
|
||
case 2: SEND("400kHz"); break;
|
||
case 3: SEND("1MHz"); break;
|
||
default: SEND("unknown");
|
||
}
|
||
NL();
|
||
}
|
||
if(SPI1->CR1 & SPI_CR1_SPE){
|
||
S(SPI); SEND(EQ);
|
||
S(SPEED); PUTCHAR(' '); SEND(u2str(the_conf.spiconfig.speed));
|
||
if(the_conf.spiconfig.cpol) SP(CPOL);
|
||
if(the_conf.spiconfig.cpha) SP(CPHA);
|
||
if(the_conf.spiconfig.lsbfirst) SP(LSBFIRST);
|
||
if(the_conf.spiconfig.rxonly) SEND(" RXONLY");
|
||
else if(the_conf.spiconfig.txonly) SEND(" TXONLY");
|
||
NL();
|
||
}
|
||
#undef S
|
||
#undef SP
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_setiface(const char* cmd, char *args){
|
||
int32_t N;
|
||
char *setter = splitargs(args, &N);
|
||
if(N < 0 || N >= InterfacesAmount) return ERR_BADPAR;
|
||
if(setter && *setter){ // setter
|
||
int l = strlen(setter);
|
||
if(l > MAX_IINTERFACE_SZ) return ERR_BADVAL;
|
||
the_conf.iIlengths[N] = (uint8_t) l * 2;
|
||
char *ptr = (char*)the_conf.iInterface[N];
|
||
for(int i = 0; i < l; ++i){
|
||
char c = *setter++;
|
||
*ptr++ = (c > ' ') ? c : '_';
|
||
*ptr++ = 0;
|
||
}
|
||
}
|
||
// getter
|
||
CMDEQP(N);
|
||
char *ptr = (char*) the_conf.iInterface[N];
|
||
int l = the_conf.iIlengths[N] / 2;
|
||
for(int j = 0; j < l; ++j){
|
||
PUTCHAR(*ptr);
|
||
ptr += 2;
|
||
}
|
||
NL();
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_sendcan(const char _U_ *cmd, char *args){
|
||
if(!args) return ERR_BADVAL;
|
||
char *setter = splitargs(args, NULL);
|
||
if(!setter) return ERR_BADVAL;
|
||
if(hex_input_mode){
|
||
int len = parse_hex_data(setter, curbuf, MAXSTRLEN);
|
||
if(len < 0) return ERR_BADVAL;
|
||
if(len == 0) return ERR_AMOUNT;
|
||
if(USB_send(ICAN, curbuf, len)) return ERR_OK;
|
||
}else{
|
||
if(USB_sendstr(ICAN, setter)){
|
||
USB_putbyte(ICAN, '\n');
|
||
return ERR_OK;
|
||
}
|
||
}
|
||
return ERR_CANTRUN;
|
||
}
|
||
|
||
static errcodes_t cmd_time(const char *cmd, char _U_ *args){
|
||
CMDEQ();
|
||
SENDn(u2str(Tms));
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_mcureset(const char _U_ *cmd, char _U_ *args){
|
||
NVIC_SystemReset();
|
||
return ERR_CANTRUN; // never reached
|
||
}
|
||
|
||
static errcodes_t cmd_readconf(const char _U_ *cmd, char _U_ *args){
|
||
flashstorage_init();
|
||
return ERR_OK;
|
||
}
|
||
|
||
static errcodes_t cmd_saveconf(const char _U_ *cmd, char _U_ *args){
|
||
if(store_userconf()) return ERR_CANTRUN;
|
||
return ERR_OK;
|
||
}
|
||
|
||
static errcodes_t cmd_eraseflash(const char _U_ *cmd, char _U_ *args){
|
||
if(erase_storage()) return ERR_CANTRUN;
|
||
return ERR_OK;
|
||
}
|
||
|
||
static errcodes_t cmd_mcutemp(const char *cmd, char _U_ *args){
|
||
CMDEQ();
|
||
SENDn(i2str(getMCUtemp()));
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_vdd(const char *cmd, char _U_ *args){
|
||
CMDEQ();
|
||
SENDn(u2str(getVdd()));
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_help(const char _U_ *cmd, char _U_ *args){
|
||
SEND(REPOURL);
|
||
for(size_t i = 0; i < sizeof(cmdInfo)/sizeof(cmdInfo[0]); i++){
|
||
SEND(cmdInfo[i].name);
|
||
SEND(" - ");
|
||
SENDn(cmdInfo[i].desc);
|
||
}
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_hexinput(const char *cmd, char *args){
|
||
int32_t val;
|
||
if(argsvals(args, NULL, &val)){
|
||
if(val == 0 || val == 1) hex_input_mode = (uint8_t)val;
|
||
else return ERR_BADVAL;
|
||
}
|
||
CMDEQ();
|
||
SENDn(hex_input_mode ? "1" : "0");
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_pwmmap(const char _U_ *cmd, char _U_ *args){
|
||
pwmtimer_t t;
|
||
SEND("PWM pins:\n");
|
||
for(int port = 0; port < 2; ++port){
|
||
for(int pin = 0; pin < 16; ++pin){
|
||
if(!canPWM(port, pin, &t)) continue;
|
||
SEND((port == 0) ? "PA" : "PB");
|
||
SEND(u2str(pin));
|
||
if(t.collision){
|
||
SEND(" conflicts with ");
|
||
SEND((t.collport == 0) ? "PA" : "PB");
|
||
SEND(u2str(t.collpin));
|
||
}
|
||
NL();
|
||
}
|
||
}
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static int sendfun(const char *s){
|
||
if(!s) return 0;
|
||
return USB_sendstr(IGPIO, s);
|
||
}
|
||
|
||
static void sendusartdata(const uint8_t *buf, int len){
|
||
if(!buf || len < 1) return;
|
||
SEND(str_keywords[STR_USART]); SEND(EQ);
|
||
if(usart_text){
|
||
USB_send(IGPIO, curbuf, len);
|
||
NL(); // always add newline at the end to mark real newline ("\n\n") and piece of line ("\n")
|
||
}else{
|
||
NL();
|
||
hexdump(sendfun, (uint8_t*)curbuf, len);
|
||
}
|
||
}
|
||
|
||
static errcodes_t cmd_USART(const char _U_ *cmd, char *args){
|
||
if(!args) return ERR_BADVAL;
|
||
char *setter = splitargs(args, NULL);
|
||
if(setter){
|
||
DBG("Try to send over USART\n");
|
||
if(hex_input_mode){
|
||
int len = parse_hex_data(setter, curbuf, MAXSTRLEN);
|
||
if(len < 0) return ERR_BADVAL;
|
||
if(len > 0) return usart_send(curbuf, len);
|
||
}else{ // text mode: "AS IS"
|
||
int l = strlen(setter);
|
||
if(usart_text){ // add '\n' as we removed it @ parser
|
||
setter[l++] = '\n';
|
||
}
|
||
return usart_send((uint8_t*)setter, l);
|
||
}
|
||
} // getter: try to read
|
||
int l = usart_receive(curbuf, MAXSTRLEN);
|
||
if(l < 0) return ERR_CANTRUN;
|
||
if(l > 0) sendusartdata(curbuf, l);
|
||
// or silence: nothing to read
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_iic(const char _U_ *cmd, char *args){
|
||
if(!(I2C1->CR1 & I2C_CR1_PE)) return ERR_CANTRUN;
|
||
if(!args) return ERR_BADVAL;
|
||
char *setter = splitargs(args, NULL);
|
||
if(!setter) return ERR_BADVAL;
|
||
int len = parse_hex_data(setter, curbuf, MAXSTRLEN);
|
||
if(len < 1) return ERR_BADVAL; // need at least address
|
||
uint8_t addr = curbuf[0];
|
||
if(addr > 0x7F) return ERR_BADVAL; // 7-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
|
||
if(len == 1){ // only address without data
|
||
return ERR_BADPAR;
|
||
}
|
||
addr <<= 1; // roll address to run i2c_write
|
||
if(!i2c_write(addr, curbuf + 1, len - 1)){ // len = address + data length
|
||
return ERR_CANTRUN;
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
|
||
static errcodes_t cmd_iicread(const char *cmd, char *args){
|
||
if(!(I2C1->CR1 & I2C_CR1_PE)) return ERR_CANTRUN;
|
||
if(!args) return ERR_BADVAL;
|
||
char *setter = splitargs(args, NULL);
|
||
if(!setter) return ERR_BADVAL;
|
||
int len = parse_hex_data(setter, curbuf, MAXSTRLEN);
|
||
if(len != 2) return ERR_BADVAL; // address, amount of bytes
|
||
uint8_t addr = curbuf[0];
|
||
uint8_t nbytes = curbuf[1];
|
||
if(addr > 0x7F) return ERR_BADVAL; // allow to "read" 0 bytes (just get ACK)
|
||
addr <<= 1;
|
||
if(!i2c_read(addr, curbuf, nbytes)) return ERR_CANTRUN;
|
||
CMDEQ();
|
||
if(nbytes > 8) NL();
|
||
hexdump(sendfun, curbuf, nbytes);
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_iicreadreg(const char *cmd, char *args){
|
||
if(!(I2C1->CR1 & I2C_CR1_PE)) return ERR_CANTRUN;
|
||
if(!args) return ERR_BADVAL;
|
||
char *setter = splitargs(args, NULL);
|
||
if(!setter) return ERR_BADVAL;
|
||
int len = parse_hex_data(setter, curbuf, MAXSTRLEN);
|
||
if(len != 3) return ERR_BADVAL; // address, register, amount of bytes
|
||
uint8_t addr = curbuf[0];
|
||
uint8_t nreg = curbuf[1];
|
||
uint8_t nbytes = curbuf[2];
|
||
if(addr > 0x7F || nbytes == 0) return ERR_BADVAL;
|
||
addr <<= 1;
|
||
if(!i2c_read_reg(addr, nreg, curbuf, nbytes)) return ERR_CANTRUN;
|
||
CMDEQ();
|
||
if(nbytes > 8) NL();
|
||
hexdump(sendfun, curbuf, nbytes);
|
||
return ERR_AMOUNT;
|
||
}
|
||
|
||
static errcodes_t cmd_iicscan(const char _U_ *cmd, char _U_ *args){
|
||
if(!(I2C1->CR1 & I2C_CR1_PE)) return ERR_CANTRUN;
|
||
i2c_init_scan_mode();
|
||
return ERR_OK;
|
||
}
|
||
|
||
// array for `cmd_pinout`
|
||
static kwindex_t func_array[FUNC_AMOUNT] = {
|
||
[FUNC_AIN] = STR_AIN,
|
||
[FUNC_USART] = STR_USART,
|
||
[FUNC_SPI] = STR_SPI,
|
||
[FUNC_I2C] = STR_I2C,
|
||
[FUNC_PWM] = STR_PWM,
|
||
};
|
||
|
||
static errcodes_t cmd_pinout(const char _U_ *cmd, char *args){
|
||
uint8_t listmask = 0xff; // bitmask for funcnames_t
|
||
if(args && *args){ // change listmask by user choise
|
||
char *setter = splitargs(args, NULL);
|
||
if(!setter) return ERR_BADVAL;
|
||
char *saveptr, *token = strtok_r(setter, DELIM_, &saveptr);
|
||
listmask = 0;
|
||
while(token){
|
||
int i = 0;
|
||
for(; i < FUNC_AMOUNT; ++i){
|
||
if(0 == strcmp(token, str_keywords[func_array[i]])){
|
||
listmask |= (1 << i);
|
||
break;
|
||
}
|
||
}
|
||
if(i == FUNC_AMOUNT) return ERR_BADVAL; // wrong argument
|
||
token = strtok_r(NULL, DELIM_, &saveptr);
|
||
}
|
||
if(listmask == 0) return ERR_BADVAL;
|
||
}
|
||
pwmtimer_t tp; // timers' pins
|
||
usart_props_t up; // USARTs' pins
|
||
i2c_props_t ip; // I2C's pins
|
||
spi_props_t sp;
|
||
|
||
SEND("\nConfigurable pins (check collisions if functions have same name!):\n");
|
||
for(int port = 0; port < 2; ++port){
|
||
for(int pin = 0; pin < 16; ++pin){
|
||
int funcs = pinfuncs(port, pin);
|
||
if(funcs == -1) continue;
|
||
uint8_t mask = (static_cast <uint8_t> (funcs)) & listmask;
|
||
if(listmask != 0xff && !mask) continue; // no asked functions
|
||
SEND((port == 0) ? "PA" : "PB");
|
||
SEND(u2str(pin));
|
||
SEND(": ");
|
||
int needcomma = FALSE;
|
||
#define COMMA() do{if(needcomma) SEND(COMMA); needcomma = TRUE;}while(0)
|
||
if(listmask == 0xff){ // don't send "GPIO" for specific choice
|
||
SEND("GPIO");
|
||
needcomma = TRUE;
|
||
}
|
||
if(mask & (1 << FUNC_AIN)){ COMMA(); SEND(str_keywords[STR_AIN]); }
|
||
if(mask & (1 << FUNC_USART)){ // USARTn_aX (n - 1/2, a - R/T)
|
||
int idx = get_usart_index(port, pin, &up);
|
||
COMMA(); SEND(str_keywords[STR_USART]); PUTCHAR('1' + idx);
|
||
PUTCHAR('_'); PUTCHAR(up.isrx ? 'R' : 'T'); PUTCHAR('X');
|
||
}
|
||
if(mask & (1 << FUNC_SPI)){
|
||
int idx = get_spi_index(port, pin, &sp);
|
||
COMMA(); SEND(str_keywords[STR_SPI]); PUTCHAR('1' + idx);
|
||
PUTCHAR('_');
|
||
if(sp.ismiso) SEND("MISO");
|
||
else if(sp.ismosi) SEND("MOSI");
|
||
else SEND("SCK");
|
||
}
|
||
if(mask & (1 << FUNC_I2C)){
|
||
int idx = get_i2c_index(port, pin, &ip);
|
||
COMMA(); SEND(str_keywords[STR_I2C]); PUTCHAR('1' + idx);
|
||
PUTCHAR('_');
|
||
SEND(ip.isscl ? "SCL" : "SDA");
|
||
}
|
||
if(mask & (1 << FUNC_PWM)){
|
||
canPWM(port, pin, &tp);
|
||
COMMA(); SEND(str_keywords[STR_PWM]);
|
||
SEND(u2str(tp.timidx)); // timidx == TIMNO!
|
||
PUTCHAR('_');
|
||
PUTCHAR('1' + tp.chidx);
|
||
}
|
||
NL();
|
||
}
|
||
}
|
||
return ERR_AMOUNT;
|
||
#undef COMMA
|
||
}
|
||
|
||
static errcodes_t cmd_SPI(const char *cmd, char *args){
|
||
if(!args) return ERR_BADVAL;
|
||
if(!(SPI1->CR1 & SPI_CR1_SPE)) return ERR_CANTRUN;
|
||
char *setter = splitargs(args, NULL);
|
||
if(!setter) return ERR_BADVAL;
|
||
int len;
|
||
uint8_t *txbuf = curbuf, *rxbuf = curbuf;
|
||
if(the_conf.spiconfig.rxonly){
|
||
uint32_t L;
|
||
char *nxt = getnum(setter, &L);
|
||
if(nxt == setter || L > MAXSTRLEN) return ERR_BADVAL;
|
||
len = static_cast <int> (L);
|
||
txbuf = NULL;
|
||
}else len = parse_hex_data(setter, curbuf, MAXSTRLEN);
|
||
if(len <= 0) return ERR_BADVAL;
|
||
if(the_conf.spiconfig.txonly) rxbuf = NULL;
|
||
int got = spi_transfer(txbuf, rxbuf, len);
|
||
if(-1 == got) return ERR_CANTRUN;
|
||
if(0 == got) return ERR_BUSY;
|
||
if(!the_conf.spiconfig.txonly){
|
||
CMDEQ();
|
||
if(got > 8) NL();
|
||
hexdump(sendfun, curbuf, got);
|
||
return ERR_AMOUNT;
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
|
||
constexpr uint32_t hash(const char* str, uint32_t h = 0){
|
||
return *str ? hash(str + 1, h + ((h << 7) ^ *str)) : h;
|
||
}
|
||
|
||
static const char *CommandParser(char *str){
|
||
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;
|
||
switch(h){
|
||
#define COMMAND(name, desc) case hash(#name): ecode = cmd_ ## name(command, restof); break;
|
||
COMMAND_TABLE
|
||
#undef COMMAND
|
||
default: SEND("Unknown command, try 'help'\n"); break;
|
||
}
|
||
if(ecode < ERR_AMOUNT) return errtxt[ecode];
|
||
return NULL;
|
||
}
|
||
|
||
void GPIO_process(){
|
||
int l;
|
||
// TODO: check SPI/I2C etc
|
||
for(uint8_t port = 0; port < 2; ++port){
|
||
uint16_t alert = gpio_alert(port);
|
||
if(alert == 0) continue;
|
||
uint16_t pinmask = 1;
|
||
for(uint8_t i = 0; i < 16; ++i, pinmask <<= 1){
|
||
if(alert & pinmask) pin_getter(port, i);
|
||
}
|
||
}
|
||
l = usart_process(curbuf, MAXSTRLEN);
|
||
if(l > 0) sendusartdata(curbuf, l);
|
||
l = RECV((char*)curbuf, MAXSTRLEN);
|
||
if(l){
|
||
if(l < 0) SEND("ERROR: USB buffer overflow or string was too long\n");
|
||
else{
|
||
const char *ans = CommandParser((char*)curbuf);
|
||
if(ans) SENDn(ans);
|
||
}
|
||
}
|
||
if(I2C_scan_mode){
|
||
uint8_t addr;
|
||
if(i2c_scan_next_addr(&addr)){
|
||
SEND("foundaddr = ");
|
||
printuhex(addr);
|
||
NL();
|
||
}
|
||
}
|
||
}
|
||
|
||
// starting init by flash settings
|
||
void GPIO_init(){
|
||
gpio_reinit();
|
||
pwm_setup();
|
||
usartconf_t usc;
|
||
if(get_curusartconf(&usc)) usart_text = usc.textproto;
|
||
}
|