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

Merge branch 'dev' - 2 boards, uart, brake-relay

Browse Source
This commit is contained in:
jonny_jr9 2023-09-06 10:24:42 +02:00
commit e3460a06ae
58 changed files with 2244 additions and 2813 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -10,8 +10,8 @@ sdkconfig.old
# React
react-app/build
react-app/.pnp
**/react-app/build
**/react-app/.pnp
.pnp.js
node_modules

9
board_control/CMakeLists.txt Normal file
View File

@ -0,0 +1,9 @@
# For more information about build system see
# https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
# The following five lines of boilerplate have to be in your project's
# CMakeLists in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
set(EXTRA_COMPONENT_DIRS "../components ../common")
project(armchair_controlBoard)

7
main/CMakeLists.txt → board_control/main/CMakeLists.txt
View File

@ -1,18 +1,13 @@
idf_component_register(
SRCS
"main.cpp"
"motordrivers.cpp"
"motorctl.cpp"
"config.cpp"
"joystick.cpp"
"buzzer.cpp"
"control.cpp"
"button.cpp"
"fan.cpp"
"wifi.c"
"http.cpp"
"auto.cpp"
"currentsensor.cpp"
"uart.cpp"
INCLUDE_DIRS
"."
)

89
board_control/main/auto.cpp Normal file
View File

@ -0,0 +1,89 @@
#include "auto.hpp"
#include "config.hpp"
//tag for logging
static const char * TAG = "automatedArmchair";
//=============================
//======== constructor ========
//=============================
automatedArmchair::automatedArmchair(void) {
//create command queue
commandQueue = xQueueCreate( 32, sizeof( commandSimple_t ) ); //TODO add max size to config?
}
//FIXME motorLeft, Right not available, needs rework to work with uart only
// //==============================
// //====== generateCommands ======
// //==============================
// motorCommands_t automatedArmchair::generateCommands(auto_instruction_t * instruction) {
// //reset instruction
// *instruction = auto_instruction_t::NONE;
// //check if previous command is finished
// if ( esp_log_timestamp() > timestampCmdFinished ) {
// //get next command from queue
// if( xQueueReceive( commandQueue, &cmdCurrent, pdMS_TO_TICKS(500) ) ) {
// ESP_LOGI(TAG, "running next command from queue...");
// //copy instruction to be provided to control task
// *instruction = cmdCurrent.instruction;
// //set acceleration / fading parameters according to command
// motorLeft.setFade(fadeType_t::DECEL, cmdCurrent.fadeDecel);
// motorRight.setFade(fadeType_t::DECEL, cmdCurrent.fadeDecel);
// motorLeft.setFade(fadeType_t::ACCEL, cmdCurrent.fadeAccel);
// motorRight.setFade(fadeType_t::ACCEL, cmdCurrent.fadeAccel);
// //calculate timestamp the command is finished
// timestampCmdFinished = esp_log_timestamp() + cmdCurrent.msDuration;
// //copy the new commands
// motorCommands = cmdCurrent.motorCmds;
// } else { //queue empty
// ESP_LOGD(TAG, "no new command in queue -> set motors to IDLE");
// motorCommands = motorCmds_bothMotorsIdle;
// }
// } else { //previous command still running
// ESP_LOGD(TAG, "command still running -> no change");
// }
//
// //TODO also return instructions via call by reference
// return motorCommands;
// }
//
//
//
// //============================
// //======== addCommand ========
// //============================
// //function that adds a basic command to the queue
// void automatedArmchair::addCommand(commandSimple_t command) {
// //add command to queue
// if ( xQueueSend( commandQueue, ( void * )&command, ( TickType_t ) 0 ) ){
// ESP_LOGI(TAG, "Successfully inserted command to queue");
// } else {
// ESP_LOGE(TAG, "Failed to insert new command to queue");
// }
// }
//
// void automatedArmchair::addCommands(commandSimple_t commands[], size_t count) {
// for (int i = 0; i < count; i++) {
// ESP_LOGI(TAG, "Reading command no. %d from provided array", i);
// addCommand(commands[i]);
// }
// }
//
//
// //===============================
// //======== clearCommands ========
// //===============================
// //function that deletes all pending/queued commands
// //e.g. when switching modes
// motorCommands_t automatedArmchair::clearCommands() {
// //clear command queue
// xQueueReset( commandQueue );
// ESP_LOGW(TAG, "command queue was successfully emptied");
// //return commands for idling both motors
// motorCommands = motorCmds_bothMotorsIdle;
// return motorCmds_bothMotorsIdle;
// }
//

2
main/auto.hpp → board_control/main/auto.hpp
View File

@ -10,7 +10,7 @@ extern "C"
#include "freertos/queue.h"
#include <cmath>
#include "motorctl.hpp"
#include "types.hpp"

222
board_control/main/button.cpp Normal file
View File

@ -0,0 +1,222 @@
#include "auto.hpp"
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include "freertos/FreeRTOS.h"
#include "esp_log.h"
}
#include "button.hpp"
//tag for logging
static const char * TAG = "button";
//FIXME needs rework, motorleft/right objectn not available anymore
//-----------------------------
//-------- constructor --------
//-----------------------------
buttonCommands::buttonCommands(
gpio_evaluatedSwitch * button_f,
evaluatedJoystick * joystick_f,
controlledArmchair * control_f,
buzzer_t * buzzer_f
){
//copy object pointers
button = button_f;
joystick = joystick_f;
control = control_f;
buzzer = buzzer_f;
//TODO declare / configure evaluatedSwitch here instead of config (unnecessary that button object is globally available - only used here)?
}
//----------------------------
//--------- action -----------
//----------------------------
//function that runs commands depending on a count value
void buttonCommands::action (uint8_t count, bool lastPressLong){
//--- variable declarations ---
bool decelEnabled; //for different beeping when toggling
commandSimple_t cmds[8]; //array for commands for automatedArmchair
//--- get joystick position ---
//joystickData_t stickData = joystick->getData();
//--- actions based on count ---
switch (count){
//no such command
default:
ESP_LOGE(TAG, "no command for count=%d defined", count);
buzzer->beep(3, 400, 100);
break;
case 1:
//restart contoller when 1x long pressed
if (lastPressLong){
ESP_LOGW(TAG, "RESTART");
buzzer->beep(1,1000,1);
vTaskDelay(1000 / portTICK_PERIOD_MS);
esp_restart();
return;
}
ESP_LOGW(TAG, "cmd %d: sending button event to control task", count);
//-> define joystick center or toggle freeze input (executed in control task)
control->sendButtonEvent(count); //TODO: always send button event to control task (not just at count=1) -> control.cpp has to be changed
break;
case 2:
//TODO no use for leg support from 1.0 anymore, add other functionality
//run automatic commands to lift leg support when pressed 1x short 1x long
//if (lastPressLong){
// //define commands
// cmds[0] =
// {
// .motorCmds = {
// .left = {motorstate_t::REV, 90},
// .right = {motorstate_t::REV, 90}
// },
// .msDuration = 1200,
// .fadeDecel = 800,
// .fadeAccel = 1300,
// .instruction = auto_instruction_t::NONE
// };
// cmds[1] =
// {
// .motorCmds = {
// .left = {motorstate_t::FWD, 70},
// .right = {motorstate_t::FWD, 70}
// },
// .msDuration = 70,
// .fadeDecel = 0,
// .fadeAccel = 300,
// .instruction = auto_instruction_t::NONE
// };
// cmds[2] =
// {
// .motorCmds = {
// .left = {motorstate_t::IDLE, 0},
// .right = {motorstate_t::IDLE, 0}
// },
// .msDuration = 10,
// .fadeDecel = 800,
// .fadeAccel = 1300,
// .instruction = auto_instruction_t::SWITCH_JOYSTICK_MODE
// };
// //send commands to automatedArmchair command queue
// armchair.addCommands(cmds, 3);
// //change mode to AUTO
// control->changeMode(controlMode_t::AUTO);
// return;
//}
//toggle idle when 2x pressed
ESP_LOGW(TAG, "cmd %d: toggle IDLE", count);
control->toggleIdle(); //toggle between idle and previous/default mode
break;
case 3:
ESP_LOGW(TAG, "cmd %d: switch to JOYSTICK", count);
control->changeMode(controlMode_t::JOYSTICK); //switch to JOYSTICK mode
break;
case 4:
ESP_LOGW(TAG, "cmd %d: toggle between HTTP and JOYSTICK", count);
control->toggleModes(controlMode_t::HTTP, controlMode_t::JOYSTICK); //toggle between HTTP and JOYSTICK mode
break;
case 6:
ESP_LOGW(TAG, "cmd %d: toggle between MASSAGE and JOYSTICK", count);
control->toggleModes(controlMode_t::MASSAGE, controlMode_t::JOYSTICK); //toggle between MASSAGE and JOYSTICK mode
break;
// case 8:
// //TODO rework this with uart config
// //toggle deceleration fading between on and off
// decelEnabled = motorLeft->toggleFade(fadeType_t::DECEL);
// motorRight->toggleFade(fadeType_t::DECEL);
// ESP_LOGW(TAG, "cmd %d: toggle deceleration fading to: %d", count, (int)decelEnabled);
// if (decelEnabled){
// buzzer->beep(3, 60, 50);
// } else {
// buzzer->beep(1, 1000, 1);
// }
break;
case 12:
ESP_LOGW(TAG, "cmd %d: sending button event to control task", count);
//-> toggle altStickMapping (executed in control task)
control->sendButtonEvent(count); //TODO: always send button event to control task (not just at count=1)?
break;
}
}
//-----------------------------
//------ startHandleLoop ------
//-----------------------------
//this function has to be started once in a separate task
//repeatedly evaluates and processes button events then takes the corresponding action
void buttonCommands::startHandleLoop() {
while(1) {
vTaskDelay(20 / portTICK_PERIOD_MS);
//run handle function of evaluatedSwitch object
button->handle();
//--- count button presses and run action ---
switch(state) {
case inputState_t::IDLE: //wait for initial button press
if (button->risingEdge) {
count = 1;
buzzer->beep(1, 65, 0);
timestamp_lastAction = esp_log_timestamp();
state = inputState_t::WAIT_FOR_INPUT;
ESP_LOGI(TAG, "first button press detected -> waiting for further events");
}
break;
case inputState_t::WAIT_FOR_INPUT: //wait for further presses
//button pressed again
if (button->risingEdge){
count++;
buzzer->beep(1, 65, 0);
timestamp_lastAction = esp_log_timestamp();
ESP_LOGI(TAG, "another press detected -> count=%d -> waiting for further events", count);
}
//timeout
else if (esp_log_timestamp() - timestamp_lastAction > 1000) {
state = inputState_t::IDLE;
buzzer->beep(count, 50, 50);
//TODO: add optional "bool wait" parameter to beep function to delay until finished beeping
ESP_LOGI(TAG, "timeout - running action function for count=%d", count);
//--- run action function ---
//check if still pressed
bool lastPressLong = false;
if (button->state == true){
//run special case when last press was longer than timeout
lastPressLong = true;
}
//run action function with current count of button presses
action(count, lastPressLong);
}
break;
}
}
}

50
board_control/main/button.hpp Normal file
View File

@ -0,0 +1,50 @@
#pragma once
#include "gpio_evaluateSwitch.hpp"
#include "buzzer.hpp"
#include "control.hpp"
#include "auto.hpp"
#include "config.hpp"
#include "joystick.hpp"
#include "types.hpp"
//===================================
//====== buttonCommands class =======
//===================================
//class which runs commands depending on the count a button was pressed
class buttonCommands {
public:
//--- constructor ---
buttonCommands (
gpio_evaluatedSwitch * button_f,
evaluatedJoystick * joystick_f,
controlledArmchair * control_f,
buzzer_t * buzzer_f
);
//--- functions ---
//the following function has to be started once in a separate task.
//repeatedly evaluates and processes button events then takes the corresponding action
void startHandleLoop();
private:
//--- functions ---
void action(uint8_t count, bool lastPressLong);
//--- objects ---
gpio_evaluatedSwitch* button;
evaluatedJoystick* joystick;
controlledArmchair * control;
buzzer_t* buzzer;
//--- variables ---
uint8_t count = 0;
uint32_t timestamp_lastAction = 0;
enum class inputState_t {IDLE, WAIT_FOR_INPUT};
inputState_t state = inputState_t::IDLE;
};

74
main/config.cpp → board_control/main/config.cpp
View File

