Platform support for Embedded targets

.github/workflows/ci.yml

@@ -12,17 +12,24 @@ jobs:
   unit-tests-single:
     uses: lf-lang/reactor-c/.github/workflows/unit-tests.yml@main
     with:
-      cmake-args: '-UNUMBER_OF_WORKERS'
+      cmake-args: '-UNUMBER_OF_WORKERS -DLF_UNTHREADED=1'
 
   unit-tests-multi:
     uses: lf-lang/reactor-c/.github/workflows/unit-tests.yml@main
     with:
-      cmake-args: '-DNUMBER_OF_WORKERS=4'
+      cmake-args: '-DNUMBER_OF_WORKERS=4 -DLF_THREADED=1'
 
   fetch-lf:
     uses: lf-lang/lingua-franca/.github/workflows/extract-ref.yml@master
     with:
       file: 'lingua-franca-ref.txt'
+
+  # lf-ssh:
+  #   needs: fetch-lf
+  #   uses: lf-lang/reactor-c/.github/workflows/ssh.yml@main
+  #   with:
+  #     runtime-ref: ${{ github.ref }}
+  #     compiler-ref: ${{ needs.fetch-lf.outputs.ref }}
 
   lf-default:
     needs: fetch-lf

core/CMakeLists.txt

@@ -42,6 +42,8 @@ define(FEDERATED_DECENTRALIZED)
 define(FEDERATED)
 define(LF_REACTION_GRAPH_BREADTH)
 define(LINGUA_FRANCA_TRACE)
+define(LF_THREADED)
+define(LF_UNTHREADED)
 define(LOG_LEVEL)
 define(MODAL_REACTORS)
 define(NUMBER_OF_FEDERATES)
@@ -89,7 +91,7 @@ target_include_directories(core PUBLIC ../include/core/modal_models)
 target_include_directories(core PUBLIC ../include/core/threaded)
 target_include_directories(core PUBLIC ../include/core/utils)
 
-if(DEFINED NUMBER_OF_WORKERS OR DEFINED LINGUA_FRANCA_TRACE)
+if(DEFINED LF_THREADED OR DEFINED LINGUA_FRANCA_TRACE)
     find_package(Threads REQUIRED)
     target_link_libraries(core PUBLIC Threads::Threads)
 endif()

core/federated/RTI/CMakeLists.txt

@@ -52,6 +52,7 @@ include_directories(${IncludeDir}/modal_models)
 include_directories(${IncludeDir}/platform)
 include_directories(${IncludeDir}/utils)
 
