3 files changed, 49 insertions, 19 deletions

diff --git a/device.cc b/device.cc
index 0111572..facdc3e 100644
--- a/device.cc
+++ b/device.cc
@@ -150,14 +150,23 @@ Stick20::Stick20():
 #define p(x) ss << #x << " " << x << ", ";
 std::string Device::ErrorCounters::get_as_string() {
   std::stringstream ss;
-  p(wrong_CRC);
-  p(CRC_other_than_awaited);
-  p(busy);
+  p(total_comm_runs);
+  p(communication_successful);
+  ss << "(";
+  p(command_successful_recv);
+  p(command_result_not_equal_0_recv);
+  ss << "), ";
+  p(sends_executed);
+  p(recv_executed);
+  p(successful_storage_commands);
   p(total_retries);
+  ss << "(";
+  p(busy);
+  p(busy_progressbar);
+  p(CRC_other_than_awaited);
+  p(wrong_CRC);
+  ss << "), ";
   p(sending_error);
   p(receiving_error);
-  p(total_comm_runs);
-  p(storage_commands);
-  p(successful	);
   return ss.str();
 }
diff --git a/include/device.h b/include/device.h
index 281c4d9..40eb376 100644
--- a/include/device.h
+++ b/include/device.h
@@ -28,21 +28,30 @@ enum class DeviceModel{
     STORAGE
 };
 
+#include <atomic>
+
 class Device {
 
 public:
 
   struct ErrorCounters{
-    int wrong_CRC;
-    int CRC_other_than_awaited;
-    int busy;
-    int total_retries;
-    int sending_error;
-    int receiving_error;
-    int total_comm_runs;
-    int storage_commands;
-    int successful;
+    using cnt = std::atomic_int;
+    cnt wrong_CRC;
+    cnt CRC_other_than_awaited;
+    cnt busy;
+    cnt total_retries;
+    cnt sending_error;
+    cnt receiving_error;
+    cnt total_comm_runs;
+    cnt successful_storage_commands;
+    cnt command_successful_recv;
+    cnt recv_executed;
+    cnt sends_executed;
+    cnt busy_progressbar;
+    cnt command_result_not_equal_0_recv;
+    cnt communication_successful;
     std::string get_as_string();
+
   } m_counters = {};
 
 
@@ -71,7 +80,7 @@ public:
   bool is_connected();
 
   void show_stats();
-  ErrorCounters get_stats(){ return m_counters; }
+//  ErrorCounters get_stats(){ return m_counters; }
   int get_retry_receiving_count() const { return m_retry_receiving_count; };
   int get_retry_sending_count() const { return m_retry_sending_count; };
   std::chrono::milliseconds get_retry_timeout() const { return m_retry_timeout; };
diff --git a/include/device_proto.h b/include/device_proto.h
index 1e381dd..3519123 100644
--- a/include/device_proto.h
+++ b/include/device_proto.h
@@ -245,6 +245,7 @@ namespace nitrokey {
               int receiving_retry_counter = 0;
               int sending_retry_counter = dev->get_retry_sending_count();
               while (sending_retry_counter-- > 0) {
+                dev->m_counters.sends_executed++;
                 status = dev->send(&outp);
                 if (status <= 0){
                     //FIXME early disconnection not yet working properly
@@ -261,6 +262,7 @@ namespace nitrokey {
                 // FIXME make checks done in device:recv here
                 receiving_retry_counter = dev->get_retry_receiving_count();
                 while (receiving_retry_counter-- > 0) {
+                  dev->m_counters.recv_executed++;
                   status = dev->recv(&resp);
 
                   if (dev->get_device_model() == DeviceModel::STORAGE &&
@@ -268,7 +270,6 @@ namespace nitrokey {
                       resp.command_id < stick20::CMD_END_VALUE ) {
                     Log::instance()(std::string("Detected storage device cmd, status: ") +
                                     std::to_string(resp.storage_status.device_status), Loglevel::DEBUG_L2);
-                    dev->m_counters.storage_commands++;
 
                     resp.last_command_status = static_cast<uint8_t>(stick10::command_status::ok);
                     switch (static_cast<stick20::device_status>(resp.storage_status.device_status)) {
@@ -362,6 +363,7 @@ namespace nitrokey {
               if (resp.device_status == static_cast<uint8_t>(stick10::device_status::busy) &&
                   static_cast<stick20::device_status>(resp.storage_status.device_status)
                   == stick20::device_status::busy_progressbar){
+                dev->m_counters.busy_progressbar++;
                 throw LongOperationInProgressException(
                     resp.command_id, resp.device_status, resp.storage_status.progress_bar_value);
               }
@@ -370,10 +372,20 @@ namespace nitrokey {
               if (receiving_retry_counter <= 0)
                 throw std::runtime_error(
                     "Maximum receiving_retry_counter count reached for receiving response from the device!");
-              if (resp.last_command_status != static_cast<uint8_t>(stick10::command_status::ok))
+              dev->m_counters.communication_successful++;
+
+              if (resp.last_command_status != static_cast<uint8_t>(stick10::command_status::ok)){
+                dev->m_counters.command_result_not_equal_0_recv++;
                 throw CommandFailedException(resp.command_id, resp.last_command_status);
+              }
 
-              dev->m_counters.successful++;
+              dev->m_counters.command_successful_recv++;
+
+              if (dev->get_device_model() == DeviceModel::STORAGE &&
+                  resp.command_id >= stick20::CMD_START_VALUE &&
+                  resp.command_id < stick20::CMD_END_VALUE ) {
+                dev->m_counters.successful_storage_commands++;
+              }
 
               // See: DeviceResponse
               return resp;