@ -1,60 +1,5 @@
#include "config.hpp"
//===================================
//======= motor configuration =======
//===================================
//--- configure left motor (hardware) ---
single100a_config_t configDriverLeft = {
.gpio_pwm = GPIO_NUM_26,
.gpio_a = GPIO_NUM_16,
.gpio_b = GPIO_NUM_4,
.ledc_timer = LEDC_TIMER_0,
.ledc_channel = LEDC_CHANNEL_0,
.aEnabledPinState = false, //-> pins inverted (mosfets)
.bEnabledPinState = false,
.resolution = LEDC_TIMER_11_BIT,
.pwmFreq = 10000
};
//--- configure right motor (hardware) ---
single100a_config_t configDriverRight = {
.gpio_pwm = GPIO_NUM_27,
.gpio_a = GPIO_NUM_2,
.gpio_b = GPIO_NUM_14,
.ledc_timer = LEDC_TIMER_1,
.ledc_channel = LEDC_CHANNEL_1,
.aEnabledPinState = false, //-> pin inverted (mosfet)
.bEnabledPinState = true, //-> not inverted (direct)
.resolution = LEDC_TIMER_11_BIT,
.pwmFreq = 10000
};
//TODO add motor name string -> then use as log tag?
//--- configure left motor (contol) ---
motorctl_config_t configMotorControlLeft = {
.msFadeAccel = 1900, //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 = true,
.currentSensor_adc = ADC1_CHANNEL_6, //GPIO34
.currentSensor_ratedCurrent = 50,
.currentMax = 30,
.deadTimeMs = 900 //minimum time motor is off between direction change
};
//--- configure right motor (contol) ---
motorctl_config_t configMotorControlRight = {
.msFadeAccel = 1900, //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 = true,
.currentSensor_adc = ADC1_CHANNEL_4, //GPIO32
.currentSensor_ratedCurrent = 50,
.currentMax = 30,
.deadTimeMs = 900 //minimum time motor is off between direction change
};
//==============================
//======= control config =======
//==============================
@ -107,29 +52,12 @@ joystick_config_t configJoystick = {
//============================
//=== configure fan contol ===
//============================
fan_config_t configCooling = {
.gpio_fan = GPIO_NUM_13,
.dutyThreshold = 40,
.minOnMs = 1500,
.minOffMs = 3000,
.turnOffDelayMs = 5000,
};
//=================================
//===== create global objects =====
//=================================
//TODO outsource global variables to e.g. global.cpp and only config options here?
//create controlled motor instances (motorctl.hpp)
controlledMotor motorLeft(configDriverLeft, configMotorControlLeft);
controlledMotor motorRight(configDriverRight, configMotorControlRight);
//create global joystic instance (joystick.hpp)
evaluatedJoystick joystick(configJoystick);
@ -143,7 +71,7 @@ buzzer_t buzzer(GPIO_NUM_12, 100);
httpJoystick httpJoystickMain(configHttpJoystickMain);
//create global control object (control.hpp)
controlledArmchair control(configControl, &buzzer, &motorLeft, &motorRight, &joystick, &httpJoystickMain);
controlledArmchair control(configControl, &buzzer, &joystick, &httpJoystickMain);
//create global automatedArmchair object (for auto-mode) (auto.hpp)
automatedArmchair armchair;

11
main/config.hpp → board_control/main/config.hpp
View File

@ -1,13 +1,10 @@
#pragma once
#include "motordrivers.hpp"
#include "motorctl.hpp"
#include "joystick.hpp"
#include "gpio_evaluateSwitch.hpp"
#include "buzzer.hpp"
#include "control.hpp"
#include "fan.hpp"
#include "http.hpp"
#include "auto.hpp"
@ -19,10 +16,6 @@
//TODO outsource global variables to e.g. global.cpp and only config options here?
//create global controlledMotor instances for both motors
extern controlledMotor motorLeft;
extern controlledMotor motorRight;
//create global joystic instance
extern evaluatedJoystick joystick;
@ -40,7 +33,3 @@ extern automatedArmchair armchair;
//create global httpJoystick object
extern httpJoystick httpJoystickMain;
//configuration for fans / cooling
extern fan_config_t configCooling;

473
board_control/main/control.cpp Normal file
View File

@ -0,0 +1,473 @@
#include "types.hpp"
extern "C"
{
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "esp_log.h"
#include "freertos/queue.h"
//custom C libraries
#include "wifi.h"
}
#include "config.hpp"
#include "control.hpp"
#include "uart.hpp"
//used definitions moved from config.hpp:
//#define JOYSTICK_TEST
//tag for logging
static const char * TAG = "control";
const char* controlModeStr[7] = {"IDLE", "JOYSTICK", "MASSAGE", "HTTP", "MQTT", "BLUETOOTH", "AUTO"};
//FIXME controlledMotor class not available for this pcb, rework
//-----------------------------
//-------- constructor --------
//-----------------------------
controlledArmchair::controlledArmchair (
control_config_t config_f,
buzzer_t * buzzer_f,
evaluatedJoystick* joystick_f,
httpJoystick* httpJoystick_f
){
//copy configuration
config = config_f;
//copy object pointers
buzzer = buzzer_f;
joystick_l = joystick_f,
httpJoystickMain_l = httpJoystick_f;
//set default mode from config
modePrevious = config.defaultMode;
//TODO declare / configure controlled motors here instead of config (unnecessary that button object is globally available - only used here)?
}
//----------------------------------
//---------- Handle loop -----------
//----------------------------------
//function that repeatedly generates motor commands depending on the current mode
//also handles fading and current-limit
void controlledArmchair::startHandleLoop() {
while (1){
ESP_LOGV(TAG, "control task executing... mode=%s", controlModeStr[(int)mode]);
switch(mode) {
default:
mode = controlMode_t::IDLE;
break;
case controlMode_t::IDLE:
//send both motors idle command to motorctl pcb
uart_sendStruct<motorCommands_t>(cmds_bothMotorsIdle);
commands_now = cmds_bothMotorsIdle;
vTaskDelay(200 / portTICK_PERIOD_MS);
#ifdef JOYSTICK_LOG_IN_IDLE
//get joystick data here (without using it)
//since loglevel is DEBUG, calculateion details is output
joystick_l->getData(); //get joystick data here
#endif
break;
case controlMode_t::JOYSTICK:
vTaskDelay(50 / portTICK_PERIOD_MS);
//get current joystick data with getData method of evaluatedJoystick
stickData = joystick_l->getData();
//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_now = joystick_generateCommandsDriving(stickData, altStickMapping);
//apply motor commands
uart_sendStruct<motorCommands_t>(commands_now);
break;
case controlMode_t::MASSAGE:
vTaskDelay(10 / portTICK_PERIOD_MS);
//--- read joystick ---
//only update joystick data when input not frozen
if (!freezeInput){
stickData = joystick_l->getData();
}
//--- generate motor commands ---
//pass joystick data from getData method of evaluatedJoystick to generateCommandsShaking function
commands_now = joystick_generateCommandsShaking(stickData);
//apply motor commands
uart_sendStruct<motorCommands_t>(commands_now);
break;
case controlMode_t::HTTP:
//--- get joystick data from queue ---
//Note this function waits several seconds (httpconfig.timeoutMs) for data to arrive, otherwise Center data or NULL is returned
//TODO: as described above, when changing modes it might delay a few seconds for the change to apply
stickData = httpJoystickMain_l->getData();
//scale coordinates additionally (more detail in slower area)
joystick_scaleCoordinatesLinear(&stickData, 0.6, 0.4); //TODO: add scaling parameters to config
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_now = joystick_generateCommandsDriving(stickData, altStickMapping);
//--- apply commands to motors ---
uart_sendStruct<motorCommands_t>(commands_now);
break;
case controlMode_t::AUTO:
//FIXME auto mode currently not supported, needs rework
vTaskDelay(20 / portTICK_PERIOD_MS);
// //generate commands
// commands_now = armchair.generateCommands(&instruction);
// //--- apply commands to motors ---
// //TODO make motorctl.setTarget also accept motorcommand struct directly
// uart_sendStruct<motorCommands_t>(commands_now);
// //motorRight->setTarget(commands_now.right.state, commands_now.right.duty);
// //motorLeft->setTarget(commands_now.left.state, commands_now.left.duty);
//
// //process received instruction
// switch (instruction) {
// case auto_instruction_t::NONE:
// break;
// case auto_instruction_t::SWITCH_PREV_MODE:
// toggleMode(controlMode_t::AUTO);
// break;
// case auto_instruction_t::SWITCH_JOYSTICK_MODE:
// changeMode(controlMode_t::JOYSTICK);
// break;
// case auto_instruction_t::RESET_ACCEL_DECEL:
//// //enable downfading (set to default value)
//// motorLeft->setFade(fadeType_t::DECEL, true);
//// motorRight->setFade(fadeType_t::DECEL, true);
//// //set upfading to default value
//// motorLeft->setFade(fadeType_t::ACCEL, true);
//// motorRight->setFade(fadeType_t::ACCEL, true);
//// break;
// case auto_instruction_t::RESET_ACCEL:
//// //set upfading to default value
//// motorLeft->setFade(fadeType_t::ACCEL, true);
//// motorRight->setFade(fadeType_t::ACCEL, true);
//// break;
// case auto_instruction_t::RESET_DECEL:
//// //enable downfading (set to default value)
//// motorLeft->setFade(fadeType_t::DECEL, true);
//// motorRight->setFade(fadeType_t::DECEL, true);
// break;
// }
break;
//TODO: add other modes here
}
//--- run actions based on received button button event ---
//note: buttonCount received by sendButtonEvent method called from button.cpp
//TODO: what if variable gets set from other task during this code? -> mutex around this code
//TODO add methods and move below code to button file possible?
switch (buttonCount) {
case 1: //define joystick center or freeze input
if (mode == controlMode_t::JOYSTICK){
//joystick mode: calibrate joystick
joystick_l->defineCenter();
buzzer->beep(2, 50, 30);
buzzer->beep(1, 200, 25);
} else if (mode == controlMode_t::MASSAGE){
//massage mode: toggle freeze of input (lock joystick at current values)
freezeInput = !freezeInput;
if (freezeInput){
buzzer->beep(5, 40, 25);
} else {
buzzer->beep(1, 300, 100);
}
}
break;
case 12: //toggle alternative joystick mapping (reverse swapped)
altStickMapping = !altStickMapping;
if (altStickMapping){
buzzer->beep(6, 70, 50);
} else {
buzzer->beep(1, 500, 100);
}
break;
}
//--- reset button event --- (only one action per run)
if (buttonCount > 0){
ESP_LOGI(TAG, "resetting button event/count");
buttonCount = 0;
}
//-----------------------
//------ slow loop ------
//-----------------------
//this section is run about every 5s (+500ms)
if (esp_log_timestamp() - timestamp_SlowLoopLastRun > 5000) {
ESP_LOGV(TAG, "running slow loop... time since last run: %.1fs", (float)(esp_log_timestamp() - timestamp_SlowLoopLastRun)/1000);
timestamp_SlowLoopLastRun = esp_log_timestamp();
//run function which detects timeout (switch to idle)
handleTimeout();
}
}//end while(1)
}//end startHandleLoop
//-----------------------------------
//---------- resetTimeout -----------
//-----------------------------------
void controlledArmchair::resetTimeout(){
//TODO mutex
timestamp_lastActivity = esp_log_timestamp();
}
//------------------------------------
//--------- sendButtonEvent ----------
//------------------------------------
void controlledArmchair::sendButtonEvent(uint8_t count){
//TODO mutex - if not replaced with queue
ESP_LOGI(TAG, "setting button event");
buttonCount = count;
}
//------------------------------------
//---------- handleTimeout -----------
//------------------------------------
//percentage the duty can vary since last timeout check and still counts as incative
//TODO: add this to config
float inactivityTolerance = 10;
//local function that checks whether two values differ more than a given tolerance
bool validateActivity(float dutyOld, float dutyNow, float tolerance){
float dutyDelta = dutyNow - dutyOld;
if (fabs(dutyDelta) < tolerance) {
return false; //no significant activity detected
} else {
return true; //there was activity
}
}
//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* so change between current and last duty is detectable
void controlledArmchair::handleTimeout(){
//check for timeout only when not idling already
if (mode != controlMode_t::IDLE) {
//activity detected between current and last generated motor commands
if (validateActivity(commands_lastActivityCheck.left.duty, commands_now.left.duty, inactivityTolerance)
|| validateActivity(commands_lastActivityCheck.right.duty, commands_now.right.duty, inactivityTolerance)
){
ESP_LOGD(TAG, "timeout check: [activity] detected since last check -> reset");
//reset last commands and timestamp
commands_lastActivityCheck = commands_now;
resetTimeout();
}
//no activity on any motor and msTimeout exceeded
else if (esp_log_timestamp() - timestamp_lastActivity > config.timeoutMs){
ESP_LOGW(TAG, "timeout check: [TIMEOUT], no activity for more than %.ds -> switch to idle", config.timeoutMs/1000);
//toggle to idle mode
toggleIdle();
}
else {
ESP_LOGD(TAG, "timeout check: [inactive], last activity %.1f s ago, timeout after %d s", (float)(esp_log_timestamp() - timestamp_lastActivity)/1000, config.timeoutMs/1000);
}
}
}
//-----------------------------------
//----------- changeMode ------------
//-----------------------------------
//function to change to a specified control mode
//FIXME FIXME: replace change with motorLeft object with update config via uart
void controlledArmchair::changeMode(controlMode_t modeNew) {
//reset timeout timer
resetTimeout();
//exit if target mode is already active
if (mode == modeNew) {
ESP_LOGE(TAG, "changeMode: Already in target mode '%s' -> nothing to change", controlModeStr[(int)mode]);
return;
}
//copy previous mode
modePrevious = mode;
ESP_LOGW(TAG, "=== changing mode from %s to %s ===", controlModeStr[(int)mode], controlModeStr[(int)modeNew]);
//========== commands change FROM mode ==========
//run functions when changing FROM certain mode
switch(modePrevious){
default:
ESP_LOGI(TAG, "noting to execute when changing FROM this mode");
break;
#ifdef JOYSTICK_LOG_IN_IDLE
case controlMode_t::IDLE:
ESP_LOGI(TAG, "disabling debug output for 'evaluatedJoystick'");
esp_log_level_set("evaluatedJoystick", ESP_LOG_WARN); //FIXME: loglevel from config
break;
#endif
case controlMode_t::HTTP:
ESP_LOGW(TAG, "switching from http mode -> disabling http and wifi");
//stop http server
ESP_LOGI(TAG, "disabling http server...");
http_stop_server();
//FIXME: make wifi function work here - currently starting wifi at startup (see notes main.cpp)
//stop wifi
//TODO: decide whether ap or client is currently used - which has to be disabled?
//ESP_LOGI(TAG, "deinit wifi...");
//wifi_deinit_client();
//wifi_deinit_ap();
ESP_LOGI(TAG, "done stopping http mode");
break;
// case controlMode_t::MASSAGE:
// ESP_LOGW(TAG, "switching from MASSAGE mode -> restoring fading, reset frozen input");
// //TODO: fix issue when downfading was disabled before switching to massage mode - currently it gets enabled again here...
// //enable downfading (set to default value)
// motorLeft->setFade(fadeType_t::DECEL, true);
// motorRight->setFade(fadeType_t::DECEL, true);
// //set upfading to default value
// motorLeft->setFade(fadeType_t::ACCEL, true);
// motorRight->setFade(fadeType_t::ACCEL, true);
// //reset frozen input state
// freezeInput = false;
// break;
//
// case controlMode_t::AUTO:
// ESP_LOGW(TAG, "switching from AUTO mode -> restoring fading to default");
// //TODO: fix issue when downfading was disabled before switching to auto mode - currently it gets enabled again here...
// //enable downfading (set to default value)
// motorLeft->setFade(fadeType_t::DECEL, true);
// motorRight->setFade(fadeType_t::DECEL, true);
// //set upfading to default value
// motorLeft->setFade(fadeType_t::ACCEL, true);
// motorRight->setFade(fadeType_t::ACCEL, true);
// break;
}
//========== commands change TO mode ==========
//run functions when changing TO certain mode
switch(modeNew){
default:
ESP_LOGI(TAG, "noting to execute when changing TO this mode");
break;
case controlMode_t::IDLE:
buzzer->beep(1, 1500, 0);
#ifdef JOYSTICK_LOG_IN_IDLE
esp_log_level_set("evaluatedJoystick", ESP_LOG_DEBUG);
#endif
break;
case controlMode_t::HTTP:
ESP_LOGW(TAG, "switching to http mode -> enabling http and wifi");
//start wifi
//TODO: decide wether ap or client should be started
ESP_LOGI(TAG, "init wifi...");
//FIXME: make wifi function work here - currently starting wifi at startup (see notes main.cpp)
//wifi_init_client();
//wifi_init_ap();
//wait for wifi
//ESP_LOGI(TAG, "waiting for wifi...");
//vTaskDelay(1000 / portTICK_PERIOD_MS);
//start http server
ESP_LOGI(TAG, "init http server...");
http_init_server();
ESP_LOGI(TAG, "done initializing http mode");
break;
// case controlMode_t::MASSAGE:
// ESP_LOGW(TAG, "switching to MASSAGE mode -> reducing fading");
// uint32_t shake_msFadeAccel = 500; //TODO: move this to config
//
// //disable downfading (max. deceleration)
// motorLeft->setFade(fadeType_t::DECEL, false);
// motorRight->setFade(fadeType_t::DECEL, false);
// //reduce upfading (increase acceleration)
// motorLeft->setFade(fadeType_t::ACCEL, shake_msFadeAccel);
// motorRight->setFade(fadeType_t::ACCEL, shake_msFadeAccel);
// break;
}
//--- update mode to new mode ---
//TODO: add mutex
mode = modeNew;
}
//TODO simplify the following 3 functions? can be replaced by one?
//-----------------------------------
//----------- toggleIdle ------------
//-----------------------------------
//function to toggle between IDLE and previous active mode
void controlledArmchair::toggleIdle() {
//toggle between IDLE and previous mode
toggleMode(controlMode_t::IDLE);
}
//------------------------------------
//----------- toggleModes ------------
//------------------------------------
//function to toggle between two modes, but prefer first argument if entirely different mode is currently active
void controlledArmchair::toggleModes(controlMode_t modePrimary, controlMode_t modeSecondary) {
//switch to secondary mode when primary is already active
if (mode == modePrimary){
ESP_LOGW(TAG, "toggleModes: switching from primaryMode %s to secondarMode %s", controlModeStr[(int)mode], controlModeStr[(int)modeSecondary]);
buzzer->beep(2,200,100);
changeMode(modeSecondary); //switch to secondary mode
}
//switch to primary mode when any other mode is active
else {
ESP_LOGW(TAG, "toggleModes: switching from %s to primary mode %s", controlModeStr[(int)mode], controlModeStr[(int)modePrimary]);
buzzer->beep(4,200,100);
changeMode(modePrimary);
}
}
//-----------------------------------
//----------- toggleMode ------------
//-----------------------------------
//function that toggles between certain mode and previous mode
void controlledArmchair::toggleMode(controlMode_t modePrimary){
//switch to previous mode when primary is already active
if (mode == modePrimary){
ESP_LOGW(TAG, "toggleMode: switching from primaryMode %s to previousMode %s", controlModeStr[(int)mode], controlModeStr[(int)modePrevious]);
//buzzer->beep(2,200,100);
changeMode(modePrevious); //switch to previous mode
}
//switch to primary mode when any other mode is active
else {
ESP_LOGW(TAG, "toggleModes: switching from %s to primary mode %s", controlModeStr[(int)mode], controlModeStr[(int)modePrimary]);
//buzzer->beep(4,200,100);
changeMode(modePrimary);
}
}

125
board_control/main/control.hpp Normal file
View File

@ -0,0 +1,125 @@
#pragma once
#include "buzzer.hpp"
#include "http.hpp"
#include "auto.hpp"
#include "types.hpp"
//FIXME controlledMotor class not available for this pcb, rework
//--------------------------------------------
//---- struct, enum, variable declarations ---
//--------------------------------------------
//enum that decides how the motors get controlled
enum class controlMode_t {IDLE, JOYSTICK, MASSAGE, HTTP, MQTT, BLUETOOTH, AUTO};
//string array representing the mode enum (for printing the state as string)
extern const char* controlModeStr[7];
//--- control_config_t ---
//struct with config parameters
typedef struct control_config_t {
controlMode_t defaultMode; //default mode after startup and toggling IDLE
//timeout options
uint32_t timeoutMs; //time of inactivity after which the mode gets switched to IDLE
float timeoutTolerancePer; //percentage the duty can vary between timeout checks considered still inactive
} control_config_t;
//==================================
//========= control class ==========
//==================================
//controls the mode the armchair operates
//repeatedly generates the motor commands corresponding to current mode and sends those to motorcontrol
class controlledArmchair {
public:
//--- constructor ---
controlledArmchair (
control_config_t config_f,
buzzer_t* buzzer_f,
evaluatedJoystick* joystick_f,
httpJoystick* httpJoystick_f
);
//--- functions ---
//task that repeatedly generates motor commands depending on the current mode
void startHandleLoop();
//function that changes to a specified control mode
void changeMode(controlMode_t modeNew);
//function that toggle between IDLE and previous active mode (or default if not switched to certain mode yet)
void toggleIdle();
//function that toggles between two modes, but prefers first argument if entirely different mode is currently active
void toggleModes(controlMode_t modePrimary, controlMode_t modeSecondary);
//toggle between certain mode and previous mode
void toggleMode(controlMode_t modePrimary);
//function that restarts timer which initiates the automatic timeout (switch to IDLE) after certain time of inactivity
void resetTimeout();
//function for sending a button event (e.g. from button task at event) to control task
//TODO: use queue instead?
void sendButtonEvent(uint8_t count);
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();
//--- objects ---
buzzer_t* buzzer;
httpJoystick* httpJoystickMain_l;
evaluatedJoystick* joystick_l;
//---variables ---
//struct for motor commands returned by generate functions of each mode
motorCommands_t commands_now;
//struct with config parameters
control_config_t config;
//store joystick data
joystickData_t stickData;
bool altStickMapping; //alternative joystick mapping (reverse mapped differently)
//variables for http mode
uint32_t http_timestamp_lastData = 0;
//variables for MASSAGE mode
bool freezeInput = false;
//variables for AUTO mode
auto_instruction_t instruction = auto_instruction_t::NONE; //variable to receive instructions from automatedArmchair
//variable to store button event
uint8_t buttonCount = 0;
//definition of mode enum
controlMode_t mode = controlMode_t::IDLE;
//variable to store mode when toggling IDLE mode
controlMode_t modePrevious; //default mode
//command preset for idling motors
const motorCommand_t cmd_motorIdle = {
.state = motorstate_t::IDLE,
.duty = 0
};
const motorCommands_t cmds_bothMotorsIdle = {
.left = cmd_motorIdle,
.right = cmd_motorIdle
};
//variable for slow loop
uint32_t timestamp_SlowLoopLastRun = 0;
//variables for detecting timeout (switch to idle, after inactivity)
uint32_t timestamp_lastActivity = 0;
motorCommands_t commands_lastActivityCheck;
};

4
main/http.cpp → board_control/main/http.cpp
View File

@ -232,8 +232,8 @@ void http_init_server()
//----- define URLs -----
//note: ignore warning here, cant define elements separately, causes crash
httpd_uri_t joystick_url = {
//note: dont use separate assignment of elements because causes controller crash
httpd_uri_t joystick_url = {
.uri = "/api/joystick",
.method = HTTP_POST,
.handler = on_joystick_url,

0
main/http.hpp → board_control/main/http.hpp
View File

0
main/joystick.cpp → board_control/main/joystick.cpp
View File

2
main/joystick.hpp → board_control/main/joystick.hpp
View File

@ -11,7 +11,7 @@ extern "C"
}
#include <cmath>
#include "motorctl.hpp" //for declaration of motorCommands_t struct
#include "types.hpp"
//======================================

243
board_control/main/main.cpp Normal file
View File

@ -0,0 +1,243 @@
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"
#include "esp_spiffs.h"
//custom C files
#include "wifi.h"
}
#include "uart.hpp"
//=========================
//======= UART TEST =======
//=========================
//only run uart test code at the end
//disables other functionality
//#define UART_TEST_ONLY
//tag for logging
static const char * TAG = "main";
#ifndef UART_TEST_ONLY
//custom C++ files
#include "config.hpp"
#include "control.hpp"
#include "button.hpp"
#include "http.hpp"
//======================================
//============ buzzer task =============
//======================================
//TODO: move the task creation to buzzer class (buzzer.cpp)
//e.g. only have function buzzer.createTask() in app_main
void task_buzzer( void * pvParameters ){
ESP_LOGI("task_buzzer", "Start of buzzer task...");
//run function that waits for a beep events to arrive in the queue
//and processes them
buzzer.processQueue();
}
//=======================================
//============ control task =============
//=======================================
//task that controls the armchair modes and initiates commands generation and applies them to driver
void task_control( void * pvParameters ){
ESP_LOGI(TAG, "Initializing controlledArmchair and starting handle loop");
//start handle loop (control object declared in config.hpp)
control.startHandleLoop();
}
//======================================
//============ button task =============
//======================================
//task that handles the button interface/commands
void task_button( void * pvParameters ){
ESP_LOGI(TAG, "Initializing command-button and starting handle loop");
//create button instance
buttonCommands commandButton(&buttonJoystick, &joystick, &control, &buzzer);
//start handle loop
commandButton.startHandleLoop();
}
//=======================================
//============== fan task ===============
//=======================================
//task that controlls fans for cooling the drivers
//void task_fans( void * pvParameters ){
// ESP_LOGI(TAG, "Initializing fans and starting fan handle loop");
// //create fan instances with config defined in config.cpp
// controlledFan fan(configCooling, &motorLeft, &motorRight);
// //repeatedly run fan handle function in a slow loop
// while(1){
// fan.handle();
// vTaskDelay(500 / portTICK_PERIOD_MS);
// }
//}
//=================================
//========== init spiffs ==========
//=================================
//initialize spi flash filesystem (used for webserver)
void init_spiffs(){
ESP_LOGI(TAG, "init spiffs");
esp_vfs_spiffs_conf_t esp_vfs_spiffs_conf = {
.base_path = "/spiffs",
.partition_label = NULL,
.max_files = 5,
.format_if_mount_failed = true};
esp_vfs_spiffs_register(&esp_vfs_spiffs_conf);
size_t total = 0;
size_t used = 0;
esp_spiffs_info(NULL, &total, &used);
ESP_LOGI(TAG, "SPIFFS: total %d, used %d", total, used);
esp_vfs_spiffs_unregister(NULL);
}
#endif
//==================================
//======== define loglevels ========
//==================================
void setLoglevels(void){
//set loglevel for all tags:
esp_log_level_set("*", ESP_LOG_WARN);
//--- set loglevel for individual tags ---
esp_log_level_set("main", ESP_LOG_INFO);
esp_log_level_set("buzzer", ESP_LOG_ERROR);
//esp_log_level_set("motordriver", ESP_LOG_INFO);
//esp_log_level_set("motor-control", ESP_LOG_DEBUG);
//esp_log_level_set("evaluatedJoystick", ESP_LOG_DEBUG);
//esp_log_level_set("joystickCommands", ESP_LOG_DEBUG);
esp_log_level_set("button", ESP_LOG_INFO);
esp_log_level_set("control", ESP_LOG_INFO);
esp_log_level_set("fan-control", ESP_LOG_INFO);
esp_log_level_set("wifi", ESP_LOG_INFO);
esp_log_level_set("http", ESP_LOG_INFO);
esp_log_level_set("automatedArmchair", ESP_LOG_DEBUG);
esp_log_level_set("uart-common", ESP_LOG_INFO);
esp_log_level_set("uart", ESP_LOG_INFO);
//
}
//=================================
//=========== app_main ============
//=================================
extern "C" void app_main(void) {
#ifndef UART_TEST_ONLY
//enable 5V volate regulator
gpio_pad_select_gpio(GPIO_NUM_17);
gpio_set_direction(GPIO_NUM_17, GPIO_MODE_OUTPUT);
gpio_set_level(GPIO_NUM_17, 1);
//---- define log levels ----
setLoglevels();
//------------------------------
//--- create task for buzzer ---
//------------------------------
xTaskCreate(&task_buzzer, "task_buzzer", 2048, NULL, 2, NULL);
//-------------------------------
//--- create task for control ---
//-------------------------------
//task that generates motor commands depending on the current mode and sends those to motorctl task
xTaskCreate(&task_control, "task_control", 5*4096, NULL, 5, NULL);
//------------------------------
//--- create task for button ---
//------------------------------
//task that evaluates and processes the button input and runs the configured commands
xTaskCreate(&task_button, "task_button", 4096, NULL, 4, NULL);
//-----------------------------------
//--- create task for fan control ---
//-----------------------------------
//task that evaluates and processes the button input and runs the configured commands
//xTaskCreate(&task_fans, "task_fans", 2048, NULL, 1, NULL);
//beep at startup
buzzer.beep(3, 70, 50);
//--- initialize nvs-flash and netif (needed for wifi) ---
wifi_initNvs_initNetif();
//--- initialize spiffs ---
init_spiffs();
//--- initialize and start wifi ---
//FIXME: run wifi_init_client or wifi_init_ap as intended from control.cpp when switching state
//currently commented out because of error "assert failed: xQueueSemaphoreTake queue.c:1549 (pxQueue->uxItemSize == 0)" when calling control->changeMode from button.cpp
//when calling control.changeMode(http) from main.cpp it worked without error for some reason?
ESP_LOGI(TAG,"starting wifi...");
//wifi_init_client(); //connect to existing wifi
wifi_init_ap(); //start access point
ESP_LOGI(TAG,"done starting wifi");
//--- testing http server ---
// wifi_init_client(); //connect to existing wifi
// vTaskDelay(2000 / portTICK_PERIOD_MS);
// ESP_LOGI(TAG, "initializing http server");
// http_init_server();
#endif
//-------------------------------------------
//--- create tasks for uart communication ---
//-------------------------------------------
uart_init();
xTaskCreate(task_uartReceive, "task_uartReceive", 4096, NULL, 10, NULL);
xTaskCreate(task_uartSend, "task_uartSend", 4096, NULL, 10, NULL);
//--- main loop ---
//does nothing except for testing things
//--- testing force http mode after startup ---
vTaskDelay(5000 / portTICK_PERIOD_MS);
control.changeMode(controlMode_t::HTTP);
while(1){
vTaskDelay(1000 / portTICK_PERIOD_MS);
//---------------------------------
//-------- TESTING section --------
//---------------------------------
}
}

55
board_control/main/uart.cpp Normal file
View File

@ -0,0 +1,55 @@
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"
#include <string.h>
#include "freertos/queue.h"
#include "driver/uart.h"
}
#include "uart.hpp"
static const char * TAG = "uart";
//==============================
//====== task_uartReceive ======
//==============================
//TODO copy receive task from board_motorctl/uart.cpp
void task_uartReceive(void *arg){
while (1) {
vTaskDelay(200 / portTICK_PERIOD_MS);
}
}
//=============================
//======= task_uartSend =======
//=============================
//repeatedly send structs via uart
//note: uart_sendStruct() from uart_common.hpp can be used anywhere
void task_uartSend(void *arg){
static const char * TAG = "uart-send";
uartData_test_t data = {123, 0, 1.1};
ESP_LOGW(TAG, "send task started");
//repeatedly send data for testing uart
while (1) {
vTaskDelay(5000 / portTICK_PERIOD_MS);
uart_sendStruct<uartData_test_t>(data);
//change data values
data.timestamp = esp_log_timestamp();
data.id++;
data.value += 0.6;
}
ESP_LOGE(TAG, "loop exit...");
}

