watch_buffer_fill/
watch_buffer_fill.rs

1//! Simple binary to illustrate that the RB buffers are filling
2//!
3//! This is for debugging purposes mainly
4extern crate liftof_rb;
5
6use std::{thread, time};
7
8use indicatif::{MultiProgress,
9                ProgressBar, 
10                ProgressStyle};
11
12use liftof_rb::api::*;
13use liftof_rb::control::*;
14use liftof_rb::memory::RamBuffer;
15use liftof_rb::memory::RegisterError;
16
17
18const UIO1_TRIP : u32 = 66520576;
19const UIO2_TRIP : u32 = 66520576;
20
21
22#[macro_use] extern crate log;
23
24/// Non-register related constants
25const TEMPLATE_BAR_A  : &str = "[{elapsed_precise}] {bar:60.blue/white} {pos:>7}/{len:7} {msg}";
26const TEMPLATE_BAR_B  : &str = "[{elapsed_precise}] {bar:60.orange/white} {pos:>7}/{len:7} {msg}";
27const TEMPLATE_BAR_EV : &str = "[{elapsed_precise}] {bar:60.red/white} {pos:>7}/{len:7} {msg}";
28
29
30
31///! Get the blob buffer size from occupancy register
32///
33///  Read out the occupancy register and compare to 
34///  a previously recoreded value. 
35///  Everything is u32 (the register can't hold more)
36///
37///  The size of the buffer can only be defined compared
38///  to a start value. If the value rools over, the 
39///  size then does not make no longer sense and needs
40///  to be updated.
41///
42///  #Arguments: 
43///
44fn get_buff_size(which : &RamBuffer, buff_start : &mut u32) ->Result<u32, RegisterError> {
45  let size : u32;
46  let occ = get_blob_buffer_occ(&which)?;
47  if *buff_start > occ {
48    debug!("The occupancy counter has rolled over!");
49    debug!("It reads {occ}");
50    //size = occ;
51    //*buff_start = occ;
52    return Err(RegisterError::Unknown);
53  } else {
54    size  = occ - *buff_start;
55  }
56  Ok(size)
57}
58
59fn buff_handler(which      : &RamBuffer,
60                buff_start : u32,
61                prog_bar   : Option<&ProgressBar>) -> u32 {
62  
63  let mut buff_start_temp = buff_start.clone();
64  let mut buff_size : u32;
65  let one_milli   = time::Duration::from_millis(1);
66
67  match get_buff_size(&which, &mut buff_start_temp) {
68    Ok(sz) => buff_size = sz,
69    Err(_) => {
70      debug!("Buffer {which:?} is full!");
71      // the buffer is actually full and needs to be reset
72      //switch_ram_buffer();
73      match reset_ram_buffer_occ(&which) {
74        Err(err) => {
75          error!("Can not reset ram_buffer! {err}");
76        },
77        Ok(_) => ()
78      }
79      thread::sleep(one_milli);
80      match get_buff_size(&which, &mut buff_start_temp) {
81        Ok(sz) => buff_size = sz,
82        Err(_) => buff_size = 0
83      }
84      debug!("Got NEW buffer size of {buff_size} for buff {which:?}");
85    }
86  }
87  trace!("Got buffer size of {buff_size} for buff {which:?}");
88  if buff_size > UIO1_TRIP {
89    debug!("Buff {which:?} tripped");  
90    // reset the buffers
91    //switch_ram_buffer();
92    match reset_ram_buffer_occ(&which) {
93      Err(err) => {
94        error!("Can not reset RAM buffers! {err}");
95      },
96      Ok(_) => (), 
97    }
98    thread::sleep(one_milli);
99    // get the new size after reset
100    match get_buff_size(&which, &mut buff_start_temp) {
101      Ok(sz) => buff_size = sz,
102      Err(_) => buff_size = 0
103    }
104    debug!("Got NEW buffer size of {buff_size} for buff {which:?}");
105  }
106  match prog_bar {
107    Some(bar) => bar.set_position(buff_size as u64),
108    None      => () 
109  }
110  buff_start_temp
111}
112
113pub fn setup_progress_bar(msg : String, size : u64, format_string : String) -> ProgressBar {
114  let bar = ProgressBar::new(size).with_style(
115    ProgressStyle::with_template(&format_string)
116    .unwrap()
117    .progress_chars("##-"));
118  //);
119  bar.set_message(msg);
120  bar
121}
122
123fn main() {
124  // some pre-defined time units for 
125  // sleeping
126  let two_seconds = time::Duration::from_millis(2000);
127  let one_milli   = time::Duration::from_millis(1);
128  info!("Setting daq to idle mode");
129  match idle_drs4_daq() {
130    Ok(_)    => info!("DRS4 set to idle:"),
131    Err(err) => panic!("Can't set DRS4 to idle!! Err {err}")
132  }
133  thread::sleep(one_milli);
134  match setup_drs4() {
135    Ok(_)    => info!("DRS4 setup routine complete!"),
136    Err(err) => panic!("Failed to setup DRS4!! Err {err}")
137  }
138
139  
140  // get the current cache sizes
141  let buf_a = RamBuffer::A;
142  let buf_b = RamBuffer::B;
143  reset_dma().unwrap();
144  thread::sleep(one_milli);
145  let mut buf_a_start = get_blob_buffer_occ(&buf_a).unwrap();
146  let mut buf_b_start = get_blob_buffer_occ(&buf_b).unwrap();
147  info!("We got start values for the blob buffers at {buf_a_start} and {buf_b_start}");
148  // now we are ready to receive data 
149  info!("Starting daq!");
150  match start_drs4_daq() {
151    Ok(_)    => info!(".. successful!"),
152    Err(err) => panic!("DRS4 start failed! Err {err}")
153  }
154
155  // let go for a few seconds to get a 
156  // rate estimate
157  println!("getting rate estimate..");
158  thread::sleep(two_seconds);
159  let rate = get_trigger_rate().unwrap();
160  println!("Running at a trigger rate of {rate} Hz");
161
162  // event loop
163  let mut evt_cnt          : u32;
164  let mut last_evt_cnt     : u32 = 0;
165
166  let mut n_events         : u64 = 0;
167
168  let mut skipped_events   : u64 = 0;
169  let mut delta_events     : u64;
170
171  let mut first_iter       = true;
172  
173  // acquire this many events
174  let max_event : u64 = 10000;
175
176  let multi_bar = MultiProgress::new();
177  let bar_a  = multi_bar.add(setup_progress_bar(String::from("buff A"), UIO1_TRIP as u64, String::from(TEMPLATE_BAR_A)));  
178  let bar_b  = multi_bar.insert_after(&bar_a,setup_progress_bar(String::from("buff B"), UIO2_TRIP as u64, String::from(TEMPLATE_BAR_B))); 
179  let bar_ev = multi_bar.insert_after(&bar_b,setup_progress_bar(String::from("events"), max_event, String::from(TEMPLATE_BAR_EV)));         
180
181  match enable_trigger() {
182    Ok(_) => (),
183    Err(err) => error!("Can not enable triggers, Error {err}")
184  }
185
186  loop {
187    evt_cnt = get_event_count().unwrap();
188    if first_iter {
189      last_evt_cnt = evt_cnt;
190      first_iter = false;
191    }
192    if evt_cnt == last_evt_cnt {
193      thread::sleep(one_milli);
194      continue;
195    }
196    // let's do some work
197    buf_a_start = buff_handler(&buf_a, buf_a_start, Some(&bar_a)); 
198    buf_b_start = buff_handler(&buf_b, buf_b_start, Some(&bar_b)); 
199    delta_events = (evt_cnt - last_evt_cnt) as u64;
200    if delta_events > 1 {
201      skipped_events += delta_events;
202    }
203    
204    n_events += 1;
205    bar_ev.inc(delta_events);   
206    // exit loop on n event basis
207    if n_events > max_event {
208      match idle_drs4_daq() {
209        Err(err) => {
210          error!("Can't set daq to idle mode! {err}");
211        },
212        Ok(_) => (),
213      }
214      println!("We skipped {skipped_events} events");
215      thread::sleep(one_milli);
216      bar_ev.finish();
217      break;
218    }
219    last_evt_cnt = evt_cnt;
220  }
221} // end main
watch_buffer_fill/watch_buffer_fill.rs

watch_buffer_fill/
watch_buffer_fill.rs
