ready to check missing trigger

channel.cc

@@ -23,12 +23,34 @@ Channel::Channel(char const * ptr, size_t len) {
 
 }
 
+Channel::Channel(char const * ptr, size_t len, uint32_t board) {
+   board_id = board;
+   valid = true;
+   uint32_t * wordData = (uint32_t *)ptr;
+   size = ((wordData[0] & 0xFFFFFF00) >> 8) * sizeof(uint32_t);
+   if (size != len) valid = false;
+
+   version = wordData[0] && 0xFF;
+   if (version != 0x1) valid = false;
+
+   for (int i = 0; i < 3; i++) 
+      integral[i] = (wordData[i + 1] & 0xFFFFFF00)>>8;
+
+   crossing = wordData[4] & 0x00FFFFFF;
+   block_count = (wordData[5] &0xFF000000) >> 24;
+   id = (wordData[5] & 0x00FF0000) >> 16;
+   spill = (wordData[5] & 0x0000FFFF);
+   if ((id > 8) || (id < 1)) {
+      valid = false;
+   }
+
+}
 void Channel::Print(){
    if (valid) {
-      spdlog::info("channel {}, spill {}, size {}, blocks {}, crossing {}, integrals {}, {}, {}",
-            id, spill, size, block_count, crossing, integral[0], integral[1], integral[2]);
+      spdlog::get("zynqDump")->debug("board {}, channel {}, spill {}, size {}, blocks {}, crossing {}, integrals {}, {}, {}",
+            board_id, id, spill, size, block_count, crossing, integral[0], integral[1], integral[2]);
    }
    else {
-      spdlog::info("Invalid channel");
+      spdlog::get("zynqDump")->info("Invalid channel");
    }
 }

channel.h

