pico-tcp-service/pico-tcp-client/.vscode/settings.json

@@ -53,5 +53,10 @@
         "xstddef": "cpp",
         "xtr1common": "cpp"
     },
+<<<<<<< HEAD
+    "C_Cpp.errorSquiggles": "disabled",
+    "python.analysis.autoImportCompletions": true
+=======
     "C_Cpp.errorSquiggles": "disabled"
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 }

pico-tcp-service/pico-tcp-client/main.cpp

@@ -5,6 +5,10 @@
 #include "picofunctions.h"
 #include "pugiconfig.hpp"
 #include "pugixml.hpp"
+<<<<<<< HEAD
+#include "simplecout.hpp"
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 #include "parser.hpp"
 #include "src/ActiveSocket.h"
 
@@ -15,6 +19,15 @@ using namespace std;
 std::vector<std::string> split(const std::string& s, const std::string& delimiter) {
     std::vector<std::string> tokens;
     size_t pos = 0;
+<<<<<<< HEAD
+    std::string token;
+    while ((pos = s.find(delimiter)) != std::string::npos) {
+        token = s.substr(0, pos);
+        tokens.push_back(token);
+        s.erase(0, pos + delimiter.length());
+    }
+    tokens.push_back(s);
+=======
     std::string temp = s;
     std::string token;
     while ((pos = temp.find(delimiter)) != std::string::npos) {
@@ -23,6 +36,7 @@ std::vector<std::string> split(const std::string& s, const std::string& delimite
         temp.erase(0, pos + delimiter.length());
     }
     tokens.push_back(temp);
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 
     return tokens;
 }
@@ -50,7 +64,11 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -59,7 +77,11 @@ class PicoLocalClient
             uint32_t bytes_received = socket->GetBytesReceived();
 
             if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+=======
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -85,7 +107,11 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xC1)
             {
@@ -110,7 +136,11 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -119,7 +149,11 @@ class PicoLocalClient
             uint32_t bytes_received = socket->GetBytesReceived();
 
             if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+=======
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -145,7 +179,11 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xC2)
             {
@@ -154,7 +192,11 @@ class PicoLocalClient
             }
 
             cout << "Pico device configured" << endl;
+<<<<<<< HEAD
+            return 0;            
+=======
             return 0;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         }
 
         int pico_set_params(uint32_t* apoints, uint32_t* times, uint32_t sample_rate, uint32_t number_channels, uint32_t size)
@@ -172,15 +214,26 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            
+            uint32_t bytes_received = socket->GetBytesReceived();
+            if(bytes_received == 0)
+            {  
+=======
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -227,7 +280,215 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
+            {
+                cerr << "Failed to receive data from socket" << endl;
+                return -1;
+            }
+
+            uint32_t bytes_received = socket->GetBytesReceived();
+            if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+                cerr << "Server disconnected" << endl;
+                return -1;
+            }
+            if(bytes_received < 2)
+            {
+                cerr << "Invalid buffer size" << endl;
+                return -1;
+            }
+            if(rcvbuf[0] != 0xAA)
+            {
+                cerr << "Invalid magic number" << endl;
+                return -1;
+            }
+
+            if(rcvbuf[1] == 0xFF)
+            {
+                if(bytes_received < 7)
+                {
+                    cerr << "Invalid buffer size" << endl;
+                    return -1;
+                }
+
+                cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
+                memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
+                memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+            }
+            else if(rcvbuf[1] != 0xC3)
+            {
+                cerr << "Invalid command callback" << endl;
+                return -1;
+            }
+
+            cout << "Pico device closed" << endl;
+            return 0;
+        }
+
+        int pico_get_current_params()
+        {
+            sndbuf[0] = 0xAA;
+            sndbuf[1] = 0x04;
+            if(socket->Send(sndbuf, 2) == -1)
+            {
+                cerr << "Failed to send data to socket" << endl;
+                return -1;
+            }
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+            {
+                cerr << "Failed to receive data from socket" << endl;
+                return -1;
+            }
+
+            uint32_t bytes_received = socket->GetBytesReceived();
+            if(bytes_received == 0)
+            {  
+                cerr << "Server disconnected" << endl;
+                return -1;
+            }
+            if(bytes_received < 2)
+            {
+                cerr << "Invalid buffer size" << endl;
+                return -1;
+            }
+            if(rcvbuf[0] != 0xAA)
+            {
+                cerr << "Invalid magic number" << endl;
+                return -1;
+            }
+
+            if(rcvbuf[1] == 0xFF)
+            {
+                if(bytes_received < 7)
+                {
+                    cerr << "Invalid buffer size" << endl;
+                    return -1;
+                }
+
+                cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
+                memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
+                memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+            }
+            else if(rcvbuf[1] != 0xC4)
+            {
+                cerr << "Invalid command callback" << endl;
+                return -1;
+            }
+
+            if(bytes_received < 18)
+            {
+                cerr << "Invalid buffer size" << endl;
+                return -1;
+            }
+
+            uint32_t size;
+            memcpy(&size, rcvbuf + 2, sizeof(uint32_t));
+            if(size < 1)
+            {
+                cerr << "Invalid data size" << endl;
+                return -1;
+            }
+
+            uint32_t* apoints = new uint32_t[size];
+            memcpy(apoints, rcvbuf + 6, size * sizeof(uint32_t));
+            for(uint32_t i = 0; i < size; ++i)
+            {
+                cout << "apoints[" << i << "] = " << std::dec << apoints[i] << endl;
+            }
+            uint32_t* atimes = new uint32_t[size];
+            memcpy(atimes, rcvbuf + 6 + size * sizeof(uint32_t), size * sizeof(uint32_t));
+            for(uint32_t i = 0; i < size; ++i)
+            {
+                cout << "atimes[" << i << "] = " << std::dec << atimes[i] << endl;
+            }
+
+            uint32_t sample_rate = 0;
+            memcpy(&sample_rate, rcvbuf + 6 + 2 * size * sizeof(uint32_t), sizeof(uint32_t));
+            cout << "sample_rate = " << std::dec << sample_rate << endl;
+
+            uint32_t number_channels = 0;
+            memcpy(&number_channels, rcvbuf + 10 + 2 * size * sizeof(uint32_t), sizeof(uint32_t));
+            cout << "number_channels = " << std::dec << number_channels << endl;
+
+            cout << "Pico device parameters retrieved" << endl;
+            return 0;
+        }
+
+        int pico_probe()
+        {
+            sndbuf[0] = 0xAA;
+            sndbuf[1] = 0x05;
+            if(socket->Send(sndbuf, 2) == -1)
+            {
+                cerr << "Failed to send data to socket" << endl;
+                return -1;
+            }
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+            {
+                cerr << "Failed to receive data from socket" << endl;
+                return -1;
+            }
+
+            uint32_t bytes_received = socket->GetBytesReceived();
+            if(bytes_received == 0)
+            {  
+                cerr << "Server disconnected" << endl;
+                return -1;
+            }
+            if(bytes_received < 2)
+            {
+                cerr << "Invalid buffer size" << endl;
+                return -1;
+            }
+            if(rcvbuf[0] != 0xAA)
+            {
+                cerr << "Invalid magic number" << endl;
+                return -1;
+            }
+
+            if(rcvbuf[1] == 0xFF)
+            {
+                if(bytes_received < 7)
+                {
+                    cerr << "Invalid buffer size" << endl;
+                    return -1;
+                }
+
+                cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
+                memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
+                memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+            }
+            else if(rcvbuf[1] != 0xC5)
+            {
+                cerr << "Invalid command callback" << endl;
+                return -1;
+            }
+
+            cout << "Pico device probe completed" << endl;
+            return 0;            
+        }
+
+        int pico_set_points(uint32_t* points, uint32_t size)
+        {
+            sndbuf[0] = 0xAA;
+            sndbuf[1] = 0x06;
+            memcpy(sndbuf + 2, &size, sizeof(uint32_t));
+            memcpy(sndbuf + 6, points, size * sizeof(uint32_t));
+
+            if(socket->Send(sndbuf, size * sizeof(uint32_t) + 6) == -1)
+            {
+                cerr << "Failed to send data to socket" << endl;
+                return -1;
+            }
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -235,7 +496,67 @@ class PicoLocalClient
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
+            {  
+                cerr << "Server disconnected" << endl;
+                return -1;
+            }
+            if(bytes_received < 2)
             {
+                cerr << "Invalid buffer size" << endl;
+                return -1;
+            }
+            if(rcvbuf[0] != 0xAA)
+            {
+                cerr << "Invalid magic number" << endl;
+                return -1;
+            }
+
+            if(rcvbuf[1] == 0xFF)
+            {
+                if(bytes_received < 7)
+                {
+                    cerr << "Invalid buffer size" << endl;
+                    return -1;
+                }
+
+                cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
+                memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
+                memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+            }
+            else if(rcvbuf[1] != 0xC6)
+            {
+                cerr << "Invalid command callback" << endl;
+                return -1;
+            }
+
+            cout << "Pico device points set" << endl;
+            return 0;
+        }
+
+        int pico_set_sample_rate(uint32_t sample_rate)
+        {
+            sndbuf[0] = 0xAA;
+            sndbuf[1] = 0x07;
+            memcpy(sndbuf + 2, &sample_rate, sizeof(uint32_t));
+
+            if(socket->Send(sndbuf, sizeof(uint32_t) + 6) == -1)
+            {
+                cerr << "Failed to send data to socket" << endl;
+                return -1;
+            }
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+            {
+                cerr << "Failed to receive data from socket" << endl;
+                return -1;
+            }
+
+            uint32_t bytes_received = socket->GetBytesReceived();
+            if(bytes_received == 0)
+            {  
+=======
+            {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -262,13 +583,33 @@ class PicoLocalClient
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+<<<<<<< HEAD
+return 0;                
+            }
+            else if(rcvbuf[1] != 0xC7)
+=======
             }
             else if(rcvbuf[1] != 0xC3)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Invalid command callback" << endl;
                 return -1;
             }
 