10
board_control/main/uart.hpp Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include "uart_common.hpp"
//===== uart board CONTROL =====
//
void task_uartReceive(void *arg);
void task_uartSend(void *arg);

0
partitions.csv → board_control/partitions.csv
View File

0
react-app/package-lock.json → board_control/react-app/package-lock.json generated
View File

0
react-app/package.json → board_control/react-app/package.json
View File

0
react-app/public/index.html → board_control/react-app/public/index.html
View File

0
react-app/src/App.js → board_control/react-app/src/App.js vendored
View File

0
react-app/src/index.js → board_control/react-app/src/index.js vendored
View File

1
CMakeLists.txt → board_motorctl/CMakeLists.txt
View File

@ -5,4 +5,5 @@
cmake_minimum_required(VERSION 3.5)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
set(EXTRA_COMPONENT_DIRS "../components ../common")
project(armchair)

143
board_motorctl/README.md Normal file
View File

@ -0,0 +1,143 @@
Firmware for a homemade automated electric armchair.
More details about this project: https://pfusch.zone/electric-armchair
# Installation
### Install esp-idf
For this project **ESP-IDF v4.4.4** is required (with other versions it might not compile)
```bash
#download esp-idf
yay -S esp-idf #alternatively clone the esp-idf repository from github
#run installation script in installed folder
/opt/esp-idf/install.sh
```
### Clone this repo
```
git clone git@github.com:Jonny999999/armchair_fw
```
### Instal node packages
For the react app packages have to be installed with npm TODO: add this to cmake?
```
cd react-app
npm install
```
# Compilation
## react-webapp
For the webapp to work on the esp32 it has to be built.
When flashing, the folder react-app/build is flashed to siffs (which is used as webroot) onto the esp32.
The following command builds the react webapp and creates this folder
TODO: add this to flash target with cmake?
```bash
cd react-app
#compile
npm run build
#remove unwanted license file (filename too long for spiffs)
rm build/static/js/main.8f9aec76.js.LICENSE.txt
```
Note: Use `npm start` for starting the webapp locally for testing
## esp project
### Set up environment
```bash
source /opt/esp-idf/export.sh
```
(run once in terminal)
### Compile
```bash
idf.py build
```
### Upload
- connect FTDI programmer to board (VCC to VCC; TX to RX; RX to TX)
- press REST and BOOT button
- release RESET button (keep pressing boot)
- run flash command:
```bash
idf.py flash
```
- once "connecting...' successfully, BOOT button can be released
### Monitor
- connect FTDI programmer to board (VCC to VCC; TX to RX; RX to TX)
- press REST and BOOT button
- release RESET button (keep pressing boot)
- run monitor command:
```bash
idf.py monitor
```
- once connected release BOOT button
- press RESET button once for restart
# Hardware setup
## pcb
Used pcb developed in this project: https://pfusch.zone/project-work-2020
## connection plan
A diagram which shows what components are connected to which terminals of the pcb exists here:
[connection-plan.drawio.pdf](connection-plan.drawio.pdf)
# Planned Features
- More sensors:
- Accelerometer
- Lidar sensor
- GPS receiver
- Anti slip regulation
- Self driving algorithm
- Lights
- drinks holder
- improved webinterface
# Todo
**Add switch functions**
- set loglevel
- define max-speed
- calibrate joystick (min, max, center)
- testing mode / dry-run
# Usage
## Switch functions
**Currently implemented**
| Count | Type | Action | Description |
| --- | --- | --- | --- |
| 1x | configure | [JOYSTICK] **calibrate stick** | when in joystick mode: set joystick center to current joystick pos |
| 1x | control | [MASSAGE] **freeze** input | when in massage mode: lock or unlock joystick input at current position |
| 2x | toggle mode | **IDLE** <=> previous | enable/disable chair armchair e.g. enable after startup or timeout |
| 3x | switch mode | **JOYSTICK** | switch to default mode JOYSTICK |
| 4x | toggle mode | **HTTP** <=> JOYSTICK | switch to '**remote control** via web-app `http://191.168.4.1`' or back to JOYSTICK mode |
| 5x | | | |
| 6x | toggle mode | **MASSAGE** <=> JOYSTICK | switch to MASSAGE mode or back to JOYSTICK mode |
| 7x | | | |
| 8x | toggle option | **deceleration limit** | disable/enable deceleration limit (default on) => more responsive |
| | | | |
| 12x | toggle option | **alt stick mapping** | toggle between default and alternative stick mapping (reverse swapped) |
| >1s | system | **restart** | Restart the controller when pressing the button longer than 1 second |
| 1x short, 1x long | auto command | **eject** foot support | automatically go forward and reverse for certain time with no acceleration limits, so foot support ejects |
## HTTP mode
Control armchair via virtual joystick on a webinterface.
**Usage**
- Connect to wifi `armchar`, no password
- Access http://192.168.4.1 (note: **http** NOT https, some browsers automatically add https!)
**Current Features**
- Control direction and speed with joystick
**Todo**
- Set parameters
- Control other modes
- Execute preset movement commands

