Merge pull request #354 from HyperloopUPV-H8/development

merge develop into main

Author: g0nz4I0

.vscode/settings.json

@@ -10,7 +10,7 @@
         "**/build": true,
         "**/cmake_install.cmake": true,
         "**/CMakeFiles": true,
-        "**/CMakeLists.txt": true,
+        "**/CMakeLists.txt": false,
         "**/compile_commands.json": true,
         "**/Debug": true,
         "**/libst-lib.a": true,

Inc/C++Utilities/CppUtils.hpp

@@ -39,8 +39,8 @@
 namespace chrono = std::chrono;
 namespace placeholders = std::placeholders;
 
-using std::map;
 using std::array;
+using std::map;
 using std::span;
 using std::pair;
 using std::function;
@@ -57,13 +57,9 @@ using std::integral_constant;
 using std::snprintf;
 using std::make_unique;
 using std::unique_ptr;
-using std::unordered_map;
-using std::vector;
-using std::queue;
 using std::hash;
 using std::unordered_map;
 using std::vector;
 using std::queue;
-using std::map;
 using std::stringstream;
 using std::move;

Inc/HALAL/HALAL.hpp

@@ -27,5 +27,5 @@
 #include "CORDIC/CORDIC.hpp"
 
 namespace HALAL {
-	void start(string ip, string subnet_mask, string gateway, UART::Peripheral& printf_peripheral);
+	void start(IPV4 ip, IPV4 subnet_mask, IPV4 gateway, UART::Peripheral& printf_peripheral);
 }

Inc/HALAL/Models/IPV4/IPV4.hpp

@@ -26,6 +26,7 @@ class IPV4{
 	IPV4();
 	IPV4(const char* address);
 	IPV4(string address);
+	IPV4(ip_addr_t address);
 
 	void operator=(const char* address);
 };

Inc/HALAL/Models/Packets/Order.hpp

