j/armchair_fw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'encoder' into dev - store parameters in nvs

Browse Source 
Several functional menu items were added, and parameters set via
menu are stored in nvs and loaded again at startup
This commit is contained in:
jonny_jr9 2024-02-23 09:43:34 +01:00
commit fab4d442e6
14 changed files with 867 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
board_single/main/button.cpp
View File

@ -67,7 +67,7 @@ void buttonCommands::action (uint8_t count, bool lastPressLong){
// ## no command ##
default:
ESP_LOGE(TAG, "no command for count=%d and long=%d defined", count, lastPressLong);
buzzer->beep(3, 400, 100);
buzzer->beep(3, 200, 100);
break;
case 1:
@ -76,7 +76,7 @@ void buttonCommands::action (uint8_t count, bool lastPressLong){
{
control->changeMode(controlMode_t::MENU);
ESP_LOGW(TAG, "1x long press -> change to menu mode");
buzzer->beep(1, 1000, 1);
buzzer->beep(20, 20, 10);
vTaskDelay(500 / portTICK_PERIOD_MS);
}
// ## toggle joystick freeze ##
@ -214,4 +214,4 @@ void buttonCommands::startHandleLoop()
}
} //end queue
} //end while(1)
} //end function
} //end function

13
board_single/main/config.cpp
View File

