OpenFFBoard/Firmware/FFBoard/Inc/CommandInterface.h at 46ea57c2869137f6fea55904c80dd664c5ceedae · Ultrawipf/OpenFFBoard · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*
 * CommandInterface.h
 *
 *  Created on: 17.11.2021
 *      Author: Yannick
 */

#ifndef SRC_COMMANDINTERFACE_H_
#define SRC_COMMANDINTERFACE_H_

#include "CmdParser.h"
#include "FFBoardMainCommandThread.h"
#include "UART.h"
#include "thread.hpp"
#include "CommandHandler.h"

#ifdef HW_ESP32SX
#define CDC_COMMANDINTERFACE_THREAD_MEM 4096
#define CDC_COMMANDINTERFACE_THREAD_PRIO (37*25/56)
#define UART_COMMANDINTERFACE_THREAD_MEM CDC_COMMANDINTERFACE_THREAD_MEM
#define UART_COMMANDINTERFACE_THREAD_PRIO CDC_COMMANDINTERFACE_THREAD_PRIO
#else
#define CDC_COMMANDINTERFACE_THREAD_MEM 512
#define CDC_COMMANDINTERFACE_THREAD_PRIO 36
#define UART_COMMANDINTERFACE_THREAD_MEM 150
#define UART_COMMANDINTERFACE_THREAD_PRIO CDC_COMMANDINTERFACE_THREAD_PRIO
#endif

class FFBoardMainCommandThread;

/**
 * Different command interface implementations
 */

class CommandInterface {
public:
	static std::vector<CommandInterface*> cmdInterfaces;

	CommandInterface();
	virtual ~CommandInterface();
	const virtual std::string getHelpstring(){return "";};
	virtual bool getNewCommands(std::vector<ParsedCommand>& commands) = 0;
	virtual bool hasNewCommands();
	static CommandResult makeCommandReply(const std::vector<CommandReply>& reply,CommandHandler* handler, uint32_t cmdId,CMDtype type = CMDtype::get,CommandInterface* originalInterface = nullptr);
	static void broadcastCommandReplyAsync(const std::vector<CommandReply>& reply,CommandHandler* handler, uint32_t cmdId,CMDtype type = CMDtype::get);
	virtual void sendReplies(const std::vector<CommandResult>& results,CommandInterface* originalInterface) = 0; // All commands from batch done
	virtual void sendReplyAsync(std::vector<CommandReply>& reply,CommandHandler* handler, uint32_t cmdId,CMDtype type);
	virtual bool readyToSend();
	virtual void batchDone();
protected:
	bool parserReady = false;
};

/**
 * Helper class for string based interfaces
 */
class StringCommandInterface : public CommandInterface{
public:
	StringCommandInterface(uint32_t bufferMaxCapacity = 512) : parser(CmdParser(bufferMaxCapacity)){}
	bool addBuf(char* Buf, uint32_t *Len);
	uint32_t bufferCapacity();
	bool getNewCommands(std::vector<ParsedCommand>& commands) override;
	static void formatReply(std::string& reply,const std::vector<CommandResult>& results,const bool formatWriteAsRead=false);
	static std::string formatOriginalCommandFromResult(const ParsedCommand& originalCommand,CommandHandler* commandHandler,const bool formatWriteAsRead=false);
	static void generateReplyValueString(std::string& replyPart,const CommandReply& reply);
	static void generateReplyFromCmd(std::string& replyPart,const ParsedCommand& originalCommand);
	const std::string getHelpstring(){return "Syntax:\nGet: cls.(instance.)cmd? or cls.(instance.)cmd?adr\nSet: cls.(instance.)cmd=val or cls.(instance.)cmd=val?adr";};


protected:
	CmdParser parser; // String parser
};


//receives bytes from mainclass. calls its own parser instance, calls global parser thread, passes replies  back to cdc port.
class CDC_CommandInterface : public StringCommandInterface,public cpp_freertos::Thread{
public:
	CDC_CommandInterface();
	virtual ~CDC_CommandInterface();

	void Run();

	void sendReplies(const std::vector<CommandResult>& results,CommandInterface* originalInterface) override;
	const std::string getHelpstring(){return "CDC interface. " + StringCommandInterface::getHelpstring();};
	bool readyToSend() override;
	void batchDone() override;

private:
	bool enableBroadcastFromOtherInterfaces = true;
	uint32_t lastSendTime = 0;
	const uint32_t parserTimeout = 500;
	//cpp_freertos::BinarySemaphore sendSem;
	std::vector<CommandResult> resultsBuffer;
	bool nextFormat = false;
	std::string sendBuffer;
	uint32_t bufferLength = 0;
	const uint32_t maxSendBuffer = 1024; // Max buffered command size before sending immediately
};


class UART_CommandInterface : public UARTDevice, public cpp_freertos::Thread,public StringCommandInterface{
public:
	UART_CommandInterface(uint32_t baud = 115200);
	virtual ~UART_CommandInterface();

	void Run();

	void sendReplies(const std::vector<CommandResult>& results,CommandInterface* originalInterface) override;
	void uartRcv(char& buf);
	bool readyToSend();
	const std::string getHelpstring(){return "UART interface. " + StringCommandInterface::getHelpstring();};
	//void endUartTransfer(UARTPort* port) override;
	void batchDone() override;

private:
	const uint32_t parserTimeout = 2000;

	UART_InitTypeDef uartconfig;
	uint32_t baud = 115200;
	std::string sendBuffer;
	bool enableBroadcastFromOtherInterfaces = false; // uart is slow. do not broadcast other messages by default
	//cpp_freertos::BinarySemaphore cmdUartSem;
	//cpp_freertos::BinarySemaphore bufferSem;
	std::vector<CommandResult> resultsBuffer;
	bool nextFormat = false;
	uint32_t bufferLength = 0;
	const uint32_t maxSendBuffer = 512; // Max buffered command size before sending immediately
};


#endif /* SRC_COMMANDINTERFACE_H_ */