@@ -36,7 +36,7 @@ template<size_t BufferLength,class... Types> requires NotCallablePack<Types*...>
 class StackOrder : public StackPacket<BufferLength,Types...>, public Order{
 public:
     StackOrder(uint16_t id,void(*callback)(void), Types*... values) : StackPacket<BufferLength,Types...>(id,values...), callback(callback) {orders[id] = this;}
-//    StackOrder(uint16_t id, Types*... values) : StackPacket<BufferLength,Types...>(id,values...) {orders[id] = this;}
+    StackOrder(uint16_t id, Types*... values) : StackPacket<BufferLength,Types...>(id,values...) {orders[id] = this;}
     void(*callback)(void) = nullptr;
     void set_callback(void(*callback)(void)) override {
         this->callback = callback;
@@ -50,7 +50,7 @@ class StackOrder : public StackPacket<BufferLength,Types...>, public Order{
     void parse(void* data) override {
         StackPacket<BufferLength,Types...>::parse(data);
     }
-    void parse(OrderProtocol* socket, void* data){
+    void parse(OrderProtocol* socket, void* data) override{
     	parse(data);
     }
     size_t get_size() override {
@@ -59,14 +59,18 @@ class StackOrder : public StackPacket<BufferLength,Types...>, public Order{
     uint16_t get_id() override {
         return StackPacket<BufferLength,Types...>::get_id();
     }
+
+	void set_pointer(size_t index, void* pointer) override{
+		StackPacket<BufferLength,Types...>::set_pointer(index, pointer);
+	}
 };
 
 #if __cpp_deduction_guides >= 201606
 template<class... Types> requires NotCallablePack<Types*...>
 StackOrder(uint16_t id,void(*callback)(void), Types*... values)->StackOrder<(!has_container<Types...>::value)*total_sizeof<Types...>::value, Types...>;
 
-//template<class... Types> requires NotCallablePack<Types*...>
-//StackOrder(uint16_t id, Types*... values)->StackOrder<(!has_container<Types...>::value)*total_sizeof<Types...>::value, Types...>;
+template<class... Types> requires NotCallablePack<Types*...>
+StackOrder(uint16_t id, Types*... values)->StackOrder<(!has_container<Types...>::value)*total_sizeof<Types...>::value, Types...>;
 #endif
 
 class HeapOrder : public HeapPacket, public Order{
@@ -99,4 +103,8 @@ class HeapOrder : public HeapPacket, public Order{
     uint16_t get_id() override {
         return HeapPacket::get_id();
     }
+    void set_pointer(size_t index, void* pointer) override{
+    	HeapPacket::set_pointer(index, pointer);
+	}
+
 };

Inc/HALAL/Models/Packets/Packet.hpp

@@ -10,6 +10,7 @@ class Packet{
     virtual void parse(void* data) = 0;
     virtual size_t get_size() = 0;
     virtual uint16_t get_id() = 0; 
+    virtual void set_pointer(size_t index, void* pointer) = 0;
     static uint16_t get_id(void* data) {
         return *((uint16_t*)data);
     }
@@ -61,6 +62,10 @@ class StackPacket : public Packet{
     uint16_t get_id() override {
         return id;
     }
+
+    void set_pointer(size_t index, void* pointer) override{
+    	values[index]->set_pointer(pointer);
+    }
 };
 
 template<class... Types>
@@ -123,6 +128,10 @@ class StackPacket<0, Types...> : public Packet{
         return id;
     }
 
+    void set_pointer(size_t index, void* pointer) override{
+		values[index]->set_pointer(pointer);
+	}
+
     ~StackPacket() {
         if (buffer != nullptr) delete[] buffer;
     }
@@ -145,6 +154,8 @@ class StackPacket<0> : public Packet{
     size_t get_size() override {
         return sizeof(id); 
     }
+
+    void set_pointer(size_t index, void* pointer) override {};
 };
 
 
@@ -210,6 +221,10 @@ class HeapPacket : public Packet{
         return id;
     }
 
+    void set_pointer(size_t index, void* pointer) override{
+		values[index]->set_pointer(pointer);
+	}
+
     ~HeapPacket() {
         if(buffer != nullptr) delete[] buffer;
     }

Inc/HALAL/Models/Packets/PacketValue.hpp

@@ -14,6 +14,7 @@ class PacketValue<> {
     PacketValue() = default;
     ~PacketValue() = default;
     virtual void* get_pointer() = 0;
+    virtual void set_pointer(void* pointer) = 0;
     virtual size_t get_size() = 0;
     virtual void parse(void* data) = 0;
     virtual void copy_to(void* data) = 0;
@@ -30,6 +31,11 @@ class PacketValue<Type>: public PacketValue<> {
     void* get_pointer() override {
         return src;
     }
+
+    void set_pointer(void* pointer){
+    	src = (Type*)pointer;
+    }
+
     size_t get_size() override {
         return sizeof(Type);
     }
@@ -53,6 +59,11 @@ class PacketValue<double>: public PacketValue<> {
     void* get_pointer() override {
         return src;
     }
+
+    void set_pointer(void* pointer){
+    	src = (double*)pointer;
+    }
+
     size_t get_size() override {
         return sizeof(double);
     }
@@ -79,6 +90,11 @@ class PacketValue<Type>: public PacketValue<> {
     void* get_pointer() override {
         return src->data();
     }
+
+    void set_pointer(void* pointer){
+		src = (Type*)pointer;
+	}
+
     size_t get_size() override {
         return src->size()*sizeof(typename Type::value_type);
     }
@@ -106,6 +122,11 @@ class PacketValue<string> : public PacketValue<>{
     void* get_pointer() override {
         return src->data();
     }
+
+    void set_pointer(void* pointer){
+		src = (string*)pointer;
+	}
+
     size_t get_size() override {
         return strlen(src->c_str()) + 1;
     }
@@ -128,6 +149,11 @@ class PacketValue<Type(&)[N]>: public PacketValue<> {
     void* get_pointer() override {
         return src;
     }
+
+    void set_pointer(void* pointer){
+		src = (Type(*)[N])pointer;
+	}
+
     size_t get_size() override {
         return N*sizeof(Type);
     }
@@ -155,6 +181,11 @@ class PacketValue<Type*(&)[N]>: public PacketValue<> {
     void* get_pointer() override {
         return src;
     }
+
+    void set_pointer(void* pointer){
+		src = (Type*(*)[N])pointer;
+	}
+
     size_t get_size() override {
         return N*sizeof(Type);
     }

Inc/HALAL/Models/Packets/SPIPacket.hpp

@@ -0,0 +1,55 @@
+/*
+ * SpiPacket.hpp
+ *
+ *  Created on: 15 nov. 2023
+ *      Author: ricardo
+ */
+
+#pragma once
+
+#include "ErrorHandler/ErrorHandler.hpp"
+
+
+class SPIPacket{
+public:
+	static map<uint16_t, SPIPacket*> SPIPacketsByID;
+	uint16_t id;
+	uint8_t* master_data;
+	uint16_t master_data_size;
+	uint8_t* slave_data;
+	uint16_t slave_data_size;
+	uint16_t greater_data_size;
+
+	/**
+	 * @brief constructor of SPIPacket. The SPIPacket uses the first byte of the data arrays to coordinate the packet id, and builds the arrays with 1 more byte of space.
+	 *
+	 */
+	SPIPacket(uint16_t id, uint16_t master_data_size, uint16_t slave_data_size) : id(id), master_data_size(master_data_size), slave_data_size(slave_data_size){
+		if(id == 0){
+			ErrorHandler("Cannot use 0 as the SPIPacketID, as it is reserved to the no packet ready signal");
+		}
+		if(master_data_size > slave_data_size){
+			greater_data_size = master_data_size+2;
+		}else{
+			greater_data_size = slave_data_size+2;
+		}
+		master_data = new uint8_t[greater_data_size];
+		slave_data = new uint8_t[greater_data_size];
+		master_data[0] = (uint8_t) id;
+		master_data[1] = (uint8_t) (id>>8);
+		slave_data[0] = (uint8_t) id;
+		slave_data[1] = (uint8_t) (id>>8);
+		SPIPacket::SPIPacketsByID[id] = this;
+	}
+
+	SPIPacket(uint16_t id, uint8_t* master_data, uint8_t* slave_data, uint16_t shared_data_size) :
+		id(id), master_data(master_data), master_data_size(shared_data_size), slave_data(slave_data), slave_data_size(shared_data_size){
+		if(id == 0){
+			ErrorHandler("Cannot use 0 as the SPIPacketID, as it is reserved to the no packet ready signal");
+		}
+
+	}
+
+};
+
+

Inc/HALAL/Services/Communication/Ethernet/TCP/ServerSocket.hpp

@@ -15,14 +15,18 @@
 
 #define PBUF_POOL_MEMORY_DESC_POSITION 8
 
+/**
+* @brief ServerSocket class
+*/
 class ServerSocket : public OrderProtocol{
 public:
 
 	enum ServerState{
 		INACTIVE,
 		LISTENING,
 		ACCEPTED,
-		CLOSING
+		CLOSING,
+		CLOSED
 	};
 
 	static unordered_map<uint32_t,ServerSocket*> listening_sockets;
@@ -31,6 +35,7 @@ class ServerSocket : public OrderProtocol{
 	queue<struct pbuf*> rx_packet_buffer;
 	IPV4 local_ip;
 	uint32_t local_port;
+	IPV4 remote_ip;
 	ServerState state;
 	static uint8_t priority;
 	struct tcp_pcb* client_control_block;
@@ -39,16 +44,39 @@ class ServerSocket : public OrderProtocol{
 	ServerSocket();
 	ServerSocket(ServerSocket&& other);
 	ServerSocket(IPV4 local_ip, uint32_t local_port);
-	ServerSocket(string local_ip, uint32_t local_port);
 	ServerSocket(EthernetNode local_node);
 	~ServerSocket();
 
 	void operator=(ServerSocket&& other);
 
+	/**
+	* @brief ends the connection between the server and the client. 
+	*/
 	void close();
 
+	/**
+	* @brief process the data received by the client orders. It is meant to be called only by Lwip on the receive_callback
+	*
+	* reads all the data received by the server in the ethernet buffer, packet by packet.
+	* Then, for each packet, it processes it depending on the order id (default behavior is not process) and removes it from the buffer. 
+	* This makes so the receive_callback (and thus the Socket) can only process declared orders, and ignores all other packets. 
+	*/
 	void process_data();
 
+	/**
+	 * @brief saves the order data into the tx_packet_buffer so it can be sent when a connection is accepted
+	 *
+	 * @param order the order to send, which contains the data and id of the message
+	 * @return true if the data could be allocated in the buffer, false otherwise
+	 */
+	bool add_order_to_queue(Order& order);
+
+	/**
+	 * @brief puts the order data into the tx_packet_buffer and sends all the data in the buffer to the client
+	 *
+	 * @param order the order to send, which contains the data and id of the message
+	 * @return true if the data was sent successfully, false otherwise
+	 */
 	bool send_order(Order& order) override{
 		if(state != ACCEPTED){
 			return false;
@@ -75,8 +103,14 @@ class ServerSocket : public OrderProtocol{
 		return true;
 	}
 
+	/**
+	* @brief sends all the binary data saved in the tx_packet_buffer to the connected client. 
+	*/
 	void send();
 
+	/**
+	* @return true if a connection with the client was established, false otherwise
+	*/
 	bool is_connected();
 
 private: