Merge pull request #293 from HyperloopUPV-H8/development

v2.6.0

Author: alejandrogonzalvo

Inc/C++Utilities/CppUtils.hpp

@@ -66,3 +66,4 @@ using std::vector;
 using std::queue;
 using std::map;
 using std::stringstream;
+using std::move;

Inc/HALAL/Models/Packets/Order.hpp

@@ -27,6 +27,7 @@ class Order : public Packet{
             orders[id]->process();
         }
     }
+
 protected:
     static map<uint16_t,Order*> orders;
 };

Inc/HALAL/Models/Packets/OrderProtocol.hpp

@@ -7,4 +7,7 @@ class OrderProtocol{
 public:
     virtual bool send_order(Order& order) = 0;
     static vector<OrderProtocol*> sockets;
+
+    friend class ServerSocket;
+    friend class Socket;
 };

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

@@ -7,14 +7,15 @@
 #pragma once
 
 #include "Communication/Ethernet/EthernetNode.hpp"
+#include "Communication/Ethernet/Ethernet.hpp"
 #include "Packets/Packet.hpp"
 #include "Packets/Order.hpp"
 #include "Packets/OrderProtocol.hpp"
 #ifdef HAL_ETH_MODULE_ENABLED
 
 #define PBUF_POOL_MEMORY_DESC_POSITION 8
 