+
 # Declare a new executable target and list all its sources
 add_executable(
     RTI
@@ -67,8 +68,8 @@ IF(CMAKE_BUILD_TYPE MATCHES DEBUG)
     target_compile_definitions(RTI PUBLIC LOG_LEVEL=4)
 ENDIF(CMAKE_BUILD_TYPE MATCHES DEBUG)
 
-# Set the number of workers to enable threading
-target_compile_definitions(RTI PUBLIC NUMBER_OF_WORKERS)
+# Set LF_THREADING to get the threaded support
+target_compile_definitions(RTI PUBLIC LF_THREADED=1)
 
 # Find threads and link to it
 find_package(Threads REQUIRED)

core/federated/net_util.c

@@ -573,7 +573,7 @@ void encode_tag(
  * Checks if str matches regex.
  * @return true if there is a match, false otherwise.
  */
-bool match_regex(char* str, char* regex) {
+bool match_regex(const char* str, char* regex) {
     regex_t regex_compiled;
     regmatch_t group;
     bool valid = false;
@@ -617,7 +617,7 @@ bool validate_port(char* port) {
  * Checks if host is valid.
  * @return true if valid, false otherwise.
  */
-bool validate_host(char* host) {
+bool validate_host(const char* host) {
     // regex taken from LFValidator.xtend
     char* ipv4_regex = "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])";
     char* host_or_FQN_regex = "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$";
@@ -629,7 +629,7 @@ bool validate_host(char* host) {
  * Checks if user is valid.
  * @return true if valid, false otherwise.
  */
-bool validate_user(char* user) {
+bool validate_user(const char* user) {
     // regex taken from LFValidator.xtend
     char* username_regex = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$";
     return match_regex(user, username_regex);
@@ -639,7 +639,8 @@ bool validate_user(char* user) {
  * Extract one match group from the rti_addr regex .
  * @return true if SUCCESS, else false.
  */
-bool extract_match_group(const char* rti_addr, char* dest, regmatch_t group, int max_len, int min_len, const char* err_msg) {
+bool extract_match_group(const char* rti_addr, char* dest, regmatch_t group, 
+        int max_len, int min_len, const char* err_msg) {
     size_t size = group.rm_eo - group.rm_so;
     if (size > max_len || size < min_len) {
         lf_print_error("%s", err_msg);
@@ -655,7 +656,7 @@ bool extract_match_group(const char* rti_addr, char* dest, regmatch_t group, int
  * @return true if success, else false.
  */
 bool extract_match_groups(const char* rti_addr, char** rti_addr_strs, bool** rti_addr_flags, regmatch_t* group_array,
-                          int* gids, int* max_lens, int* min_lens, const char** err_msgs) {
+        int* gids, int* max_lens, int* min_lens, const char** err_msgs) {
     for (int i = 0; i < 3; i++) {
         if (group_array[gids[i]].rm_so != -1) {
             if (!extract_match_group(rti_addr, rti_addr_strs[i], group_array[gids[i]], max_lens[i], min_lens[i], err_msgs[i])) {

core/platform/CMakeLists.txt

@@ -13,8 +13,12 @@ elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
     message("Using Windows SDK version ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}")
 elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Arduino")
     set(LF_PLATFORM_FILES lf_arduino_support.c)
+    add_compile_definitions(PUBLIC PLATFORM_ARDUINO)
+elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Nrf52")
+    set(LF_PLATFORM_FILES lf_nrf52_support.c)
+    add_compile_definitions(PUBLIC PLATFORM_NRF52)
 else()
-    message(FATAL_ERROR "Your platform is not supported! The C target supports Linux, MacOS, Windows, and Arduino.")
+    message(FATAL_ERROR "Your platform is not supported! The C target supports Linux, MacOS, Windows, Arduino and Nrf52.")
 endif()
 
 set(GENERAL_SOURCES ${LF_PLATFORM_FILES})

core/platform/Platform.cmake

@@ -8,9 +8,6 @@ elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
     set(LF_PLATFORM_FILE lf_windows_support.c)
     set(CMAKE_SYSTEM_VERSION 10.0)
     message("Using Windows SDK version ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}")
-elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Arduino")
-    set(LF_PLATFORM_FILE lf_arduino_support.c)
-    message("Using Arduino CMake")
 else()
     message(FATAL_ERROR "Your platform is not supported! The C target supports Linux, MacOS and Windows.")
 endif()

core/platform/lf_arduino_support.c

@@ -1,82 +1,167 @@
-/* Arduino Platform API support for the C target of Lingua Franca. */
-
-/*************
-Copyright (c) 2022, The University of California at Berkeley.
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-***************/
-
-/** Arduino API support for the C target of Lingua Franca.
- *
- *  @author{Anirudh Rengarajan <arengarajan@berkeley.edu>}
- */
-
-
-#include <time.h>
-#include <errno.h>
-
-#include "lf_arduino_support.h"
-#include "platform.h"
-#include "Arduino.h"
-
-/**
- * Pause execution for a number of microseconds.
- *
- * This function works very accurately in the range from 3 to 16383 microseconds.
- * We cannot assure that delayMicroseconds will perform precisely for smaller delay-times.
- * Larger delay times may actually delay for an extremely brief time.
- *
- * @return 0 always.
- */
-int lf_nanosleep(instant_t requested_time) {
-    unsigned int microsec = (unsigned int) requested_time;
-    if(microsec < 3) {
-        return 0;
-    }
-    else if(microsec <= 16383) {
-        delayMicroseconds(microsec);
-    }
-    else {
-        delay(microsec / 1000);
-    }
-    return 0;
-}
-
-/**
- * Initialize the LF clock. Arduino auto-initializes its clock, so we don't do anything.
- */
-void lf_initialize_clock() {}
-
-/**
- * Fetch the value of _LF_CLOCK (see lf_arduino_support.h) and store it in t. The
- * timestamp value in 't' will be physical Arduino time in microseconds,
- * which starts once Arduino boots up.
- *
- * @return 0 for success, or -1 for failure. In case of failure, errno will be
- *  set appropriately.
- */
-int lf_clock_gettime(instant_t* t) {
-
-    if (t == NULL) {
-        // The t argument address references invalid memory
-        errno = EFAULT;
-        return -1;
-    }
-
-    *t = micros();
-    return 0;
-}
+/* Arduino Platform API support for the C target of Lingua Franca. */
+
+/*************
+Copyright (c) 2022, The University of California at Berkeley.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***************/
+
+/** Arduino API support for the C target of Lingua Franca.
+ *  
+ *  @author{Anirudh Rengarajan <arengarajan@berkeley.edu>}
+ *  @author{Erling Rennemo Jellum <erling.r.jellum@ntnu.no>}
+ */
+
+
+#include <time.h>
+#include <errno.h>
+
+#include "lf_arduino_support.h"
+#include "../platform.h"
+#include "Arduino.h"
+
+// Combine 2 32bit values into a 64bit
+#define COMBINE_HI_LO(hi,lo) ((((uint64_t) hi) << 32) | ((uint64_t) lo))
+
+// Keep track of physical actions being entered into the system
+static volatile bool _lf_async_event = false;
+// Keep track of whether we are in a critical section or not
+static volatile int _lf_in_critical_section = 0;
+
+/**
+ * Global timing variables:
+ * Since Arduino is 32bit, we need to also maintain the 32 higher bits.
+
+ * _lf_time_us_high is incremented at each overflow of 32bit Arduino timer.
+ * _lf_time_us_low_last is the last value we read from the 32 bit Arduino timer.
+ *  We can detect overflow by reading a value that is lower than this.
+ *  This does require us to read the timer and update this variable at least once per 35 minutes.
+ *  This is not an issue when we do a busy-sleep. If we go to HW timer sleep we would want to register an interrupt 
+ *  capturing the overflow.
+
+ */
+static volatile uint32_t _lf_time_us_high = 0;
+static volatile uint32_t _lf_time_us_low_last = 0;
+
+/**
+ * @brief Sleep until an absolute time.
+ * TODO: For improved power consumption this should be implemented with a HW timer and interrupts.
+ * 
+ * @param wakeup int64_t time of wakeup 
+ * @return int 0 if successful sleep, -1 if awoken by async event
+ */
+int lf_sleep_until(instant_t wakeup) {
+    instant_t now;
+    _lf_async_event = false;
+    lf_critical_section_exit();
+
+    // Do busy sleep
+    do {
+        lf_clock_gettime(&now);        
+    } while ((now < wakeup) && !_lf_async_event);
+
+    lf_critical_section_enter();
+
+    if (_lf_async_event) {
+        lf_ack_events();
+        return -1;
+    } else {
+        return 0;
+    }
+
+}
+
+/**
+ * @brief Sleep for a specified duration.
+
+ * 
+ * @param sleep_duration int64_t nanoseconds representing the desired sleep duration
+ * @return int 0 if success. -1 if interrupted by async event.
+ */
+int lf_sleep(interval_t sleep_duration) {
+    instant_t now;
+    lf_clock_gettime(&now);
+    instant_t wakeup = now + sleep_duration;
+
+    return lf_sleep_until(wakeup);
+
+}
+
+/**
+ * Initialize the LF clock. Arduino auto-initializes its clock, so we don't do anything.
+ */
+void lf_initialize_clock() {}
+
+/**
+ * Write the current time in nanoseconds into the location given by the argument.
+ * This returns 0 (it never fails, assuming the argument gives a valid memory location).
+ * This has to be called at least once per 35 minutes to properly handle overflows of the 32-bit clock.
+ * TODO: This is only addressable by setting up interrupts on a timer peripheral to occur at wrap.
+ */
+int lf_clock_gettime(instant_t* t) {
+
+    assert(t != NULL);
+
+    uint32_t now_us_low = micros();
+
+    // Detect whether overflow has occured since last read
+    // TODO: This assumes that we lf_clock_gettime is called at least once per overflow
+    if (now_us_low < _lf_time_us_low_last) {
+        _lf_time_us_high++;
+    }
+
+    *t = COMBINE_HI_LO(_lf_time_us_high, now_us_low) * 1000ULL;
+    return 0;
+}
+
+/**
+ * Enter a critical section by disabling interrupts, supports 
+ * nested critical sections.
+*/
+int lf_critical_section_enter() { 
+    if (_lf_in_critical_section++ == 0) {
+        // First nested entry into a critical section.
+        // If interrupts are not initially enabled, then increment again to prevent
+        // TODO: Do we need to check whether the interrupts were enabled to
+        //  begin with? AFAIK there is no Arduino API for that 
+        noInterrupts();
+    }
+    return 0;
+}
+
+/**
+ * @brief Exit a critical section.
+ * If interrupts were enabled when the matching call to 
+ * lf_critical_section_enter()
+ * occurred, then they will be re-enabled here.
+ */
+int lf_critical_section_exit() {
+    _lf_in_critical_section--;
+    if (_lf_in_critical_section == 0) {
+        interrupts();
+    }
+    return 0;
+}
+
+/**
+ * Handle notifications from the runtime of changes to the event queue.
+ * If a sleep is in progress, it should be interrupted.
+*/
+int lf_notify_of_event() {
+   _lf_async_event = true;
+   return 0;
+}