Merge branch 'eiger' of https://github.com/paulscherrerinstitute/sf_daq_buffer into eiger

Conflicts:
	jf-assembler/src/main.cpp
	jf-udp-recv/src/main.cpp
	std-udp-recv/src/FrameUdpReceiver.cpp

std-udp-recv/src/FrameUdpReceiver.cpp

@@ -0,0 +1,177 @@
+#include <cstring>
+#include "FrameUdpReceiver.hpp"
+#include <ostream>
+#include <iostream>
+#include <chrono>
+#include "date.h"
+
+using namespace std;
+using namespace buffer_config;
+
+FrameUdpReceiver::FrameUdpReceiver(
+        const uint16_t port, const int n_packets_per_frame) :
+            n_packets_per_frame_(n_packets_per_frame),
+            packet_buffer_(new det_packet[n_packets_per_frame_]),
+            recv_buff_ptr_(new iovec[n_packets_per_frame_]),
+            msgs_(new mmsghdr[n_packets_per_frame_]),
+            sock_from_(new sockaddr_in[n_packets_per_frame_])
+{
+    #ifdef DEBUG_OUTPUT
+        using namespace date;
+        cout << " [" << std::chrono::system_clock::now();
+        cout << "] [FrameUdpReceiver::FrameUdpReceiver] :";
+        cout << " Details of FrameUdpReceiver:";
+        cout << " || port: " << port;
+        cout << " || n_packets_per_frame: " << n_packets_per_frame_;
+        cout << endl;
+    #endif
+
+    udp_receiver_.bind(port);
+
+    for (int i = 0; i < n_packets_per_frame_; i++) {
+        recv_buff_ptr_[i].iov_base = (void*) &(packet_buffer_[i]);
+        recv_buff_ptr_[i].iov_len = sizeof(det_packet);
+
+        msgs_[i].msg_hdr.msg_iov = &recv_buff_ptr_[i];
+        msgs_[i].msg_hdr.msg_iovlen = 1;
+        msgs_[i].msg_hdr.msg_name = &sock_from_[i];
+        msgs_[i].msg_hdr.msg_namelen = sizeof(sockaddr_in);
+    }
+}
+
+FrameUdpReceiver::~FrameUdpReceiver() {
+    udp_receiver_.disconnect();
+
+    delete[] packet_buffer_;
+    delete[] recv_buff_ptr_;
+    delete[] msgs_;
+    delete[] sock_from_;
+}
+
+inline void FrameUdpReceiver::init_frame(
+        ModuleFrame& frame_metadata, const int i_packet)
+{
+    frame_metadata.pulse_id = packet_buffer_[i_packet].bunchid;
+    frame_metadata.frame_index = packet_buffer_[i_packet].framenum;
+    frame_metadata.daq_rec = (uint64_t) packet_buffer_[i_packet].debug;
+    frame_metadata.pos_y = (int16_t) packet_buffer_[i_packet].row;
+    frame_metadata.pos_x = (int16_t) packet_buffer_[i_packet].column;
+
+    #ifdef DEBUG_OUTPUT
+        using namespace date;
+        cout << " [" << std::chrono::system_clock::now();
+        cout << "] [FrameUdpReceiver::init_frame] :";
+        cout << " || pos_y: " << frame_metadata.pos_x;
+        cout << " || pos_x: " << frame_metadata.pos_x;
+        cout << " || pulse_id: " << frame_metadata.pulse_id;
+        cout << " || frame_index: " << frame_metadata.frame_index;
+        cout << endl;
+    #endif
+
+}
+
+inline void FrameUdpReceiver::copy_packet_to_buffers(
+        ModuleFrame& metadata, char* frame_buffer, const int i_packet)
+{
+    size_t frame_buffer_offset =
+            DATA_BYTES_PER_PACKET * packet_buffer_[i_packet].packetnum;
+    memcpy(
+            (void*) (frame_buffer + frame_buffer_offset),
+            packet_buffer_[i_packet].data,
+            DATA_BYTES_PER_PACKET);
+    if (i_packet == 0){
+        // cout << " BUFFER LOCATION " << (frame_buffer + frame_buffer_offset) << endl;
+    }
+    metadata.n_recv_packets++;
+}
+
+inline uint64_t FrameUdpReceiver::process_packets(
+        const int start_offset,
+        ModuleFrame& metadata,
+        char* frame_buffer)
+{
+    for (int i_packet=start_offset;
+         i_packet < packet_buffer_n_packets_;
+         i_packet++) {
+
+        // First packet for this frame.
+        if (metadata.frame_index == 0) {
+            init_frame(metadata, i_packet);
+
+        // Happens if the last packet from the previous frame gets lost.
+        // In the jungfrau_packet, framenum is the trigger number
+        // (how many triggers from detector power-on) happened
+        } else if (metadata.frame_index != packet_buffer_[i_packet].framenum) {
+            packet_buffer_loaded_ = true;
+            // Continue on this packet.
+            packet_buffer_offset_ = i_packet;
+
+            return metadata.frame_index;
+        }
+
+        copy_packet_to_buffers(metadata, frame_buffer, i_packet);
+        
+        // Last frame packet received. Frame finished.
+        if (packet_buffer_[i_packet].packetnum ==
+            n_packets_per_frame_ - 1)
+        {
+            #ifdef DEBUG_OUTPUT
+                using namespace date;
+                cout << " [" << std::chrono::system_clock::now();
+                cout << "] [frameudpreceiver::process_packets] :";
+                cout << " frame " << metadata.frame_index << " || ";
+                cout << packet_buffer_[i_packet].packetnum << " packets received.";
+                cout << " pulse id "<<  metadata.pulse_id;
+                cout << endl;
+            #endif
+            // buffer is loaded only if this is not the last message.
+            if (i_packet+1 != packet_buffer_n_packets_) {
+                packet_buffer_loaded_ = true;
+                // continue on next packet.
+                packet_buffer_offset_ = i_packet + 1;
+
+            // if i_packet is the last packet the buffer is empty.
+            } else {
+                packet_buffer_loaded_ = false;
+                packet_buffer_offset_ = 0;
+            }
+
+            return metadata.pulse_id;
+        }
+    }
+    // We emptied the buffer.
+    packet_buffer_loaded_ = false;
+    packet_buffer_offset_ = 0;
+
+    return 0;
+}
+
+uint64_t FrameUdpReceiver::get_frame_from_udp(
+        ModuleFrame& meta, char* frame_buffer)
+{
+    // Happens when last packet from previous frame was missed.
+    if (packet_buffer_loaded_) {
+
+        auto frame_index = process_packets(
+                packet_buffer_offset_, meta, frame_buffer);
+        if (frame_index != 0) {
+            return frame_index;
+        }
+    }
+
+    while (true) {
+
+        packet_buffer_n_packets_ = udp_receiver_.receive_many(
+                msgs_, n_packets_per_frame_);
+
+        if (packet_buffer_n_packets_ == 0) {
+            continue;
+        }
+
+        auto frame_index = process_packets(0, meta, frame_buffer);
+
+        if (frame_index != 0) {
+            return frame_index;
+        }
+    }
+}