12
board_motorctl/main/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
idf_component_register(
SRCS
"main.cpp"
"motordrivers.cpp"
"motorctl.cpp"
"config.cpp"
"fan.cpp"
"currentsensor.cpp"
"uart.cpp"
INCLUDE_DIRS
"."
)

85
board_motorctl/main/config.cpp Normal file
View File

@ -0,0 +1,85 @@
#include "config.hpp"
//===================================
//======= motor configuration =======
//===================================
//--- configure left motor (hardware) ---
single100a_config_t configDriverLeft = {
.gpio_pwm = GPIO_NUM_26,
.gpio_a = GPIO_NUM_4,
.gpio_b = GPIO_NUM_16,
.gpio_brakeRelay = GPIO_NUM_5, //power mosfet 2
.ledc_timer = LEDC_TIMER_0,
.ledc_channel = LEDC_CHANNEL_0,
.aEnabledPinState = false, //-> pins inverted (mosfets)
.bEnabledPinState = false,
.resolution = LEDC_TIMER_11_BIT,
.pwmFreq = 10000
};
//--- configure right motor (hardware) ---
single100a_config_t configDriverRight = {
.gpio_pwm = GPIO_NUM_27,
.gpio_a = GPIO_NUM_2,
.gpio_b = GPIO_NUM_15,
.gpio_brakeRelay = GPIO_NUM_18, //power mosfet 1
.ledc_timer = LEDC_TIMER_1,
.ledc_channel = LEDC_CHANNEL_1,
.aEnabledPinState = false, //-> pins inverted (mosfets)
.bEnabledPinState = false,
.resolution = LEDC_TIMER_11_BIT,
.pwmFreq = 10000
};
//TODO add motor name string -> then use as log tag?
//--- configure left motor (contol) ---
motorctl_config_t configMotorControlLeft = {
.msFadeAccel = 1900, //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,
.currentSensor_adc = ADC1_CHANNEL_0, //GPIO36
.currentSensor_ratedCurrent = 50,
.currentMax = 30,
.deadTimeMs = 900 //minimum time motor is off between direction change
};
//--- configure right motor (contol) ---
motorctl_config_t configMotorControlRight = {
.msFadeAccel = 1900, //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,
.currentSensor_adc = ADC1_CHANNEL_3, //GPIO39
.currentSensor_ratedCurrent = 50,
.currentMax = 30,
.deadTimeMs = 900 //minimum time motor is off between direction change
};
//============================
//=== configure fan contol ===
//============================
fan_config_t configCooling = {
.gpio_fan = GPIO_NUM_13,
.dutyThreshold = 40,
.minOnMs = 1500,
.minOffMs = 3000,
.turnOffDelayMs = 5000,
};
//=================================
//===== create global objects =====
//=================================
//TODO outsource global variables to e.g. global.cpp and only config options here?
//create controlled motor instances (motorctl.hpp)
controlledMotor motorLeft(configDriverLeft, configMotorControlLeft);
controlledMotor motorRight(configDriverRight, configMotorControlRight);
//create buzzer object on pin 12 with gap between queued events of 100ms
buzzer_t buzzer(GPIO_NUM_12, 100);

27
board_motorctl/main/config.hpp Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include "motordrivers.hpp"
#include "motorctl.hpp"
#include "gpio_evaluateSwitch.hpp"
#include "buzzer.hpp"
#include "fan.hpp"
//in IDLE mode: set loglevel for evaluatedJoystick to DEBUG
//and repeatedly read joystick e.g. for manually calibrating / testing joystick
//#define JOYSTICK_LOG_IN_IDLE
//TODO outsource global variables to e.g. global.cpp and only config options here?
//create global controlledMotor instances for both motors
extern controlledMotor motorLeft;
extern controlledMotor motorRight;
//create global buzzer object
extern buzzer_t buzzer;
//configuration for fans / cooling
extern fan_config_t configCooling;

0
main/currentsensor.cpp → board_motorctl/main/currentsensor.cpp
View File

0
main/currentsensor.hpp → board_motorctl/main/currentsensor.hpp
View File

0
main/fan.cpp → board_motorctl/main/fan.cpp
View File

0
main/fan.hpp → board_motorctl/main/fan.hpp
View File

217
board_motorctl/main/main.cpp Normal file
View File

