Warping a infinite loop using ctypes

Question

I have some dlls that control a hardware piece to acquire some information. They work by having a infinite loop that keeps doing constant acquisitions of new data every couple of seconds.

Is it possible to warp this infinite loop function so it can be called in python in parallel while other work is done (periodically checking the loop for new data)? Or would it be better to replicate the loop in python (I would need them to save all the current state of the C functions on each execution)?

In other words, I want to call this function and have it start acquiring and them every couple of seconds peak at the data (from python) to see it.

Bellow a minimal example

On C:

#include <stdio.h>
void loop()
{
    while( 1 )
    {
        GetNewData();
        sleep(1);
    }
}

On python:

import multiprocessing as mp
from multiprocessing.pool import Pool
from ctypes import *

def worker():
    lib = CDLL("test.dll")
    lib.loop()

def call(func):
    global p
    a = p.apply_async(func)
    a.get()       

if __name__ == '__main__':
    p = Pool(1)
    call(worker)
    DoSomethingElse() # Code never reaches this point.

Although it doesn't have any effect here, check [\[SO\]: C function called from Python via ctypes returns incorrect value (@CristiFati's answer)](https://stackoverflow.com/questions/58610333/c-function-called-from-python-via-ctypes-returns-incorrect-value/58611011#58611011). The *C* loop looks poorly designed to me, there should be a condition alterable from outside so that clean exit is possible. How does data get out of it? You're misusing the pool, start it in a separate process, but then wait for it to end which obviously never happens. Maybe give it a timeout? p is not global (argument?). — CristiFati, Apr 13 '22 at 14:51

score 1 · Accepted Answer · answered Apr 13 '22 at 19:55

It sounds like you need a thread with a callback function and a way to stop it. Here's a rough example:

test.c

#ifdef _WIN32
#   define API __declspec(dllexport)
#else
#   define API
#endif

typedef void (*CALLBACK)(int);

int g_running;

API void run(CALLBACK cb) {
    g_running = 1;
    int data = 0;
    while(g_running)
        cb(data++);
}

API void stop() {
    g_running = 0;
}

test.py

import ctypes as ct
import threading
import time

# ctypes wrapper for a C function callback.
# returns None and takes an integer.
CALLBACK = ct.CFUNCTYPE(None,ct.c_int)

dll = ct.CDLL('./test')
dll.run.argtypes = CALLBACK,
dll.run.restype = None
dll.stop.argtypes = ()
dll.stop.restype = None

# decorate a Python function with the ctypes callback
# and it can be passed to a C function and called.
@CALLBACK
def callback(data):
    print(data)
    time.sleep(.1) # just to slow it down.

# start a thread with the run function.
t = threading.Thread(target=dll.run, args=(callback,))
t.start()

time.sleep(.2)
print('\tdoing')
time.sleep(.2)
print('\tsomething')
time.sleep(.2)
print('\telse')
time.sleep(.4)

# issue stop and wait for graceful exit of thread
dll.stop()
t.join()

Output:

0
1
        doing
2
3
        something
4
5
        else
6
7
8
9

Thank you So much! Using threading instead of the multiprocessing makes it work perfect. Also thanks for the suggestion on using the callback from python. I wasn't aware that this was possible and it makes the process of receiving the data much better — Sicks, Apr 15 '22 at 16:12

Warping a infinite loop using ctypes

1 Answers1