tests: update tests to work with ph1024

nraultwang · nraultwang · commit fb53cc5ef01c · 2025-08-18T20:40:41.000-07:00
diff --git a/snapshot.c b/snapshot.c
@@ -361,59 +361,3 @@ void write_32x32_to_uds(DATA_PRODUCT dp, PACKET_HEADER *header, uint8_t *data) {
         hashpipe_error(__FUNCTION__, "Failed to sprint Img snapshot JSON for UDS");
     }
 }
-
-// =====================================================================
-// Filesystem snapshot functions (originally from net_thread.c) 
-// =====================================================================
-
-
-// // Writes a single-packet pulse-height snapshot to a file.
-// void WritePHSnapshots(FILE *fp, PACKET_HEADER *header, uint8_t *data) {
-//     char json_buffer[1024];
-
-//     // Create the JSON header in memory using the unified function
-//     if (sprint_ph_snapshot_json(json_buffer, sizeof(json_buffer), header) <= 0) {
-//         hashpipe_error(__FUNCTION__, "Failed to sprint PH snapshot JSON for filesystem");
-//         return;
-//     }
-
-//     // Write the PFF frame to the file
-//     // move the pointer to the beginning,
-//     // as we only need one pkt in the snapshot file.
-//     fseek(fp, 0, SEEK_SET);
-//     pff_start_json(fp);
-//     fputs(json_buffer, fp); // Write the generated JSON string
-//     pff_end_json(fp);
-//     pff_write_image(fp, PIXELS_PER_IMAGE * 2, data);
-//     fflush(fp);
-//     if (ftruncate(fileno(fp), ftell(fp)) < 0) {
-//         hashpipe_error(__FUNCTION__, "Failed to truncate PH snapshot file");
-//     }
-//     fsync(fileno(fp));
-// }
-
-
-// // write data into img snapshot file
-// void WriteImgSnapshots(FILE *fp, PACKET_HEADER *header, uint8_t *data) {
-//     char json_buffer[4096];
-
-//     // Create the JSON header in memory using the unified function
-//     if (sprint_img_snapshot_json(json_buffer, sizeof(json_buffer), header) <= 0) {
-//         hashpipe_error(__FUNCTION__, "Failed to sprint Img snapshot JSON for filesystem");
-//         return;
-//     }
-
-//     // Write the PFF frame to the file
-//     // move the pointer to the beginning,
-//     // as we only need one pkt in the snapshot file.
-//     fseek(fp, 0, SEEK_SET);
-//     pff_start_json(fp);
-//     fputs(json_buffer, fp); // Write the generated JSON string
-//     pff_end_json(fp);
-//     pff_write_image(fp, BYTES_PER_MODULE_FRAME, data);
-//     fflush(fp);
-//     if (ftruncate(fileno(fp), ftell(fp)) < 0) {
-//         hashpipe_error(__FUNCTION__, "Failed to truncate Img snapshot file");
-//     }
-//     fsync(fileno(fp));
-// }
diff --git a/snapshot.h b/snapshot.h
@@ -130,57 +130,56 @@ struct module_snapshot_buffer {
     }
 
     void update_snapshot(PACKET_HEADER *header, uint8_t *data, struct timeval *nowTime, int snapshot_interval_ms, int group_ph_frames) {
-        char acq_mode = header->acq_mode;
-        int quabo_num = header->quabo_num;
-        DATA_PRODUCT dp = acq_mode_to_dp(acq_mode, group_ph_frames);
-        snapshot_t *s = this->get_snapshot(dp);
-
-        // If timestamp difference exceeds snapshot interval, write snapshot to the unix-domain socket for this data product
-        bool write_snapshot = false;
-        uint64_t tdiff = timeval_diff(&s->last_update_time, nowTime);
-        if ((tdiff > snapshot_interval_ms * 1000))
-        {
-            write_snapshot = true;
+    char acq_mode = header->acq_mode;
+    int quabo_num = header->quabo_num;
+    DATA_PRODUCT dp = acq_mode_to_dp(acq_mode, group_ph_frames);
+    snapshot_t *s = this->get_snapshot(dp);
+    if (!s) return; // Snapshot for this data product not found
+
+    bool write_snapshot = false;
+    uint64_t tdiff = timeval_diff(&s->last_update_time, nowTime);
+    if (tdiff > snapshot_interval_ms * 1000) {
+        write_snapshot = true;
+    }
+
+    bool is_single_quabo = (dp == DP_PH_256_IMG);
+    bool is_complete = false;
+
+    if (is_single_quabo) {
+        quabo16_to_quabo16_copy(data, quabo_num, s->data);
+        memcpy(&s->headers[0], header, sizeof(PACKET_HEADER));
+        is_complete = true;
+    } else {
+        s->quabo_bitmap |= 1 << quabo_num;
+        memcpy(&s->headers[quabo_num], header, sizeof(PACKET_HEADER));
+
+        if (bytes_per_pixel(dp) == 1) {
+            quabo8_to_module8_copy(data, quabo_num, s->data);
+        } else if (bytes_per_pixel(dp) == 2) {
+            quabo16_to_module16_copy(data, quabo_num, s->data);
         }
 
-        if (dp == DP_PH_256_IMG) {
-            // For PH 256 images, use only the 0th index of the header and data buffers.
-            s->quabo_bitmap = 0x01; // Only one quabo for PH 256
-            // memcpy(&s->headers[0], header, sizeof(PACKET_HEADER));
-            quabo16_to_quabo16_copy(data, quabo_num, s->data);
-
-            if (write_snapshot) {
-                write_16x16_to_uds(dp, header, s->data);
-                // memset(s->headers, 0, sizeof(s->headers));
-                s->last_update_time.tv_sec = nowTime->tv_sec;
-                s->last_update_time.tv_usec = nowTime->tv_usec;
-            }
-            memset(s->data, 0, sizeof(s->data));
+        if (s->quabo_bitmap == 0xf) {
+            is_complete = true;
+        }
+    }
+
+    if (is_complete && write_snapshot) {
+        if (is_single_quabo) {
+            write_16x16_to_uds(dp, &s->headers[0], s->data);
         } else {
-            // Require 4 quabo images 
-            s->quabo_bitmap |= 1 << quabo_num;
-            memcpy(&s->headers[quabo_num], header, sizeof(PACKET_HEADER));
-
-            if (bytes_per_pixel(dp) == 1) {
-                quabo8_to_module8_copy(data, quabo_num, s->data);
-            } else if (bytes_per_pixel(dp) == 2) {
-                quabo16_to_module16_copy(data, quabo_num, s->data);
-            } else {
-                fprintf(stderr, "Unsupported data product for snapshot: %d\n", dp);
-                return; // Unsupported data product
-            }
-            if (s->quabo_bitmap == 0xf) {
-                if (write_snapshot) {
-                    write_16x16_to_uds(dp, s->headers, s->data);
-                    s->last_update_time.tv_sec = nowTime->tv_sec;
-                    s->last_update_time.tv_usec = nowTime->tv_usec;
-                }
-                memset(s->headers, 0, sizeof(s->headers));
-                memset(s->data, 0, sizeof(s->data));
-                s->quabo_bitmap = 0;
-            }
+            write_32x32_to_uds(dp, s->headers, s->data);
         }
+        
+        // Reset for next snapshot
+        s->last_update_time.tv_sec = nowTime->tv_sec;
+        s->last_update_time.tv_usec = nowTime->tv_usec;
+        memset(s->headers, 0, sizeof(s->headers));
+        memset(s->data, 0, sizeof(s->data));
+        s->quabo_bitmap = 0;
     }
+}
+
 
 
     ~module_snapshot_buffer() {
diff --git a/tests/ci_tests/conftest.py b/tests/ci_tests/conftest.py
@@ -20,6 +20,7 @@ def is_utility_available(name):
 MODULE_IDS = [1, 254]
 PCAP_FILE = "/app/test_data.pcapng"
 UDS_TEMPLATE = "/tmp/hashpipe_grpc.dp_{dp_name}.sock"
+GROUP_PH_FRAMES = 1  # Default to not grouping frames
 
 def _ensure_dirs_and_module_config():
     cfg_str = ""
@@ -169,6 +170,7 @@ def daq_env():
         "--run_dir", str(BASE_DIR),
         "--max_file_size_mb", "5",
         "--bindhost", "lo",
+        "--group_ph_frames", str(GROUP_PH_FRAMES)
     ]
     for mid in MODULE_IDS:
         start_daq.extend(["--module_id", str(mid)])
@@ -190,6 +192,8 @@ def daq_env():
         "base_dir": BASE_DIR,
         "run_name": RUN_NAME,
         "module_ids": MODULE_IDS,
+        "group_ph_frames": GROUP_PH_FRAMES,
+        "ph_dp": "ph256" if GROUP_PH_FRAMES == 0 else "ph1024",
         "uds_paths": uds_paths,
         "uds_manager": uds_mgr,
         "tcpreplay_proc": tcpreplay_proc,
diff --git a/tests/ci_tests/start_daq.py b/tests/ci_tests/start_daq.py
@@ -12,6 +12,7 @@ def _parse_args(argv):
     module_ids = []
     bindhost = "0.0.0.0"
     obs = "TEST"
+    group_ph_frames = 0
     i = 1
     while i < len(argv):
         a = argv[i]
@@ -25,12 +26,14 @@ def _parse_args(argv):
             i += 1; bindhost = argv[i]
         elif a == "--obs":
             i += 1; obs = argv[i]
+        elif a == "--group_ph_frames":
+            i += 1; group_ph_frames = int(argv[i])
         else:
             raise SystemExit(f"Unknown arg {a}\n{USAGE}")
         i += 1
     if not run_dir or not module_ids:
         raise SystemExit(f"Missing required args\n{USAGE}")
-    return run_dir, max_file_size_mb, bindhost, obs, module_ids
+    return run_dir, max_file_size_mb, bindhost, group_ph_frames, obs, module_ids
 
 def _write_module_config(run_dir, run_name, module_ids):
     cfg_dir = os.path.join(run_dir, run_name)
@@ -40,7 +43,7 @@ def _write_module_config(run_dir, run_name, module_ids):
         f.write("".join(f"{m}\n" for m in module_ids))
     return cfg_path
 
-def _write_run_script(run_dir, run_name, bindhost, max_file_size_mb, obs):
+def _write_run_script(run_dir, run_name, bindhost, max_file_size_mb, group_ph_frames, obs):
     # Hashpipe runs with cwd = run_dir (parent), RUNDIR is run_name
     script_path = os.path.join(run_dir, "run_hashpipe.sh")
     cfg_rel = f"{run_name}/module.config"
@@ -53,7 +56,7 @@ def _write_run_script(run_dir, run_name, bindhost, max_file_size_mb, obs):
         f'-o RUNDIR={run_name} '
         f'-o CONFIG={cfg_rel} '
         f'-o MAXFILESIZE={max_file_size_mb} '
-        f'-o GROUPPHFRAMES=0 '
+        f'-o GROUPPHFRAMES={group_ph_frames} '
         f'-o OBS={obs} '
         f'net_thread compute_thread output_thread'
     ]
@@ -79,7 +82,7 @@ def _find_hashpipe_pid(expected_tokens, retries=30, delay=0.5):
     return None
 
 def main():
-    run_dir, max_file_size_mb, bindhost, obs, module_ids = _parse_args(sys.argv)
+    run_dir, max_file_size_mb, bindhost, group_ph_frames, obs, module_ids = _parse_args(sys.argv)
     # The tests set cwd to run_dir’s parent (/tmp/ci_run_dir). We ensure directories exist.
     os.makedirs(run_dir, exist_ok=True)
 
@@ -89,7 +92,7 @@ def main():
         os.makedirs(os.path.join(run_dir, f"module_{mid}", run_name), exist_ok=True)
 
     cfg_path = _write_module_config(run_dir, run_name, module_ids)
-    script_path = _write_run_script(run_dir, run_name, bindhost, max_file_size_mb, obs)
+    script_path = _write_run_script(run_dir, run_name, bindhost, max_file_size_mb, group_ph_frames, obs)
 
     # Launch the wrapper script detached from stdio
     proc = subprocess.Popen(
diff --git a/tests/ci_tests/test_can_hashpipe_init.py b/tests/ci_tests/test_can_hashpipe_init.py
@@ -63,13 +63,14 @@ def test_filesystem_outputs_progress(daq_env):
     assert progressed, "Expected at least one module to have updated PFF outputs."
 
 @pytest.mark.usefixtures("daq_env")
-def test_uds_ph256_frames(daq_env):
+def test_uds_ph_frames(daq_env):
     """
-    The tests act as the UDS SERVER. Verify that the ph256 server accepted a connection
+    The tests act as the UDS SERVER. Verify that the ph256 or ph1024 server accepted a connection
     and received at least one frame from hashpipe within a reasonable time.
     """
     uds_mgr = daq_env["uds_manager"]
-    srv = uds_mgr.servers["ph256"]
+    ph_dp = daq_env["ph_dp"]
+    srv = uds_mgr.servers[ph_dp]
 
     # Wait up to 10s for a client connection (hashpipe)
     start = time.time()
@@ -79,13 +80,13 @@ def test_uds_ph256_frames(daq_env):
             connected = True
             break
         time.sleep(0.2)
-    assert connected, "ph256 UDS server did not receive a connection from hashpipe within 10s"
+    assert connected, f"{ph_dp} UDS server did not receive a connection from hashpipe within 10s"
 
     # Wait a bit for at least one frame
     start = time.time()
     while time.time() - start < 10 and srv.frames_received == 0:
         time.sleep(0.2)
-    assert srv.frames_received > 0, "ph256 UDS server did not receive any frames within 10s"
+    assert srv.frames_received > 0, f"{ph_dp} UDS server did not receive any frames within 10s"
 
 # @pytest.mark.usefixtures("daq_env")
 # def test_uds_img16_frames(daq_env):
diff --git a/tests/ci_tests/test_pff_header_consistency.py b/tests/ci_tests/test_pff_header_consistency.py
diff --git a/tests/ci_tests/test_uds_data_path.py b/tests/ci_tests/test_uds_data_path.py
