sch_event_management.c updated

Added the smiplest function of arbitraging the execution of processes

Author: drowsymike

examples/stm32f4x/app/src/main.c

@@ -1,3 +1,4 @@
+#include "sch_event_management.h"
 #include "stm32f4xx_hal.h"
 #include "main.h"
 #include "sch.h"
@@ -30,7 +31,7 @@ int main(void)
   MX_GPIO_Init();
   MX_USART2_UART_Init();
 
-  /*sch_task_t first_task;
+  sch_task_t first_task;
   sch_task_t second_task;
   sch_task_t echo_data;
   sch_task_t another_system_task;
@@ -46,13 +47,15 @@ int main(void)
 
   sch_task_create(&echo_data, -4, 3, echo_task_dispatch, echo_task_init);
   sch_task_activate(&echo_data);
-  sch_task_run(&echo_data, NULL);*/
+  sch_task_run(&echo_data, NULL);
+
+  sch_event_management();
 
   /*char buf[40] = {0};
   snprintf(buf, sizeof(buf), "%d\r\n", sch_find_most_significant_task(sch_preempt_tasks_ready_set));
   HAL_UART_Transmit(&huart2, (uint8_t*)buf, strlen(buf), HAL_MAX_DELAY);*/
 
-  sch_context_change_interrupt_check = 1;
+  /*sch_context_change_interrupt_check = 1;
   sch_context_change();
   if (sch_context_change_interrupt_check == 0) 
   {
@@ -62,7 +65,7 @@ int main(void)
   {
     HAL_UART_Transmit(&huart2, (uint8_t*)"sch_context_change_interrupt_check != 0", \
     strlen("sch_context_change_interrupt_check != 0"), HAL_MAX_DELAY);
-  }
+  }*/
 
 
   while (1)

sch/inc/sch.h