@ -0,0 +1,217 @@
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"
#include "esp_spiffs.h"
#include <string.h>
#include "driver/ledc.h"
//custom C files
#include "wifi.h"
}
//custom C++ files
#include "config.hpp"
#include "uart.hpp"
//=========================
//======= UART TEST =======
//=========================
//only run uart test code at the end
//disables other functionality
//#define UART_TEST_ONLY
//==========================
//======= BRAKE TEST =======
//==========================
//only run brake-test (ignore uart input)
#define BRAKE_TEST_ONLY
//tag for logging
static const char * TAG = "main";
#ifndef UART_TEST_ONLY
//====================================
//========== motorctl task ===========
//====================================
//task for handling the motors (ramp, current limit, driver)
void task_motorctl( void * pvParameters ){
ESP_LOGI(TAG, "starting handle loop...");
while(1){
motorRight.handle();
motorLeft.handle();
//10khz -> T=100us
vTaskDelay(10 / portTICK_PERIOD_MS);
}
}
//======================================
//============ buzzer task =============
//======================================
//TODO: move the task creation to buzzer class (buzzer.cpp)
//e.g. only have function buzzer.createTask() in app_main
void task_buzzer( void * pvParameters ){
ESP_LOGI("task_buzzer", "Start of buzzer task...");
//run function that waits for a beep events to arrive in the queue
//and processes them
buzzer.processQueue();
}
//=======================================
//============== fan task ===============
//=======================================
//task that controlls fans for cooling the drivers
void task_fans( void * pvParameters ){
ESP_LOGI(TAG, "Initializing fans and starting fan handle loop");
//create fan instances with config defined in config.cpp
controlledFan fan(configCooling, &motorLeft, &motorRight);
//repeatedly run fan handle function in a slow loop
while(1){
fan.handle();
vTaskDelay(500 / portTICK_PERIOD_MS);
}
}
//==================================
//======== define loglevels ========
//==================================
void setLoglevels(void){
//set loglevel for all tags:
esp_log_level_set("*", ESP_LOG_WARN);
//--- set loglevel for individual tags ---
esp_log_level_set("main", ESP_LOG_INFO);
esp_log_level_set("buzzer", ESP_LOG_ERROR);
esp_log_level_set("motordriver", ESP_LOG_VERBOSE);
esp_log_level_set("motor-control", ESP_LOG_INFO);
//esp_log_level_set("evaluatedJoystick", ESP_LOG_DEBUG);
//esp_log_level_set("joystickCommands", ESP_LOG_DEBUG);
esp_log_level_set("button", ESP_LOG_INFO);
esp_log_level_set("control", ESP_LOG_INFO);
esp_log_level_set("fan-control", ESP_LOG_INFO);
esp_log_level_set("wifi", ESP_LOG_INFO);
esp_log_level_set("http", ESP_LOG_INFO);
esp_log_level_set("automatedArmchair", ESP_LOG_DEBUG);
esp_log_level_set("uart_common", ESP_LOG_INFO);
esp_log_level_set("uart", ESP_LOG_INFO);
//esp_log_level_set("current-sensors", ESP_LOG_INFO);
}
#endif
//=================================
//=========== app_main ============
//=================================
extern "C" void app_main(void) {
#ifndef UART_TEST_ONLY
//enable 5V volate regulator
gpio_pad_select_gpio(GPIO_NUM_17);
gpio_set_direction(GPIO_NUM_17, GPIO_MODE_OUTPUT);
gpio_set_level(GPIO_NUM_17, 1);
//---- define log levels ----
setLoglevels();
//----------------------------------------------
//--- create task for controlling the motors ---
//----------------------------------------------
//task that receives commands, handles ramp and current limit and executes commands using the motordriver function
xTaskCreate(&task_motorctl, "task_motor-control", 2048, NULL, 6, NULL);
//------------------------------
//--- create task for buzzer ---
//------------------------------
xTaskCreate(&task_buzzer, "task_buzzer", 2048, NULL, 2, NULL);
//-----------------------------------
//--- create task for fan control ---
//-----------------------------------
//task that evaluates and processes the button input and runs the configured commands
xTaskCreate(&task_fans, "task_fans", 2048, NULL, 1, NULL);
//beep at startup
buzzer.beep(3, 70, 50);
#endif
//-------------------------------------------
//--- create tasks for uart communication ---
//-------------------------------------------
#ifndef BRAKE_TEST_ONLY
uart_init();
xTaskCreate(task_uartReceive, "task_uartReceive", 4096, NULL, 10, NULL);
xTaskCreate(task_uartSend, "task_uartSend", 4096, NULL, 10, NULL);
#endif
//--- main loop ---
//does nothing except for testing things
while(1){
vTaskDelay(500 / portTICK_PERIOD_MS);
#ifdef BRAKE_TEST_ONLY
//test relays at standstill
ESP_LOGW("brake-test", "test relays via motorctl");
//turn on
motorRight.setTarget(motorstate_t::BRAKE, 0);
vTaskDelay(500 / portTICK_PERIOD_MS);
motorRight.setTarget(motorstate_t::BRAKE, 0);
vTaskDelay(1000 / portTICK_PERIOD_MS);
//turn off
motorRight.setTarget(motorstate_t::IDLE, 0);
vTaskDelay(500 / portTICK_PERIOD_MS);
motorRight.setTarget(motorstate_t::IDLE, 0);
vTaskDelay(1000 / portTICK_PERIOD_MS);
//go forward and brake
ESP_LOGW("brake-test", "go forward 30%% then brake");
motorRight.setTarget(motorstate_t::FWD, 30);
vTaskDelay(1000 / portTICK_PERIOD_MS);
motorRight.setTarget(motorstate_t::BRAKE, 0);
vTaskDelay(3000 / portTICK_PERIOD_MS);
//brake partial
ESP_LOGW("brake-test", "go forward 30%% then brake partial 10%%, hold for 5sec");
motorRight.setTarget(motorstate_t::FWD, 30);
vTaskDelay(1000 / portTICK_PERIOD_MS);
motorRight.setTarget(motorstate_t::BRAKE, 10);
vTaskDelay(5000 / portTICK_PERIOD_MS);
//reset to idle
motorRight.setTarget(motorstate_t::IDLE, 0);
#endif
//--- test controlledMotor --- (ramp)
// //brake for 1 s
// motorLeft.setTarget(motorstate_t::BRAKE);
// vTaskDelay(1000 / portTICK_PERIOD_MS);
// //command 90% - reverse
// motorLeft.setTarget(motorstate_t::REV, 90);
// vTaskDelay(5000 / portTICK_PERIOD_MS);
// //command 100% - forward
// motorLeft.setTarget(motorstate_t::FWD, 100);
// vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}

36
main/motorctl.cpp → board_motorctl/main/motorctl.cpp
View File

@ -1,8 +1,11 @@
#include "motorctl.hpp"
#include "esp_log.h"
#include "types.hpp"
//tag for logging
static const char * TAG = "motor-control";
#define TIMEOUT_IDLE_WHEN_NO_COMMAND 8000
//=============================
//======== constructor ========
@ -77,9 +80,11 @@ 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_LOGI(TAG, "Read command from queue: state=%s, duty=%.2f", motorstateStr[(int)commandReceive.state], commandReceive.duty);
state = commandReceive.state;
dutyTarget = commandReceive.duty;
receiveTimeout = false;
timestamp_commandReceived = esp_log_timestamp();
//--- convert duty ---
//define target duty (-100 to 100) from provided duty and motorstate
@ -88,7 +93,8 @@ void controlledMotor::handle(){
case motorstate_t::BRAKE:
//update state
state = motorstate_t::BRAKE;
dutyTarget = 0;
//dutyTarget = 0;
dutyTarget = fabs(commandReceive.duty);
break;
case motorstate_t::IDLE:
dutyTarget = 0;
@ -102,6 +108,15 @@ void controlledMotor::handle(){
}
}
//--- timeout, no data ---
//turn motors off if no data received for long time (e.g. no uart data / control offline)
//TODO no timeout when braking?
if ((esp_log_timestamp() - timestamp_commandReceived) > TIMEOUT_IDLE_WHEN_NO_COMMAND && !receiveTimeout){
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);
}
//--- calculate increment ---
//calculate increment for fading UP with passed time since last run and configured fade time
@ -119,14 +134,15 @@ void controlledMotor::handle(){
dutyIncrementDecel = 100;
}
//--- BRAKE ---
//brake immediately, update state, duty and exit this cycle of handle function
if (state == motorstate_t::BRAKE){
motor.set(motorstate_t::BRAKE, 0);
dutyNow = 0;
return; //no need to run the fade algorithm
}
//--- BRAKE ---
//brake immediately, update state, duty and exit this cycle of handle function
if (state == motorstate_t::BRAKE){
ESP_LOGD(TAG, "braking - skip fading");
motor.set(motorstate_t::BRAKE, dutyTarget);
//dutyNow = 0;
return; //no need to run the fade algorithm
}
//--- calculate difference ---

31
main/motorctl.hpp → board_motorctl/main/motorctl.hpp
View File

@ -16,33 +16,9 @@ extern "C"
//=======================================
//====== struct/type declarations ======
//=======================================
//outsourced to common/types.hpp
#include "types.hpp"
//struct for sending command for one motor in the queue
struct motorCommand_t {
motorstate_t state;
float duty;
};
//struct containing commands for two motors
typedef struct motorCommands_t {
motorCommand_t left;
motorCommand_t right;
} motorCommands_t;
//struct with all config parameters for a motor regarding ramp and current limit
typedef struct motorctl_config_t {
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;
adc1_channel_t currentSensor_adc;
float currentSensor_ratedCurrent;
float currentMax;
uint32_t deadTimeMs; //time motor stays in IDLE before direction change
} motorctl_config_t;
//enum fade type (acceleration, deceleration)
//e.g. used for specifying which fading should be modified with setFade, togleFade functions
enum class fadeType_t {ACCEL, DECEL};
@ -101,4 +77,7 @@ class controlledMotor {
struct motorCommand_t commandReceive = {};
struct motorCommand_t commandSend = {};
uint32_t timestamp_commandReceived = 0;
bool receiveTimeout = false;
};

66
main/motordrivers.cpp → board_motorctl/main/motordrivers.cpp
View File

@ -1,4 +1,6 @@
#include "motordrivers.hpp"
#include "esp_log.h"
#include "types.hpp"
//TODO: move from ledc to mcpwm?
//https://docs.espressif.com/projects/esp-idf/en/v4.3/esp32/api-reference/peripherals/mcpwm.html#
@ -7,12 +9,11 @@
//Note fade functionality provided by LEDC would be very useful but unfortunately is not usable here because:
//"Due to hardware limitations, there is no way to stop a fade before it reaches its target duty."
//definition of string array to be able to convert state enum to readable string
const char* motorstateStr[4] = {"IDLE", "FWD", "REV", "BRAKE"};
//tag for logging
static const char * TAG = "motordriver";
//ms to wait in IDLE before BRAKE until relay actually switched
#define BRAKE_RELAY_DELAY_MS 300
//====================================
@ -64,11 +65,13 @@ void single100a::init(){
gpio_set_direction(config.gpio_a, GPIO_MODE_OUTPUT);
gpio_pad_select_gpio(config.gpio_b);
gpio_set_direction(config.gpio_b, GPIO_MODE_OUTPUT);
gpio_pad_select_gpio(config.gpio_brakeRelay);
gpio_set_direction(config.gpio_brakeRelay, GPIO_MODE_OUTPUT);
//--- calculate max duty according to selected resolution ---
dutyMax = pow(2, ledc_timer.duty_resolution) -1;
ESP_LOGI(TAG, "initialized single100a driver");
ESP_LOGI(TAG, "resolution=%dbit, dutyMax value=%d, resolution=%.4f %%", ledc_timer.duty_resolution, dutyMax, 100/(float)dutyMax);
ESP_LOGW(TAG, "initialized single100a driver");
ESP_LOGW(TAG, "resolution=%dbit, dutyMax value=%d, resolution=%.4f %%", ledc_timer.duty_resolution, dutyMax, 100/(float)dutyMax);
}
@ -83,7 +86,7 @@ void single100a::set(motorstate_t state_f, float duty_f){
uint32_t dutyScaled;
if (duty_f > 100) { //target duty above 100%
dutyScaled = dutyMax;
} else if (duty_f <= 0) { //target at or below 0%
} else if (duty_f < 0) { //target at or below 0%
state_f = motorstate_t::IDLE;
dutyScaled = 0;
} else { //target duty 0-100%
@ -91,7 +94,18 @@ void single100a::set(motorstate_t state_f, float duty_f){
dutyScaled = duty_f / 100 * dutyMax;
}
ESP_LOGV(TAG, "target-state=%s, duty=%d/%d, duty_input=%.3f%%", motorstateStr[(int)state_f], dutyScaled, dutyMax, duty_f);
//TODO: only when previous mode was BRAKE?
if (state_f != motorstate_t::BRAKE){
//reset brake wait state
brakeWaitingForRelay = false;
//turn of brake relay
gpio_set_level(config.gpio_brakeRelay, 0);
}
//put the single100a h-bridge module in the desired state update duty-cycle
//TODO maybe outsource mode code from once switch case? e.g. idle() brake()...
switch (state_f){
case motorstate_t::IDLE:
ledc_set_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel, dutyScaled);
@ -103,13 +117,37 @@ void single100a::set(motorstate_t state_f, float duty_f){
gpio_set_level(config.gpio_a, config.aEnabledPinState);
gpio_set_level(config.gpio_b, config.bEnabledPinState);
break;
case motorstate_t::BRAKE:
ledc_set_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel, 0);
ledc_update_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel);
//brake:
gpio_set_level(config.gpio_a, !config.aEnabledPinState);
gpio_set_level(config.gpio_b, !config.bEnabledPinState);
break;
case motorstate_t::BRAKE:
//prevent full short (no brake resistors) due to slow relay, also reduces switching load
if (!brakeWaitingForRelay){
ESP_LOGW(TAG, "BRAKE: turned on relay, waiting in IDLE for %d ms, then apply brake", BRAKE_RELAY_DELAY_MS);
//switch driver to IDLE for now
gpio_set_level(config.gpio_a, config.aEnabledPinState);
gpio_set_level(config.gpio_b, config.bEnabledPinState);
//start brake relay
gpio_set_level(config.gpio_brakeRelay, 1);
timestamp_brakeRelayPowered = esp_log_timestamp();
brakeWaitingForRelay = true;
}
//check if delay for relay to switch has passed
else if ((esp_log_timestamp() - timestamp_brakeRelayPowered) > BRAKE_RELAY_DELAY_MS) {
ESP_LOGD(TAG, "applying brake with brake-resistors at duty=%.2f%%", duty_f);
//switch driver to BRAKE
gpio_set_level(config.gpio_a, !config.aEnabledPinState);
gpio_set_level(config.gpio_b, !config.bEnabledPinState);
//apply duty
//FIXME switch between BREAK and IDLE with PWM and ignore pwm-pin? (needs test)
ledc_set_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel, dutyScaled);
ledc_update_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel);
} else {
//waiting... stay in IDLE
ESP_LOGD(TAG, "waiting for brake relay to close (IDLE)...");
gpio_set_level(config.gpio_a, config.aEnabledPinState);
gpio_set_level(config.gpio_b, config.bEnabledPinState);
}
break;
case motorstate_t::FWD:
ledc_set_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel, dutyScaled);
ledc_update_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel);
@ -117,6 +155,7 @@ void single100a::set(motorstate_t state_f, float duty_f){
gpio_set_level(config.gpio_a, config.aEnabledPinState);
gpio_set_level(config.gpio_b, !config.bEnabledPinState);
break;
case motorstate_t::REV:
ledc_set_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel, dutyScaled);
ledc_update_duty(LEDC_HIGH_SPEED_MODE, config.ledc_channel);
@ -125,5 +164,4 @@ void single100a::set(motorstate_t state_f, float duty_f){
gpio_set_level(config.gpio_b, config.bEnabledPinState);
break;
}
ESP_LOGD(TAG, "set module to state=%s, duty=%d/%d, duty_input=%.3f%%", motorstateStr[(int)state_f], dutyScaled, dutyMax, duty_f);
}

10
main/motordrivers.hpp → board_motorctl/main/motordrivers.hpp
View File

@ -21,17 +21,15 @@ extern "C"
//--------------------------------------------
//---- struct, enum, variable declarations ---
//--------------------------------------------
//class which controls a motor using a 'single100a' h-bridge module
enum class motorstate_t {IDLE, FWD, REV, BRAKE};
//definition of string array to be able to convert state enum to readable string (defined in motordrivers.cpp)
extern const char* motorstateStr[4];
//motorstate_t, motorstateStr outsourced to common/types.hpp
#include "types.hpp"
//struct with all config parameters for single100a motor driver
typedef struct single100a_config_t {
gpio_num_t gpio_pwm;
gpio_num_t gpio_a;
gpio_num_t gpio_b;
gpio_num_t gpio_brakeRelay;
ledc_timer_t ledc_timer;
ledc_channel_t ledc_channel;
bool aEnabledPinState;
@ -62,4 +60,6 @@ class single100a {
single100a_config_t config;
uint32_t dutyMax;
motorstate_t state = motorstate_t::IDLE;
bool brakeWaitingForRelay = false;
uint32_t timestamp_brakeRelayPowered;
};

71
board_motorctl/main/uart.cpp Normal file
View File

@ -0,0 +1,71 @@
#include "uart.hpp"
#include "config.hpp"
#include "types.hpp"
#include "uart_common.hpp"
//===== uart board MOTORCTL =====
static const char * TAG = "uart";
//handle received payload from uart
void handleMessage(uint8_t *receivedData, int len) {
ESP_LOGI(TAG, "complete message received len=%d", len);
//local variables
uartData_test_t dataTest;
motorCommands_t dataMotorCommands;
//assign data to struct
switch (len){
case sizeof(uartData_test_t):
dataTest = serialData2Struct<uartData_test_t>(receivedData);
ESP_LOGW(TAG, "received uartDataStruct len=%d DATA: timestamp=%d, id=%d, value=%.1f", len, dataTest.timestamp, dataTest.id, dataTest.value);
break;
case sizeof(motorCommands_t):
dataMotorCommands = serialData2Struct<motorCommands_t>(receivedData);
ESP_LOGI(TAG, "received motorCommands struct len=%d left=%.2f%% right=%.2f%%, update target...", len, dataMotorCommands.left.duty, dataMotorCommands.right.duty);
//update target motor state and duty
motorLeft.setTarget(dataMotorCommands.left.state,
dataMotorCommands.left.duty);
motorRight.setTarget(dataMotorCommands.right.state,
dataMotorCommands.right.duty);
break;
//TODO add other received structs here
default:
ESP_LOGE(TAG, "received data len=%d cant be associated with configures struct", len);
break;
}
}
//==============================
//====== task_uartReceive ======
//==============================
//TODO duplicate code, same task in both boards, only handleMessage function has to be passed -> move to uart_common
void task_uartReceive(void *arg){
ESP_LOGW(TAG, "receive task started");
while (1) {
uint8_t byte;
//read 1 byte TODO: use uart queue here? data might get lost when below function takes longer than data arrives
int len = uart_read_bytes(UART_NUM_1, &byte, 1, portMAX_DELAY);
if (len > 0) {
//process received byte
uart_processReceivedByte(byte, handleMessage);
}
}
}
//=============================
//======= task_uartSend =======
//=============================
//TODO copy send task from board_control/uart.cpp
void task_uartSend(void *arg){
ESP_LOGW(TAG, "send task started");
while (1) {
vTaskDelay(500 / portTICK_PERIOD_MS);
}
}

8
board_motorctl/main/uart.hpp Normal file
View File

@ -0,0 +1,8 @@
#pragma once
#include "uart_common.hpp"
//===== uart board MOTORCTL =====
void task_uartReceive(void *arg);
void task_uartSend(void *arg);

11
common/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
idf_component_register(
SRCS
"wifi.c"
"buzzer.cpp"
"uart_common.cpp"
"types.cpp"
INCLUDE_DIRS
"."
PRIV_REQUIRES nvs_flash
)

1
main/buzzer.cpp → common/buzzer.cpp
View File

@ -1,5 +1,4 @@
#include "buzzer.hpp"
#include "config.hpp"
static const char *TAG_BUZZER = "buzzer";

0
main/buzzer.hpp → common/buzzer.hpp
View File

4
common/types.cpp Normal file
View File

@ -0,0 +1,4 @@
#include "types.hpp"
const char* motorstateStr[4] = {"IDLE", "FWD", "REV", "BRAKE"};

55
common/types.hpp Normal file
View File

@ -0,0 +1,55 @@
#pragma once
extern "C"
{
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_timer.h"
#include <driver/adc.h>
}
//=======================================
//====== struct/type declarations ======
//=======================================
//global structs and types that need to be available for all boards
//===============================
//==== from motordrivers.hpp ====
//===============================
enum class motorstate_t {IDLE, FWD, REV, BRAKE};
//definition of string array to be able to convert state enum to readable string (defined in motordrivers.cpp)
extern const char* motorstateStr[4];
//===========================
//==== from motorctl.hpp ====
//===========================
//struct for sending command for one motor in the queue
struct motorCommand_t {
motorstate_t state;
float duty;
};
//struct containing commands for two motors
typedef struct motorCommands_t {
motorCommand_t left;
motorCommand_t right;
} motorCommands_t;
//struct with all config parameters for a motor regarding ramp and current limit
typedef struct motorctl_config_t {
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;
adc1_channel_t currentSensor_adc;
float currentSensor_ratedCurrent;
float currentMax;
uint32_t deadTimeMs; //time motor stays in IDLE before direction change
} motorctl_config_t;
//enum fade type (acceleration, deceleration)
//e.g. used for specifying which fading should be modified with setFade, togleFade functions
enum class fadeType_t {ACCEL, DECEL};

117
common/uart_common.cpp Normal file
View File

@ -0,0 +1,117 @@
#include "uart_common.hpp"
static const char * TAG = "uart-common";
SemaphoreHandle_t uart_semaphoreSend = NULL;
bool uart_isInitialized = false;
//===========================
//======== uart_init =======
//===========================
//initial struct on given pins
//TODO add pins and baud rate to config?
void uart_init(void){
ESP_LOGW(TAG, "initializing uart1...");
uart_semaphoreSend = xSemaphoreCreateBinary();
uart_config_t uart1_config = {
.baud_rate = 115198,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_EVEN,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
};
ESP_LOGI(TAG, "configure...");
ESP_ERROR_CHECK(uart_param_config(UART_NUM_1, &uart1_config));
ESP_LOGI(TAG, "setpins...");
ESP_ERROR_CHECK(uart_set_pin(UART_NUM_1, 23, 22, 0, 0));
ESP_LOGI(TAG, "init...");
ESP_ERROR_CHECK(uart_driver_install(UART_NUM_1, 1024, 1024, 10, NULL, 0));
uart_isInitialized = true;
xSemaphoreGive(uart_semaphoreSend);
}
//===========================
//===== uart_sendBinary ====
//===========================
//encode byte array to message (start, stop, escape pattern)
//and send it via uart
//note: use sendStruct template in uart_common.hpp
void uart_sendBinary(uint8_t *data, int length) {
const uint8_t startPattern = START_PATTERN;
const uint8_t endPattern = END_PATTERN;
const uint8_t escapeByte = ESCAPE_BYTE;
ESP_LOGI(TAG, "encoding and sending bytes len=%d", length);
//wait for last message to finish sending
if (xSemaphoreTake(uart_semaphoreSend, UART_WRITE_WAIT_TIMEOUT / portTICK_PERIOD_MS) == pdTRUE){
//send start byte
uart_write_bytes(UART_NUM_1, &startPattern, 1);
for (int i = 0; i < length; i++) {
if (data[i] == START_PATTERN || data[i] == END_PATTERN || data[i] == ESCAPE_BYTE) {
//add escape byte if next byte is special pattern by accident
uart_write_bytes(UART_NUM_1, &escapeByte, 1);
}
uart_write_bytes(UART_NUM_1, (const char *)&data[i], 1);
}
//send end byte
uart_write_bytes(UART_NUM_1, &endPattern, 1);
vTaskDelay(UART_WRITE_MIN_DELAY / portTICK_PERIOD_MS);
xSemaphoreGive(uart_semaphoreSend);
} else ESP_LOGE(TAG, "timeout waiting for uart write semaphore! dropping data");
}
//================================
//=== uart_processReceivedByte ===
//================================
//decode received message to byte array (start, stop, escape pattern)
//has to be run for each receibed byte
//runs provided messageHandler function when complete message received
uint8_t receivedData[MAX_MESSAGE_LENGTH];
int dataIndex = 0;
bool insideMessage = false;
bool escaped = false;
void uart_processReceivedByte(uint8_t data, messageHandleFunc_t messageHandler){
ESP_LOGD(TAG, "process byte %x", data);
if (escaped) {
//this byte is actual data, no end/start byte
escaped = false;
receivedData[dataIndex++] = data;
if (dataIndex >= MAX_MESSAGE_LENGTH) {
insideMessage = false;
dataIndex = 0;
}
} else if (data == START_PATTERN) {
//start of message
insideMessage = true;
dataIndex = 0;
} else if (insideMessage) {
if (data == ESCAPE_BYTE) {
ESP_LOGI(TAG, "escape byte received");
//escape next byte
escaped = true;
} else if (data == END_PATTERN) {
//end of message
insideMessage = false;
//call provided function that handles actual messages
messageHandler(receivedData, dataIndex);
dataIndex = 0;
} else if (dataIndex < MAX_MESSAGE_LENGTH - 2) {
//normal byte - append byte to data
receivedData[dataIndex++] = data;
} else {
//message too long / buffer exceeded
insideMessage = false;
dataIndex = 0;
ESP_LOGE(TAG, "received message too long! dropped");
}
} else ESP_LOGE(TAG, "start pattern missing! ignoreing byte");
}

121
common/uart_common.hpp Normal file
View File

@ -0,0 +1,121 @@
#pragma once
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"
#include <string.h>
#include "freertos/semphr.h"
#include "freertos/queue.h"
#include "driver/uart.h"
}
#include "types.hpp"
//idea with time gap dropped, replaced with encoding
//#define UART_RECEIVE_DURATION 10
//receive interval may not miss messages but also may not read multiple messages
//has to be significantly smaller than WRITE_MNIN_DELAY but larger than longest message
//semaphore for assuring min delay between sent data
//extern SemaphoreHandle_t uart_semaphoreSend;
//==== parameters message frame ====
#define START_PATTERN 0xAA
#define END_PATTERN 0xBB
#define MAX_MESSAGE_LENGTH 1024
#define ESCAPE_BYTE 0xCC
//min delay after each message (no significant effect)
#define UART_WRITE_MIN_DELAY 50
#define UART_WRITE_WAIT_TIMEOUT 2000
extern bool uart_isInitialized;
//struct for testing uart
typedef struct {
uint32_t timestamp;
int id;
float value;
} uartData_test_t;
//unnecessary, using commands struct directly
typedef struct {
uint32_t timestamp;
motorCommands_t commands;
} uartData_motorCommands_t;
//function that handles receieved messages as byte array
//-> do something with received data
typedef void (*messageHandleFunc_t)(uint8_t *data, int length);
//===== uart_init =====
//should be run once at startup
void uart_init(void);
//===== uart_processReceivedByte =====
//decode received message to byte array (start, stop, escape pattern)
//has to be run for each receibed byte
//runs provided messageHandler function when complete message received
void uart_processReceivedByte(uint8_t data, messageHandleFunc_t messageHandler);
//===== uart_sendBinary =====
//encode byte array to message (start, stop, escape pattern)
//and send it via uart
void uart_sendBinary(uint8_t *data, int length);
//============================
//====== uart_sendStruct =====
//============================
//send and struct via uart
//waits when another struct was sent less than UART_WRITE_MIN_DELAY ago
template <typename T> void uart_sendStruct(T dataStruct) {
static const char * TAG = "uart-common";
//check if uart is initialized
if (!uart_isInitialized){
ESP_LOGE(TAG, "uart not initialized! droping data");
return;
}
uint8_t dataSerial[sizeof(T)];
//struct to serial bytes
memcpy(dataSerial, &dataStruct, sizeof(T));
// //wait for min delay after last write DROPPED
// if (xSemaphoreTake(uart_semaphoreSend, UART_WRITE_WAIT_TIMEOUT / portTICK_PERIOD_MS) == pdTRUE){
// //send bytes
// uart_write_bytes(UART_NUM_1, (const char *)dataSerial, sizeof(T));
// ESP_LOGW(TAG, "sent data struct with len %d", sizeof(T));
// } else ESP_LOGE(TAG, "timeout waiting for uart write semaphore! dropping data");
// //wait min delay before next write is allowed
// vTaskDelay(UART_WRITE_MIN_DELAY / portTICK_PERIOD_MS);
// xSemaphoreGive(uart_semaphoreSend);
uart_sendBinary(dataSerial, sizeof(T));
}
//==============================
//====== serialData2Struct =====
//==============================
//convert serial data (byte array) to given struct and return it
//note check whether serial data length actually matches size of struct is necessary before
template <typename T> T serialData2Struct(uint8_t *dataSerial){
static const char * TAG = "uart-common";
T dataStruct;
memcpy(&dataStruct, dataSerial, sizeof(T));
ESP_LOGI(TAG, "converted serial data len=%d to struct", sizeof(T));
return dataStruct;
}