@ -90,6 +90,7 @@ sabertooth2x60_config_t sabertoothConfig = {
// TODO add motor name string -> then use as log tag?
//--- configure left motor (contol) ---
motorctl_config_t configMotorControlLeft = {
.name = "left",
.msFadeAccel = 1500, // acceleration of the motor (ms it takes from 0% to 100%)
.msFadeDecel = 1000, // deceleration of the motor (ms it takes from 100% to 0%)
.currentLimitEnabled = false,
@ -101,6 +102,7 @@ motorctl_config_t configMotorControlLeft = {
//--- configure right motor (contol) ---
motorctl_config_t configMotorControlRight = {
.name = "right",
.msFadeAccel = 1500, // acceleration of the motor (ms it takes from 0% to 100%)
.msFadeDecel = 1000, // deceleration of the motor (ms it takes from 100% to 0%)
.currentLimitEnabled = false,
@ -218,4 +220,15 @@ rotary_encoder_t encoder_config = {
.index = 0,
.btn_pressed_time_us = 20000,
.btn_state = RE_BTN_RELEASED //default state
};
//-----------------------------------
//--- joystick command generation ---
//-----------------------------------
//configure parameters for motor command generation from joystick data
joystickGenerateCommands_config_t joystickGenerateCommands_config{
.maxDuty = 100,
.dutyOffset = 5, // duty at which motors start immediately
.altStickMapping = false,
};

74
board_single/main/control.cpp
View File

@ -32,14 +32,17 @@ controlledArmchair::controlledArmchair(
controlledMotor *motorLeft_f,
controlledMotor *motorRight_f,
evaluatedJoystick *joystick_f,
joystickGenerateCommands_config_t *joystickGenerateCommands_config_f,
httpJoystick *httpJoystick_f,
automatedArmchair_c *automatedArmchair_f,
cControlledRest *legRest_f,
cControlledRest *backRest_f)
cControlledRest *backRest_f,
nvs_handle_t * nvsHandle_f)
{
//copy configuration
config = config_f;
joystickGenerateCommands_config = *joystickGenerateCommands_config_f;
//copy object pointers
buzzer = buzzer_f;
motorLeft = motorLeft_f;
@ -49,9 +52,13 @@ controlledArmchair::controlledArmchair(
automatedArmchair = automatedArmchair_f;
legRest = legRest_f;
backRest = backRest_f;
nvsHandle = nvsHandle_f;
//set default mode from config
modePrevious = config.defaultMode;
// override default config value if maxDuty is found in nvs
loadMaxDuty();
//TODO declare / configure controlled motors here instead of config (unnecessary that button object is globally available - only used here)?
}
@ -104,7 +111,7 @@ void controlledArmchair::startHandleLoop() {
//additionaly scale coordinates (more detail in slower area)
joystick_scaleCoordinatesLinear(&stickData, 0.6, 0.35); //TODO: add scaling parameters to config
//generate motor commands
commands = joystick_generateCommandsDriving(stickData, altStickMapping);
commands = joystick_generateCommandsDriving(stickData, &joystickGenerateCommands_config);
//apply motor commands
motorRight->setTarget(commands.right.state, commands.right.duty);
motorLeft->setTarget(commands.left.state, commands.left.duty);
@ -138,7 +145,7 @@ void controlledArmchair::startHandleLoop() {
ESP_LOGD(TAG, "generating commands from x=%.3f y=%.3f radius=%.3f angle=%.3f", stickData.x, stickData.y, stickData.radius, stickData.angle);
//--- generate motor commands ---
//Note: timeout (no data received) is handled in getData method
commands = joystick_generateCommandsDriving(stickData, altStickMapping);
commands = joystick_generateCommandsDriving(stickData, &joystickGenerateCommands_config);
//--- apply commands to motors ---
//TODO make motorctl.setTarget also accept motorcommand struct directly
@ -268,8 +275,8 @@ bool controlledArmchair::toggleFreezeInputMassage()
// toggle between normal and alternative stick mapping (joystick reverse position inverted)
bool controlledArmchair::toggleAltStickMapping()
{
altStickMapping = !altStickMapping;
if (altStickMapping)
joystickGenerateCommands_config.altStickMapping = !joystickGenerateCommands_config.altStickMapping;
if (joystickGenerateCommands_config.altStickMapping)
{
buzzer->beep(6, 70, 50);
ESP_LOGW(TAG, "changed to alternative stick mapping");
@ -279,7 +286,7 @@ bool controlledArmchair::toggleAltStickMapping()
buzzer->beep(1, 500, 100);
ESP_LOGW(TAG, "changed to default stick mapping");
}
return altStickMapping;
return joystickGenerateCommands_config.altStickMapping;
}
@ -419,7 +426,7 @@ void controlledArmchair::changeMode(controlMode_t modeNew) {
break;
case controlMode_t::IDLE:
buzzer->beep(1, 1500, 0);
buzzer->beep(1, 1000, 0);
#ifdef JOYSTICK_LOG_IN_IDLE
esp_log_level_set("evaluatedJoystick", ESP_LOG_DEBUG);
#endif
@ -503,3 +510,56 @@ void controlledArmchair::toggleMode(controlMode_t modePrimary){
changeMode(modePrimary);
}
}
//-------------------------------
//------ loadDecelDuration ------
//-------------------------------
// update local config value when maxDuty is stored in nvs
void controlledArmchair::loadMaxDuty(void)
{
// default value is already loaded (constructor)
// read from nvs
uint16_t valueRead;
esp_err_t err = nvs_get_u16(*nvsHandle, "c-maxDuty", &valueRead);
switch (err)
{
case ESP_OK:
ESP_LOGW(TAG, "Successfully read value '%s' from nvs. Overriding default value %.2f with %.2f", "c-maxDuty", joystickGenerateCommands_config.maxDuty, valueRead/100.0);
joystickGenerateCommands_config.maxDuty = (float)(valueRead/100.0);
break;
case ESP_ERR_NVS_NOT_FOUND:
ESP_LOGW(TAG, "nvs: the value '%s' is not initialized yet, keeping default value %.2f", "c-maxDuty", joystickGenerateCommands_config.maxDuty);
break;
default:
ESP_LOGE(TAG, "Error (%s) reading nvs!", esp_err_to_name(err));
}
}
//-----------------------------------
//---------- writeMaxDuty -----------
//-----------------------------------
// write provided value to nvs to be persistent and update local variable in joystickGenerateCommmands_config struct
// note: duty percentage gets stored as uint with factor 100 (to get more precision)
void controlledArmchair::writeMaxDuty(float newValue){
// check if unchanged
if(joystickGenerateCommands_config.maxDuty == newValue){
ESP_LOGW(TAG, "value unchanged at %.2f, not writing to nvs", newValue);
return;
}
// update nvs value
ESP_LOGW(TAG, "updating nvs value '%s' from %.2f to %.2f", "c-maxDuty", joystickGenerateCommands_config.maxDuty, newValue) ;
esp_err_t err = nvs_set_u16(*nvsHandle, "c-maxDuty", (uint16_t)(newValue*100));
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed writing");
err = nvs_commit(*nvsHandle);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed committing updates");
else
ESP_LOGI(TAG, "nvs: successfully committed updates");
// update variable
joystickGenerateCommands_config.maxDuty = newValue;
}

22
board_single/main/control.hpp
View File

@ -1,5 +1,10 @@
#pragma once
extern "C"
{
#include "nvs_flash.h"
#include "nvs.h"
}
#include "motordrivers.hpp"
#include "motorctl.hpp"
#include "buzzer.hpp"
@ -50,10 +55,12 @@ class controlledArmchair {
controlledMotor* motorLeft_f,
controlledMotor* motorRight_f,
evaluatedJoystick* joystick_f,
joystickGenerateCommands_config_t* joystickGenerateCommands_config_f,
httpJoystick* httpJoystick_f,
automatedArmchair_c* automatedArmchair,
cControlledRest * legRest,
cControlledRest * backRest
cControlledRest * backRest,
nvs_handle_t * nvsHandle_f
);
//--- functions ---
@ -79,27 +86,37 @@ class controlledArmchair {
controlMode_t getCurrentMode() const {return mode;};
const char *getCurrentModeStr() const { return controlModeStr[(int)mode]; };
//--- mode specific ---
// releases or locks joystick in place when in massage mode, returns true when input is frozen
bool toggleFreezeInputMassage();
// toggle between normal and alternative stick mapping (joystick reverse position inverted), returns true when alt mapping is active
bool toggleAltStickMapping();
// configure max dutycycle (in joystick or http mode)
void setMaxDuty(float maxDutyNew) { writeMaxDuty(maxDutyNew); };
float getMaxDuty() const {return joystickGenerateCommands_config.maxDuty; };
private:
//--- functions ---
//function that evaluates whether there is no activity/change on the motor duty for a certain time, if so a switch to IDLE is issued. - has to be run repeatedly in a slow interval
void handleTimeout();
void loadMaxDuty(); //load stored value for maxDuty from nvs
void writeMaxDuty(float newMaxDuty); //write new value for maxDuty to nvs
//--- objects ---
buzzer_t* buzzer;
controlledMotor* motorLeft;
controlledMotor* motorRight;
httpJoystick* httpJoystickMain_l;
evaluatedJoystick* joystick_l;
joystickGenerateCommands_config_t joystickGenerateCommands_config;
automatedArmchair_c *automatedArmchair;
cControlledRest * legRest;
cControlledRest * backRest;
//handle for using the nvs flash (persistent config variables)
nvs_handle_t * nvsHandle;
//---variables ---
//struct for motor commands returned by generate functions of each mode
@ -109,7 +126,6 @@ class controlledArmchair {
//store joystick data
joystickData_t stickData;
bool altStickMapping; //alternative joystick mapping (reverse mapped differently)
//variables for http mode
uint32_t http_timestamp_lastData = 0;

3
board_single/main/display.hpp
View File

@ -8,6 +8,8 @@ extern "C" {
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "ssd1306.h"
#include "font8x8_basic.h"
@ -42,6 +44,7 @@ typedef struct display_task_parameters_t {
speedSensor * speedLeft;
speedSensor * speedRight;
buzzer_t *buzzer;
nvs_handle_t * nvsHandle;
} display_task_parameters_t;

40
board_single/main/main.cpp
View File

@ -4,6 +4,7 @@ extern "C"
#include <esp_system.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include "nvs.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
@ -93,9 +94,12 @@ esp_err_t on_joystick_url(httpd_req_t *req)
return (httpJoystickMain->*pointerToReceiveFunc)(req);
}
//-- tag for logging --
//--- tag for logging ---
static const char * TAG = "main";
//-- handle passed to tasks for accessing nvs --
nvs_handle_t nvsHandle;
@ -140,23 +144,23 @@ void createObjects()
// create controlled motor instances (motorctl.hpp)
// with configurations from config.cpp
motorLeft = new controlledMotor(setLeftFunc, configMotorControlLeft);
motorRight = new controlledMotor(setRightFunc, configMotorControlRight);
motorLeft = new controlledMotor(setLeftFunc, configMotorControlLeft, &nvsHandle);
motorRight = new controlledMotor(setRightFunc, configMotorControlRight, &nvsHandle);
// create speedsensor instances
// with configurations from config.cpp
speedLeft = new speedSensor(speedLeft_config);
speedRight = new speedSensor(speedRight_config);
// create joystic instance (joystick.hpp)
joystick = new evaluatedJoystick(configJoystick);
// create joystick instance (joystick.hpp)
joystick = new evaluatedJoystick(configJoystick, &nvsHandle);
// create httpJoystick object (http.hpp)
httpJoystickMain = new httpJoystick(configHttpJoystickMain);
http_init_server(on_joystick_url);
// create buzzer object on pin 12 with gap between queued events of 100ms
buzzer = new buzzer_t(GPIO_NUM_12, 100);
// create buzzer object on pin 12 with gap between queued events of 1ms
buzzer = new buzzer_t(GPIO_NUM_12, 1);
// create objects for controlling the chair position
// gpio_up, gpio_down, name
@ -165,7 +169,7 @@ void createObjects()
// create control object (control.hpp)
// with configuration from config.cpp
control = new controlledArmchair(configControl, buzzer, motorLeft, motorRight, joystick, httpJoystickMain, automatedArmchair, legRest, backRest);
control = new controlledArmchair(configControl, buzzer, motorLeft, motorRight, joystick, &joystickGenerateCommands_config, httpJoystickMain, automatedArmchair, legRest, backRest, &nvsHandle);
// create automatedArmchair_c object (for auto-mode) (auto.hpp)
automatedArmchair = new automatedArmchair_c(motorLeft, motorRight);
@ -207,6 +211,22 @@ extern "C" void app_main(void) {
//--- initialize encoder ---
const QueueHandle_t encoderQueue = encoder_init(&encoder_config);
//--- initialize nvs-flash --- (for persistant config values)
ESP_LOGW(TAG, "initializing nvs-flash...");
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND)
{
ESP_LOGE(TAG, "NVS truncated -> deleting flash");
// Retry nvs_flash_init
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
//--- open nvs-flash ---
err = nvs_open("storage", NVS_READWRITE, &nvsHandle);
if (err != ESP_OK)
ESP_LOGE(TAG, "Error (%s) opening NVS handle!\n", esp_err_to_name(err));
printf("\n");
@ -266,8 +286,8 @@ extern "C" void app_main(void) {
//-----------------------------------
//----- create task for display -----
//-----------------------------------
////task that handles the display (show stats, handle menu in 'MENU' mode)
display_task_parameters_t display_param = {display_config, control, joystick, encoderQueue, motorLeft, motorRight, speedLeft, speedRight, buzzer};
//task that handles the display (show stats, handle menu in 'MENU' mode)
display_task_parameters_t display_param = {display_config, control, joystick, encoderQueue, motorLeft, motorRight, speedLeft, speedRight, buzzer, &nvsHandle};
xTaskCreate(&display_task, "display_task", 3*2048, &display_param, 3, NULL);
vTaskDelay(200 / portTICK_PERIOD_MS); //wait for all tasks to finish initializing

532
board_single/main/menu.cpp
View File

@ -25,7 +25,10 @@ static int value = 0;
//================================
//===== CONFIGURE MENU ITEMS =====
//================================
// note: when line4 * and line5 * are empty the value is printed large
// Instructions / Behavior:
// - when line4 * and line5 * are empty the value is printed large
// - when 3rd element is not NULL (pointer to defaultValue function) return int value of that function is shown in line 2
// - when 2nd element is NULL (pointer to currentValue function): instead of current value "click to confirm is shown" in line 3
//#########################
//#### center Joystick ####
@ -33,27 +36,149 @@ static int value = 0;
void item_centerJoystick_action(display_task_parameters_t * objects, SSD1306_t * display, int value){
if (!value) return;
ESP_LOGW(TAG, "defining joystick center");
(*objects).joystick->defineCenter();
//objects->joystick->defineCenter();
//joystick->defineCenter();
objects->joystick->defineCenter();
objects->buzzer->beep(3, 60, 40);
}
int item_centerJoystick_value(display_task_parameters_t * objects){
return 1;
}
menuItem_t item_centerJoystick = {
item_centerJoystick_action, // function action
item_centerJoystick_value,
0, // valueMin
1, // valueMAx
1, // valueIncrement
"Center Joystick", // title
"Center Joystick", // line1 (above value)
"click to confirm", // line2 (above value)
"defines current", // line4 * (below value)
"pos as center", // line5 *
"click to confirm", // line6
"set 0 to cancel", // line7
NULL, // function get initial value or NULL(show in line 2)
NULL, // function get default value or NULL(dont set value, show msg)
0, // valueMin
0, // valueMax
0, // valueIncrement
"Center Joystick ", // title
"Center Joystick ", // line1 (above value)
"", // line2 (above value)
"defines current ", // line4 * (below value)
"pos as center ", // line5 *
"", // line6
"=>long to cancel", // line7
};
// ############################
// #### calibrate Joystick ####
// ############################
// continously show/update joystick data on display
#define CALIBRATE_JOYSTICK_UPDATE_INTERVAL 50
void item_calibrateJoystick_action(display_task_parameters_t *objects, SSD1306_t *display, int value)
{
//--- variables ---
bool running = true;
joystickCalibrationMode_t mode = X_MIN;
rotary_encoder_event_t event;
int valueNow = 0;
//-- pre loop instructions --
ESP_LOGW(TAG, "starting joystick calibration sequence");
ssd1306_clear_screen(display, false);
//-- show static lines --
// show first line (title)
displayTextLine(display, 0, false, true, "calibrate stick");
// show last line (info)
displayTextLineCentered(display, 7, false, true, " click: confirm ");
// show initital state
displayTextLineCentered(display, 1, true, false, "%s", "X-min");
//-- loop until all positions are defined --
while (running && objects->control->getCurrentMode() == controlMode_t::MENU)
{
// repeatedly print adc value depending on currently selected axis
switch (mode)
{
case X_MIN:
case X_MAX:
displayTextLineCentered(display, 4, true, false, "%d", valueNow = objects->joystick->getRawX()); // large
break;
case Y_MIN:
case Y_MAX:
displayTextLineCentered(display, 4, true, false, "%d", valueNow = objects->joystick->getRawY()); // large
break;
case X_CENTER:
case Y_CENTER:
displayTextLine(display, 4, false, false, " x = %d", objects->joystick->getRawX());
displayTextLine(display, 5, false, false, " y = %d", objects->joystick->getRawY());
displayTextLine(display, 6, false, false, "release & click!");
break;
}
// handle encoder event
// save and next when button clicked, exit when long pressed
if (xQueueReceive(objects->encoderQueue, &event, CALIBRATE_JOYSTICK_UPDATE_INTERVAL / portTICK_PERIOD_MS))
{
objects->control->resetTimeout();
switch (event.type)
{
case RE_ET_BTN_CLICKED:
objects->buzzer->beep(2, 120, 50);
switch (mode)
{
case X_MIN:
// save x min position
ESP_LOGW(TAG, "calibrate-stick: saving X_MIN");
objects->joystick->writeCalibration(mode, valueNow);
displayTextLineCentered(display, 1, true, false, "%s", "X-max");
mode = X_MAX;
break;
case X_MAX:
// save x max position
ESP_LOGW(TAG, "calibrate-stick: saving X_MAX");
objects->joystick->writeCalibration(mode, valueNow);
displayTextLineCentered(display, 1, true, false, "%s", "Y-min");
mode = Y_MIN;
break;
case Y_MIN:
// save y min position
ESP_LOGW(TAG, "calibrate-stick: saving Y_MIN");
objects->joystick->writeCalibration(mode, valueNow);
displayTextLineCentered(display, 1, true, false, "%s", "Y-max");
mode = Y_MAX;
break;
case Y_MAX:
// save y max position
ESP_LOGW(TAG, "calibrate-stick: saving Y_MAX");
objects->joystick->writeCalibration(mode, valueNow);
displayTextLineCentered(display, 1, true, false, "%s", "CENTR");
mode = X_CENTER;
break;
case X_CENTER:
case Y_CENTER:
// save center position
ESP_LOGW(TAG, "calibrate-stick: saving CENTER -> finished");
objects->joystick->defineCenter();
// finished
running = false;
break;
}
break;
case RE_ET_BTN_LONG_PRESSED:
//exit to main-menu
objects->buzzer->beep(1, 1000, 10);
ESP_LOGW(TAG, "aborting calibration sqeuence");
running = false;
case RE_ET_CHANGED:
case RE_ET_BTN_PRESSED:
case RE_ET_BTN_RELEASED:
break;
}
}
}
}
menuItem_t item_calibrateJoystick = {
item_calibrateJoystick_action, // function action
NULL, // function get initial value or NULL(show in line 2)
NULL, // function get default value or NULL(dont set value, show msg)
0, // valueMin
0, // valueMax
0, // valueIncrement
"Calibrate Stick ", // title
" Calibrate ", // line1 (above value)
" Joystick ", // line2 (above value)
" click to start ", // line4 * (below value)
" sequence ", // line5 *
" ", // line6
"=>long to cancel", // line7
};
@ -61,6 +186,7 @@ menuItem_t item_centerJoystick = {
//#### debug Joystick ####
//########################
//continously show/update joystick data on display
#define DEBUG_JOYSTICK_UPDATE_INTERVAL 50
void item_debugJoystick_action(display_task_parameters_t * objects, SSD1306_t * display, int value)
{
//--- variables ---
@ -68,8 +194,6 @@ void item_debugJoystick_action(display_task_parameters_t * objects, SSD1306_t *
rotary_encoder_event_t event;
//-- pre loop instructions --
if (!value) // dont open menu when value was set to 0
return;
ESP_LOGW(TAG, "showing joystick debug page");
ssd1306_clear_screen(display, false);
// show title
@ -90,40 +214,39 @@ void item_debugJoystick_action(display_task_parameters_t * objects, SSD1306_t *
displayTextLine(display, 5, false, false, "pos=%-12s ", joystickPosStr[(int)data.position]);
// exit when button pressed
if (xQueueReceive(objects->encoderQueue, &event, 20 / portTICK_PERIOD_MS))
if (xQueueReceive(objects->encoderQueue, &event, DEBUG_JOYSTICK_UPDATE_INTERVAL / portTICK_PERIOD_MS))
{
objects->control->resetTimeout();
switch (event.type)
{
case RE_ET_BTN_CLICKED:
case RE_ET_BTN_LONG_PRESSED:
running = false;
objects->buzzer->beep(1, 100, 10);
break;
case RE_ET_CHANGED:
case RE_ET_BTN_PRESSED:
case RE_ET_BTN_RELEASED:
case RE_ET_BTN_LONG_PRESSED:
break;
}
}
}
}
int item_debugJoystick_value(display_task_parameters_t * objects){
return 1;
}
menuItem_t item_debugJoystick = {
item_debugJoystick_action, // function action
item_debugJoystick_value,
0, // valueMin
1, // valueMAx
1, // valueIncrement
"Debug joystick", // title
"Debug joystick", // line1 (above value)
"", // line2 (above value)
"click to enter", // line4 * (below value)
"debug screen", // line5 *
"prints values", // line6
"set 0 to cancel", // line7
NULL, // function get initial value or NULL(show in line 2)
NULL, // function get default value or NULL(dont set value, show msg)
0, // valueMin
0, // valueMax
0, // valueIncrement
"Debug joystick ", // title
"Debug joystick ", // line1 (above value)
"", // line2 (above value)
"", // line4 * (below value)
"debug screen ", // line5 *
"prints values ", // line6
"=>long to cancel", // line7
};
@ -132,29 +255,29 @@ menuItem_t item_debugJoystick = {
//########################
void maxDuty_action(display_task_parameters_t * objects, SSD1306_t * display, int value)
{
//TODO actually store the value
ESP_LOGW(TAG, "set max duty to %d", value);
objects->control->setMaxDuty(value);
}
int maxDuty_currentValue(display_task_parameters_t * objects)
{
//TODO get real current value
return 84;
return (int)objects->control->getMaxDuty();
}
menuItem_t item_maxDuty = {
maxDuty_action, // function action
maxDuty_currentValue,
1, // valueMin
99, // valueMAx
1, // valueIncrement
"max duty", // title
"", // line1 (above value)
" set max-duty: ", // line2 (above value)
"", // line4 * (below value)
"", // line5 *
" 1-99 ", // line6
" percent ", // line7
maxDuty_action, // function action
maxDuty_currentValue, // function get initial value or NULL(show in line 2)
NULL, // function get default value or NULL(dont set value, show msg)
1, // valueMin
100, // valueMax
1, // valueIncrement
"Set max Duty ", // title
"", // line1 (above value)
" set max-duty: ", // line2 (above value)
"", // line4 * (below value)
"", // line5 *
" 1-100 ", // line6
" percent ", // line7
};
//######################
//##### accelLimit #####
//######################
@ -167,21 +290,27 @@ int item_accelLimit_value(display_task_parameters_t * objects)
{
return objects->motorLeft->getFade(fadeType_t::ACCEL);
}
int item_accelLimit_default(display_task_parameters_t * objects)
{
return objects->motorLeft->getFadeDefault(fadeType_t::ACCEL);
}
menuItem_t item_accelLimit = {
item_accelLimit_action, // function action
item_accelLimit_value,
0, // valueMin
10000, // valueMAx
100, // valueIncrement
"Accel limit", // title
"Accel limit /", // line1 (above value)
"Fade up time", // line2 (above value)
"", // line4 * (below value)
"", // line5 *
"milliseconds", // line6
"from 0 to 100%", // line7
item_accelLimit_action, // function action
item_accelLimit_value, // function get initial value or NULL(show in line 2)
item_accelLimit_default, // function get default value or NULL(dont set value, show msg)
0, // valueMin
10000, // valueMax
100, // valueIncrement
"Accel limit ", // title
" Fade up time ", // line1 (above value)
"", // line2 <= showing "default = %d"
"", // line4 * (below value)
"", // line5 *
"milliseconds ", // line6
"from 0 to 100% ", // line7
};
// ######################
// ##### decelLimit #####
// ######################
@ -194,21 +323,65 @@ int item_decelLimit_value(display_task_parameters_t * objects)
{
return objects->motorLeft->getFade(fadeType_t::DECEL);
}
int item_decelLimit_default(display_task_parameters_t * objects)
{
return objects->motorLeft->getFadeDefault(fadeType_t::DECEL);
}
menuItem_t item_decelLimit = {
item_decelLimit_action, // function action
item_decelLimit_value,
0, // valueMin
10000, // valueMAx
100, // valueIncrement
"Decel limit", // title
"Decel limit /", // line1 (above value)
"Fade down time", // line2 (above value)
"", // line4 * (below value)
"", // line5 *
"milliseconds", // line6
"from 100 to 0%", // line7
item_decelLimit_action, // function action
item_decelLimit_value, // function get initial value or NULL(show in line 2)
item_decelLimit_default, // function get default value or NULL(dont set value, show msg)
0, // valueMin
10000, // valueMax
100, // valueIncrement
"Decel limit ", // title
" Fade down time ", // line1 (above value)
"", // line2 <= showing "default = %d"
"", // line4 * (below value)
"", // line5 *
"milliseconds ", // line6
"from 100 to 0% ", // line7
};
//#####################
//####### RESET #######
//#####################
void item_reset_action(display_task_parameters_t *objects, SSD1306_t *display, int value)
{
objects->buzzer->beep(1, 2000, 0);
// close and erase NVS
ESP_LOGW(TAG, "closing and ERASING non-volatile-storage...");
nvs_close(*(objects->nvsHandle));
ESP_ERROR_CHECK(nvs_flash_erase());
// show message restarting
ssd1306_clear_screen(display, false);
displayTextLineCentered(display, 0, false, true, "");
displayTextLineCentered(display, 1, true, true, "RE-");
displayTextLineCentered(display, 4, true, true, "START");
displayTextLineCentered(display, 7, false, true, "");
vTaskDelay(1000 / portTICK_PERIOD_MS); // wait for buzzer to beep
// restart
ESP_LOGW(TAG, "RESTARTING");
esp_restart();
}
menuItem_t item_reset = {
item_reset_action, // function action
NULL, // function get initial value or NULL(show in line 2)
NULL, // function get default value or NULL(dont set value, show msg)
0, // valueMin
0, // valueMax
0, // valueIncrement
"RESET defaults ", // title
" reset nvs ", // line1 (above value)
" and restart ", // line2 <= showing "default = %d"
"reset all stored", // line4 * (below value)
" parameters ", // line5 *
"", // line6
"=>long to cancel", // line7
};
//#####################
//###### example ######
//#####################
@ -217,42 +390,49 @@ void item_example_action(display_task_parameters_t * objects, SSD1306_t * displa
return;
}
int item_example_value(display_task_parameters_t * objects){
return 53;
return 53; //initial value shown / changed from
}
int item_example_valueDefault(display_task_parameters_t * objects){
return 931; // optionally shown in line 2 as "default = %d"
}
menuItem_t item_example = {
item_example_action, // function action
item_example_value,
-255, // valueMin
255, // valueMAx
2, // valueIncrement
"example-item-max", // title
"line 1 - above", // line1 (above value)
"line 2 - above", // line2 (above value)
"line 4 - below", // line4 * (below value)
"line 5 - below", // line5 *
"line 6 - below", // line6
"line 7 - last", // line7
item_example_value, // function get initial value or NULL(show in line 2)
NULL, // function get default value or NULL(dont set value, show msg)
-255, // valueMin
255, // valueMax
2, // valueIncrement
"example-item-max", // title
"line 1 - above ", // line1 (above value)
"line 2 - above ", // line2 (above value)
"line 4 - below ", // line4 * (below value)
"line 5 - below ", // line5 *
"line 6 - below ", // line6
"line 7 - last ", // line7
};
menuItem_t item_last = {
item_example_action, // function action
item_example_value,
-500, // valueMin
4500, // valueMAx
50, // valueIncrement
"set large number", // title
"line 1 - above", // line1 (above value)
"line 2 - above", // line2 (above value)
"", // line4 * (below value)
"", // line5 *
"line 6 - below", // line6
"line 7 - last", // line7
item_example_value, // function get initial value or NULL(show in line 2)
item_example_valueDefault, // function get default value or NULL(dont set value, show msg)
-500, // valueMin
4500, // valueMax
50, // valueIncrement
"set large number", // title
"line 1 - above ", // line1 (above value)
"line 2 - above ", // line2 (above value)
"", // line4 * (below value)
"", // line5 *
"line 6 - below ", // line6
"line 7 - last ", // line7
};
//store all configured menu items in one array
menuItem_t menuItems[] = {item_centerJoystick, item_debugJoystick, item_accelLimit, item_decelLimit, item_example, item_last};
int itemCount = 6;
//####################################################
//### store all configured menu items in one array ###
//####################################################
const menuItem_t menuItems[] = {item_centerJoystick, item_calibrateJoystick, item_debugJoystick, item_maxDuty, item_accelLimit, item_decelLimit, item_reset, item_example, item_last};
const int itemCount = 9;
@ -298,43 +478,79 @@ void showItemList(SSD1306_t *display, int selectedItem)
}
}
//---------------------------
//----- showValueSelect -----
//---------------------------
// function that renders value-select screen to display (one update)
// shows configured text of selected item and currently selected value
// TODO show previous value in one line?
// TODO update changed line only (value)
void showValueSelect(SSD1306_t *display, int selectedItem)
//-----------------------------
//--- showValueSelectStatic ---
//-----------------------------
// function that renders lines that do not update of value-select screen to display (initial update)
// shows configured text of currently selected item
void showValueSelectStatic(display_task_parameters_t * objects, SSD1306_t *display, int selectedItem)
{
//-- show title line --
displayTextLine(display, 0, false, true, " -- set value -- "); // inverted
//-- show text above value --
displayTextLine(display, 1, false, false, "%-16s", menuItems[selectedItem].line1);
displayTextLine(display, 2, false, false, "%-16s", menuItems[selectedItem].line2);
//-- show line 2 or default value ---
if (menuItems[selectedItem].defaultValue != NULL){
displayTextLineCentered(display, 2, false, false, "default = %d", menuItems[selectedItem].defaultValue(objects));
}
else
{
// displayTextLine(display, 2, false, false, "previous=%d", menuItems[selectedItem].currentValue(objects)); // <= show previous value
displayTextLine(display, 2, false, false, "%-16s", menuItems[selectedItem].line2);
}
//-- show value and other configured lines --
// print value large, if 2 description lines are empty
// print value large, if two description lines are empty
if (strlen(menuItems[selectedItem].line4) == 0 && strlen(menuItems[selectedItem].line5) == 0)
{
// print large value + line5 and line6
displayTextLineCentered(display, 3, true, false, "%d", value); //large centered
// print less lines: line5 and line6 only (due to large value)
//displayTextLineCentered(display, 3, true, false, "%d", value); //large centered (value shown in separate function)
displayTextLine(display, 6, false, false, "%-16s", menuItems[selectedItem].line6);
displayTextLine(display, 7, false, false, "%-16s", menuItems[selectedItem].line7);
}
else
{
displayTextLineCentered(display, 3, false, false, "%d", value); //centered
//displayTextLineCentered(display, 3, false, false, "%d", value); //centered (value shown in separate function)
// print description lines 4 to 7
displayTextLine(display, 4, false, false, "%-16s", menuItems[selectedItem].line4);
displayTextLine(display, 5, false, false, "%-16s", menuItems[selectedItem].line5);
displayTextLine(display, 6, false, false, "%-16s", menuItems[selectedItem].line6);
displayTextLine(display, 7, false, false, "%-16s", menuItems[selectedItem].line7);
}
//-- show info msg instead of value --
//when pointer to default value func not defined (set value not used, action only)
if (menuItems[selectedItem].currentValue == NULL)
{
//show static text
displayTextLineCentered(display, 3, false, true, "%s", "click to confirm");
}
// otherwise value gets updated in next iteration of menu-handle function
}
//-----------------------------
//----- updateValueSelect -----
//-----------------------------
// update line with currently set value only (increses performance significantly)
void updateValueSelect(SSD1306_t *display, int selectedItem)
{
// print value large, if 2 description lines are empty
if (strlen(menuItems[selectedItem].line4) == 0 && strlen(menuItems[selectedItem].line5) == 0)
{
// print large and centered value in line 3-5
displayTextLineCentered(display, 3, true, false, "%d", value); // large centered
}
else
{
//print value centered in line 3
displayTextLineCentered(display, 3, false, false, "%d", value); // centered
}
}
//========================
@ -342,8 +558,8 @@ void showValueSelect(SSD1306_t *display, int selectedItem)
//========================
//controls menu with encoder input and displays the text on oled display
//function is repeatedly called by display task when in menu state
#define QUEUE_TIMEOUT 3000 //timeout no encoder event - to handle timeout and not block the display loop
#define MENU_TIMEOUT 60000 //inactivity timeout (switch to IDLE mode)
#define QUEUE_TIMEOUT 3000 //timeout no encoder event - to not block the display loop and actually handle menu-timeout
#define MENU_TIMEOUT 60000 //inactivity timeout (switch to IDLE mode) note: should be smaller than IDLE timeout in control task
void handleMenu(display_task_parameters_t * objects, SSD1306_t *display)
{
static uint32_t lastActivity = 0;
@ -362,7 +578,9 @@ void handleMenu(display_task_parameters_t * objects, SSD1306_t *display)
// wait for encoder event
if (xQueueReceive(objects->encoderQueue, &event, QUEUE_TIMEOUT / portTICK_PERIOD_MS))
{
// reset menu- and control-timeout on any encoder event
lastActivity = esp_log_timestamp();
objects->control->resetTimeout();
switch (event.type)
{
case RE_ET_CHANGED:
@ -370,33 +588,46 @@ void handleMenu(display_task_parameters_t * objects, SSD1306_t *display)
if (event.diff < 0)
{
if (selectedItem != itemCount - 1)
{
objects->buzzer->beep(1, 20, 0);
selectedItem++;
ESP_LOGD(TAG, "showing next item: %d '%s'", selectedItem, menuItems[selectedItem].title);
ESP_LOGD(TAG, "showing next item: %d '%s'", selectedItem, menuItems[selectedItem].title);
}
//note: display will update at start of next run
}
else
{
if (selectedItem != 0)
{
objects->buzzer->beep(1, 20, 0);
selectedItem--;
ESP_LOGD(TAG, "showing previous item: %d '%s'", selectedItem, menuItems[selectedItem].title);
ESP_LOGD(TAG, "showing previous item: %d '%s'", selectedItem, menuItems[selectedItem].title);
}
//note: display will update at start of next run
}
break;
case RE_ET_BTN_CLICKED:
//--- switch to edit value page ---
objects->buzzer->beep(1, 50, 10);
ESP_LOGI(TAG, "Button pressed - switching to state SET_VALUE");
// change state (menu to set value)
menuState = SET_VALUE;
// get currently configured value
value = menuItems[selectedItem].currentValue(objects);
// clear display
ssd1306_clear_screen(display, false);
//update static content of set-value screen once at change only
showValueSelectStatic(objects, display, selectedItem);
// get currently configured value, when value-select feature is actually used in this item
if (menuItems[selectedItem].currentValue != NULL)
value = menuItems[selectedItem].currentValue(objects);
else
value = 0;
break;
//exit menu mode
case RE_ET_BTN_LONG_PRESSED:
//change to previous mode (e.g. JOYSTICK)
//--- exit menu mode ---
// change to previous mode (e.g. JOYSTICK)
objects->buzzer->beep(12, 15, 8);
objects->control->toggleMode(controlMode_t::MENU); //currently already in MENU -> changes to previous mode
ssd1306_clear_screen(display, false);
break;
@ -412,38 +643,55 @@ void handleMenu(display_task_parameters_t * objects, SSD1306_t *display)
//---- State SET VALUE ----
//-------------------------
case SET_VALUE:
// wait for encoder event
showValueSelect(display, selectedItem);
// update currently selected value
// note: static lines are updated at mode change
if (menuItems[selectedItem].currentValue != NULL) // dont update when set-value not used for this item
updateValueSelect(display, selectedItem);
// wait for encoder event
if (xQueueReceive(objects->encoderQueue, &event, QUEUE_TIMEOUT / portTICK_PERIOD_MS))
{
lastActivity = esp_log_timestamp();
objects->control->resetTimeout();
switch (event.type)
{
case RE_ET_CHANGED:
//-- change value --
// increment value
if (event.diff < 0)
value += menuItems[selectedItem].valueIncrement;
else
value -= menuItems[selectedItem].valueIncrement;
// limit to min/max range
if (value > menuItems[selectedItem].valueMax)
value = menuItems[selectedItem].valueMax;
if (value < menuItems[selectedItem].valueMin)
value = menuItems[selectedItem].valueMin;
// no need to increment value when item configured to not show value
if (menuItems[selectedItem].currentValue != NULL)
{
objects->buzzer->beep(1, 25, 10);
// increment value
if (event.diff < 0)
value += menuItems[selectedItem].valueIncrement;
else
value -= menuItems[selectedItem].valueIncrement;
// limit to min/max range
if (value > menuItems[selectedItem].valueMax)
value = menuItems[selectedItem].valueMax;
if (value < menuItems[selectedItem].valueMin)
value = menuItems[selectedItem].valueMin;
}
break;
case RE_ET_BTN_CLICKED:
//-- apply value --
ESP_LOGI(TAG, "Button pressed - running action function with value=%d for item '%s'", value, menuItems[selectedItem].title);
objects->buzzer->beep(2, 50, 50);
menuItems[selectedItem].action(objects, display, value);
menuState = MAIN_MENU;
break;
case RE_ET_BTN_LONG_PRESSED:
//-- exit value select to main menu --
objects->buzzer->beep(2, 100, 50);
ssd1306_clear_screen(display, false);
menuState = MAIN_MENU;
break;
case RE_ET_BTN_PRESSED:
case RE_ET_BTN_RELEASED:
case RE_ET_BTN_LONG_PRESSED:
break;
}
// reset menu- and control-timeout on any encoder event
lastActivity = esp_log_timestamp();
objects->control->resetTimeout();
}
break;
}
@ -452,7 +700,7 @@ void handleMenu(display_task_parameters_t * objects, SSD1306_t *display)
//--------------------
//--- menu timeout ---
//--------------------
//close menu and switch to IDLE mode when no encoder event within MENU_TIMEOUT
//close menu and switch to IDLE mode when no encoder event occured within MENU_TIMEOUT
if (esp_log_timestamp() - lastActivity > MENU_TIMEOUT)
{
ESP_LOGW(TAG, "TIMEOUT - no activity for more than %ds -> closing menu, switching to IDLE", MENU_TIMEOUT/1000);
@ -464,4 +712,4 @@ void handleMenu(display_task_parameters_t * objects, SSD1306_t *display)
objects->control->changeMode(controlMode_t::IDLE);
return;
}
}
}

1
board_single/main/menu.hpp
View File

@ -17,6 +17,7 @@ typedef struct
{
void (*action)(display_task_parameters_t * objects, SSD1306_t * display, int value); // pointer to function run when confirmed
int (*currentValue)(display_task_parameters_t * objects); // pointer to function to get currently configured value
int (*defaultValue)(display_task_parameters_t * objects); // pointer to function to get currently configured value
int valueMin; // min allowed value
int valueMax; // max allowed value
int valueIncrement; // amount changed at one encoder tick (+/-)

2
common/buzzer.cpp
View File

@ -82,7 +82,7 @@ void buzzer_t::processQueue(){
// otherwise waits for at least 7 weeks
if( xQueueReceive( beepQueue, &entryRead, portMAX_DELAY ) )
{
ESP_LOGW(TAG_BUZZER, "Read entry from queue: count=%d, msOn=%d, msOff=%d", entryRead.count, entryRead.msOn, entryRead.msOff);
ESP_LOGI(TAG_BUZZER, "Read entry from queue: count=%d, msOn=%d, msOff=%d", entryRead.count, entryRead.msOn, entryRead.msOff);
//beep requested count with requested delays
for (int i = entryRead.count; i--;){

147
common/joystick.cpp
View File

@ -19,8 +19,9 @@ static const char * TAG_CMD = "joystickCommands";
//-------- constructor --------
//-----------------------------
//copy provided struct with all configuration and run init function
evaluatedJoystick::evaluatedJoystick(joystick_config_t config_f){
evaluatedJoystick::evaluatedJoystick(joystick_config_t config_f, nvs_handle_t * nvsHandle_f){
config = config_f;
nvsHandle = nvsHandle_f;
init();
}
@ -30,7 +31,7 @@ evaluatedJoystick::evaluatedJoystick(joystick_config_t config_f){
//---------- init ------------
//----------------------------
void evaluatedJoystick::init(){
ESP_LOGI(TAG, "initializing joystick");
ESP_LOGW(TAG, "initializing ADC's and loading calibration...");
//initialize adc
adc1_config_width(ADC_WIDTH_BIT_12); //=> max resolution 4096
@ -41,6 +42,12 @@ void evaluatedJoystick::init(){
adc1_config_channel_atten(config.adc_x, ADC_ATTEN_DB_11); //max voltage
adc1_config_channel_atten(config.adc_y, ADC_ATTEN_DB_11); //max voltage
//load stored calibration values (if not found loads defaults from config)
loadCalibration(X_MIN);
loadCalibration(X_MAX);
loadCalibration(Y_MIN);
loadCalibration(Y_MAX);
//define joystick center from current position
defineCenter(); //define joystick center from current position
}
@ -81,17 +88,17 @@ joystickData_t evaluatedJoystick::getData() {
ESP_LOGV(TAG, "getting X coodrdinate...");
uint32_t adcRead;
adcRead = readAdc(config.adc_x, config.x_inverted);
float x = scaleCoordinate(readAdc(config.adc_x, config.x_inverted), config.x_min, config.x_max, x_center, config.tolerance_zeroX_per, config.tolerance_end_per);
float x = scaleCoordinate(readAdc(config.adc_x, config.x_inverted), x_min, x_max, x_center, config.tolerance_zeroX_per, config.tolerance_end_per);
data.x = x;
ESP_LOGD(TAG, "X: adc-raw=%d \tadc-conv=%d \tmin=%d \t max=%d \tcenter=%d \tinverted=%d => x=%.3f",
adc1_get_raw(config.adc_x), adcRead, config.x_min, config.x_max, x_center, config.x_inverted, x);
adc1_get_raw(config.adc_x), adcRead, x_min, x_max, x_center, config.x_inverted, x);
ESP_LOGV(TAG, "getting Y coodrinate...");
adcRead = readAdc(config.adc_y, config.y_inverted);
float y = scaleCoordinate(adcRead, config.y_min, config.y_max, y_center, config.tolerance_zeroY_per, config.tolerance_end_per);
float y = scaleCoordinate(adcRead, y_min, y_max, y_center, config.tolerance_zeroY_per, config.tolerance_end_per);
data.y = y;
ESP_LOGD(TAG, "Y: adc-raw=%d \tadc-conv=%d \tmin=%d \t max=%d \tcenter=%d \tinverted=%d => y=%.3lf",
adc1_get_raw(config.adc_y), adcRead, config.y_min, config.y_max, y_center, config.y_inverted, y);
adc1_get_raw(config.adc_y), adcRead, y_min, y_max, y_center, config.y_inverted, y);
//calculate radius
data.radius = sqrt(pow(data.x,2) + pow(data.y,2));
@ -297,7 +304,7 @@ joystickPos_t joystick_evaluatePosition(float x, float y){
//========= joystick_CommandsDriving =========
//============================================
//function that generates commands for both motors from the joystick data
motorCommands_t joystick_generateCommandsDriving(joystickData_t data, bool altStickMapping){
motorCommands_t joystick_generateCommandsDriving(joystickData_t data, joystickGenerateCommands_config_t * config){
//struct with current data of the joystick
//typedef struct joystickData_t {
@ -310,10 +317,8 @@ motorCommands_t joystick_generateCommandsDriving(joystickData_t data, bool altSt
//--- variables ---
motorCommands_t commands;
float dutyMax = 100; //TODO add this to config, make changeable during runtime
float dutyOffset = 5; //immediately starts with this duty, TODO add this to config
float dutyRange = dutyMax - dutyOffset;
float dutyRange = config->maxDuty - config->dutyOffset;
float ratio = fabs(data.angle) / 90; //90degree = x=0 || 0degree = y=0
//--- snap ratio to max at angle threshold ---
@ -327,7 +332,7 @@ motorCommands_t joystick_generateCommandsDriving(joystickData_t data, bool altSt
*/
//--- experimental alternative control mode ---
if (altStickMapping == true){
if (config->altStickMapping == true){
//swap BOTTOM_LEFT and BOTTOM_RIGHT
if (data.position == joystickPos_t::BOTTOM_LEFT){
data.position = joystickPos_t::BOTTOM_RIGHT;
@ -569,4 +574,124 @@ motorCommands_t joystick_generateCommandsShaking(joystickData_t data){
ESP_LOGI(TAG_CMD, "motor right: state=%s, duty=%.3f", motorstateStr[(int)commands.right.state], commands.right.duty);
return commands;
}
// corresponding storage key strings to each joystickCalibratenMode variable
const char *calibrationStorageKeys[] = {"stick_x-min", "stick_x-max", "stick_y-min", "stick_y-max", "", ""};
//-------------------------------
//------- loadCalibration -------
//-------------------------------
// loads selected calibration value from nvs or default values from config if no data stored
void evaluatedJoystick::loadCalibration(joystickCalibrationMode_t mode)
{
// determine desired variables
int *configValue, *usedValue;
switch (mode)
{
case X_MIN:
configValue = &(config.x_min);
usedValue = &x_min;
break;
case X_MAX:
configValue = &(config.x_max);
usedValue = &x_max;
break;
case Y_MIN:
configValue = &(config.y_min);
usedValue = &y_min;
break;
case Y_MAX:
configValue = &(config.y_max);
usedValue = &y_max;
break;
case X_CENTER:
case Y_CENTER:
default:
// center position is not stored in nvs, it gets defined at startup or during calibration
ESP_LOGE(TAG, "loadCalibration: 'center_x' and 'center_y' are not stored in nvs -> not assigning anything");
// defineCenter();
return;
}
// read from nvs
int16_t valueRead;
esp_err_t err = nvs_get_i16(*nvsHandle, calibrationStorageKeys[(int)mode], &valueRead);
switch (err)
{
case ESP_OK:
ESP_LOGW(TAG, "Successfully read value '%s' from nvs. Overriding default value %d with %d", calibrationStorageKeys[(int)mode], *configValue, valueRead);
*usedValue = (int)valueRead;
break;
case ESP_ERR_NVS_NOT_FOUND:
ESP_LOGW(TAG, "nvs: the value '%s' is not initialized yet, loading default value %d", calibrationStorageKeys[(int)mode], *configValue);
*usedValue = *configValue;
break;
default:
ESP_LOGE(TAG, "Error (%s) reading nvs!", esp_err_to_name(err));
*usedValue = *configValue;
}
}
//-------------------------------
//------- loadCalibration -------
//-------------------------------
// loads selected calibration value from nvs or default values from config if no data stored
void evaluatedJoystick::writeCalibration(joystickCalibrationMode_t mode, int newValue)
{
// determine desired variables
int *configValue, *usedValue;
switch (mode)
{
case X_MIN:
configValue = &(config.x_min);
usedValue = &x_min;
break;
case X_MAX:
configValue = &(config.x_max);
usedValue = &x_max;
break;
case Y_MIN:
configValue = &(config.y_min);
usedValue = &y_min;
break;
case Y_MAX:
configValue = &(config.y_max);
usedValue = &y_max;
break;
case X_CENTER:
x_center = newValue;
ESP_LOGW(TAG, "writeCalibration: 'center_x' or 'center_y' are not stored in nvs -> loading only");
return;
case Y_CENTER:
y_center = newValue;
ESP_LOGW(TAG, "writeCalibration: 'center_x' or 'center_y' are not stored in nvs -> loading only");
default:
return;
}
// check if unchanged
if (*usedValue == newValue)
{
ESP_LOGW(TAG, "writeCalibration: value '%s' unchanged at %d, not writing to nvs", calibrationStorageKeys[(int)mode], newValue);
return;
}
// update nvs value
ESP_LOGW(TAG, "writeCalibration: updating nvs value '%s' from %d to %d", calibrationStorageKeys[(int)mode], *usedValue, newValue);
esp_err_t err = nvs_set_i16(*nvsHandle, calibrationStorageKeys[(int)mode], newValue);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed writing");
err = nvs_commit(*nvsHandle);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed committing updates");
else
ESP_LOGI(TAG, "nvs: successfully committed updates");
// update variable
*usedValue = newValue;
}

55
common/joystick.hpp
View File

@ -8,6 +8,9 @@ extern "C"
#include "driver/adc.h"
#include "esp_log.h"
#include "esp_err.h"
#include "nvs_flash.h"
#include "nvs.h"
#include <stdbool.h>
}
#include <cmath>
@ -55,6 +58,7 @@ typedef struct joystick_config_t {
enum class joystickPos_t {CENTER, Y_AXIS, X_AXIS, TOP_RIGHT, TOP_LEFT, BOTTOM_LEFT, BOTTOM_RIGHT};
extern const char* joystickPosStr[7];
typedef enum joystickCalibrationMode_t { X_MIN = 0, X_MAX, Y_MIN, Y_MAX, X_CENTER, Y_CENTER } joystickCalibrationMode_t;
//struct with current data of the joystick
typedef struct joystickData_t {
@ -66,35 +70,56 @@ typedef struct joystickData_t {
} joystickData_t;
// struct with parameters provided to joystick_GenerateCommandsDriving()
typedef struct joystickGenerateCommands_config_t {
float maxDuty;
float dutyOffset;
bool altStickMapping;
} joystickGenerateCommands_config_t;
//------------------------------------
//----- evaluatedJoystick class -----
//------------------------------------
class evaluatedJoystick {
public:
//--- constructor ---
evaluatedJoystick(joystick_config_t config_f);
class evaluatedJoystick
{
public:
//--- constructor ---
evaluatedJoystick(joystick_config_t config_f, nvs_handle_t * nvsHandle);
//--- functions ---
joystickData_t getData(); //read joystick, calculate values and return the data in a struct
void defineCenter(); //define joystick center from current position
//--- functions ---
joystickData_t getData(); // read joystick, calculate values and return the data in a struct
// get raw adc value (inversion applied)
int getRawX() { return readAdc(config.adc_x, config.x_inverted); }
int getRawY() { return readAdc(config.adc_y, config.y_inverted); }
void defineCenter(); // define joystick center from current position
void writeCalibration(joystickCalibrationMode_t mode, int newValue); // load certain new calibration value and store it in nvs
private:
//--- functions ---
//initialize adc inputs, define center
void init();
//read adc while making multiple samples with option to invert the result
int readAdc(adc1_channel_t adc_channel, bool inverted = false);
private:
//--- functions ---
// initialize adc inputs, define center
void init();
// loads selected calibration value from nvs or default values from config if no data stored
void loadCalibration(joystickCalibrationMode_t mode);
// read adc while making multiple samples with option to invert the result
int readAdc(adc1_channel_t adc_channel, bool inverted = false);
//--- variables ---
// handle for using the nvs flash (persistent config variables)
nvs_handle_t *nvsHandle;
joystick_config_t config;
int x_min;
int x_max;
int y_min;
int y_max;
int x_center;
int y_center;
joystickData_t data;
float x;
float y;
};
};
@ -103,7 +128,7 @@ class evaluatedJoystick {
//============================================
//function that generates commands for both motors from the joystick data
//motorCommands_t joystick_generateCommandsDriving(evaluatedJoystick joystick);
motorCommands_t joystick_generateCommandsDriving(joystickData_t data, bool altStickMapping = false);
motorCommands_t joystick_generateCommandsDriving(joystickData_t data, joystickGenerateCommands_config_t * config);

170
common/motorctl.cpp
View File

@ -15,7 +15,7 @@ static const char * TAG = "motor-control";
//task for handling the motors (ramp, current limit, driver)
void task_motorctl( void * task_motorctl_parameters ){
task_motorctl_parameters_t *objects = (task_motorctl_parameters_t *)task_motorctl_parameters;
ESP_LOGW(TAG, "Task-motorctl: starting handle loop...");
ESP_LOGW(TAG, "Task-motorctl: starting handle loops for left and right motor...");
while(1){
objects->motorRight->handle();
objects->motorLeft->handle();
@ -29,19 +29,17 @@ void task_motorctl( void * task_motorctl_parameters ){
//======== constructor ========
//=============================
//constructor, simultaniously initialize instance of motor driver 'motor' and current sensor 'cSensor' with provided config (see below lines after ':')
controlledMotor::controlledMotor(motorSetCommandFunc_t setCommandFunc, motorctl_config_t config_control):
controlledMotor::controlledMotor(motorSetCommandFunc_t setCommandFunc, motorctl_config_t config_control, nvs_handle_t * nvsHandle_f):
cSensor(config_control.currentSensor_adc, config_control.currentSensor_ratedCurrent) {
//copy parameters for controlling the motor
config = config_control;
//pointer to update motot dury method
motorSetCommand = setCommandFunc;
//copy configured default fading durations to actually used variables
msFadeAccel = config.msFadeAccel;
msFadeDecel = config.msFadeDecel;
//pointer to nvs handle
nvsHandle = nvsHandle_f;
//create queue, initialize config values
init();
//TODO: add currentsensor object here
//currentSensor cSensor(config.currentSensor_adc, config.currentSensor_ratedCurrent);
}
@ -54,7 +52,11 @@ void controlledMotor::init(){
if (commandQueue == NULL)
ESP_LOGE(TAG, "Failed to create command-queue");
else
ESP_LOGW(TAG, "Initialized command-queue");
ESP_LOGI(TAG, "[%s] Initialized command-queue", config.name);
// load config values from nvs, otherwise use default from config object
loadAccelDuration();
loadDecelDuration();
//cSensor.calibrateZeroAmpere(); //currently done in currentsensor constructor TODO do this regularly e.g. in idle?
}
@ -104,7 +106,7 @@ void controlledMotor::handle(){
//--- receive commands from queue ---
if( xQueueReceive( commandQueue, &commandReceive, ( TickType_t ) 0 ) )
{
ESP_LOGD(TAG, "Read command from queue: state=%s, duty=%.2f", motorstateStr[(int)commandReceive.state], commandReceive.duty);
ESP_LOGD(TAG, "[%s] Read command from queue: state=%s, duty=%.2f", config.name, motorstateStr[(int)commandReceive.state], commandReceive.duty);
state = commandReceive.state;
dutyTarget = commandReceive.duty;
receiveTimeout = false;
@ -139,7 +141,7 @@ void controlledMotor::handle(){
receiveTimeout = true;
state = motorstate_t::IDLE;
dutyTarget = 0;
ESP_LOGE(TAG, "TIMEOUT, no target data received for more than %ds -> switch to IDLE", TIMEOUT_IDLE_WHEN_NO_COMMAND/1000);
ESP_LOGE(TAG, "[%s] TIMEOUT, no target data received for more than %ds -> switch to IDLE", config.name, TIMEOUT_IDLE_WHEN_NO_COMMAND/1000);
}
//--- calculate increment ---
@ -164,7 +166,7 @@ void controlledMotor::handle(){
if (state == motorstate_t::BRAKE){
ESP_LOGD(TAG, "braking - skip fading");
motorSetCommand({motorstate_t::BRAKE, dutyTarget});
ESP_LOGI(TAG, "Set Motordriver: state=%s, duty=%.2f - Measurements: current=%.2f, speed=N/A", motorstateStr[(int)state], dutyNow, currentNow);
ESP_LOGI(TAG, "[%s] Set Motordriver: state=%s, duty=%.2f - Measurements: current=%.2f, speed=N/A", config.name, motorstateStr[(int)state], dutyNow, currentNow);
//dutyNow = 0;
return; //no need to run the fade algorithm
}
@ -211,7 +213,7 @@ void controlledMotor::handle(){
} else if (dutyNow > currentLimitDecrement) {
dutyNow -= currentLimitDecrement;
}
ESP_LOGW(TAG, "current limit exceeded! now=%.3fA max=%.1fA => decreased duty from %.3f to %.3f", currentNow, config.currentMax, dutyOld, dutyNow);
ESP_LOGW(TAG, "[%s] current limit exceeded! now=%.3fA max=%.1fA => decreased duty from %.3f to %.3f", config.name, currentNow, config.currentMax, dutyOld, dutyNow);
}
}
@ -255,7 +257,7 @@ void controlledMotor::handle(){
//--- apply new target to motor ---
motorSetCommand({state, (float)fabs(dutyNow)});
ESP_LOGI(TAG, "Set Motordriver: state=%s, duty=%.2f - Measurements: current=%.2f, speed=N/A", motorstateStr[(int)state], dutyNow, currentNow);
ESP_LOGI(TAG, "[%s] Set Motordriver: state=%s, duty=%.2f - Measurements: current=%.2f, speed=N/A", config.name, motorstateStr[(int)state], dutyNow, currentNow);
//note: BRAKE state is handled earlier
@ -275,7 +277,7 @@ void controlledMotor::setTarget(motorstate_t state_f, float duty_f){
.state = state_f,
.duty = duty_f
};
ESP_LOGI(TAG, "setTarget: Inserting command to queue: state='%s'(%d), duty=%.2f", motorstateStr[(int)commandSend.state], (int)commandSend.state, commandSend.duty);
ESP_LOGI(TAG, "[%s] setTarget: Inserting command to queue: state='%s'(%d), duty=%.2f", config.name, motorstateStr[(int)commandSend.state], (int)commandSend.state, commandSend.duty);
//send command to queue (overwrite if an old command is still in the queue and not processed)
xQueueOverwrite( commandQueue, ( void * )&commandSend);
//xQueueSend( commandQueue, ( void * )&commandSend, ( TickType_t ) 0 );
@ -316,6 +318,22 @@ uint32_t controlledMotor::getFade(fadeType_t fadeType){
return 0;
}
//==============================
//======= getFadeDefault =======
//==============================
//return default accel / decel time (from config)
uint32_t controlledMotor::getFadeDefault(fadeType_t fadeType){
switch(fadeType){
case fadeType_t::ACCEL:
return config.msFadeAccel;
break;
case fadeType_t::DECEL:
return config.msFadeDecel;
break;
}
return 0;
}
//===============================
@ -328,12 +346,13 @@ void controlledMotor::setFade(fadeType_t fadeType, uint32_t msFadeNew){
//TODO: mutex for msFade variable also used in handle function
switch(fadeType){
case fadeType_t::ACCEL:
ESP_LOGW(TAG, "changed fade-up time from %d to %d", msFadeAccel, msFadeNew);
msFadeAccel = msFadeNew;
ESP_LOGW(TAG, "[%s] changed fade-up time from %d to %d", config.name, msFadeAccel, msFadeNew);
writeAccelDuration(msFadeNew);
break;
case fadeType_t::DECEL:
ESP_LOGW(TAG, "changed fade-down time from %d to %d", msFadeDecel, msFadeNew);
msFadeDecel = msFadeNew;
ESP_LOGW(TAG, "[%s] changed fade-down time from %d to %d",config.name, msFadeDecel, msFadeNew);
// write new value to nvs and update the variable
writeDecelDuration(msFadeNew);
break;
}
}
@ -390,3 +409,118 @@ bool controlledMotor::toggleFade(fadeType_t fadeType){
return enabled;
}
//-----------------------------
//----- loadAccelDuration -----
//-----------------------------
// load stored value from nvs if not successfull uses config default value
void controlledMotor::loadAccelDuration(void)
{
// load default value
msFadeAccel = config.msFadeAccel;
// read from nvs
uint32_t valueNew;
char key[15];
snprintf(key, 15, "m-%s-accel", config.name);
esp_err_t err = nvs_get_u32(*nvsHandle, key, &valueNew);
switch (err)
{
case ESP_OK:
ESP_LOGW(TAG, "Successfully read value '%s' from nvs. Overriding default value %d with %d", key, config.msFadeAccel, valueNew);
msFadeAccel = valueNew;
break;
case ESP_ERR_NVS_NOT_FOUND:
ESP_LOGW(TAG, "nvs: the value '%s' is not initialized yet, keeping default value %d", key, msFadeAccel);
break;
default:
ESP_LOGE(TAG, "Error (%s) reading nvs!", esp_err_to_name(err));
}
}
//-----------------------------
//----- loadDecelDuration -----
//-----------------------------
void controlledMotor::loadDecelDuration(void)
{
// load default value
msFadeDecel = config.msFadeDecel;
// read from nvs
uint32_t valueNew;
char key[15];
snprintf(key, 15, "m-%s-decel", config.name);
esp_err_t err = nvs_get_u32(*nvsHandle, key, &valueNew);
switch (err)
{
case ESP_OK:
ESP_LOGW(TAG, "Successfully read value '%s' from nvs. Overriding default value %d with %d", key, config.msFadeDecel, valueNew);
msFadeDecel = valueNew;
break;
case ESP_ERR_NVS_NOT_FOUND:
ESP_LOGW(TAG, "nvs: the value '%s' is not initialized yet, keeping default value %d", key, msFadeDecel);
break;
default:
ESP_LOGE(TAG, "Error (%s) reading nvs!", esp_err_to_name(err));
}
}
//------------------------------
//----- writeAccelDuration -----
//------------------------------
// write provided value to nvs to be persistent and update the local variable msFadeAccel
void controlledMotor::writeAccelDuration(uint32_t newValue)
{
// check if unchanged
if(msFadeAccel == newValue){
ESP_LOGW(TAG, "value unchanged at %d, not writing to nvs", newValue);
return;
}
// generate nvs storage key
char key[15];
snprintf(key, 15, "m-%s-accel", config.name);
// update nvs value
ESP_LOGW(TAG, "[%s] updating nvs value '%s' from %d to %d", config.name, key, msFadeAccel, newValue);
esp_err_t err = nvs_set_u32(*nvsHandle, key, newValue);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed writing");
err = nvs_commit(*nvsHandle);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed committing updates");
else
ESP_LOGI(TAG, "nvs: successfully committed updates");
// update variable
msFadeAccel = newValue;
}
//------------------------------
//----- writeDecelDuration -----
//------------------------------
// write provided value to nvs to be persistent and update the local variable msFadeDecel
// TODO: reduce duplicate code
void controlledMotor::writeDecelDuration(uint32_t newValue)
{
// check if unchanged
if(msFadeDecel == newValue){
ESP_LOGW(TAG, "value unchanged at %d, not writing to nvs", newValue);
return;
}
// generate nvs storage key
char key[15];
snprintf(key, 15, "m-%s-decel", config.name);
// update nvs value
ESP_LOGW(TAG, "[%s] updating nvs value '%s' from %d to %d", config.name, key, msFadeDecel, newValue);
esp_err_t err = nvs_set_u32(*nvsHandle, key, newValue);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed writing");
err = nvs_commit(*nvsHandle);
if (err != ESP_OK)
ESP_LOGE(TAG, "nvs: failed committing updates");
else
ESP_LOGI(TAG, "nvs: successfully committed updates");
// update variable
msFadeDecel = newValue;
}

13
common/motorctl.hpp
View File

@ -7,6 +7,8 @@ extern "C"
#include "freertos/queue.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "nvs_flash.h"
#include "nvs.h"
}
#include "motordrivers.hpp"
@ -28,12 +30,13 @@ typedef void (*motorSetCommandFunc_t)(motorCommand_t cmd);
class controlledMotor {
public:
//--- functions ---
controlledMotor(motorSetCommandFunc_t setCommandFunc, motorctl_config_t config_control); //constructor with structs for configuring motordriver and parameters for control TODO: add configuration for currentsensor
controlledMotor(motorSetCommandFunc_t setCommandFunc, motorctl_config_t config_control, nvs_handle_t * nvsHandle); //constructor with structs for configuring motordriver and parameters for control TODO: add configuration for currentsensor
void handle(); //controls motor duty with fade and current limiting feature (has to be run frequently by another task)
void setTarget(motorstate_t state_f, float duty_f = 0); //adds target command to queue for handle function
motorCommand_t getStatus(); //get current status of the motor (returns struct with state and duty)
uint32_t getFade(fadeType_t fadeType); //get currently set acceleration or deceleration fading time
uint32_t getFadeDefault(fadeType_t fadeType); //get acceleration or deceleration fading time from config
void setFade(fadeType_t fadeType, bool enabled); //enable/disable acceleration or deceleration fading
void setFade(fadeType_t fadeType, uint32_t msFadeNew); //set acceleration or deceleration fade time
bool toggleFade(fadeType_t fadeType); //toggle acceleration or deceleration on/off
@ -44,7 +47,11 @@ class controlledMotor {
private:
//--- functions ---
void init(); //creates currentsensor objects, motordriver objects and queue
void init(); // creates command-queue and initializes config values
void loadAccelDuration(void); // load stored value for msFadeAccel from nvs
void loadDecelDuration(void);
void writeAccelDuration(uint32_t newValue); // write value to nvs and update local variable
void writeDecelDuration(uint32_t newValue);
//--- objects ---
//queue for sending commands to the separate task running the handle() function very fast
@ -60,6 +67,8 @@ class controlledMotor {
//struct for storing control specific parameters
motorctl_config_t config;
motorstate_t state = motorstate_t::IDLE;
//handle for using the nvs flash (persistent config variables)
nvs_handle_t * nvsHandle;
float currentMax;
float currentNow;

1
common/types.hpp
View File

@ -41,6 +41,7 @@ typedef struct motorCommands_t {
//struct with all config parameters for a motor regarding ramp and current limit
typedef struct motorctl_config_t {
char * name; //name for unique nvs storage-key prefix and logging
uint32_t msFadeAccel; //acceleration of the motor (ms it takes from 0% to 100%)
uint32_t msFadeDecel; //deceleration of the motor (ms it takes from 100% to 0%)
bool currentLimitEnabled;