+<<<<<<< HEAD
+            cout << "Pico device sample rate set" << endl;
+            return 0;            
+        }
+
+        int pico_set_times(uint32_t* times, uint32_t size)
+        {
+            sndbuf[0] = 0xAA;
+            sndbuf[1] = 0x08;
+            memcpy(sndbuf + 2, &size, sizeof(uint32_t));
+            memcpy(sndbuf + 6, times, size * sizeof(uint32_t));
+
+            if(socket->Send(sndbuf, size * sizeof(uint32_t) + 6) == -1)
+=======
             cout << "Pico device closed" << endl;
             return 0;
         }
@@ -278,11 +619,16 @@ class PicoLocalClient
             sndbuf[0] = 0xAA;
             sndbuf[1] = 0x04;
             if(socket->Send(sndbuf, 2) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -290,7 +636,11 @@ class PicoLocalClient
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+=======
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -316,6 +666,9 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
             }
             else if(rcvbuf[1] != 0xC4)
@@ -581,6 +934,7 @@ class PicoLocalClient
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xC8)
             {
@@ -589,7 +943,11 @@ class PicoLocalClient
             }
 
             cout << "Pico device times set" << endl;
+<<<<<<< HEAD
+            return 0;            
+=======
             return 0;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         }
 
         int pico_configure_channels(const uint32_t number_channels, uint8_t trigger_channel, int32_t direction, uint16_t threshold, int16_t autoTrigger_ms)
@@ -607,7 +965,11 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -615,7 +977,11 @@ class PicoLocalClient
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+=======
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -641,7 +1007,11 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xC9)
             {
@@ -650,7 +1020,11 @@ class PicoLocalClient
             }
 
             cout << "Pico device channels configured" << endl;
+<<<<<<< HEAD
+            return 0;            
+=======
             return 0;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         }
 
         int pico_begin_measurement()