-class ServerSocket : OrderProtocol{
+class ServerSocket : public OrderProtocol{
 public:
 
 	enum ServerState{
@@ -36,9 +37,13 @@ class ServerSocket : 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);
 
 	void close();
 

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

@@ -7,14 +7,15 @@
 #pragma once
 
 #include "Communication/Ethernet/EthernetNode.hpp"
+#include "Communication/Ethernet/Ethernet.hpp"
 #include "Packets/Packet.hpp"
 #include "Packets/Order.hpp"
 #include "Packets/OrderProtocol.hpp"
 #ifdef HAL_ETH_MODULE_ENABLED
 
 #define PBUF_POOL_MEMORY_DESC_POSITION 8
 
-class Socket : OrderProtocol{
+class Socket : public OrderProtocol{
 public:
 	enum SocketState{
 		INACTIVE,
@@ -32,11 +33,13 @@ class Socket : OrderProtocol{
 	static unordered_map<EthernetNode,Socket*> connecting_sockets;
 
 	Socket();
+	Socket(Socket&& other);
 	Socket(IPV4 local_ip, uint32_t local_port, IPV4 remote_ip, uint32_t remote_port);
 	Socket(string local_ip, uint32_t local_port, string remote_ip, uint32_t remote_port);
 	Socket(EthernetNode local_node, EthernetNode remote_node);
+	~Socket();
 
-
+	void operator=(Socket&& other);
 	void close();
 
 	void reconnect();
@@ -57,12 +60,12 @@ class Socket : OrderProtocol{
 		}
 
 		uint8_t* order_buffer = order.build();
-		if(order.size > tcp_sndbuf(socket_control_block)){
+		if(order.get_size() > tcp_sndbuf(socket_control_block)){
 			return false;
 		}
 
-		struct pbuf* packet = pbuf_alloc(PBUF_TRANSPORT, order.size, PBUF_POOL);
-		pbuf_take(packet, order_buffer, order.size);
+		struct pbuf* packet = pbuf_alloc(PBUF_TRANSPORT, order.get_size(), PBUF_POOL);
+		pbuf_take(packet, order_buffer, order.get_size());
 		tx_packet_buffer.push(packet);
 		send();
 		return true;

Inc/HALAL/Services/Communication/Ethernet/UDP/DatagramSocket.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "Communication/Ethernet/EthernetNode.hpp"
+#include "Communication/Ethernet/Ethernet.hpp"
 #include "Packets/Packet.hpp"
 
 #ifdef HAL_ETH_MODULE_ENABLED
@@ -15,10 +16,13 @@ class DatagramSocket{
 	uint32_t remote_port;
 
 	DatagramSocket();
+	DatagramSocket(DatagramSocket&& other);
 	DatagramSocket(IPV4 local_ip, uint32_t local_port, IPV4 remote_ip, uint32_t remote_port);
 	DatagramSocket(EthernetNode local_node, EthernetNode remote_node);
 	~DatagramSocket();
 
+	void operator=(DatagramSocket&&);
+
 	bool send(Packet& packet){
 		uint8_t* packet_buffer = packet.build();
 
@@ -30,6 +34,8 @@ class DatagramSocket{
 		return true;
 	}
 
+	void reconnect();
+
 	void close();
 
 private:

Inc/HALAL/Services/Time/Time.hpp

@@ -38,6 +38,7 @@ private :
 		TIM_HandleTypeDef* tim;
 		function<void()> alarm;
 		uint64_t offset;
+		bool is_on = false;
 	};
 
 	static constexpr uint32_t HIGH_PRECISION_MAX_ARR = 4294967295;
@@ -53,10 +54,14 @@ private :
 	static unordered_map<uint8_t, Alarm> low_precision_alarms_by_id;
 	static unordered_map<uint8_t, Alarm> mid_precision_alarms_by_id;
 
+	static stack<uint8_t> low_precision_erasable_ids;
+	static stack<uint8_t> mid_precision_erasable_ids;
+
 	static void stop_timer(TIM_HandleTypeDef* htim);
 	static void start_timer(TIM_HandleTypeDef* htim,uint32_t prescaler, uint32_t period);
 	static void init_timer(TIM_TypeDef* tim, TIM_HandleTypeDef* htim,uint32_t prescaler, uint32_t period, IRQn_Type interrupt_channel);
 	static void ConfigTimer(TIM_HandleTypeDef* tim, uint32_t period_in_us);
+	static bool is_valid_timer(TIM_HandleTypeDef* tim);
 
 public :
 	static TIM_HandleTypeDef* global_timer;

Inc/ST-LIB_HIGH/Control/Blocks/MatrixMultiplier.hpp

@@ -13,18 +13,18 @@ class MatrixMultiplier<U,V,W> : public ControlBlock<float(*)[U][V], float(*)[U][
 	}
 
 	void execute() override{
-	    for (int i = 0; i < U; i++) {
-	        for (int j = 0; j < W; j++) {
+	    for (size_t i = 0; i < U; i++) {
+	        for (size_t j = 0; j < W; j++) {
 	            result[i][j] = 0;
-	            for (int k = 0; k < V; k++)
+	            for (size_t k = 0; k < V; k++)
 	                result[i][j] += A[i][k] * B[k][j];
 	        }
 	    }
 	}
 
 	void reset(){
-	    for (int i = 0; i < U; i++) {
-	        for (int j = 0; j < W; j++)
+	    for (size_t i = 0; i < U; i++) {
+	        for (size_t j = 0; j < W; j++)
 	        	result[i][j] = 0.0;
 	    }
 	}
@@ -46,15 +46,15 @@ class MatrixMultiplier<U,V,1> : public ControlBlock<float(*)[U][V], float(*)[U]>
     }
 
     void execute() override{
-        for (int i = 0; i < U; i++) {
+        for (size_t i = 0; i < U; i++) {
             result[i] = 0;
-            for (int k = 0; k < V; k++)
+            for (size_t k = 0; k < V; k++)
                 result[i] += A[i][k] * B[k];
         }
     }
 
     void reset(){
-    	for(int i = 0; i < U; i++){
+    	for(size_t i = 0; i < U; i++){
     		result[i] = 0.0;
     	}
     }
@@ -76,15 +76,15 @@ class MatrixMultiplier<1,U,V> : public ControlBlock<float(*)[U], float(*)[V]>{
     }
 
     void execute() override{
-        for (int j = 0; j < V; j++) {
+        for (size_t j = 0; j < V; j++) {
             result[j] = 0;
-            for (int k = 0; k < U; k++)
+            for (size_t k = 0; k < U; k++)
                 result[j] += A[k] * B[k][j];
         }
     }
 
     void reset(){
-    	for(int i = 0; i < V; i++){
+    	for(size_t i = 0; i < V; i++){
     		result[i] = 0.0;
     	}
     }
@@ -107,7 +107,7 @@ class MatrixMultiplier<1,U,1> : public ControlBlock<float(*)[U], float(*)>{
 
     void execute() override{
         result = 0;
-        for (int k = 0; k < U; k++)
+        for (size_t k = 0; k < U; k++)
             result += A[k] * B[k];
     }
 

Inc/ST-LIB_HIGH/Control/Blocks/MeanCalculator.hpp

@@ -1,16 +1,20 @@
 #pragma once
 
 #include "../ControlBlock.hpp"
+#include "ErrorHandler/ErrorHandler.hpp"
 template<size_t N>
 class MeanCalculator : public ControlBlock<double,double>{
 public:
     int index = 0;
     double mean = 0.0;
 public:
-    MeanCalculator():ControlBlock<double,double>(0.0){}
+    MeanCalculator():ControlBlock<double,double>(0.0){
+    	output_value = 0.0;
+    }
     void execute() override	{
         mean += input_value/N;
         index++;
+        if(index > N) ErrorHandler("MeanCalculator is receiving just 0");
         if(index == N) output_value = mean;
         else output_value = 0.0;
         return;
@@ -19,4 +23,4 @@ class MeanCalculator : public ControlBlock<double,double>{
         mean = 0.0;
         index = 0;
     }
-};
+};

Inc/ST-LIB_HIGH/Control/Blocks/Zeroing.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include "../ControlBlock.hpp"
+#include "MeanCalculator.hpp"
+#include "Sensors/LinearSensor/LinearSensor.hpp"
+template<class Type, size_t Order>
+class Zeroing : public ControlBlock<Type,Type>{
+public:
+	MeanCalculator<Order> mean_calculator;
+	LinearSensor<Type>& sensor;
+	Type max_value_offset;
+	bool has_max_value = false;
+	Zeroing(LinearSensor<Type>& sensor) : sensor(sensor), mean_calculator(){};
+	Zeroing(LinearSensor<Type>& sensor, Type max_value_offset) : mean_calculator(), sensor(sensor), max_value_offset(max_value_offset), has_max_value(true){};
+	void execute(){
+		while(mean_calculator.output_value == 0){
+			sensor.read();
+			mean_calculator.input(*sensor.get_value_pointer());
+			mean_calculator.execute();
+		}
+		if(has_max_value && abs(mean_calculator.output_value) > max_value_offset) ErrorHandler("Zeroing offset is calculated to be above specified maximum");
+		else sensor.set_offset(sensor.get_offset() - mean_calculator.output_value);
+		mean_calculator.reset();
+	}
+};