@@ -14,7 +14,7 @@
 extern "C" {
 #endif
 
-#include <stdio.h>
+#include <stddef.h>
 #include <stdint.h>
 
 #include "sch_config.h"
@@ -23,6 +23,14 @@ extern "C" {
 #include "sch_task_management.h"
 #include "sch_event_management.h"
 
+/*--Functions----------------------------------------------------------------*/
+
+/**
+ * @brief Wrapper function for starting the arbitraging the processes
+ * 
+ */
+uint8_t sch_run(void);
+
 #ifdef __cplusplus
 }
 #endif

sch/inc/sch_common.h

@@ -9,7 +9,7 @@
 #ifndef SCH_COMMON_H
 #define SCH_COMMON_H
 
-#include <cstdint>
+#include <stdint.h>
 #ifdef __cplusplus
 extern "C" {
 #endif

sch/inc/sch_config.h

@@ -16,18 +16,27 @@ extern "C" {
 
 /**
  * @brief the SCH_MAX_QUANTITY_OF_TASKS macros 
- *   defines the max quantity of tasks
+ * defines the max quantity of tasks
+ * 
  */
 #define SCH_MAX_QUANTITY_OF_TASKS 3
 
 /**
  * @brief mode of SCH arbitration. There're options:
- *   Manual (SCH_ARBITRATION_MODE_MANUAL)
- *   Systick (SCH_ARBITRATION_MODE_SYSTICK)
+ * Manual (SCH_ARBITRATION_MODE_MANUAL)
+ * Systick (SCH_ARBITRATION_MODE_SYSTICK)
  * 
  */
 #define SCH_ARBITRATION_MODE SCH_ARBITRATION_MODE_MANUAL
 
+/**
+ * @brief Turning on/off the events. There're options:
+ * On (SCH_EVENTS_ON)
+ * Off (SCH_EVENTS_OFF)
+ * 
+ */
+#define SCH_EVENTS_STATE SCH_EVENTS_OFF
+
 #ifdef __cplusplus
 }
 #endif

sch/inc/sch_event_management.h

@@ -1,3 +1,19 @@
+/**
+ * @file sch_event_management.h
+ * @author Mike Strangewood (michael.a.strangewood@gmail.com)
+ * @brief This file contains any solutions for implementing the communication 
+ * between processes (or between a process and something outside)
+ * @version 0.1
+ * @date 2026-04-07
+ * 
+ */
+
+/**
+ * @note: In commentaries I'll name communcation between processes by the name
+ * "P2P", and communication between a process and environment by the "P2E" name
+ *
+ */
+
 #ifndef SCH_EVENT_MANAGEMENT_H
 #define SCH_EVENT_MANAGEMENT_H
 
@@ -7,20 +23,43 @@
 extern "C" {
 #endif
 
-typedef struct {
-    uint16_t sig;
-} sch_event_header;
+#if SCH_EVENTS_STATE == SCH_EVENTS_ON
 
-typedef struct {
-    sch_event_header event_header;
-    int16_t first_data;
-    int16_t second_data;
-} sch_event;
+  /*--Structures---------------------------------------------------------------*/
+  
+  /**
+   * @brief Structure for defining the header of packet (a particle) of 
+   * communication between processes
+   * 
+   */
+  typedef struct {
+      uint16_t sig;
+  } sch_event_header;
 
-void sch_event_management(sch_task_t* sch_task);
+  /**
+   * @brief Structure for defining for the package of communication intself
+   * 
+   */
+  typedef struct {
+      sch_event_header event_header;
+      int16_t first_data;
+      int16_t second_data;
+  } sch_event;
+
+  /*--Functions----------------------------------------------------------------*/
+
+  /**
+   * @brief Portable function. Defines the "process" of scheduling and arbitrating
+   * the processes
+   * 
+   * @param sch_task
+   */
+  uint8_t sch_event_management(void);
+
+  #ifdef __cplusplus
+  }
+  #endif
 
-#ifdef __cplusplus
-}
 #endif
 
 #endif

sch/port/stm32f4xx/sch_context_change.s

@@ -12,16 +12,16 @@
 
 @ -----------------------------------------------------------------------------
 
-PendSV_Handler:
-    push {lr}
-    ldr r0, =sch_system_tasks_ready_set
-    ldr r0, [r0
-    bl sch_find_most_significant_task
-    cbz r0, .exit_pendsv
-    sub r0, r0, #1
-    bl sch_call_dispatch[cite: 17]
-.exit_pendsv:
-    pop {pc}
+@ PendSV_Handler:
+@    push {lr}
+@    ldr r0, =sch_system_tasks_ready_set
+@    ldr r0, [r0
+@    bl sch_find_most_significant_task
+@    cbz r0, .exit_pendsv
+@    sub r0, r0, #1
+@    bl sch_call_dispatch[cite: 17]
+@.exit_pendsv:
+@    pop {pc}
 
 @ -----------------------------------------------------------------------------
 

sch/port/stm32f4xx/sch_event_management.c

@@ -1,20 +1,41 @@
+/**
+ * @file sch_event_management.c
+ * @author Mike Strangewood (michael.a.strangewood@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2026-04-07
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+
 #include "sch.h"
 #include "sch_config.h"
 #include "sch_event_management.h"
 
-/*
-  todo:
-  i know you do read this hehe
-  
-*/
+/*--Functions----------------------------------------------------------------*/
 
-void sch_event_management(sch_task_t* sch_task) {
-  #if SCH_ARBITRATION_MODE == SCH_ARBITRATION_MODE_SYSTICK
+/**
+ * @brief Portable function. Defines the "process" of scheduling and arbitrating
+ * the processes
+ * 
+ * @param sch_task
+ */
+uint8_t sch_event_management(void) {
+  #if SCH_EVENTS_STATE == SCH_EVENTS_ON
+    #if SCH_ARBITRATION_MODE == SCH_ARBITRATION_MODE_SYSTICK
 
-  #elif SCH_ARBITRATION_MODE == SCH_ARBITRATION_MODE_MANUAL
-    switch (sch_task -> priority) {
-      case 1:
-      //other cases
-    }
+    #elif SCH_ARBITRATION_MODE == SCH_ARBITRATION_MODE_MANUAL
+      uint8_t priority = sch_find_most_significant_task(sch_preempt_tasks_ready_set);
+        if (priority > 0) {
+          sch_task_t* task_to_run = sch_task_registry[priority - 1];
+          if (task_to_run != NULL) {
+              sch_task_run(task_to_run, NULL);
+          }
+        }
+    #endif
+  #elif SCH_EVENTS_STATE == SCH_EVENTS_OFF
+    return 0;
   #endif
+  return 0;
 }

sch/src/sch.c

@@ -10,6 +10,7 @@
  */
 
 #include "sch.h"
+#include "sch_event_management.h"
 
 int32_t sch_system_tasks_ready_set = 0;
 int32_t sch_preempt_tasks_ready_set = 0;
@@ -26,14 +27,14 @@ sch_task_t* sch_task_registry[SCH_MAX_QUANTITY_OF_TASKS] = {0};
  * @param init 
  */
 void sch_task_create(sch_task_t* const task, sch_task_priority priority, sch_irq irq, sch_task_dispatch_fn dispatch, sch_task_presetting_fn presetting) {
-    if (task != (sch_task_t* const)NULL) {
-        task->irq = irq;
-        task->priority = priority;
-        task->task_dispatch = dispatch;
-        task->task_presetting = presetting;
+  if (task != (sch_task_t* const)NULL) {
+    task->irq = irq;
+    task->priority = priority;
+    task->task_dispatch = dispatch;
+    task->task_presetting = presetting;
 
-        task->task_presetting(task);
-    }
+    task->task_presetting(task);
+  }
 }
 
 /**
@@ -43,15 +44,15 @@ void sch_task_create(sch_task_t* const task, sch_task_priority priority, sch_irq
  * @param param 
  */
 void sch_task_run(sch_task_t* const task, void* param) {
-    SCH_ASSERT((task->priority > 0) && (task->priority < SCH_MAX_QUANTITY_OF_TASKS));
-    (*task->task_dispatch)(task);
+  SCH_ASSERT((task->priority > 0) && (task->priority < SCH_MAX_QUANTITY_OF_TASKS));
+  (*task->task_dispatch)(task);
 
-    //afterword
-    if (task->priority < 0) {
-        sch_system_tasks_ready_set &= ~(1U << (uint8_t)(-task->priority - 1));
-    } else {
-        sch_preempt_tasks_ready_set &= ~(1U << (uint8_t)(task->priority - 1));
-    }
+  //afterword
+  if (task->priority < 0) {
+    sch_system_tasks_ready_set &= ~(1U << (uint8_t)(-task->priority - 1));
+  } else {
+    sch_preempt_tasks_ready_set &= ~(1U << (uint8_t)(task->priority - 1));
+  }
 }
 
 /**
@@ -60,9 +61,18 @@ void sch_task_run(sch_task_t* const task, void* param) {
  * @param task 
  */
 void sch_task_activate(sch_task_t* const task) {
-    if (task->priority < 0) {
-        sch_system_tasks_ready_set |= (1U << (uint8_t)(-task->priority - 1));
-    } else {
-        sch_preempt_tasks_ready_set |= (1U << (uint8_t)(task->priority - 1));
-    }
+  if (task->priority < 0) {
+    sch_system_tasks_ready_set |= (1U << (uint8_t)(-task->priority - 1));
+  } else {
+    sch_preempt_tasks_ready_set |= (1U << (uint8_t)(task->priority - 1));
+  }
+}
+
+/**
+ * @brief Wrapper function for starting the arbitraging the processes
+ * 
+ */
+uint8_t sch_run(void) {
+  sch_event_management();
+  return 0;
 }