0
main/wifi.c → common/wifi.c
View File

0
main/wifi.h → common/wifi.h
View File

BIN
connection-plan.drawio.pdf
View File

Binary file not shown.

BIN
function-diagram.drawio.pdf
View File

Binary file not shown.

88
main/auto.cpp
View File

@ -1,88 +0,0 @@
#include "auto.hpp"
#include "config.hpp"
//tag for logging
static const char * TAG = "automatedArmchair";
//=============================
//======== constructor ========
//=============================
automatedArmchair::automatedArmchair(void) {
//create command queue
commandQueue = xQueueCreate( 32, sizeof( commandSimple_t ) ); //TODO add max size to config?
}
//==============================
//====== generateCommands ======
//==============================
motorCommands_t automatedArmchair::generateCommands(auto_instruction_t * instruction) {
//reset instruction
*instruction = auto_instruction_t::NONE;
//check if previous command is finished
if ( esp_log_timestamp() > timestampCmdFinished ) {
//get next command from queue
if( xQueueReceive( commandQueue, &cmdCurrent, pdMS_TO_TICKS(500) ) ) {
ESP_LOGI(TAG, "running next command from queue...");
//copy instruction to be provided to control task
*instruction = cmdCurrent.instruction;
//set acceleration / fading parameters according to command
motorLeft.setFade(fadeType_t::DECEL, cmdCurrent.fadeDecel);
motorRight.setFade(fadeType_t::DECEL, cmdCurrent.fadeDecel);
motorLeft.setFade(fadeType_t::ACCEL, cmdCurrent.fadeAccel);
motorRight.setFade(fadeType_t::ACCEL, cmdCurrent.fadeAccel);
//calculate timestamp the command is finished
timestampCmdFinished = esp_log_timestamp() + cmdCurrent.msDuration;
//copy the new commands
motorCommands = cmdCurrent.motorCmds;
} else { //queue empty
ESP_LOGD(TAG, "no new command in queue -> set motors to IDLE");
motorCommands = motorCmds_bothMotorsIdle;
}
} else { //previous command still running
ESP_LOGD(TAG, "command still running -> no change");
}
//TODO also return instructions via call by reference
return motorCommands;
}
//============================
//======== addCommand ========
//============================
//function that adds a basic command to the queue
void automatedArmchair::addCommand(commandSimple_t command) {
//add command to queue
if ( xQueueSend( commandQueue, ( void * )&command, ( TickType_t ) 0 ) ){
ESP_LOGI(TAG, "Successfully inserted command to queue");
} else {
ESP_LOGE(TAG, "Failed to insert new command to queue");
}
}
void automatedArmchair::addCommands(commandSimple_t commands[], size_t count) {
for (int i = 0; i < count; i++) {
ESP_LOGI(TAG, "Reading command no. %d from provided array", i);
addCommand(commands[i]);
}
}
//===============================
//======== clearCommands ========
//===============================
//function that deletes all pending/queued commands
//e.g. when switching modes
motorCommands_t automatedArmchair::clearCommands() {
//clear command queue
xQueueReset( commandQueue );
ESP_LOGW(TAG, "command queue was successfully emptied");
//return commands for idling both motors
motorCommands = motorCmds_bothMotorsIdle;
return motorCmds_bothMotorsIdle;
}

215
main/button.cpp
View File

@ -1,215 +0,0 @@
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include "freertos/FreeRTOS.h"
#include "esp_log.h"
}
#include "button.hpp"
//tag for logging
static const char * TAG = "button";
//-----------------------------
//-------- constructor --------
//-----------------------------
buttonCommands::buttonCommands(gpio_evaluatedSwitch * button_f, evaluatedJoystick * joystick_f, controlledArmchair * control_f, buzzer_t * buzzer_f, controlledMotor * motorLeft_f, controlledMotor * motorRight_f){
//copy object pointers
button = button_f;
joystick = joystick_f;
control = control_f;
buzzer = buzzer_f;
motorLeft = motorLeft_f;
motorRight = motorRight_f;
//TODO declare / configure evaluatedSwitch here instead of config (unnecessary that button object is globally available - only used here)?
}
//----------------------------
//--------- action -----------
//----------------------------
//function that runs commands depending on a count value
void buttonCommands::action (uint8_t count, bool lastPressLong){
//--- variable declarations ---
bool decelEnabled; //for different beeping when toggling
commandSimple_t cmds[8]; //array for commands for automatedArmchair
//--- get joystick position ---
//joystickData_t stickData = joystick->getData();
//--- actions based on count ---
switch (count){
//no such command
default:
ESP_LOGE(TAG, "no command for count=%d defined", count);
buzzer->beep(3, 400, 100);
break;
case 1:
//restart contoller when 1x long pressed
if (lastPressLong){
ESP_LOGW(TAG, "RESTART");
buzzer->beep(1,1000,1);
vTaskDelay(1000 / portTICK_PERIOD_MS);
esp_restart();
return;
}
ESP_LOGW(TAG, "cmd %d: sending button event to control task", count);
//-> define joystick center or toggle freeze input (executed in control task)
control->sendButtonEvent(count); //TODO: always send button event to control task (not just at count=1) -> control.cpp has to be changed
break;
case 2:
//run automatic commands to lift leg support when pressed 1x short 1x long
if (lastPressLong){
//define commands
cmds[0] =
{
.motorCmds = {
.left = {motorstate_t::REV, 90},
.right = {motorstate_t::REV, 90}
},
.msDuration = 1200,
.fadeDecel = 800,
.fadeAccel = 1300,
.instruction = auto_instruction_t::NONE
};
cmds[1] =
{
.motorCmds = {
.left = {motorstate_t::FWD, 70},
.right = {motorstate_t::FWD, 70}
},
.msDuration = 70,
.fadeDecel = 0,
.fadeAccel = 300,
.instruction = auto_instruction_t::NONE
};
cmds[2] =
{
.motorCmds = {
.left = {motorstate_t::IDLE, 0},
.right = {motorstate_t::IDLE, 0}
},
.msDuration = 10,
.fadeDecel = 800,
.fadeAccel = 1300,
.instruction = auto_instruction_t::SWITCH_JOYSTICK_MODE
};
//send commands to automatedArmchair command queue
armchair.addCommands(cmds, 3);
//change mode to AUTO
control->changeMode(controlMode_t::AUTO);
return;
}
//toggle idle when 2x pressed
ESP_LOGW(TAG, "cmd %d: toggle IDLE", count);
control->toggleIdle(); //toggle between idle and previous/default mode
break;
case 3:
ESP_LOGW(TAG, "cmd %d: switch to JOYSTICK", count);
control->changeMode(controlMode_t::JOYSTICK); //switch to JOYSTICK mode
break;
case 4:
ESP_LOGW(TAG, "cmd %d: toggle between HTTP and JOYSTICK", count);
control->toggleModes(controlMode_t::HTTP, controlMode_t::JOYSTICK); //toggle between HTTP and JOYSTICK mode
break;
case 6:
ESP_LOGW(TAG, "cmd %d: toggle between MASSAGE and JOYSTICK", count);
control->toggleModes(controlMode_t::MASSAGE, controlMode_t::JOYSTICK); //toggle between MASSAGE and JOYSTICK mode
break;
case 8:
//toggle deceleration fading between on and off
decelEnabled = motorLeft->toggleFade(fadeType_t::DECEL);
motorRight->toggleFade(fadeType_t::DECEL);
ESP_LOGW(TAG, "cmd %d: toggle deceleration fading to: %d", count, (int)decelEnabled);
if (decelEnabled){
buzzer->beep(3, 60, 50);
} else {
buzzer->beep(1, 1000, 1);
}
break;
case 12:
ESP_LOGW(TAG, "cmd %d: sending button event to control task", count);
//-> toggle altStickMapping (executed in control task)
control->sendButtonEvent(count); //TODO: always send button event to control task (not just at count=1)?
break;
}
}
//-----------------------------
//------ startHandleLoop ------
//-----------------------------
//this function has to be started once in a separate task
//repeatedly evaluates and processes button events then takes the corresponding action
void buttonCommands::startHandleLoop() {
while(1) {
vTaskDelay(20 / portTICK_PERIOD_MS);
//run handle function of evaluatedSwitch object
button->handle();
//--- count button presses and run action ---
switch(state) {
case inputState_t::IDLE: //wait for initial button press
if (button->risingEdge) {
count = 1;
buzzer->beep(1, 65, 0);
timestamp_lastAction = esp_log_timestamp();
state = inputState_t::WAIT_FOR_INPUT;
ESP_LOGI(TAG, "first button press detected -> waiting for further events");
}
break;
case inputState_t::WAIT_FOR_INPUT: //wait for further presses
//button pressed again
if (button->risingEdge){
count++;
buzzer->beep(1, 65, 0);
timestamp_lastAction = esp_log_timestamp();
ESP_LOGI(TAG, "another press detected -> count=%d -> waiting for further events", count);
}
//timeout
else if (esp_log_timestamp() - timestamp_lastAction > 1000) {
state = inputState_t::IDLE;
buzzer->beep(count, 50, 50);
//TODO: add optional "bool wait" parameter to beep function to delay until finished beeping
ESP_LOGI(TAG, "timeout - running action function for count=%d", count);
//--- run action function ---
//check if still pressed
bool lastPressLong = false;
if (button->state == true){
//run special case when last press was longer than timeout
lastPressLong = true;
}
//run action function with current count of button presses
action(count, lastPressLong);
}
break;
}
}
}