@@ -663,15 +1037,26 @@ class PicoLocalClient
                 return -1;
             }
 
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            
+            uint32_t bytes_received = socket->GetBytesReceived();
+            if(bytes_received == 0)
+            {  
+=======
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -697,7 +1082,11 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xCA)
             {
@@ -707,17 +1096,27 @@ class PicoLocalClient
             cout << "Pico device measurement started" << endl;
             cout << "Measurement in progress..." << endl;
 
+<<<<<<< HEAD
+            while(rcvbuf[1] != 0xCB)
+            {
+                if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             bool end_of_data = false;
             while(!end_of_data)
             {
                 if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 {
                     cerr << "Failed to receive data from socket" << endl;
                     return -1;
                 }
                 bytes_received = socket->GetBytesReceived();
                 if(bytes_received == 0)
+<<<<<<< HEAD
+                {  
+=======
                 {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                     cerr << "Server disconnected" << endl;
                     return -1;
                 }
@@ -743,6 +1142,11 @@ class PicoLocalClient
                     cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                     memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                     memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                    cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+                }
+                else if(rcvbuf[1] != 0xCA)
+=======
                     cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
                 }
 
@@ -756,6 +1160,7 @@ class PicoLocalClient
                     cout << "Measurement in progress..." << endl;
                 }
                 else
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 {
                     cerr << "Invalid command callback" << endl;
                     return -1;
@@ -777,7 +1182,11 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -785,7 +1194,11 @@ class PicoLocalClient
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+=======
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -799,7 +1212,11 @@ class PicoLocalClient
                 cerr << "Invalid magic number" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            
+=======
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             if(rcvbuf[1] == 0xFF)
             {
                 if(bytes_received < 7)
@@ -811,7 +1228,11 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xCE)
             {
@@ -832,7 +1253,11 @@ class PicoLocalClient
                 cerr << "Failed to send data to socket" << endl;
                 return -1;
             }
+<<<<<<< HEAD
+            if(socket->Receive(rcvbuf, sizeof(rcvbuf)) == -1)
+=======
             if(socket->Receive(MAX_PACKET, rcvbuf) == -1)
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             {
                 cerr << "Failed to receive data from socket" << endl;
                 return -1;
@@ -840,7 +1265,11 @@ class PicoLocalClient
 
             uint32_t bytes_received = socket->GetBytesReceived();
             if(bytes_received == 0)
+<<<<<<< HEAD
+            {  
+=======
             {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 cerr << "Server disconnected" << endl;
                 return -1;
             }
@@ -866,7 +1295,11 @@ class PicoLocalClient
                 cerr << "Error at ADC: " << std::hex << rcvbuf[2] << endl;
                 memcpy(&error_state, rcvbuf + 2, sizeof(uint8_t));
                 memcpy(&error_code, rcvbuf + 3, sizeof(uint32_t));
+<<<<<<< HEAD
+                cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;                
+=======
                 cerr << "Error code: " << std::hex << error_code << " " << return_fun(error_code) << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             }
             else if(rcvbuf[1] != 0xCD)
             {
@@ -880,27 +1313,43 @@ class PicoLocalClient
 
         int get_command()
         {
+<<<<<<< HEAD
+            if(socket->Receive(sndbuf, sizeof(sndbuf)) != 0)
+            {
+                std::getline(std::cin, line_edit);
+=======
             if(true)
             {
                 cout << "cmd$ ";
                 std::getline(std::cin, line_edit);
                 cout << endl;
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 tokens = split(line_edit, " ");
 
                 if(tokens.size() < 1)
                 {
                     cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+                    return -1;
+                }
+
+                if(tokens[0] = "open")
+=======
                     cout << endl;
                     return -1;
                 }
 
                 if(tokens[0] == "open")
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 {
                     if(pico_open() != 0)
                     {
                         cerr << "Failed to open pico device" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -909,13 +1358,19 @@ class PicoLocalClient
                     if(tokens.size() < 2)
                     {
                         cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                     if(pico_xml_config(tokens[1]) != 0)
                     {
                         cerr << "Failed to configure pico device" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -924,12 +1379,25 @@ class PicoLocalClient
                     if(tokens.size() < 5)
                     {
                         cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
 
                     std::vector<uint32_t> points;
                     std::vector<uint32_t> times;
+<<<<<<< HEAD
+                    uint32_t sample_rate = std::stoi(tokens[2]);
+                    uint32_t number_channels = std::stoi(tokens[3]);
+                    uint32_t size = std::stoi(tokens[4]);
+                    points = string_to_vector(points);
+                    times = string_to_vector(times);
+                    if(points.size() != size || times.size() != size)
+                    {
+                        cerr << "Invalid data size" << endl;
+=======
 
                     points = string_to_vector(tokens[1]);
                     times = string_to_vector(tokens[2]);
@@ -941,12 +1409,16 @@ class PicoLocalClient
                     {
                         cerr << "Invalid data size" << endl;
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                     if(pico_set_params(points.data(), times.data(), sample_rate, number_channels, size) != 0)
                     {
                         cerr << "Failed to set pico device parameters" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                     return 0;
@@ -956,7 +1428,10 @@ class PicoLocalClient
                     if(pico_close() != 0)
                     {
                         cerr << "Failed to close pico device" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -965,7 +1440,10 @@ class PicoLocalClient
                     if(pico_exit() != 0)
                     {
                         cerr << "Failed to exit pico device" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
 
@@ -976,7 +1454,10 @@ class PicoLocalClient
                     if(pico_get_current_params() != 0)
                     {
                         cerr << "Failed to get pico device parameters" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -985,7 +1466,10 @@ class PicoLocalClient
                     if(pico_probe() != 0)
                     {
                         cerr << "Failed to probe pico device" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -994,6 +1478,16 @@ class PicoLocalClient
                     if(tokens.size() < 3)
                     {
                         cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+                        return -1;
+                    }
+
+                    uint32_t size = std::stoi(tokens[2]);
+                    std::vector<uint32_t> points = string_to_vector(points);
+                    if(points.size() != size)
+                    {
+                        cerr << "Invalid data size" << endl;
+=======
                         cout << endl;
                         return -1;
                     }
@@ -1005,12 +1499,16 @@ class PicoLocalClient
                     {
                         cerr << "Invalid data size" << endl;
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                     if(pico_set_points(points.data(), size) != 0)
                     {
                         cerr << "Failed to set pico device points" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -1019,7 +1517,10 @@ class PicoLocalClient
                     if(tokens.size() < 2)
                     {
                         cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
 
@@ -1027,7 +1528,10 @@ class PicoLocalClient
                     if(pico_set_sample_rate(sample_rate) != 0)
                     {
                         cerr << "Failed to set pico device sample rate" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -1036,6 +1540,16 @@ class PicoLocalClient
                     if(tokens.size() < 3)
                     {
                         cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+                        return -1;
+                    }
+
+                    uint32_t size = std::stoi(tokens[2]);
+                    std::vector<uint32_t> times = string_to_vector(times);
+                    if(times.size() != size)
+                    {
+                        cerr << "Invalid data size" << endl;
+=======
                         cout << endl;
                         return -1;
                     }
@@ -1046,12 +1560,16 @@ class PicoLocalClient
                     {
                         cerr << "Invalid data size" << endl;
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                     if(pico_set_times(times.data(), size) != 0)
                     {
                         cerr << "Failed to set pico device times" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -1060,7 +1578,10 @@ class PicoLocalClient
                     if(tokens.size() < 6)
                     {
                         cerr << "Invalid command" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                     uint32_t number_channels = std::stoi(tokens[1]); // number of channels (1-8)
@@ -1071,7 +1592,10 @@ class PicoLocalClient
                     if(pico_configure_channels(number_channels, trigger_channel, direction, threshold, autoTrigger_ms) != 0)
                     {
                         cerr << "Failed to configure pico device channels" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -1080,7 +1604,10 @@ class PicoLocalClient
                     if(pico_begin_measurement() != 0)
                     {
                         cerr << "Failed to begin pico device measurement" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -1089,7 +1616,10 @@ class PicoLocalClient
                     if(pico_stop() != 0)
                     {
                         cerr << "Failed to stop pico device measurement" << endl;
+<<<<<<< HEAD
+=======
                         cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                         return -1;
                     }
                 }
@@ -1117,26 +1647,72 @@ class PicoLocalClient
                 else
                 {
                     cerr << "Unknown command" << endl;
+<<<<<<< HEAD
+=======
                     cout << endl;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                     return -1;
                 }
             }
 
+<<<<<<< HEAD
+            return 0;
+        }
+}
+=======
             cout << endl;
 
             return 0;
         }
 };
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 
 int main()
 {
     cout << "Open socket" << endl;
+<<<<<<< HEAD
+    CPassiveSocket SocketPassive(CSimpleSocket::CSocketType::SocketTypeTcp);
+    if (!SocketPassive.Initialize())
+=======
     CActiveSocket SocketActive(CSimpleSocket::CSocketType::SocketTypeTcp);
     if (!SocketActive.Initialize())
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     {
         cerr << "Socket initialization failed" << endl;
         return -1;
     }
+<<<<<<< HEAD
+    if(!SocketPassive.Listen("localhost", 5002))
+    {
+        cerr << "Socket listening failed" << endl;
+        return -1;
+    }
+
+    CActiveSocket* ClientSocket;
+
+    while(true)
+    {
+        if ((ClientSocket = SocketPassive.Accept()) != nullptr)
+        {
+            cerr << "Socket accept failed" << endl;
+            return -1;
+        }
+
+        cout << LogPref::Flag(INFO) << "Client connected" << endl;
+        pico_service = new PicoLocalService(ClientSocket);
+
+        while(pico_service->get_request() != 0)
+        {
+            cout << LogPref::Flag(INFO) << "Request received" << endl;
+        }
+
+        cout << LogPref::Flag(INFO) << "Request processing finished" << endl;
+        delete pico_service;
+        pico_service = nullptr;
+
+        delete ClientSocket;
+        ClientSocket = nullptr;
+=======
     if(!SocketActive.Open("127.0.0.1", 5003))
     {
         cerr << "Socket opening failed" << endl;
@@ -1147,6 +1723,7 @@ int main()
 
     while(pico_client.get_command() != 1) {
         // empty
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     }
 
     return 0;

pico-tcp-service/pico-tcp-client/pico-tcp.cbp

@@ -70,6 +70,13 @@
 		<Unit filename="src/SimpleSocket.cpp" />
 		<Unit filename="src/SimpleSocket.h" />
 		<Unit filename="src/StatTimer.h" />
+<<<<<<< HEAD
+		<Unit filename="src/requests.cpp" />
+		<Unit filename="src/requests.h" />
+		<Unit filename="src/simplelogger.cpp" />
+		<Unit filename="src/simplelogger.hpp" />
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 		<Extensions>
 			<lib_finder disable_auto="1" />
 		</Extensions>

pico-tcp-service/pico-tcp-client/pico-tcp.depend

@@ -184,6 +184,8 @@
 	<sys/stat.h>
 	<unistd.h>
 
+<<<<<<< HEAD
+=======
 1732277880 source:c:\lf_mri\pico-tcp-service\pico-tcp-client\parser.cpp
 	"parser.hpp"
 
@@ -514,3 +516,4 @@
 1741610104 source:c:\lf_mri\lowfield_mri_programs\pico-tcp-service\pico-tcp-client\src\simplesocket.cpp
 	"SimpleSocket.h"
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99

pico-tcp-service/pico-tcp-client/pico-tcp.layout

@@ -2,6 +2,16 @@
 <CodeBlocks_layout_file>
 	<FileVersion major="1" minor="0" />
 	<ActiveTarget name="Debug" />
+<<<<<<< HEAD
+	<File name="src\simplelogger.hpp" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="12" />
+		</Cursor>
+	</File>
+	<File name="main.cpp" open="1" top="1" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="0" />
+=======
 	<File name="main.cpp" open="1" top="1" tabpos="1" split="0" active="1" splitpos="0" zoom_1="-2" zoom_2="0">
 		<Cursor>
 			<Cursor1 position="31933" topLine="266" />
@@ -25,6 +35,7 @@
 	<File name="picofunctions.cpp" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
 			<Cursor1 position="11126" topLine="288" />
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 		</Cursor>
 	</File>
 </CodeBlocks_layout_file>

pico-tcp-service/pico-tcp-client/src/simplelogger.cpp

@@ -107,7 +107,10 @@ SimpleLogger::SimpleLogger(const SimpleLogger& other) : log_stream(other.log_str
 
 void SimpleLogger::closeLogger()
 {
+<<<<<<< HEAD
+=======
     this->log_stream.rdbuf(cout.rdbuf());
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     this->file_stream.close();
 }
 

pico-tcp-service/pico-tcp/main.cpp

@@ -27,9 +27,18 @@ private:
     int32_t points_value = 0;
     uint32_t sample_rate = 0;
     std::vector<uint32_t> times;
+<<<<<<< HEAD
+    uint32_t num_triggers = 0;
     uint32_t number_channels = 0;
     std::vector<PS4000A_CHANNEL> channels;
     std::vector<uint32_t> points_vector;
+    uint32_t points_simple = 0;
+    uint32_t premeasurement_percentage = 0;
+=======
+    uint32_t number_channels = 0;
+    std::vector<PS4000A_CHANNEL> channels;
+    std::vector<uint32_t> points_vector;
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     PS4000A_CONDITION* conditions;
     PS4000A_CHANNEL trig_channel = PS4000A_CHANNEL_A;
     PS4000A_THRESHOLD_DIRECTION th_direction = PS4000A_ABOVE;
@@ -38,6 +47,10 @@ private:
     int16_t trig_autoTrigger_ms = 0;
     uint32_t nbytes_sent = 0;
     std::vector<std::vector<int16_t*>> data_buffer_vec;
+<<<<<<< HEAD
+    std::vector<int16_t*> simple_data_buffer;
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 
     uint8_t rcbuf[MAX_PACKET]{0};
     uint8_t sndbuf[MAX_PACKET]{0};
@@ -318,7 +331,11 @@ public:
             {
                 this->last_command = 0x09;
                 logger << LogPref::Flag(INFO) << "Command 0x09 received" << endl;
+<<<<<<< HEAD
+                if(bytes_recieved < 16) {
+=======
                 if(bytes_recieved < 15) {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                     logger << LogPref::Flag(ERROR) << "Invalid buffer size" << endl;
                     sndbuf[0] = magic_number;
                     sndbuf[1] = 0xFF;
@@ -332,6 +349,32 @@ public:
                 }
                 uint32_t channels = 0;
                 memcpy(&channels, rcbuf + 2, sizeof(uint32_t));
+<<<<<<< HEAD
+                if(channels < 1 || channels > 16) {
+                    logger << LogPref::Flag(ERROR) << "Invalid number of channels" << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x02;
+                    this->error_code = 0x00000000;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+                enPicoConnectProbeRange* channels_range = new enPicoConnectProbeRange[channels];
+                memset(channels_range, PICO_X1_PROBE_5V, sizeof(uint8_t) * channels);
+                memcpy(channels_range, rcbuf + 6, sizeof(uint8_t) * channels);
+                uint8_t trigger_channel = 0;
+                memcpy(&trigger_channel, rcbuf + 6 + channels, sizeof(uint8_t));
+                int32_t direction = 0;
+                memcpy(&direction, rcbuf + 7 + channels, sizeof(int32_t));
+                uint16_t threshold = 0;
+                memcpy(&threshold, rcbuf + 11 + channels, sizeof(uint16_t));
+                int16_t autoTrigger_ms = 0;
+                memcpy(&autoTrigger_ms, rcbuf + 13, sizeof(int16_t));
+                pico_configure_channels(channels, channels_range, trigger_channel, direction, threshold, autoTrigger_ms);
+=======
                 uint8_t trigger_channel = 0;
                 memcpy(&trigger_channel, rcbuf + 6, sizeof(uint8_t));
                 int32_t direction = 0;
@@ -341,6 +384,7 @@ public:
                 int16_t autoTrigger_ms = 0;
                 memcpy(&autoTrigger_ms, rcbuf + 13, sizeof(int16_t));
                 pico_configure_channels(channels, trigger_channel, direction, threshold, autoTrigger_ms);
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 logger << LogPref::Flag(INFO) << "Pico device channels configured" << endl;
                 break;
             }
@@ -348,7 +392,11 @@ public:
             {
                 this->last_command = 0x0A;
                 logger << LogPref::Flag(INFO) << "Command 0x0A received" << endl;
+<<<<<<< HEAD
+                pico_begin_measurement_times();
+=======
                 pico_begin_measurement();
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 logger << LogPref::Flag(INFO) << "Pico device measurement started" << endl;
                 break;
             }
@@ -373,6 +421,127 @@ public:
                 logger << LogPref::Flag(INFO) << "Pico device stopped" << endl;
                 break;
             }
+<<<<<<< HEAD
+            case 0x20:
+            {
+                this->last_command = 0x20;
+                logger << LogPref::Flag(INFO) << "Command 0x0F received" << endl;
+                if(bytes_recieved < 12) {
+                    logger << LogPref::Flag(ERROR) << "Invalid buffer size" << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x01;
+                    this->error_code = 0x00000000;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+                uint32_t trigger_channel = 0;
+                memcpy(&trigger_channel, rcbuf + 2, sizeof(uint32_t));
+                int32_t direction = 0;
+                memcpy(&direction, rcbuf + 6, sizeof(int32_t));
+                uint16_t threshold = 0;
+                memcpy(&threshold, rcbuf + 10, sizeof(uint16_t));
+                int16_t autoTrigger_ms = 0;
+                memcpy(&autoTrigger_ms, rcbuf + 12, sizeof(int16_t));
+
+                pico_configure_trigger(trigger_channel, direction, threshold, autoTrigger_ms);
+                break;
+            }
+            case 0x28:
+            {
+                this->last_command = 0x28;
+                logger << LogPref::Flag(INFO) << "Command 0x28 received" << endl;
+                if(bytes_recieved < 6) {
+                    logger << LogPref::Flag(ERROR) << "Invalid buffer size" << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x01;
+                    this->error_code = 0x00000000;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+                uint32_t percentage = 0;
+                memcpy(&percentage, rcbuf + 2, sizeof(uint32_t));
+                if(percentage < 0 || percentage > 100) {
+                    logger << LogPref::Flag(ERROR) << "Invalid premeasurement percentage" << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x02;
+                    this->error_code = 0x00000000;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+                pico_set_premeasurement(percentage);
+                break;
+            }
+            case 0x2B:
+            {
+                this->last_command = 0x2B;
+                logger << LogPref::Flag(INFO) << "Command 0x2B received" << endl;
+                pico_simple_measure();
+                break;
+            }
+            case 0x17:
+            {
+                this->last_command = 0x17;
+                logger << LogPref::Flag(INFO) << "Command 0x17 received" << endl;
+                if(bytes_recieved < 6) {
+                    logger << LogPref::Flag(ERROR) << "Invalid buffer size" << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x01;
+                    this->error_code = 0x00000000;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+                uint32_t points = 0;
+                memcpy(&points, rcbuf + 2, sizeof(uint32_t));
+                pico_set_simple_points(points);
+                break;
+            }
+            case 0x19:
+            {
+                this->last_command = 0x19;
+                logger << LogPref::Flag(INFO) << "Command 0x19 received" << endl;
+                if(bytes_recieved < 6) {
+                    logger << LogPref::Flag(ERROR) << "Invalid buffer size" << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x01;
+                    this->error_code = 0x00000000;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+                uint32_t num_trigger = 0;
+                memcpy(&num_trigger, rcbuf + 2, sizeof(uint32_t));
+                pico_set_num_trigger(num_trigger);
+                break;
+            }
+            case 0x1B:
+            {
+                this->last_command = 0x1B;
+                logger << LogPref::Flag(INFO) << "Command 0x1B received" << endl;
+                pico_multitrigger_measure();
+                break;
+            }
+
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             default:
             {
                 this->last_command = 0xFF;
@@ -470,6 +639,10 @@ public:
         return 0;
     }
 
+<<<<<<< HEAD
+    // To be deprecated in future versions
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     int pico_xml_config(const string& file_name) {
         // Load configuration from XML file
         auto data_set = parse_xml_function(file_name.c_str());
@@ -491,6 +664,10 @@ public:
         return 0;
     }
 
+<<<<<<< HEAD
+    // Deprecated function, use other functions instead
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     int pico_set_params(const uint32_t* points, const uint32_t* times, const uint32_t sample_rate, const uint32_t number_channels, const uint32_t size) {
         // Set parameters for measurement
         this->points_vector.assign(points, points + size);
@@ -552,6 +729,13 @@ public:
 
         sndbuf[0] = magic_number;
         sndbuf[1] = 0xC4;
+<<<<<<< HEAD
+
+        memcpy(sndbuf + 2, points_vector.data(), sizeof(points_vector.data()));
+        memcpy(sndbuf + 2 + sizeof(points_vector.data()), times.data(), sizeof(times.data()));
+        memcpy(sndbuf + 2 + sizeof(points_vector.data()) + sizeof(times.data()), &sample_rate, sizeof(sample_rate));
+        memcpy(sndbuf + 6 + sizeof(points_vector.data()) + sizeof(times.data()), &number_channels, sizeof(number_channels));
+=======
         uint32_t bsize = points_vector.size() * sizeof(uint32_t);
         uint32_t test = 0;
 
@@ -563,6 +747,7 @@ public:
         logger << LogPref::Flag(INFO) << times.data()[0] << endl;
         memcpy(sndbuf + 6 + 2 * bsize, &sample_rate, sizeof(sample_rate));
         memcpy(sndbuf + 10 + 2 * bsize, &number_channels, sizeof(number_channels));
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 
         if(SocketActive->Send(sndbuf, 10 + sizeof(points_vector.data()) + sizeof(times.data())) == -1) {
             logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
@@ -604,6 +789,25 @@ public:
         return 0;
     }
 
+<<<<<<< HEAD
+    int pico_set_simple_points(const uint32_t points) {
+        // Set simple points for measurement
+        this->points_simple = points;
+        logger << LogPref::Flag(INFO) << "Simple points set to: " << points << endl;
+
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xD7;
+
+        if(SocketActive->Send(sndbuf, 2) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+
+        return 0;
+    }
+
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     int pico_set_sample_rate(const uint32_t sample_rate) {
         // Set sample rate for measurement
         this->sample_rate = sample_rate;
@@ -636,7 +840,26 @@ public:
         return 0;
     }
 
+<<<<<<< HEAD
+    int pico_set_num_trigger(const uint32_t num_trigger) {
+        // Set number of channels for trigger
+        this->num_triggers = num_trigger;
+        logger << LogPref::Flag(INFO) << "Number of triggers set to: " << num_trigger << endl;
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xD9;
+        memcpy(sndbuf + 2, &num_triggers, sizeof(uint32_t));
+        if(SocketActive->Send(sndbuf, 6) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+        logger << LogPref::Flag(INFO) << "Data sent to socket" << endl;
+        return 0;
+    }
+
+    int pico_configure_channels(const uint32_t number_channels, enPicoConnectProbeRange* channel_ranges, uint8_t trigger_channel, int32_t direction, uint16_t threshold, int16_t autoTrigger_ms) {
+=======
     int pico_configure_channels(const uint32_t number_channels, uint8_t trigger_channel, int32_t direction, uint16_t threshold, int16_t autoTrigger_ms) {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         // Set number of channels for measurement
         this->number_channels = number_channels;
         logger << LogPref::Flag(INFO) << "Number of channels set to: " << number_channels << endl;
@@ -648,7 +871,11 @@ public:
             conditions[i].condition = PS4000A_CONDITION_FALSE;
         }
 
+<<<<<<< HEAD
+        if(auto retval = ps4000aSetChannel(handle, channels[trigger_channel], true, PS4000A_DC, channel_ranges[trigger_channel], 0) != 0) {
+=======
         if(auto retval = ps4000aSetChannel(handle, channels[trigger_channel], true, PS4000A_DC, PICO_X1_PROBE_5V, 0) != 0) {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
             logger << LogPref::Flag(ERROR) << "Failed to set trigger channel. Code: " << retval << endl;
             sndbuf[0] = magic_number;
             sndbuf[1] = 0xFF;
@@ -671,7 +898,11 @@ public:
         for(uint8_t i = 0; i < number_channels; ++i) {
             if(i == trigger_channel) continue;
             else {
+<<<<<<< HEAD
+                auto retval = ps4000aSetChannel(handle, channels[i], true, PS4000A_AC, channel_ranges[i], 0);
+=======
                 auto retval = ps4000aSetChannel(handle, channels[i], true, PS4000A_AC, PICO_X1_PROBE_5V, 0);
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
                 if (retval != 0) {
                     logger << LogPref::Flag(ERROR) << "Failed to set channel " << i << ". Code: " << retval << endl;
                     sndbuf[0] = magic_number;
@@ -723,7 +954,12 @@ public:
         return 0;
     }
 
+<<<<<<< HEAD
+    // To be deprecated in future versions
+    int pico_begin_measurement_times() {
+=======
     int pico_begin_measurement() {
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         // Begin measurement on Pico device
 
         data_buffer_vec.assign(times.size(), std::vector<int16_t*>(number_channels, nullptr));
@@ -856,11 +1092,23 @@ public:
             std::string filename = "data" + std::to_string(i) + ".csv";
             writing_data_fixed_name(filename, data_buffer_vec[i], points_vector[i], number_channels);
             logger << LogPref::Flag(INFO) << "Data collection done" << endl;
+<<<<<<< HEAD
+        }
+
+        logger << LogPref::Flag(INFO) << "Free buffers" << endl;
+        for(uint8_t j = 0; j < times.size(); ++j)
+        {
+            free_buffers(data_buffer_vec[j]);
+        }
+        logger << LogPref::Flag(INFO) << "Buffers freed" << endl;
+
+=======
             logger << LogPref::Flag(INFO) << "Free buffers? Why?" << endl;
             free_buffers(data_buffer_vec[i]);
             logger << LogPref::Flag(INFO) << "Buffers freed" << endl;
         }
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         logger << LogPref::Flag(INFO) << "Measurement done" << endl;
         sndbuf[0] = magic_number;
         sndbuf[1] = 0xCB;
@@ -869,14 +1117,21 @@ public:
             logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
             return -1;
         }
+<<<<<<< HEAD
+=======
 
 
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         logger << LogPref::Flag(INFO) << "Data sent to socket" << endl;
 
         return 0;
     }
+<<<<<<< HEAD
+    
+=======
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     int pico_exit() {
         // Exit Pico device and free resources
         if (handle != NULL) {
@@ -907,12 +1162,386 @@ public:
 
         return 0;
     }
+<<<<<<< HEAD
+
+    int pico_configure_trigger(int8_t trigger_channel, int32_t direction, uint16_t threshold, int16_t autoTrigger_ms) {
+        // Configure trigger for Pico device
+        this->trig_channel = channels[trigger_channel];
+        this->th_direction = static_cast<PS4000A_THRESHOLD_DIRECTION>(direction);
+        this->trig_delay = 10;
+        this->threshold = threshold;
+        this->trig_autoTrigger_ms = autoTrigger_ms;
+
+        logger << LogPref::Flag(INFO) << "Trigger configured" << endl;
+
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xC9;
+
+        if(SocketActive->Send(sndbuf, 2) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+        
+        auto retval = ps4000aSetSimpleTrigger
+        (
+         handle,
+         true,
+         channels[trigger_channel],
+         this->threshold,
+         this->th_direction,
+         this->trig_delay,
+         this->trig_autoTrigger_ms
+        );
+
+        if (retval != 0) {
+            logger << LogPref::Flag(ERROR) << "Failed to set trigger. Code: " << retval << endl;
+            sndbuf[0] = magic_number;
+            sndbuf[1] = 0xFF;
+            sndbuf[2] = 0x16;
+            this->error_code = retval;
+            memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+            if(SocketActive->Send(sndbuf, 7) == -1) {
+                logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            }
+            return -1;
+        }
+
+        logger << LogPref::Flag(INFO) << "Trigger set successfully" << endl;\
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xE0;
+        if(SocketActive->Send(sndbuf, 2) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+        return 0;
+    }
+
+    int pico_simple_measure()
+    {
+        simple_data_buffer = std::vector<int16_t*>(number_channels, nullptr);
+
+        logger << LogPref::Flag(INFO) << "Set simple data buffer:" << endl;
+        for(size_t j = 0; j < number_channels; ++j) {
+            simple_data_buffer[j] = new int16_t[points_simple];
+        }
+
+        logger << LogPref::Flag(INFO) << "Get timebase:" << endl;\
+        uint32_t timebase = timebase_choice(sample_rate);
+        logger << "Timebase = " << timebase << endl;
+        int32_t timeIntervalNanoseconds = 0;
+        int32_t maxSamples = 0;
+        int32_t segmentIndex = 0;
+
+        int32_t retval = ps4000aGetTimebase(handle, timebase, points_simple, &timeIntervalNanoseconds,
+                                            &maxSamples, segmentIndex);
+        logger << "retval: " << retval << endl;
+        if(retval != 0) {
+            logger << LogPref::Flag(ERROR) << "Failed to get timebase. Code: " << retval << endl;
+            sndbuf[0] = magic_number;
+            sndbuf[1] = 0xFF;
+            sndbuf[2] = 0x17;
+            this->error_code = retval;
+            memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+            if(SocketActive->Send(sndbuf, 7) == -1) {
+                logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            }
+            return -1;
+        }
+
+        logger << LogPref::Flag(INFO) << "Run block:" << endl;
+        int32_t noOfPreTriggerSamples = (int32_t) (points_simple * premeasurement_percentage / 100.0f);
+        int32_t noOfPostTriggerSamples = points_simple;
+        retval = ps4000aRunBlock(handle, noOfPreTriggerSamples, noOfPostTriggerSamples, timebase,
+                                  nullptr, segmentIndex, nullptr, nullptr);
+        logger << "retval: " << retval << endl;
+
+        if(retval != 0) {
+            logger << LogPref::Flag(ERROR) << "Failed to run block. Code: " << retval << endl;
+            sndbuf[0] = magic_number;
+            sndbuf[1] = 0xFF;
+            sndbuf[2] = 0x18;
+            this->error_code = retval;
+            memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+            if(SocketActive->Send(sndbuf, 7) == -1) {
+                logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            }
+            return -1;
+        }
+
+        logger << LogPref::Flag(INFO) << "Run block done" << endl;
+
+        int16_t ready = 0;
+        while (ready == 0) {
+            retval = ps4000aIsReady(handle, &ready);
+        }
+
+        for(uint8_t j = 0; j < number_channels; ++j) {
+            logger << LogPref::Flag(INFO) << "Set simple data buffer for channel " << j << endl;
+            PS4000A_RATIO_MODE mode = PS4000A_RATIO_MODE_NONE;
+            retval = ps4000aSetDataBuffer(handle, channels[j], simple_data_buffer[j], points_simple,
+                                          segmentIndex, mode);
+            logger << "retval: " << retval << endl;
+            if(retval != 0) {
+                logger << LogPref::Flag(ERROR) << "Failed to set data buffer for channel " << j << ". Code: " << retval << endl;
+                sndbuf[0] = magic_number;
+                sndbuf[1] = 0xFF;
+                sndbuf[2] = 0x19 + j;
+                this->error_code = retval;
+                memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                if(SocketActive->Send(sndbuf, 7) == -1) {
+                    logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                }
+                return -1;
+            }
+        }
+
+        logger << LogPref::Flag(INFO) << "Set simple data buffer done" << endl;
+        logger << LogPref::Flag(INFO) << "Data collection start" << endl;
+        uint32_t StartIndex = 0;
+        uint32_t noOfSamples = static_cast<uint32_t>(points_simple);
+        int16_t overflow = 0;
+        uint32_t DownSampleRatio = 1;
+        retval = ps4000aGetValues(handle, StartIndex, &noOfSamples, DownSampleRatio, PS4000A_RATIO_MODE_NONE,
+                                  segmentIndex, &overflow);
+        logger << "retval: " << retval << endl;
+        if(retval != 0) {
+            logger << LogPref::Flag(ERROR) << "Failed to get values. Code: " << retval << endl;
+            sndbuf[0] = magic_number;
+            sndbuf[1] = 0xFF;
+            sndbuf[2] = 0x20;
+            this->error_code = retval;
+            memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+            if(SocketActive->Send(sndbuf, 7) == -1) {
+                logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            }
+            return -1;
+        }
+        logger << LogPref::Flag(INFO) << "Data collection done" << endl;
+
+        std::string filename = "simple_data_channel.csv";
+        writing_data_fixed_name(filename, simple_data_buffer, points_simple, 1);
+
+        logger << LogPref::Flag(INFO) << "Free simple data buffers" << endl;
+        for(uint8_t j = 0; j < number_channels; ++j)
+        {
+            delete[] simple_data_buffer[j];
+            simple_data_buffer[j] = nullptr;
+        }
+        logger << LogPref::Flag(INFO) << "Simple data buffers freed" << endl;
+
+        logger << LogPref::Flag(INFO) << "Simple measurement done" << endl;
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xEB;
+        if(SocketActive->Send(sndbuf, 2) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+
+        logger << LogPref::Flag(INFO) << "Data sent to socket" << endl;
+        return 0;
+    }
+
+    int pico_set_premeasurement(uint32_t percentage)
+    {
+        // Set pre-measurement percentage
+        this->premeasurement_percentage = percentage;
+        logger << LogPref::Flag(INFO) << "Pre-measurement percentage set to: " << percentage << "%" << endl;
+
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xE8;
+
+        if(SocketActive->Send(sndbuf, 2) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+
+        return 0;
+    }
+
+    int pico_multitrigger_measure()
+    {
+        // Multi-trigger measurement
+        logger << LogPref::Flag(INFO) << "Multi-trigger measurement started" << endl;
+
+        data_buffer_vec = std::vector<std::vector<int16_t*>>(num_triggers, std::vector<int16_t*>(number_channels, nullptr));
+        for(size_t i = 0; i < num_triggers; ++i) {
+            data_buffer_vec[i].assign(number_channels, nullptr);
+            for(size_t j = 0; j < number_channels; ++j) {
+                data_buffer_vec[i][j] = new int16_t[points_value];
+            }
+        }
+
+        for(size_t i = 0; i < num_triggers; ++i) {
+            logger << LogPref::Flag(INFO) << "Set data buffer for trigger " << i << ":" << endl;
+            for(size_t j = 0; j < number_channels; ++j) {
+                data_buffer_vec[i][j] = new int16_t[points_value];
+            }
+
+            logger << LogPref::Flag(INFO) << "Get timebase:" << endl;
+            uint32_t timebase = timebase_choice(sample_rate);
+            logger << "Timebase = " << timebase << endl;
+
+            int32_t timeIntervalNanoseconds = 0;
+            int32_t maxSamples = 0;
+            int32_t segmentIndex = 0;
+
+            int32_t retval = ps4000aGetTimebase(handle, timebase, points_value, &timeIntervalNanoseconds,
+                                                &maxSamples, segmentIndex);
+            logger << "retval: " << retval << endl;
+            if(retval != 0) {
+                logger << LogPref::Flag(ERROR) << "Failed to get timebase. Code: " << retval << endl;
+                sndbuf[0] = magic_number;
+                sndbuf[1] = 0xFF;
+                sndbuf[2] = 0x22;
+                this->error_code = retval;
+                memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                if(SocketActive->Send(sndbuf, 7) == -1) {
+                    logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                }
+                return -1;
+            }
+
+            logger << LogPref::Flag(INFO) << "Run block:" << endl;
+
+            int32_t noOfPreTriggerSamples = 0;
+            int32_t noOfPostTriggerSamples = points_value;
+
+            retval = ps4000aRunBlock(handle, noOfPreTriggerSamples, noOfPostTriggerSamples, timebase,
+                                      nullptr, segmentIndex, nullptr, nullptr);
+            logger << "retval: " << retval << endl;
+            if(retval != 0) {
+                logger << LogPref::Flag(ERROR) << "Failed to run block. Code: " << retval << endl;
+                sndbuf[0] = magic_number;
+                sndbuf[1] = 0xFF;
+                sndbuf[2] = 0x23;
+                this->error_code = retval;
+                memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                if(SocketActive->Send(sndbuf, 7) == -1) {
+                    logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                }
+                return -1;
+            }
+
+            logger << LogPref::Flag(INFO) << "Run block done" << endl;
+            int16_t ready = 0;
+            while (ready == 0) {
+                retval = ps4000aIsReady(handle, &ready);
+            }
+
+            logger << LogPref::Flag(INFO) << "Set data buffer for channels:" << endl;
+            for(uint8_t j = 0; j < number_channels; ++j) {
+                PS4000A_RATIO_MODE mode = PS4000A_RATIO_MODE_NONE;
+                retval = ps4000aSetDataBuffer(handle, channels[j], data_buffer_vec[i][j], points_value,
+                                              segmentIndex, mode);
+                logger << "retval: " << retval << endl;
+                if(retval != 0) {
+                    logger << LogPref::Flag(ERROR) << "Failed to set data buffer for channel " << j << ". Code: " << retval << endl;
+                    sndbuf[0] = magic_number;
+                    sndbuf[1] = 0xFF;
+                    sndbuf[2] = 0x24 + j;
+                    this->error_code = retval;
+                    memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                    if(SocketActive->Send(sndbuf, 7) == -1) {
+                        logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                    }
+                    return -1;
+                }
+            }
+            logger << LogPref::Flag(INFO) << "Set data buffer done" << endl;
+            logger << LogPref::Flag(INFO) << "Data collection start" << endl;
+            uint32_t StartIndex = 0;
+            uint32_t noOfSamples = static_cast<uint32_t>(points_value);
+            int16_t overflow = 0;
+            uint32_t DownSampleRatio = 1;
+            retval = ps4000aGetValues(handle, StartIndex, &noOfSamples, DownSampleRatio, PS4000A_RATIO_MODE_NONE,
+                                      segmentIndex, &overflow);
+            logger << "retval: " << retval << endl;
+            if(retval != 0) {
+                logger << LogPref::Flag(ERROR) << "Failed to get values. Code: " << retval << endl;
+                sndbuf[0] = magic_number;
+                sndbuf[1] = 0xFF;
+                sndbuf[2] = 0x25;
+                this->error_code = retval;
+                memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                if(SocketActive->Send(sndbuf, 7) == -1) {
+                    logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                }
+                return -1;
+            }
+
+            logger << LogPref::Flag(INFO) << "Data collection done" << endl;
+            logger << LogPref::Flag(INFO) << "Confirm data to socket" << endl;
+            sndbuf[0] = magic_number;
+            sndbuf[1] = 0xDA;
+            if(SocketActive->Send(sndbuf, 2) == -1) {
+                logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                return -1;
+            }
+
+            logger << LogPref::Flag(INFO) << "Data sent to socket" << endl;
+            logger << LogPref::Flag(INFO) << "Data confirmed" << endl;
+
+            auto trig_retval = ps4000aSetSimpleTrigger
+            (
+             handle,
+             true,
+             channels[this->trig_channel],
+             threshold,
+             th_direction,
+             trig_delay,
+             trig_autoTrigger_ms
+            );
+
+            if (trig_retval != 0) {
+                logger << LogPref::Flag(ERROR) << "Failed to set trigger. Code: " << trig_retval << endl;
+                sndbuf[0] = magic_number;
+                sndbuf[1] = 0xFF;
+                sndbuf[2] = 0x26;
+                this->error_code = trig_retval;
+                memcpy(sndbuf + 3, &this->error_code, sizeof(uint32_t));
+                if(SocketActive->Send(sndbuf, 7) == -1) {
+                    logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+                }
+                return -1;
+            }
+
+            logger << LogPref::Flag(INFO) << "Trigger set successfully" << endl;
+        }
+
+        logger << LogPref::Flag(INFO) << "Writing data to files" << endl;
+        for(int i = 0; i < data_buffer_vec.size(); ++i) {
+            logger << LogPref::Flag(INFO) << "Writing data " << i << " to file" << endl;
+            std::string filename = "data_trigger_" + std::to_string(i) + ".csv";
+            writing_data_fixed_name(filename, data_buffer_vec[i], points_value, number_channels);
+            logger << LogPref::Flag(INFO) << "Data collection done" << endl;
+        }
+        logger << LogPref::Flag(INFO) << "Free buffers" << endl;
+        for(uint8_t j = 0; j < num_triggers; ++j)
+        {
+            free_buffers(data_buffer_vec[j]);
+        }
+        logger << LogPref::Flag(INFO) << "Buffers freed" << endl;
+        logger << LogPref::Flag(INFO) << "Multi-trigger measurement done" << endl;
+        sndbuf[0] = magic_number;
+        sndbuf[1] = 0xDB;
+        if(SocketActive->Send(sndbuf, 2) == -1) {
+            logger << LogPref::Flag(ERROR) << "Failed to send data to socket" << endl;
+            return -1;
+        }
+        logger << LogPref::Flag(INFO) << "Data sent to socket" << endl;
+        return 0;
+    }
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 };
 
 int main()
 {
+<<<<<<< HEAD
+=======
     logger.enableConsoleOutput(true);
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     logger << "Open socket" << endl;
     CPassiveSocket SocketPassive(CSimpleSocket::CSocketType::SocketTypeTcp);
     if (!SocketPassive.Initialize())
@@ -920,19 +1549,34 @@ int main()
         logger << LogPref::Flag(ERROR) << "Socket initialization failed" << endl;
         return -1;
     }
+<<<<<<< HEAD
+    if(!SocketPassive.Listen("localhost", 5002))
+=======
     if(!SocketPassive.Listen("127.0.0.1", 5003))
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     {
         logger << LogPref::Flag(ERROR) << "Socket listening failed" << endl;
         return -1;
     }
 
+<<<<<<< HEAD
+=======
     logger << "Socket initialized!" << endl;
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
     CActiveSocket* ClientSocket;
     PicoLocalService* pico_service;
 
     while(true)
     {
+<<<<<<< HEAD
+        if ((ClientSocket = SocketPassive.Accept()) != nullptr)
+        {
+            logger << LogPref::Flag(ERROR) << "Socket accept failed" << endl;
+            return -1;
+        }
+
+=======
         logger << LogPref::Flag(INFO) << "Wait for connection..." << endl;
         logger.closeLogger();
 
@@ -949,6 +1593,7 @@ int main()
         logger.initializeLogger("picologs", "pico");
         logger.enableConsoleOutput(true);
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
         logger << LogPref::Flag(INFO) << "Client connected" << endl;
         pico_service = new PicoLocalService(ClientSocket);
 
@@ -967,5 +1612,8 @@ int main()
 
     return 0;
 }
+<<<<<<< HEAD
+=======
 
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99

pico-tcp-service/pico-tcp/pico-tcp.cbp

@@ -65,8 +65,11 @@
 		<Unit filename="parser.cpp" />
 		<Unit filename="picofunctions.cpp" />
 		<Unit filename="pugixml.cpp" />
+<<<<<<< HEAD
+=======
 		<Unit filename="simplelogger.cpp" />
 		<Unit filename="simplelogger.hpp" />
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 		<Unit filename="src/ActiveSocket.cpp" />
 		<Unit filename="src/ActiveSocket.h" />
 		<Unit filename="src/Host.h" />
@@ -75,6 +78,11 @@
 		<Unit filename="src/SimpleSocket.cpp" />
 		<Unit filename="src/SimpleSocket.h" />
 		<Unit filename="src/StatTimer.h" />
+<<<<<<< HEAD
+		<Unit filename="src/simplelogger.cpp" />
+		<Unit filename="src/simplelogger.hpp" />
+=======
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 		<Extensions>
 			<lib_finder disable_auto="1" />
 		</Extensions>

pico-tcp-service/pico-tcp/pico-tcp.depend

@@ -184,6 +184,8 @@
 	<sys/stat.h>
 	<unistd.h>
 
+<<<<<<< HEAD
+=======
 1745850220 source:c:\lf_mri\pico-tcp-service\pico-tcp\main.cpp
 	<iostream>
 	<memory>
@@ -372,3 +374,4 @@
 1736725608 source:c:\lf_mri\pico-tcp-service\pico-tcp\simplelogger.cpp
 	"simplelogger.hpp"
 
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99

pico-tcp-service/pico-tcp/pico-tcp.layout

@@ -2,6 +2,21 @@
 <CodeBlocks_layout_file>
 	<FileVersion major="1" minor="0" />
 	<ActiveTarget name="Debug" />
+<<<<<<< HEAD
+	<File name="main.cpp" open="1" top="1" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="16847" topLine="392" />
+		</Cursor>
+	</File>
+	<File name="src\SimpleSocket.cpp" open="1" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="6005" topLine="123" />
+		</Cursor>
+	</File>
+	<File name="src\simplelogger.hpp" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="12" />
+=======
 	<File name="main.cpp" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="1" zoom_2="0">
 		<Cursor>
 			<Cursor1 position="36698" topLine="852" />
@@ -15,6 +30,7 @@
 	<File name="src\SimpleSocket.cpp" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
 			<Cursor1 position="6005" topLine="27" />
+>>>>>>> 6a0c5e06dc737368566c8c5b45d8073a39148b99
 		</Cursor>
 	</File>
 </CodeBlocks_layout_file>

pico-tcp-service/pico-test.py

@@ -0,0 +1,92 @@
+import numpy as np
+from enum import Enum
+import socket
+import struct
+
+probe = Enum('probe', [('10mV', 0), 
+                       ('20mV', 1), 
+                       ('50mV', 2), 
+                       ('100mV', 3), 
+                       ('200mV', 4), 
+                       ('500mV', 5), 
+                       ('1V', 6), 
+                       ('2V', 7), 
+                       ('5V', 8),
+                       ('10V', 9), 
+                       ('20V', 10), 
+                       ('50V', 11), 
+                       ('100V', 12), 
+                       ('200V', 13)])
+
+
+
+# # # # # # # 3 # # # # #  #
+# CONFIGURATION PARAMETERS #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+# Sample rate in MHz
+sample_rate = np.float32(10.0)
+# Total measurement time in seconds
+total_measure_time = np.float32(0.01)
+
+# Get the number of samples by multiplying sample rate by total measurement time
+num_samples = np.uint32(sample_rate * total_measure_time * 1e6)
+
+# Number of channels
+nchannels = np.uint32(2)
+# Channel ranges in volts, represented as an array of uint8
+channel_ranges = np.array([probe['1V'].value, probe['500mV'].value], dtype=np.uint8)
+
+# Number of expected signals
+num_trigger = np.uint32(64)
+# Trigger direction: 1 for rising edge, 0 for falling edge
+trig_dirrection = np.int32(1)
+# Trigger pre-measurement time in percentage of the total measurement time
+trig_premeasure = np.uint32(100)
+# Trigger channel, 0 for channel 1, 1 for channel 2, etc.
+trig_channel = np.uint8(0)
+# Trigger threshold (0 is 0V and 32767 is max of channel range)
+trig_threshold = np.int16(32767)
+
+# Auto trigger time in milliseconds
+auto_trigger_time = np.int16(10000)
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+
+
+# # # # # # #  #
+# MAIN PROGRAM #
+# # # # # # #  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+client_socket.settimeout(5.0)
+client_socket.connect(('localhost', 5002))
+
+# Open device
+msg = struct.pack('<BB', 0xAA, 0x01)
+client_socket.sendall(msg)
+
+# Set sample rate
+msg = struct.pack('<BBI', 0xAA, 0x07, np.uint32(sample_rate * 1e6))
+client_socket.sendall(msg)
+
+# Set number of samples
+msg = struct.pack('<BBI', 0xAA, 0x17, num_samples)
+client_socket.sendall(msg)
+
+# Configure channels
+msg = struct.pack('<BBIsBiHh', 0xAA, 0x09, nchannels, channel_ranges.tobytes(), trig_channel, trig_dirrection, trig_threshold, auto_trigger_time)
+client_socket.sendall(msg)
+
+# Set pre-measure time
+msg = struct.pack('<BBI', 0xAA, 0x28, trig_premeasure)
+client_socket.sendall(msg)
+
+# Set trigger number
+msg = struct.pack('<BBI', 0xAA, 0x19, num_trigger)
+client_socket.sendall(msg)
+
+# Start measurement
+msg = struct.pack('<BB', 0xAA, 0x1B)
+client_socket.sendall(msg)