@@ -5,6 +5,7 @@
 #include <cstdlib>
 
 class Channel {
+   uint32_t board_id;
    uint32_t id;
    uint32_t size;
    uint32_t version;
@@ -16,6 +17,7 @@ class Channel {
    bool valid;
    public:
    Channel(char const * ptr, size_t len);
+   Channel(char const * ptr, size_t len, uint32_t board);
    void Print();
 
 };

client.cc

@@ -15,6 +15,7 @@
 #include <csignal>
 #include "channel.h"
 #include "spdlog/spdlog.h"
+#include "spdlog/sinks/rotating_file_sink.h"
 
 const char * HOST = "192.168.30.89";
 const uint32_t PORT = 9999;
@@ -32,12 +33,139 @@ bool bad_data = true;
 int open_socket();
 void signalHandler( int signum );
 void setup_logger();
-size_t process_channel(char const * ptr, size_t len);
+size_t process_channel(char const * ptr, size_t len, uint32_t board_id);
 size_t process_block(char const * ptr, size_t len);
 size_t process_block(char const * ptr, size_t len){
    return len;
 }
-size_t process_channel(char const * ptr, size_t len){
+
+
+int main(int argc, char * argv[])
+{
+   setup_logger();
+   signal(SIGINT, signalHandler);
+   int ret = open_socket();
+   if (ret != 0)
+      return -1;
+
+   char char_buffer[MAX_EVENT_SIZE];
+   uint32_t * wordData = (uint32_t*) char_buffer;
+   ssize_t nread;
+
+   fd_set select_fds;                // fd's used by select
+   struct timeval timeout;           // Time value for time out
+   //Timeout set for 0 sec + 200 millisec
+   timeout.tv_sec = 0;         
+   timeout.tv_usec = 200*1000;
+   std::chrono::duration<int, std::milli> polling_period(2);
+
+   while (running) {
+      // Setup the descriptor set for select()
+      FD_ZERO(&select_fds);            
+      FD_SET(sock, &select_fds);           
+      if ( select(sock + 1, &select_fds, NULL, NULL, &timeout) == 0 ){
+         std::this_thread::sleep_for(polling_period);
+      }
+      else{
+         // read in first 4 bytes
+         nread = recv(sock, char_buffer, 4, 0);
+         spdlog::get("zynqDump")->debug("read in {:d} bytes: 0x{:X}", nread, wordData[0]);
+         // if not A5 marker, go to next iteration (read in 4 more bytes)
+         if ((char_buffer[0] & 0xFF) != 0xA5){
+            bad_data = true;
+            continue;
+         }
+         else {
+            bad_data = false;
+            size_t frameSize = 4 * (wordData[0] >> 8);
+            nread = recv(sock, char_buffer, frameSize - 4, 0);
+            // nread + 4 must be between MIN_EVENT_SIZE and MAX_EVENT_SIZE, and equal to frameSize.
+            if (((size_t)nread != frameSize - 4) || (frameSize < MIN_EVENT_SIZE)|| (frameSize > MAX_EVENT_SIZE)){
+               bad_data = true;
+               continue;
+            }
+            else {
+               // ok, this seems to be good data
+               spdlog::get("zynqDump")->debug("next {:d} bytes (expecting {:d}): {:X} {:X} {:X} {:X}",
+                     nread, frameSize - 4, wordData[0], wordData[1], wordData[2], wordData[3]);
+               spdlog::get("zynqDump")->debug("{:X} {:X} {:X} {:X}", wordData[4], wordData[5], wordData[6], wordData[7]);
+               uint8_t board_id = (wordData[0] >> 24) & 0xFF;
+               uint8_t version = wordData[0] & 0xFF;
+               uint16_t spill_id = (wordData[1] & 0x00FFFF00) >> 8;
+               uint8_t channel_count = (wordData[1]) & 0x000000FF;
+               spdlog::get("zynqDump")->info("board {}, version {}, spill {}, channel_count {}",
+                     static_cast<uint32_t>(board_id),
+                     static_cast<uint32_t>(version),
+                     static_cast<uint32_t>(spill_id),
+                     static_cast<uint32_t>(channel_count));
+
+               if ((board_id > 4) || (board_id < 1) || (version != 1) || (channel_count > 8) || (channel_count < 1)) {
+                  bad_data = true;
+                  continue;
+               }
+               else {
+                  size_t bytes_left = (frameSize - 3 * sizeof(uint32_t));
+                  size_t bytes_processed = 0;
+                  while ((bytes_left - bytes_processed >= MIN_CHANNEL_SIZE) && (bytes_processed < bytes_left)) {
+                     bytes_processed += process_channel(
+                           char_buffer + 2 * sizeof(uint32_t) + bytes_processed,
+                           bytes_left - bytes_processed,
+                           static_cast<uint32_t>(board_id));
+                  }
+                  spdlog::get("zynqDump")->debug("Done, {} bytes processed.", bytes_processed);
+               }
+
+            }
+         }
+      }
+   }
+
+   close(sock);
+   return 0;
+}
+
+void signalHandler( int signum ) {
+   spdlog::get("zynqDump")->info("Interrupt signal ({}) received, exiting...", signum);
+   running = false;
+}
+
+int open_socket(){
+   struct sockaddr_in serv_addr;
+   if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+      std::cerr << "Cannot create socket" << std::endl;
+      return -1;
+   }
+
+   memset(&serv_addr, '0', sizeof(serv_addr));
+   serv_addr.sin_family = AF_INET;
+   serv_addr.sin_port = htons(PORT);
+
+   if(inet_pton(AF_INET, HOST, &serv_addr.sin_addr)<=0) {
+      std::cerr << "Invalid address or Address not supported" << std::endl;
+      return -1;
+   }
+
+   if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+      std::cerr << "Cannot connect to " << HOST << ":" << PORT << std::endl;
+      return -1;
+   }
+
+   return 0;
+}
+
+void setup_logger(){
+   try {
+      auto max_size = 1048576 * 5;
+      auto max_files = 3;
+      auto logger = spdlog::rotating_logger_mt("zynqDump", "logs/dump.txt", max_size, max_files);
+   }
+   catch (const spdlog::spdlog_ex &ex) {
+      std::cerr << "Log init failed: " << ex.what() << std::endl;
+      exit(-1);
+   }
+}
+
+size_t process_channel(char const * ptr, size_t len, uint32_t board_id){
    if ((len < MIN_CHANNEL_SIZE) || (len > MAX_CHANNEL_SIZE)) {
       spdlog::debug("channel length must be between {} and {}.",
             MIN_CHANNEL_SIZE, MAX_CHANNEL_SIZE);
@@ -83,7 +211,7 @@ size_t process_channel(char const * ptr, size_t len){
          // processing
          bytes_left -= channel_size;
 
-         Channel c(ptr, channel_size);
+         Channel c(ptr, channel_size, board_id);
          c.Print();
       }
    }
@@ -93,117 +221,3 @@ size_t process_channel(char const * ptr, size_t len){
    return len - bytes_left;
 }
 
-
-int main(int argc, char * argv[])
-{
-   setup_logger();
-   signal(SIGINT, signalHandler);
-   int ret = open_socket();
-   if (ret != 0)
-      return -1;
-
-   char char_buffer[MAX_EVENT_SIZE];
-   uint32_t * wordData = (uint32_t*) char_buffer;
-   ssize_t nread;
-
-   fd_set select_fds;                // fd's used by select
-   struct timeval timeout;           // Time value for time out
-   //Timeout set for 0 sec + 200 millisec
-   timeout.tv_sec = 0;         
-   timeout.tv_usec = 200*1000;
-   std::chrono::duration<int, std::milli> polling_period(2);
-
-   while (running) {
-      // Setup the descriptor set for select()
-      FD_ZERO(&select_fds);            
-      FD_SET(sock, &select_fds);           
-      if ( select(sock + 1, &select_fds, NULL, NULL, &timeout) == 0 ){
-         std::this_thread::sleep_for(polling_period);
-      }
-      else{
-         // read in first 4 bytes
-         nread = recv(sock, char_buffer, 4, 0);
-         spdlog::info("read in {:d} bytes: 0x{:X}", nread, wordData[0]);
-         // if not A5 marker, go to next iteration (read in 4 more bytes)
-         if ((char_buffer[0] & 0xFF) != 0xA5){
-            bad_data = true;
-            continue;
-         }
-         else {
-            bad_data = false;
-            size_t frameSize = 4 * (wordData[0] >> 8);
-            nread = recv(sock, char_buffer, frameSize - 4, 0);
-            // nread + 4 must be between MIN_EVENT_SIZE and MAX_EVENT_SIZE, and equal to frameSize.
-            if (((size_t)nread != frameSize - 4) || (frameSize < MIN_EVENT_SIZE)|| (frameSize > MAX_EVENT_SIZE)){
-               bad_data = true;
-               continue;
-            }
-            else {
-               // ok, this seems to be good data
-               spdlog::info("next {:d} bytes (expecting {:d}): {:X} {:X} {:X} {:X}",
-                     nread, frameSize - 4, wordData[0], wordData[1], wordData[2], wordData[3]);
-               spdlog::info("{:X} {:X} {:X} {:X}", wordData[4], wordData[5], wordData[6], wordData[7]);
-               uint8_t board_id = (wordData[0] >> 24) & 0xFF;
-               uint8_t version = wordData[0] & 0xFF;
-               uint16_t spill_id = (wordData[1] & 0x00FFFF00) >> 8;
-               uint8_t channel_count = (wordData[1]) & 0x000000FF;
-               spdlog::info("board {}, version {}, spill {}, channel_count {}",
-                     static_cast<uint32_t>(board_id),
-                     static_cast<uint32_t>(version),
-                     static_cast<uint32_t>(spill_id),
-                     static_cast<uint32_t>(channel_count));
-
-               if ((board_id > 4) || (board_id < 1) || (version != 1) || (channel_count > 8) || (channel_count < 1)) {
-                  bad_data = true;
-                  continue;
-               }
-               else {
-                  size_t bytes_left = (frameSize - 3 * sizeof(uint32_t));
-                  size_t bytes_processed = 0;
-                  while ((bytes_left - bytes_processed >= MIN_CHANNEL_SIZE) && (bytes_processed < bytes_left)) {
-                     bytes_processed += process_channel(char_buffer + 2 * sizeof(uint32_t) + bytes_processed,
-                           bytes_left - bytes_processed);
-                  }
-                  spdlog::info("Done, {} bytes processed.", bytes_processed);
-               }
-
-            }
-         }
-      }
-   }
-
-   close(sock);
-   return 0;
-}
-
-void signalHandler( int signum ) {
-   spdlog::info("Interrupt signal ({}) received, exiting...", signum);
-   running = false;
-}
-
-int open_socket(){
-   struct sockaddr_in serv_addr;
-   if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-      std::cerr << "Cannot create socket" << std::endl;
-      return -1;
-   }
-
-   memset(&serv_addr, '0', sizeof(serv_addr));
-   serv_addr.sin_family = AF_INET;
-   serv_addr.sin_port = htons(PORT);
-
-   if(inet_pton(AF_INET, HOST, &serv_addr.sin_addr)<=0) {
-      std::cerr << "Invalid address or Address not supported" << std::endl;
-      return -1;
-   }
-
-   if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
-      std::cerr << "Cannot connect to " << HOST << ":" << PORT << std::endl;
-      return -1;
-   }
-
-   return 0;
-}
-
-void setup_logger(){
-}