53
main/button.hpp
View File

@ -1,53 +0,0 @@
#pragma once
#include "gpio_evaluateSwitch.hpp"
#include "buzzer.hpp"
#include "control.hpp"
#include "motorctl.hpp"
#include "auto.hpp"
#include "config.hpp"
#include "joystick.hpp"
//===================================
//====== buttonCommands class =======
//===================================
//class which runs commands depending on the count a button was pressed
class buttonCommands {
public:
//--- constructor ---
buttonCommands (
gpio_evaluatedSwitch * button_f,
evaluatedJoystick * joystick_f,
controlledArmchair * control_f,
buzzer_t * buzzer_f,
controlledMotor * motorLeft_f,
controlledMotor * motorRight_f
);
//--- functions ---
//the following function has to be started once in a separate task.
//repeatedly evaluates and processes button events then takes the corresponding action
void startHandleLoop();
private:
//--- functions ---
void action(uint8_t count, bool lastPressLong);
//--- objects ---
gpio_evaluatedSwitch* button;
evaluatedJoystick* joystick;
controlledArmchair * control;
buzzer_t* buzzer;
controlledMotor * motorLeft;
controlledMotor * motorRight;
//--- variables ---
uint8_t count = 0;
uint32_t timestamp_lastAction = 0;
enum class inputState_t {IDLE, WAIT_FOR_INPUT};
inputState_t state = inputState_t::IDLE;
};

479
main/control.cpp
View File

@ -1,479 +0,0 @@
extern "C"
{
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "esp_log.h"
#include "freertos/queue.h"
//custom C libraries
#include "wifi.h"
}
#include "config.hpp"
#include "control.hpp"
//used definitions moved from config.hpp:
//#define JOYSTICK_TEST
//tag for logging
static const char * TAG = "control";
const char* controlModeStr[7] = {"IDLE", "JOYSTICK", "MASSAGE", "HTTP", "MQTT", "BLUETOOTH", "AUTO"};
//-----------------------------
//-------- constructor --------
//-----------------------------
controlledArmchair::controlledArmchair (
control_config_t config_f,
buzzer_t * buzzer_f,
controlledMotor* motorLeft_f,
controlledMotor* motorRight_f,
evaluatedJoystick* joystick_f,
httpJoystick* httpJoystick_f
){
//copy configuration
config = config_f;
//copy object pointers
buzzer = buzzer_f;
motorLeft = motorLeft_f;
motorRight = motorRight_f;
joystick_l = joystick_f,
httpJoystickMain_l = httpJoystick_f;
//set default mode from config
modePrevious = config.defaultMode;
//TODO declare / configure controlled motors here instead of config (unnecessary that button object is globally available - only used here)?
}
//----------------------------------
//---------- Handle loop -----------
//----------------------------------
//function that repeatedly generates motor commands depending on the current mode
//also handles fading and current-limit
void controlledArmchair::startHandleLoop() {
while (1){
ESP_LOGV(TAG, "control task executing... mode=%s", controlModeStr[(int)mode]);
switch(mode) {
default:
mode = controlMode_t::IDLE;
break;
case controlMode_t::IDLE:
//copy preset commands for idling both motors
commands = cmds_bothMotorsIdle;
motorRight->setTarget(commands.right.state, commands.right.duty);
motorLeft->setTarget(commands.left.state, commands.left.duty);
vTaskDelay(200 / portTICK_PERIOD_MS);
#ifdef JOYSTICK_LOG_IN_IDLE
//get joystick data here (without using it)
//since loglevel is DEBUG, calculateion details is output
joystick_l->getData(); //get joystick data here
#endif
break;
case controlMode_t::JOYSTICK:
vTaskDelay(20 / portTICK_PERIOD_MS);
//get current joystick data with getData method of evaluatedJoystick
stickData = joystick_l->getData();
//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);
//apply motor commands
motorRight->setTarget(commands.right.state, commands.right.duty);
motorLeft->setTarget(commands.left.state, commands.left.duty);
//TODO make motorctl.setTarget also accept motorcommand struct directly
break;
case controlMode_t::MASSAGE:
vTaskDelay(10 / portTICK_PERIOD_MS);
//--- read joystick ---
//only update joystick data when input not frozen
if (!freezeInput){
stickData = joystick_l->getData();
}
//--- generate motor commands ---
//pass joystick data from getData method of evaluatedJoystick to generateCommandsShaking function
commands = joystick_generateCommandsShaking(stickData);
//apply motor commands
motorRight->setTarget(commands.right.state, commands.right.duty);
motorLeft->setTarget(commands.left.state, commands.left.duty);
break;
case controlMode_t::HTTP:
//--- get joystick data from queue ---
//Note this function waits several seconds (httpconfig.timeoutMs) for data to arrive, otherwise Center data or NULL is returned
//TODO: as described above, when changing modes it might delay a few seconds for the change to apply
stickData = httpJoystickMain_l->getData();
//scale coordinates additionally (more detail in slower area)
joystick_scaleCoordinatesLinear(&stickData, 0.6, 0.4); //TODO: add scaling parameters to config
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);
//--- apply commands to motors ---
//TODO make motorctl.setTarget also accept motorcommand struct directly
motorRight->setTarget(commands.right.state, commands.right.duty);
motorLeft->setTarget(commands.left.state, commands.left.duty);
break;
case controlMode_t::AUTO:
vTaskDelay(20 / portTICK_PERIOD_MS);
//generate commands
commands = armchair.generateCommands(&instruction);
//--- apply commands to motors ---
//TODO make motorctl.setTarget also accept motorcommand struct directly
motorRight->setTarget(commands.right.state, commands.right.duty);
motorLeft->setTarget(commands.left.state, commands.left.duty);
//process received instruction
switch (instruction) {
case auto_instruction_t::NONE:
break;
case auto_instruction_t::SWITCH_PREV_MODE:
toggleMode(controlMode_t::AUTO);
break;
case auto_instruction_t::SWITCH_JOYSTICK_MODE:
changeMode(controlMode_t::JOYSTICK);
break;
case auto_instruction_t::RESET_ACCEL_DECEL:
//enable downfading (set to default value)
motorLeft->setFade(fadeType_t::DECEL, true);
motorRight->setFade(fadeType_t::DECEL, true);
//set upfading to default value
motorLeft->setFade(fadeType_t::ACCEL, true);
motorRight->setFade(fadeType_t::ACCEL, true);
break;
case auto_instruction_t::RESET_ACCEL:
//set upfading to default value
motorLeft->setFade(fadeType_t::ACCEL, true);
motorRight->setFade(fadeType_t::ACCEL, true);
break;
case auto_instruction_t::RESET_DECEL:
//enable downfading (set to default value)
motorLeft->setFade(fadeType_t::DECEL, true);
motorRight->setFade(fadeType_t::DECEL, true);
break;
}
break;
//TODO: add other modes here
}
//--- run actions based on received button button event ---
//note: buttonCount received by sendButtonEvent method called from button.cpp
//TODO: what if variable gets set from other task during this code? -> mutex around this code
switch (buttonCount) {
case 1: //define joystick center or freeze input
if (mode == controlMode_t::JOYSTICK){
//joystick mode: calibrate joystick
joystick_l->defineCenter();
} else if (mode == controlMode_t::MASSAGE){
//massage mode: toggle freeze of input (lock joystick at current values)
freezeInput = !freezeInput;
if (freezeInput){
buzzer->beep(5, 40, 25);
} else {
buzzer->beep(1, 300, 100);
}
}
break;
case 12: //toggle alternative joystick mapping (reverse swapped)
altStickMapping = !altStickMapping;
if (altStickMapping){
buzzer->beep(6, 70, 50);
} else {
buzzer->beep(1, 500, 100);
}
break;
}
//--- reset button event --- (only one action per run)
if (buttonCount > 0){
ESP_LOGI(TAG, "resetting button event/count");
buttonCount = 0;
}
//-----------------------
//------ slow loop ------
//-----------------------
//this section is run about every 5s (+500ms)
if (esp_log_timestamp() - timestamp_SlowLoopLastRun > 5000) {
ESP_LOGV(TAG, "running slow loop... time since last run: %.1fs", (float)(esp_log_timestamp() - timestamp_SlowLoopLastRun)/1000);
timestamp_SlowLoopLastRun = esp_log_timestamp();
//run function which detects timeout (switch to idle)
handleTimeout();
}
}//end while(1)
}//end startHandleLoop
//-----------------------------------
//---------- resetTimeout -----------
//-----------------------------------
void controlledArmchair::resetTimeout(){
//TODO mutex
timestamp_lastActivity = esp_log_timestamp();
}
//------------------------------------
//--------- sendButtonEvent ----------
//------------------------------------
void controlledArmchair::sendButtonEvent(uint8_t count){
//TODO mutex - if not replaced with queue
ESP_LOGI(TAG, "setting button event");
buttonCount = count;
}
//------------------------------------
//---------- handleTimeout -----------
//------------------------------------
//percentage the duty can vary since last timeout check and still counts as incative
//TODO: add this to config
float inactivityTolerance = 10;
//local function that checks whether two values differ more than a given tolerance
bool validateActivity(float dutyOld, float dutyNow, float tolerance){
float dutyDelta = dutyNow - dutyOld;
if (fabs(dutyDelta) < tolerance) {
return false; //no significant activity detected
} else {
return true; //there was activity
}
}
//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 controlledArmchair::handleTimeout(){
//check for timeout only when not idling already
if (mode != controlMode_t::IDLE) {
//get current duty from controlled motor objects
float dutyLeftNow = motorLeft->getStatus().duty;
float dutyRightNow = motorRight->getStatus().duty;
//activity detected on any of the two motors
if (validateActivity(dutyLeft_lastActivity, dutyLeftNow, inactivityTolerance)
|| validateActivity(dutyRight_lastActivity, dutyRightNow, inactivityTolerance)
){
ESP_LOGD(TAG, "timeout check: [activity] detected since last check -> reset");
//reset last duty and timestamp
dutyLeft_lastActivity = dutyLeftNow;
dutyRight_lastActivity = dutyRightNow;
resetTimeout();
}
//no activity on any motor and msTimeout exceeded
else if (esp_log_timestamp() - timestamp_lastActivity > config.timeoutMs){
ESP_LOGI(TAG, "timeout check: [TIMEOUT], no activity for more than %.ds -> switch to idle", config.timeoutMs/1000);
//toggle to idle mode
toggleIdle();
}
else {
ESP_LOGD(TAG, "timeout check: [inactive], last activity %.1f s ago, timeout after %d s", (float)(esp_log_timestamp() - timestamp_lastActivity)/1000, config.timeoutMs/1000);
}
}
}
//-----------------------------------
//----------- changeMode ------------
//-----------------------------------
//function to change to a specified control mode
void controlledArmchair::changeMode(controlMode_t modeNew) {
//reset timeout timer
resetTimeout();
//exit if target mode is already active
if (mode == modeNew) {
ESP_LOGE(TAG, "changeMode: Already in target mode '%s' -> nothing to change", controlModeStr[(int)mode]);
return;
}
//copy previous mode
modePrevious = mode;
ESP_LOGW(TAG, "=== changing mode from %s to %s ===", controlModeStr[(int)mode], controlModeStr[(int)modeNew]);
//========== commands change FROM mode ==========
//run functions when changing FROM certain mode
switch(modePrevious){
default:
ESP_LOGI(TAG, "noting to execute when changing FROM this mode");
break;
#ifdef JOYSTICK_LOG_IN_IDLE
case controlMode_t::IDLE:
ESP_LOGI(TAG, "disabling debug output for 'evaluatedJoystick'");
esp_log_level_set("evaluatedJoystick", ESP_LOG_WARN); //FIXME: loglevel from config
break;
#endif
case controlMode_t::HTTP:
ESP_LOGW(TAG, "switching from http mode -> disabling http and wifi");
//stop http server
ESP_LOGI(TAG, "disabling http server...");
http_stop_server();
//FIXME: make wifi function work here - currently starting wifi at startup (see notes main.cpp)
//stop wifi
//TODO: decide whether ap or client is currently used - which has to be disabled?
//ESP_LOGI(TAG, "deinit wifi...");
//wifi_deinit_client();
//wifi_deinit_ap();
ESP_LOGI(TAG, "done stopping http mode");
break;
case controlMode_t::MASSAGE:
ESP_LOGW(TAG, "switching from MASSAGE mode -> restoring fading, reset frozen input");
//TODO: fix issue when downfading was disabled before switching to massage mode - currently it gets enabled again here...
//enable downfading (set to default value)
motorLeft->setFade(fadeType_t::DECEL, true);
motorRight->setFade(fadeType_t::DECEL, true);
//set upfading to default value
motorLeft->setFade(fadeType_t::ACCEL, true);
motorRight->setFade(fadeType_t::ACCEL, true);
//reset frozen input state
freezeInput = false;
break;
case controlMode_t::AUTO:
ESP_LOGW(TAG, "switching from AUTO mode -> restoring fading to default");
//TODO: fix issue when downfading was disabled before switching to auto mode - currently it gets enabled again here...
//enable downfading (set to default value)
motorLeft->setFade(fadeType_t::DECEL, true);
motorRight->setFade(fadeType_t::DECEL, true);
//set upfading to default value
motorLeft->setFade(fadeType_t::ACCEL, true);
motorRight->setFade(fadeType_t::ACCEL, true);
break;
}
//========== commands change TO mode ==========
//run functions when changing TO certain mode
switch(modeNew){
default:
ESP_LOGI(TAG, "noting to execute when changing TO this mode");
break;
case controlMode_t::IDLE:
buzzer->beep(1, 1500, 0);
#ifdef JOYSTICK_LOG_IN_IDLE
esp_log_level_set("evaluatedJoystick", ESP_LOG_DEBUG);
#endif
break;
case controlMode_t::HTTP:
ESP_LOGW(TAG, "switching to http mode -> enabling http and wifi");
//start wifi
//TODO: decide wether ap or client should be started
ESP_LOGI(TAG, "init wifi...");
//FIXME: make wifi function work here - currently starting wifi at startup (see notes main.cpp)
//wifi_init_client();
//wifi_init_ap();
//wait for wifi
//ESP_LOGI(TAG, "waiting for wifi...");
//vTaskDelay(1000 / portTICK_PERIOD_MS);
//start http server
ESP_LOGI(TAG, "init http server...");
http_init_server();
ESP_LOGI(TAG, "done initializing http mode");
break;
case controlMode_t::MASSAGE:
ESP_LOGW(TAG, "switching to MASSAGE mode -> reducing fading");
uint32_t shake_msFadeAccel = 500; //TODO: move this to config
//disable downfading (max. deceleration)
motorLeft->setFade(fadeType_t::DECEL, false);
motorRight->setFade(fadeType_t::DECEL, false);
//reduce upfading (increase acceleration)
motorLeft->setFade(fadeType_t::ACCEL, shake_msFadeAccel);
motorRight->setFade(fadeType_t::ACCEL, shake_msFadeAccel);
break;
}
//--- update mode to new mode ---
//TODO: add mutex
mode = modeNew;
}
//TODO simplify the following 3 functions? can be replaced by one?
//-----------------------------------
//----------- toggleIdle ------------
//-----------------------------------
//function to toggle between IDLE and previous active mode
void controlledArmchair::toggleIdle() {
//toggle between IDLE and previous mode
toggleMode(controlMode_t::IDLE);
}
//------------------------------------
//----------- toggleModes ------------
//------------------------------------
//function to toggle between two modes, but prefer first argument if entirely different mode is currently active
void controlledArmchair::toggleModes(controlMode_t modePrimary, controlMode_t modeSecondary) {
//switch to secondary mode when primary is already active
if (mode == modePrimary){
ESP_LOGW(TAG, "toggleModes: switching from primaryMode %s to secondarMode %s", controlModeStr[(int)mode], controlModeStr[(int)modeSecondary]);
buzzer->beep(2,200,100);
changeMode(modeSecondary); //switch to secondary mode
}
//switch to primary mode when any other mode is active
else {
ESP_LOGW(TAG, "toggleModes: switching from %s to primary mode %s", controlModeStr[(int)mode], controlModeStr[(int)modePrimary]);
buzzer->beep(4,200,100);
changeMode(modePrimary);
}
}
//-----------------------------------
//----------- toggleMode ------------
//-----------------------------------
//function that toggles between certain mode and previous mode
void controlledArmchair::toggleMode(controlMode_t modePrimary){
//switch to previous mode when primary is already active
if (mode == modePrimary){
ESP_LOGW(TAG, "toggleMode: switching from primaryMode %s to previousMode %s", controlModeStr[(int)mode], controlModeStr[(int)modePrevious]);
//buzzer->beep(2,200,100);
changeMode(modePrevious); //switch to previous mode
}
//switch to primary mode when any other mode is active
else {
ESP_LOGW(TAG, "toggleModes: switching from %s to primary mode %s", controlModeStr[(int)mode], controlModeStr[(int)modePrimary]);
//buzzer->beep(4,200,100);
changeMode(modePrimary);
}
}

