juliac demo working!

Co-authored-by: Cody Tapscott <topolarity@tapscott.me>

Author: baggepinnen

examples/juliac/juliac_pid.jl

@@ -44,7 +44,7 @@ end
 
 end
 
-# compile using something like
+# compile using something like this, modified to suit your local paths
 # cd(@__DIR__)
 # run(`/home/fredrikb/repos/julia/julia --project --experimental /home/fredrikb/repos/julia/contrib/juliac.jl --output-lib juliac_pid --experimental --trim=unsafe-warn --compile-ccallable juliac_pid.jl`)
-# run(`ls -ltrh`) # marvel at the smallness of the binary
+# run(`ls -ltrh`)

examples/juliac/test_juliac_pid.c

@@ -1,48 +1,74 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <dlfcn.h>
-#include <julia.h>
+// #include <julia.h>
 
-// Define the type of the function calculate_control
+// Path to julia binary folder
+#define JULIA_PATH "/home/fredrikb/repos/julia/usr/bin/" // NOTE: modify this path
+
+// Path to juliac compiled shared object file
+#define LIB_PATH "/home/fredrikb/.julia/dev/DiscretePIDs/examples/juliac/juliac_pid.so" // NOTE: modify this path
+
+
+
+// Define the types of the julia @ccallable functions
+typedef void (*jl_init_with_image_t)(const char *bindir, const char *sysimage);
 typedef double (*calculate_control_t)(double r, double y, double uff);
+typedef void (*set_K_t)(double K, double r, double y);
+typedef void (*set_Ti_t)(double Ti);
+typedef void (*set_Td_t)(double Td);
+typedef void (*reset_state_t)();
 
-int main() {
-    jl_init();
 
-    const char *lib_path = "/home/fredrikb/.julia/dev/DiscretePIDs/examples/juliac/juliac_pid.so";
+int main() {
 
     // Load the shared library
     printf("Loading juliac_pid.so\n");
-    void *lib_handle = dlopen(lib_path, RTLD_LAZY);
+    void *lib_handle = dlopen(LIB_PATH, RTLD_LAZY);
     if (!lib_handle) {
         fprintf(stderr, "Error: Unable to load library %s\n", dlerror());
         exit(EXIT_FAILURE);
     }
     printf("Loaded juliac_pid.so\n");
 
-    // Locate the calculate_control function
-    printf("Finding calculate_control!\n");
+    // Locate the julia functions function
+    printf("Finding symbols\n");
+    jl_init_with_image_t jl_init_with_image = (jl_init_with_image_t)dlsym(lib_handle, "jl_init_with_image");
+
     calculate_control_t calculate_control = (calculate_control_t)dlsym(lib_handle, "calculate_control!");
-    char *error = dlerror();
-    if (error != NULL) {
-        fprintf(stderr, "Error: Unable to find symbol calculate_control!: %s\n", error);
-        dlclose(lib_handle);
+    set_K_t set_K = (set_K_t)dlsym(lib_handle, "set_K!");
+    set_Ti_t set_Ti = (set_Ti_t)dlsym(lib_handle, "set_Ti!");
+    set_Td_t set_Td = (set_Td_t)dlsym(lib_handle, "set_Td!");
+    reset_state_t reset_state = (reset_state_t)dlsym(lib_handle, "reset_state!");
+
+
+    if (jl_init_with_image == NULL || calculate_control == NULL) {
+        char *error = dlerror();
+        fprintf(stderr, "Error: Unable to find symbol: %s\n", error);
         exit(EXIT_FAILURE);
     }
-    printf("Found calculate_control!\n");
+    printf("Found all symbols!\n");
+
+    // Init julia
+    jl_init_with_image(JULIA_PATH, LIB_PATH);
 
-    // Call the function
-    double r = 0.0, y = 0.0, uff = 0.0;
+    // Trivial test program that computes a few control outputs and modifies K
+    double r = 1.0, y = 0.0, uff = 0.0;
     double result = calculate_control(r, y, uff);
     printf("calculate_control! returned: %f\n", result);
+    result = calculate_control(r, y, uff);
+    printf("calculate_control! returned: %f\n", result);
+    set_K(0.0, r, y);
+    for (int i = 0; i < 3; ++i) {
+        result = calculate_control(r, y, uff);
+        printf("calculate_control! returned: %f\n", result);
+    }
 
-    // Close the library
-    dlclose(lib_handle);
-
-    jl_atexit_hook(0);
+    // jl_atexit_hook(0);
     return 0;
 }
 
 
+// Compile this C program using a command like the one above, modified to suit your paths
 // export LD_LIBRARY_PATH=/home/fredrikb/repos/julia/usr/lib:$LD_LIBRARY_PATH
 // gcc -o pid_program test_juliac_pid.c -I /home/fredrikb/repos/julia/usr/include/julia -L/home/fredrikb/repos/julia/usr/lib -ljulia -ldl

examples/juliac/test_juliac_pid.jl

@@ -2,8 +2,11 @@
 cd(@__DIR__)
 
 const T = Float64
+@info("Loading juliac_pid.so")
 lib = Libc.Libdl.dlopen("/home/fredrikb/.julia/dev/DiscretePIDs/examples/juliac/juliac_pid.so")
+@info("Loaded juliac_pid.so, finding calculate_control!")
 const calc = Libc.Libdl.dlsym(lib, :calculate_control!)
+@info("Found calculate_control!")
 
 function pid(r::T, y::T, uff::T)
     ccall(calc, T, (T, T, T), r, y, uff)

src/DiscretePIDs.jl

@@ -71,7 +71,7 @@ u = calculate_control!(pid, r, y, uff) # Equivalent to the above
 - `D`: Derivative part
 - `yold`: Last measurement signal
 
-See also [`calculate_control!`](@ref), [`set_K!`](@ref), [`set_Ti!`](@ref), [`set_Td!`](@ref)
+See also [`calculate_control!`](@ref), [`set_K!`](@ref), [`set_Ti!`](@ref), [`set_Td!`](@ref), [`reset_state!`](@ref).
 """
 function DiscretePID(;
     K::T  = 1f0,
@@ -115,6 +115,8 @@ end
     set_K!(pid::DiscretePID, K, r, y)
 
 Update `K` in the PID controller. This function takes the current reference and measurement as well in order to provide bumpless transfer. This is realized by updating the internal state `I`.
+
+Note: Due to the bumpless transfer, setting ``K = 0`` does not imply that the controller output will be 0 if the integral state is non zero. To reset the controller state, call `reset_state!(pid)`.
 """
 function set_K!(pid::DiscretePID, K, r, y)
     Kold = pid.K