def test_pop(self):
ring_buffer = RingBuffer(size=5)
add1 = np.array([1, 2, 3], dtype=np.complex64)
ring_buffer.push(add1)
self.assertTrue(np.array_equal(add1, ring_buffer.pop(40)))
self.assertTrue(ring_buffer.is_empty)
add2 = np.array([1, 2, 3, 4], dtype=np.complex64)
ring_buffer.push(add2)
self.assertTrue(np.array_equal(add2, ring_buffer.pop(4)))
self.assertTrue(ring_buffer.is_empty)
add3 = np.array([1, 2], dtype=np.complex64)
ring_buffer.push(add3)
popped_item = ring_buffer.pop(1)
self.assertTrue(np.array_equal(add3[0:1], popped_item),
msg=popped_item)
self.assertFalse(ring_buffer.is_empty)
add4 = np.array([7, 8, 9, 10], dtype=np.complex64)
ring_buffer.push(add4)
self.assertFalse(ring_buffer.will_fit(1))
self.assertTrue(
np.array_equal(np.concatenate((np.atleast_1d(add3[1]), add4)),
ring_buffer.pop(5)))
def test_pop(self):
ring_buffer = RingBuffer(size=5)
add1 = np.array([1, 2, 3], dtype=np.complex64)
ring_buffer.push(add1)
self.assertTrue(np.array_equal(add1, ring_buffer.pop(40)))
self.assertTrue(ring_buffer.is_empty)
add2 = np.array([1, 2, 3, 4], dtype=np.complex64)
ring_buffer.push(add2)
self.assertTrue(np.array_equal(add2, ring_buffer.pop(4)))
self.assertTrue(ring_buffer.is_empty)
add3 = np.array([1, 2], dtype=np.complex64)
ring_buffer.push(add3)
popped_item = ring_buffer.pop(1)
self.assertTrue(np.array_equal(add3[0:1], popped_item),
msg=popped_item)
self.assertFalse(ring_buffer.is_empty)
def test_continuous_pop(self):
ring_buffer = RingBuffer(size=10)
values = np.array(list(range(10)), dtype=np.complex64)
ring_buffer.push(values)
retrieved = np.array([], dtype=np.complex64)
for i in range(10):
retrieved = np.append(retrieved, ring_buffer.pop(1))
self.assertTrue(np.array_equal(values, retrieved))
def test_continuous_pop(self):
ring_buffer = RingBuffer(size=10)
values = np.array(list(range(10)), dtype=np.complex64)
ring_buffer.push(values)
retrieved = np.array([], dtype=np.complex64)
for i in range(10):
retrieved = np.append(retrieved, ring_buffer.pop(1))
self.assertTrue(np.array_equal(values, retrieved))
def test_continuous_pop(self):
ring_buffer = RingBuffer(size=10)
values = IQArray(np.array(list(range(10)), dtype=np.complex64))
ring_buffer.push(values)
retrieved = np.empty(0, dtype=np.float32)
for i in range(10):
retrieved = np.append(retrieved, ring_buffer.pop(1))
self.assertEqual(values, IQArray(retrieved))
def test_pop(self):
ring_buffer = RingBuffer(size=5)
add1 = np.array([1, 2, 3], dtype=np.complex64)
ring_buffer.push(add1)
self.assertTrue(np.array_equal(add1, ring_buffer.pop(40)))
self.assertTrue(ring_buffer.is_empty)
add2 = np.array([1, 2, 3, 4], dtype=np.complex64)
ring_buffer.push(add2)
self.assertTrue(np.array_equal(add2, ring_buffer.pop(4)))
self.assertTrue(ring_buffer.is_empty)
add3 = np.array([1, 2], dtype=np.complex64)
ring_buffer.push(add3)
popped_item = ring_buffer.pop(1)
self.assertTrue(np.array_equal(add3[0:1], popped_item), msg=popped_item)
self.assertFalse(ring_buffer.is_empty)
add4 = np.array([7, 8, 9, 10], dtype=np.complex64)
ring_buffer.push(add4)
self.assertFalse(ring_buffer.will_fit(1))
self.assertTrue(np.array_equal(np.concatenate((np.atleast_1d(add3[1]), add4)), ring_buffer.pop(5)))
def send_raw_data_continuously(self, ring_buffer: RingBuffer, num_samples_to_send: int, num_repeats: int):
rng = iter(int, 1) if num_repeats <= 0 else range(0, num_repeats) # <= 0 = forever
samples_per_iteration = 65536 // 2
for _ in rng:
if self.__sending_interrupt_requested:
break
while self.current_sent_sample < num_samples_to_send:
if self.__sending_interrupt_requested:
break
n = max(0, min(samples_per_iteration, num_samples_to_send - self.current_sent_sample))
data = ring_buffer.pop(n, ensure_even_length=True)
self.send_data(data)
self.current_sent_sample += len(data)
self.current_sending_repeat += 1
self.current_sent_sample = 0
self.current_sent_sample = num_samples_to_send
def send_raw_data_continuously(self, ring_buffer: RingBuffer,
num_samples_to_send: int, num_repeats: int):
rng = iter(int, 1) if num_repeats <= 0 else range(
0, num_repeats) # <= 0 = forever
samples_per_iteration = 65536 // 2
sock = self.prepare_send_connection()
if sock is None:
return
try:
for _ in rng:
if self.__sending_interrupt_requested:
break
while num_samples_to_send is None or self.current_sent_sample < num_samples_to_send:
while ring_buffer.is_empty and not self.__sending_interrupt_requested:
time.sleep(0.1)
if self.__sending_interrupt_requested:
break
if num_samples_to_send is None:
n = samples_per_iteration
else:
n = max(
0,
min(samples_per_iteration, num_samples_to_send -
self.current_sent_sample))
data = ring_buffer.pop(n, ensure_even_length=True)
if len(data) > 0:
self.send_data(data, sock)
self.current_sent_sample += len(data)
time.sleep(0.0000001)
self.current_sending_repeat += 1
self.current_sent_sample = 0
self.current_sent_sample = num_samples_to_send
finally:
self.shutdown_socket(sock)
def send_raw_data_continuously(self, ring_buffer: RingBuffer, num_samples_to_send: int, num_repeats: int):
rng = iter(int, 1) if num_repeats <= 0 else range(0, num_repeats) # <= 0 = forever
samples_per_iteration = 65536 // 2
sock = self.prepare_send_connection()
if sock is None:
return
try:
for _ in rng:
if self.__sending_interrupt_requested:
break
while num_samples_to_send is None or self.current_sent_sample < num_samples_to_send:
while ring_buffer.is_empty and not self.__sending_interrupt_requested:
time.sleep(0.1)
if self.__sending_interrupt_requested:
break
if num_samples_to_send is None:
n = samples_per_iteration
else:
n = max(0, min(samples_per_iteration, num_samples_to_send - self.current_sent_sample))
data = ring_buffer.pop(n, ensure_even_length=True)
if len(data) > 0:
self.send_data(data, sock)
self.current_sent_sample += len(data)
self.current_sending_repeat += 1
self.current_sent_sample = 0
self.current_sent_sample = num_samples_to_send
finally:
self.shutdown_socket(sock)