130
main/control.hpp
View File

@ -1,130 +0,0 @@
#pragma once
#include "motordrivers.hpp"
#include "motorctl.hpp"
#include "buzzer.hpp"
#include "http.hpp"
#include "auto.hpp"
//--------------------------------------------
//---- struct, enum, variable declarations ---
//--------------------------------------------
//enum that decides how the motors get controlled
enum class controlMode_t {IDLE, JOYSTICK, MASSAGE, HTTP, MQTT, BLUETOOTH, AUTO};
//string array representing the mode enum (for printing the state as string)
extern const char* controlModeStr[7];
//--- control_config_t ---
//struct with config parameters
typedef struct control_config_t {
controlMode_t defaultMode; //default mode after startup and toggling IDLE
//timeout options
uint32_t timeoutMs; //time of inactivity after which the mode gets switched to IDLE
float timeoutTolerancePer; //percentage the duty can vary between timeout checks considered still inactive
} control_config_t;
//==================================
//========= control class ==========
//==================================
//controls the mode the armchair operates
//repeatedly generates the motor commands corresponding to current mode and sends those to motorcontrol
class controlledArmchair {
public:
//--- constructor ---
controlledArmchair (
control_config_t config_f,
buzzer_t* buzzer_f,
controlledMotor* motorLeft_f,
controlledMotor* motorRight_f,
evaluatedJoystick* joystick_f,
httpJoystick* httpJoystick_f
);
//--- functions ---
//task that repeatedly generates motor commands depending on the current mode
void startHandleLoop();
//function that changes to a specified control mode
void changeMode(controlMode_t modeNew);
//function that toggle between IDLE and previous active mode (or default if not switched to certain mode yet)
void toggleIdle();
//function that toggles between two modes, but prefers first argument if entirely different mode is currently active
void toggleModes(controlMode_t modePrimary, controlMode_t modeSecondary);
//toggle between certain mode and previous mode
void toggleMode(controlMode_t modePrimary);
//function that restarts timer which initiates the automatic timeout (switch to IDLE) after certain time of inactivity
void resetTimeout();
//function for sending a button event (e.g. from button task at event) to control task
//TODO: use queue instead?
void sendButtonEvent(uint8_t count);
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();
//--- objects ---
buzzer_t* buzzer;
controlledMotor* motorLeft;
controlledMotor* motorRight;
httpJoystick* httpJoystickMain_l;
evaluatedJoystick* joystick_l;
//---variables ---
//struct for motor commands returned by generate functions of each mode
motorCommands_t commands;
//struct with config parameters
control_config_t config;
//store joystick data
joystickData_t stickData;
bool altStickMapping; //alternative joystick mapping (reverse mapped differently)
//variables for http mode
uint32_t http_timestamp_lastData = 0;
//variables for MASSAGE mode
bool freezeInput = false;
//variables for AUTO mode
auto_instruction_t instruction = auto_instruction_t::NONE; //variable to receive instructions from automatedArmchair
//variable to store button event
uint8_t buttonCount = 0;
//definition of mode enum
controlMode_t mode = controlMode_t::IDLE;
//variable to store mode when toggling IDLE mode
controlMode_t modePrevious; //default mode
//command preset for idling motors
const motorCommand_t cmd_motorIdle = {
.state = motorstate_t::IDLE,
.duty = 0
};
const motorCommands_t cmds_bothMotorsIdle = {
.left = cmd_motorIdle,
.right = cmd_motorIdle
};
//variable for slow loop
uint32_t timestamp_SlowLoopLastRun = 0;
//variables for detecting timeout (switch to idle, after inactivity)
float dutyLeft_lastActivity = 0;
float dutyRight_lastActivity = 0;
uint32_t timestamp_lastActivity = 0;
};

299
main/main.cpp
View File

@ -1,299 +0,0 @@
extern "C"
{
#include <stdio.h>
#include <esp_system.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"
#include "esp_spiffs.h"
#include "driver/ledc.h"
//custom C files
#include "wifi.h"
}
//custom C++ files
#include "config.hpp"
#include "control.hpp"
#include "button.hpp"
#include "http.hpp"
//tag for logging
static const char * TAG = "main";
//====================================
//========== motorctl task ===========
//====================================
//task for handling the motors (ramp, current limit, driver)
void task_motorctl( void * pvParameters ){
ESP_LOGI(TAG, "starting handle loop...");
while(1){
motorRight.handle();
motorLeft.handle();
//10khz -> T=100us
vTaskDelay(10 / portTICK_PERIOD_MS);
}
}
//======================================
//============ buzzer task =============
//======================================
//TODO: move the task creation to buzzer class (buzzer.cpp)
//e.g. only have function buzzer.createTask() in app_main
void task_buzzer( void * pvParameters ){
ESP_LOGI("task_buzzer", "Start of buzzer task...");
//run function that waits for a beep events to arrive in the queue
//and processes them
buzzer.processQueue();
}
//=======================================
//============ control task =============
//=======================================
//task that controls the armchair modes and initiates commands generation and applies them to driver
void task_control( void * pvParameters ){
ESP_LOGI(TAG, "Initializing controlledArmchair and starting handle loop");
//start handle loop (control object declared in config.hpp)
control.startHandleLoop();
}
//======================================
//============ button task =============
//======================================
//task that handles the button interface/commands
void task_button( void * pvParameters ){
ESP_LOGI(TAG, "Initializing command-button and starting handle loop");
//create button instance
buttonCommands commandButton(&buttonJoystick, &joystick, &control, &buzzer, &motorLeft, &motorRight);
//start handle loop
commandButton.startHandleLoop();
}
//=======================================
//============== fan task ===============
//=======================================
//task that controlls fans for cooling the drivers
void task_fans( void * pvParameters ){
ESP_LOGI(TAG, "Initializing fans and starting fan handle loop");
//create fan instances with config defined in config.cpp
controlledFan fan(configCooling, &motorLeft, &motorRight);
//repeatedly run fan handle function in a slow loop
while(1){
fan.handle();
vTaskDelay(500 / portTICK_PERIOD_MS);
}
}
//=================================
//========== init spiffs ==========
//=================================
//initialize spi flash filesystem (used for webserver)
void init_spiffs(){
ESP_LOGI(TAG, "init spiffs");
esp_vfs_spiffs_conf_t esp_vfs_spiffs_conf = {
.base_path = "/spiffs",
.partition_label = NULL,
.max_files = 5,
.format_if_mount_failed = true};
esp_vfs_spiffs_register(&esp_vfs_spiffs_conf);
size_t total = 0;
size_t used = 0;
esp_spiffs_info(NULL, &total, &used);
ESP_LOGI(TAG, "SPIFFS: total %d, used %d", total, used);
esp_vfs_spiffs_unregister(NULL);
}
//==================================
//======== define loglevels ========
//==================================
void setLoglevels(void){
//set loglevel for all tags:
esp_log_level_set("*", ESP_LOG_WARN);
//--- set loglevel for individual tags ---
esp_log_level_set("main", ESP_LOG_INFO);
esp_log_level_set("buzzer", ESP_LOG_ERROR);
//esp_log_level_set("motordriver", ESP_LOG_INFO);
//esp_log_level_set("motor-control", ESP_LOG_DEBUG);
//esp_log_level_set("evaluatedJoystick", ESP_LOG_DEBUG);
//esp_log_level_set("joystickCommands", ESP_LOG_DEBUG);
esp_log_level_set("button", ESP_LOG_INFO);
esp_log_level_set("control", ESP_LOG_INFO);
esp_log_level_set("fan-control", ESP_LOG_INFO);
esp_log_level_set("wifi", ESP_LOG_INFO);
esp_log_level_set("http", ESP_LOG_INFO);
esp_log_level_set("automatedArmchair", ESP_LOG_DEBUG);
//esp_log_level_set("current-sensors", ESP_LOG_INFO);
}
//=================================
//=========== app_main ============
//=================================
extern "C" void app_main(void) {
//enable 5V volate regulator
gpio_pad_select_gpio(GPIO_NUM_17);
gpio_set_direction(GPIO_NUM_17, GPIO_MODE_OUTPUT);
gpio_set_level(GPIO_NUM_17, 1);
//---- define log levels ----
setLoglevels();
//----------------------------------------------
//--- create task for controlling the motors ---
//----------------------------------------------
//task that receives commands, handles ramp and current limit and executes commands using the motordriver function
xTaskCreate(&task_motorctl, "task_motor-control", 2048, NULL, 6, NULL);
//------------------------------
//--- create task for buzzer ---
//------------------------------
xTaskCreate(&task_buzzer, "task_buzzer", 2048, NULL, 2, NULL);
//-------------------------------
//--- create task for control ---
//-------------------------------
//task that generates motor commands depending on the current mode and sends those to motorctl task
xTaskCreate(&task_control, "task_control", 4096, NULL, 5, NULL);
//------------------------------
//--- create task for button ---
//------------------------------
//task that evaluates and processes the button input and runs the configured commands
xTaskCreate(&task_button, "task_button", 4096, NULL, 4, NULL);
//-----------------------------------
//--- create task for fan control ---
//-----------------------------------
//task that evaluates and processes the button input and runs the configured commands
xTaskCreate(&task_fans, "task_fans", 2048, NULL, 1, NULL);
//beep at startup
buzzer.beep(3, 70, 50);
//--- initialize nvs-flash and netif (needed for wifi) ---
wifi_initNvs_initNetif();
//--- initialize spiffs ---
init_spiffs();
//--- initialize and start wifi ---
//FIXME: run wifi_init_client or wifi_init_ap as intended from control.cpp when switching state
//currently commented out because of error "assert failed: xQueueSemaphoreTake queue.c:1549 (pxQueue->uxItemSize == 0)" when calling control->changeMode from button.cpp
//when calling control.changeMode(http) from main.cpp it worked without error for some reason?
ESP_LOGI(TAG,"starting wifi...");
//wifi_init_client(); //connect to existing wifi
wifi_init_ap(); //start access point
ESP_LOGI(TAG,"done starting wifi");
//--- testing http server ---
// wifi_init_client(); //connect to existing wifi
// vTaskDelay(2000 / portTICK_PERIOD_MS);
// ESP_LOGI(TAG, "initializing http server");
// http_init_server();
//--- testing force http mode after startup ---
//control.changeMode(controlMode_t::HTTP);
//--- main loop ---
//does nothing except for testing things
while(1){
vTaskDelay(1000 / portTICK_PERIOD_MS);
//---------------------------------
//-------- TESTING section --------
//---------------------------------
// //--- test functions at mode change HTTP ---
// control.changeMode(controlMode_t::HTTP);
// vTaskDelay(10000 / portTICK_PERIOD_MS);
// control.changeMode(controlMode_t::IDLE);
// vTaskDelay(10000 / portTICK_PERIOD_MS);
//--- test wifi functions ---
// ESP_LOGI(TAG, "creating AP");
// wifi_init_ap(); //start accesspoint
// vTaskDelay(15000 / portTICK_PERIOD_MS);
// ESP_LOGI(TAG, "stopping wifi");
// wifi_deinit_ap(); //stop wifi access point
// vTaskDelay(5000 / portTICK_PERIOD_MS);
// ESP_LOGI(TAG, "connecting to wifi");
// wifi_init_client(); //connect to existing wifi
// vTaskDelay(10000 / portTICK_PERIOD_MS);
// ESP_LOGI(TAG, "stopping wifi");
// wifi_deinit_client(); //stop wifi client
// vTaskDelay(5000 / portTICK_PERIOD_MS);
//--- test button ---
//buttonJoystick.handle();
// if (buttonJoystick.risingEdge){
// ESP_LOGI(TAG, "button pressed, was released for %d ms", buttonJoystick.msReleased);
// buzzer.beep(2, 100, 50);
// }else if (buttonJoystick.fallingEdge){
// ESP_LOGI(TAG, "button released, was pressed for %d ms", buttonJoystick.msPressed);
// buzzer.beep(1, 200, 0);
// }
//--- test joystick commands ---
// motorCommands_t commands = joystick_generateCommandsDriving(joystick);
// motorRight.setTarget(commands.right.state, commands.right.duty); //TODO make motorctl.setTarget also accept motorcommand struct directly
// motorLeft.setTarget(commands.left.state, commands.left.duty); //TODO make motorctl.setTarget also accept motorcommand struct directly
// //motorRight.setTarget(commands.right.state, commands.right.duty);
//--- test joystick class ---
//joystickData_t data = joystick.getData();
//ESP_LOGI(TAG, "position=%s, x=%.1f%%, y=%.1f%%, radius=%.1f%%, angle=%.2f",
// joystickPosStr[(int)data.position], data.x*100, data.y*100, data.radius*100, data.angle);
//--- test the motor driver ---
//fade up duty - forward
// for (int duty=0; duty<=100; duty+=5) {
// motorLeft.setTarget(motorstate_t::FWD, duty);
// vTaskDelay(100 / portTICK_PERIOD_MS);
// }
//--- test controlledMotor --- (ramp)
// //brake for 1 s
// motorLeft.setTarget(motorstate_t::BRAKE);
// vTaskDelay(1000 / portTICK_PERIOD_MS);
// //command 90% - reverse
// motorLeft.setTarget(motorstate_t::REV, 90);
// vTaskDelay(5000 / portTICK_PERIOD_MS);
// //command 100% - forward
// motorLeft.setTarget(motorstate_t::FWD, 100);
// vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}

1397
sdkconfig
View File

File diff suppressed because it is too large Load Diff