From eca1bd9aedf963291a92f7e43270ac53cca7cc94 Mon Sep 17 00:00:00 2001 From: cfif Date: Fri, 19 Dec 2025 16:07:24 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Model_Task.c | 53 ++++ Model_Task.h | 27 ++ Model_actuator.c | 666 +++++++++++++++++++++++++++++++++++++++ Model_actuator.h | 191 +++++++++++ Model_actuator_private.h | 36 +++ Model_actuator_types.h | 47 +++ modular.json | 13 + 7 files changed, 1033 insertions(+) create mode 100644 Model_Task.c create mode 100644 Model_Task.h create mode 100644 Model_actuator.c create mode 100644 Model_actuator.h create mode 100644 Model_actuator_private.h create mode 100644 Model_actuator_types.h create mode 100644 modular.json diff --git a/Model_Task.c b/Model_Task.c new file mode 100644 index 0000000..88e8e19 --- /dev/null +++ b/Model_Task.c @@ -0,0 +1,53 @@ +// +// Created by cfif on 19.12.2025. +// +#include "Model_Task.h" +#include +#include +#include "Model_actuator.h" + +void ModelTask_Init( + tModelTask *env +) { + Model_actuator_initialize(); + env->access = osMutexNew(NULL); + + InitThreadAtrStatic(&env->thread.attr, "ModelTask", env->thread.controlBlock, env->thread.stack, osPriorityNormal); + env->thread.id = 0; +} + +static void setActuatorBusy() { + + for (uint8_t i = 0; i < 9; ++i) { + if (rtY.Out1.COM[i] != 0) { + rtU.in_Busy_Ch0 = 1; + return; + } + } + +} + +static _Noreturn void ModelTask_Thread(tModelTask *env) { + for (;;) { + if (osMutexAcquire(env->access, 1000) == osOK) { + Model_actuator_step(); + setActuatorBusy(); + osMutexRelease(env->access); + } + SystemDelayMs(100); + } +} + +void ModelTask_StartThread(tModelTask *env) { + if (!env->thread.id) { + env->thread.id = osThreadNew((osThreadFunc_t) (ModelTask_Thread), (void *) (env), &env->thread.attr); + } else { + osThreadResume(env->thread.id); + } +} + +void ModelTask_StopThread(tModelTask *env) { + if (env->thread.id) { + osThreadSuspend(env->thread.id); + } +} \ No newline at end of file diff --git a/Model_Task.h b/Model_Task.h new file mode 100644 index 0000000..1b7f47c --- /dev/null +++ b/Model_Task.h @@ -0,0 +1,27 @@ +// +// Created by cfif on 19.12.2025. +// + +#ifndef HVAC_M7_MODEL_TASK_H +#define HVAC_M7_MODEL_TASK_H + +#include + + +typedef struct { + + osMutexId_t access; + + struct { + osThreadId_t id; + uint32_t stack[1024]; + StaticTask_t controlBlock; + osThreadAttr_t attr; + } thread; +} tModelTask; + +void ModelTask_Init(tModelTask *env); +void ModelTask_StartThread(tModelTask *env); +void ModelTask_StopThread(tModelTask *env); + +#endif //HVAC_M7_MODEL_TASK_H diff --git a/Model_actuator.c b/Model_actuator.c new file mode 100644 index 0000000..af86b52 --- /dev/null +++ b/Model_actuator.c @@ -0,0 +1,666 @@ +/* + * File: Model_actuator.c + * + * Code generated for Simulink model 'Model_actuator'. + * + * Model version : 1.538 + * Simulink Coder version : 24.1 (R2024a) 19-Nov-2023 + * C/C++ source code generated on : Fri Dec 19 14:23:04 2025 + * + * Target selection: ert.tlc + * Embedded hardware selection: ARM Compatible->ARM Cortex-M + * Emulation hardware selection: + * Differs from embedded hardware (MATLAB Host) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#include "Model_actuator.h" +#include +#include "Model_actuator_private.h" +#include "Model_actuator_types.h" + +/* Exported block states */ +ActuatorCmdBus controllerData; /* '/Data Store Memory15' */ + +/* Block signals (default storage) */ +B rtB; + +/* Block states (default storage) */ +DW rtDW; + +/* External inputs (root inport signals with default storage) */ +ExtU rtU; + +/* External outputs (root outports fed by signals with default storage) */ +ExtY rtY; + +/* Real-time model */ +static RT_MODEL rtM_; +RT_MODEL *const rtM = &rtM_; + +/* + * Output and update for action system: + * '/If Action Subsystem2' + * '/If Action Subsystem2' + */ +void IfActionSubsystem2(int8_t rtu_stepIn, int8_t *rty_step, uint8_t + rtd_autos_set_loc[9], uint8_t rtd_coils_stop_set_loc[9], uint8_t rtd_com_loc[9], + uint8_t rtd_lnoise_set_loc[9], uint8_t rtd_speed_set_loc[9], uint8_t + rtd_stall_set_loc[9]) +{ + int32_t i; + for (i = 0; i < 9; i++) { + /* DataStoreWrite: '/Data Store Write1' incorporates: + * Constant: '/Constant1' + */ + rtd_stall_set_loc[i] = 0U; + + /* DataStoreWrite: '/Data Store Write3' incorporates: + * Constant: '/Constant2' + */ + rtd_lnoise_set_loc[i] = 0U; + + /* DataStoreWrite: '/Data Store Write2' */ + rtd_com_loc[i] = 2U; + + /* DataStoreWrite: '/Data Store Write4' incorporates: + * Constant: '/Constant4' + */ + rtd_autos_set_loc[i] = 0U; + + /* DataStoreWrite: '/Data Store Write5' incorporates: + * Constant: '/Constant5' + */ + rtd_speed_set_loc[i] = 0U; + + /* DataStoreWrite: '/Data Store Write6' incorporates: + * Constant: '/Constant6' + */ + rtd_coils_stop_set_loc[i] = 0U; + } + + /* Sum: '/step inc' incorporates: + * Constant: '/Constant' + */ + *rty_step = (int8_t)(rtu_stepIn + 1); +} + +/* Model step function */ +void Model_actuator_step(void) +{ + int32_t i; + uint16_t tmp; + int8_t rtb_Switch; + + /* BusCreator: '/Bus Creator' incorporates: + * DataStoreRead: '/Data Store Read1' + * DataStoreRead: '/Data Store Read2' + * DataStoreRead: '/Data Store Read3' + * DataStoreRead: '/Data Store Read4' + * DataStoreRead: '/Data Store Read5' + * DataStoreRead: '/Data Store Read6' + * DataStoreRead: '/Data Store Read7' + * DataStoreRead: '/Data Store Read8' + * DataStoreRead: '/Data Store Read9' + * DataStoreWrite: '/Data Store Write' + */ + for (i = 0; i < 9; i++) { + controllerData.POS[i] = rtDW.pos_loc[i]; + controllerData.BUS_ADR[i] = rtDW.busAdr_loc[i]; + controllerData.MODE[i] = rtDW.mode_loc[i]; + controllerData.COM[i] = rtDW.com_loc[i]; + controllerData.Stall_SET[i] = rtDW.stall_set_loc[i]; + controllerData.Lnoise_SET[i] = rtDW.lnoise_set_loc[i]; + controllerData.Autos_SET[i] = rtDW.autos_set_loc[i]; + controllerData.Speed_SET[i] = rtDW.speed_set_loc[i]; + controllerData.Coils_Stop_SET[i] = rtDW.coils_stop_set_loc[i]; + } + + /* End of BusCreator: '/Bus Creator' */ + + /* Switch: '/Switch' incorporates: + * Constant: '/Constant1' + * DataStoreRead: '/Data Store Read' + * UnitDelay: '/Unit Delay' + */ + if (rtDW.stepSig >= 1) { + rtb_Switch = rtDW.UnitDelay_DSTATE; + } else { + rtb_Switch = 1; + } + + /* End of Switch: '/Switch' */ + + /* SwitchCase: '/Switch Case' */ + switch (rtb_Switch) { + case 1: + /* Outputs for IfAction SubSystem: '/Stop Mode' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + for (i = 0; i < 9; i++) { + /* DataStoreWrite: '/Data Store Write2' */ + rtDW.mode_loc[i] = 2U; + + /* DataStoreWrite: '/Data Store Write3' */ + rtDW.com_loc[i] = 0U; + } + + /* Merge: '/Merge' incorporates: + * Constant: '/Constant' + * Merge: '/Merge' + * Sum: '/step inc' + */ + rtB.Merge = (int8_t)(rtb_Switch + 1); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/stop mode' */ + /* : y = step; */ + /* : fprintf('Stop Mode\n'); */ + printf("Stop Mode\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Stop Mode' */ + break; + + case 2: + /* Outputs for IfAction SubSystem: '/Initial CPOS Min' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem' incorporates: + * ActionPort: '/Action Port' + */ + for (i = 0; i < 9; i++) { + /* DataStoreWrite: '/Data Store Write' */ + rtDW.pos_loc[i] = 6000U; + + /* DataStoreWrite: '/Data Store Write1' */ + rtDW.com_loc[i] = 1U; + } + + /* Merge: '/Merge' incorporates: + * Constant: '/Constant' + * Merge: '/Merge' + * Sum: '/step inc' + */ + rtB.Merge = (int8_t)(rtb_Switch + 1); + + /* End of Outputs for SubSystem: '/If Action Subsystem' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/step' + * SignalConversion generated from: '/stepIn1' + */ + /* : y = step; */ + /* : coder.extrinsic('fprintf'); */ + /* : fprintf('Actuator else: step = %d\n', step); */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If' */ + + /* MATLAB Function: '/Initial CPOS Min' */ + /* : y = step; */ + /* : fprintf('Initial CPOS Min\n'); */ + printf("Initial CPOS Min\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Initial CPOS Min' */ + break; + + case 3: + /* Outputs for IfAction SubSystem: '/Normal Mode' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + for (i = 0; i < 9; i++) { + /* DataStoreWrite: '/Data Store Write' */ + rtDW.mode_loc[i] = 0U; + + /* DataStoreWrite: '/Data Store Write2' */ + rtDW.com_loc[i] = 0U; + } + + /* Merge: '/Merge' incorporates: + * Constant: '/Constant' + * Merge: '/Merge' + * Sum: '/step inc' + */ + rtB.Merge = (int8_t)(rtb_Switch + 1); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/Normal Mode' */ + /* : y = step; */ + /* : fprintf('Normal Mode\n'); */ + printf("Normal Mode\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Normal Mode' */ + break; + + case 4: + /* Outputs for IfAction SubSystem: '/Move to position Min' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' */ + IfActionSubsystem2(rtb_Switch, &rtB.Merge, rtDW.autos_set_loc, + rtDW.coils_stop_set_loc, rtDW.com_loc, + rtDW.lnoise_set_loc, rtDW.speed_set_loc, + rtDW.stall_set_loc); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/Move to position Min' */ + /* : y = step; */ + /* : fprintf('Move to position Min\n'); */ + printf("Move to position Min\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Move to position Min' */ + break; + + case 5: + /* Outputs for IfAction SubSystem: '/Check Stall Min' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + /* DataStoreWrite: '/Data Store Write1' incorporates: + * DataStoreWrite: '/Data Store Write1' + * Inport: '/in_CPOS_ALL_Ch0' + */ + for (i = 0; i < 9; i++) { + rtDW.Min_position_Ch0[i] = rtU.in_CPOS_ALL_Ch0[i]; + } + + /* End of DataStoreWrite: '/Data Store Write1' */ + + /* Merge: '/Merge' incorporates: + * Constant: '/Constant' + * Merge: '/Merge' + * Sum: '/step inc' + */ + rtB.Merge = (int8_t)(rtb_Switch + 1); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/Check Stall Min' */ + /* : y = step; */ + /* : fprintf('Check Stall Min\n'); */ + printf("Check Stall Min\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Check Stall Min' */ + break; + + case 6: + /* Outputs for IfAction SubSystem: '/Initial CPOS Max' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + for (i = 0; i < 9; i++) { + /* DataStoreWrite: '/Data Store Write' */ + rtDW.pos_loc[i] = 0U; + + /* DataStoreWrite: '/Data Store Write1' */ + rtDW.com_loc[i] = 1U; + } + + /* Merge: '/Merge' incorporates: + * Constant: '/Constant' + * Merge: '/Merge' + * Sum: '/step inc' + */ + rtB.Merge = (int8_t)(rtb_Switch + 1); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/Initial CPOS Max' */ + /* : y = step; */ + /* : fprintf('Initial CPOS Max\n'); */ + printf("Initial CPOS Max\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Initial CPOS Max' */ + break; + + case 7: + /* Outputs for IfAction SubSystem: '/Move to position Max' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' */ + IfActionSubsystem2(rtb_Switch, &rtB.Merge, rtDW.autos_set_loc, + rtDW.coils_stop_set_loc, rtDW.com_loc, + rtDW.lnoise_set_loc, rtDW.speed_set_loc, + rtDW.stall_set_loc); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/Move to position Max' */ + /* : y = step; */ + /* : fprintf('Move to position Max\n'); */ + printf("Move to position Max\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Move to position Max' */ + break; + + case 8: + /* Outputs for IfAction SubSystem: '/Check Stall Max' incorporates: + * ActionPort: '/Action Port' + */ + /* If: '/If1' incorporates: + * Inport: '/in_Busy_Ch0' + * Inport: '/in_Error_Connect_Ch0' + */ + if ((rtU.in_Busy_Ch0 == 0) && (rtU.in_Error_Connect_Ch0 == 0)) { + /* Outputs for IfAction SubSystem: '/If Action Subsystem2' incorporates: + * ActionPort: '/Action Port' + */ + /* DataStoreWrite: '/Data Store Write1' incorporates: + * DataStoreWrite: '/Data Store Write1' + * Inport: '/in_CPOS_ALL_Ch0' + */ + for (i = 0; i < 9; i++) { + rtDW.Max_position_Ch0[i] = rtU.in_CPOS_ALL_Ch0[i]; + } + + /* End of DataStoreWrite: '/Data Store Write1' */ + + /* Merge: '/Merge' incorporates: + * Constant: '/Constant' + * Merge: '/Merge' + * Sum: '/step inc' + */ + rtB.Merge = (int8_t)(rtb_Switch + 1); + + /* End of Outputs for SubSystem: '/If Action Subsystem2' */ + } else { + /* Outputs for IfAction SubSystem: '/If Action Subsystem3' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Merge: '/Merge' + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/If Action Subsystem3' */ + } + + /* End of If: '/If1' */ + + /* MATLAB Function: '/Check Stall Max' */ + /* : y = step; */ + /* : fprintf('Check Stall Max\n'); */ + printf("Check Stall Max\n"); + fflush(stdout); + + /* End of Outputs for SubSystem: '/Check Stall Max' */ + break; + + case 9: + /* Outputs for IfAction SubSystem: '/Homing' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * Constant: '/Constant2' + * SignalConversion generated from: '/step' + */ + rtB.Merge = 1; + + /* MATLAB Function: '/MAX POSITION' incorporates: + * DataStoreRead: '/Data Store Read2' + */ + /* : y = step; */ + /* : fprintf('MAX POSITION '); */ + printf("MAX POSITION "); + fflush(stdout); + + /* : for i = 1:numel(step) */ + for (i = 0; i < 9; i++) { + /* : fprintf('%d ', int16(step(i))); */ + tmp = rtDW.Max_position_Ch0[i]; + if (tmp > 32767) { + tmp = 32767U; + } + + printf("%d ", (int16_t)tmp); + fflush(stdout); + } + + /* : fprintf('\n'); */ + printf("\n"); + fflush(stdout); + + /* End of MATLAB Function: '/MAX POSITION' */ + + /* MATLAB Function: '/MIN POSITION' incorporates: + * DataStoreRead: '/Data Store Read3' + */ + /* : y = step; */ + /* : fprintf('MIN POSITION '); */ + printf("MIN POSITION "); + fflush(stdout); + + /* : for i = 1:numel(step) */ + for (i = 0; i < 9; i++) { + /* : fprintf('%d ', int16(step(i))); */ + tmp = rtDW.Min_position_Ch0[i]; + if (tmp > 32767) { + tmp = 32767U; + } + + printf("%d ", (int16_t)tmp); + fflush(stdout); + } + + /* : fprintf('\n'); */ + printf("\n"); + fflush(stdout); + + /* End of MATLAB Function: '/MIN POSITION' */ + /* End of Outputs for SubSystem: '/Homing' */ + break; + + case 0: + /* Outputs for IfAction SubSystem: '/Homing1' incorporates: + * ActionPort: '/Action Port' + */ + /* Merge: '/Merge' incorporates: + * SignalConversion generated from: '/stepIn' + */ + rtB.Merge = rtb_Switch; + + /* End of Outputs for SubSystem: '/Homing1' */ + break; + } + + /* End of SwitchCase: '/Switch Case' */ + + /* Outport: '/Out1' incorporates: + * DataStoreRead: '/Data Store Read10' + */ + rtY.Out1 = controllerData; + + /* DataStoreWrite: '/Start write stepSig' incorporates: + * Constant: '/Constant1' + */ + rtDW.stepSig = 1; + + /* MATLAB Function: '/Finish case' incorporates: + * UnitDelay: '/Unit Delay' + */ + /* : y = step; */ + /* : fprintf('Finish case: step = %d\n', step); */ + printf("Finish case: step = %d\n", rtDW.UnitDelay_DSTATE); + fflush(stdout); + + /* MATLAB Function: '/Start case' */ + /* : y = step; */ + /* : fprintf('Start case: step = %d\n', step); */ + printf("Start case: step = %d\n", rtb_Switch); + fflush(stdout); + + /* Update for UnitDelay: '/Unit Delay' */ + rtDW.UnitDelay_DSTATE = rtB.Merge; +} + +/* Model initialize function */ +void Model_actuator_initialize(void) +{ + /* (no initialization code required) */ +} + +/* Model terminate function */ +void Model_actuator_terminate(void) +{ + /* (no terminate code required) */ +} + +/* + * File trailer for generated code. + * + * [EOF] + */ diff --git a/Model_actuator.h b/Model_actuator.h new file mode 100644 index 0000000..93f8a13 --- /dev/null +++ b/Model_actuator.h @@ -0,0 +1,191 @@ +/* + * File: Model_actuator.h + * + * Code generated for Simulink model 'Model_actuator'. + * + * Model version : 1.538 + * Simulink Coder version : 24.1 (R2024a) 19-Nov-2023 + * C/C++ source code generated on : Fri Dec 19 14:23:04 2025 + * + * Target selection: ert.tlc + * Embedded hardware selection: ARM Compatible->ARM Cortex-M + * Emulation hardware selection: + * Differs from embedded hardware (MATLAB Host) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef Model_actuator_h_ +#define Model_actuator_h_ +#ifndef Model_actuator_COMMON_INCLUDES_ +#define Model_actuator_COMMON_INCLUDES_ +#include +#include +#include +#endif /* Model_actuator_COMMON_INCLUDES_ */ + +#include "Model_actuator_types.h" + +/* Macros for accessing real-time model data structure */ +#ifndef rtmGetErrorStatus +#define rtmGetErrorStatus(rtm) ((rtm)->errorStatus) +#endif + +#ifndef rtmSetErrorStatus +#define rtmSetErrorStatus(rtm, val) ((rtm)->errorStatus = (val)) +#endif + +/* user code (top of header file) */ +#include + +/* Block signals (default storage) */ +typedef struct { + int8_t Merge; /* '/Merge' */ +} B; + +/* Block states (default storage) for system '' */ +typedef struct { + uint16_t Min_position_Ch0[9]; /* '/Data Store Memory12' */ + uint16_t Max_position_Ch0[9]; /* '/Data Store Memory13' */ + uint16_t pos_loc[9]; /* '/Data Store Memory4' */ + int8_t UnitDelay_DSTATE; /* '/Unit Delay' */ + int8_t stepSig; /* '/Data Store Memory' */ + uint8_t mode_loc[9]; /* '/Data Store Memory1' */ + uint8_t com_loc[9]; /* '/Data Store Memory2' */ + uint8_t busAdr_loc[9]; /* '/Data Store Memory3' */ + uint8_t stall_set_loc[9]; /* '/Data Store Memory5' */ + uint8_t lnoise_set_loc[9]; /* '/Data Store Memory6' */ + uint8_t autos_set_loc[9]; /* '/Data Store Memory7' */ + uint8_t speed_set_loc[9]; /* '/Data Store Memory8' */ + uint8_t coils_stop_set_loc[9]; /* '/Data Store Memory9' */ +} DW; + +/* External inputs (root inport signals with default storage) */ +typedef struct { + uint16_t in_CPOS_ALL_Ch0[9]; /* '/in_CPOS_ALL_Ch0' */ + uint8_t in_Act_Emrf_Slave_Ch0[9]; /* '/in_Act_Emrf_Slave_Ch0' */ + uint8_t in_Mode_Slave_Ch0[9]; /* '/in_Mode_Slave_Ch0' */ + uint8_t in_Act_Err1_Supply_Ch0[9]; /* '/in_Act_Err1_Supply_Ch0' */ + uint8_t in_Act_Err2_Communication_Ch0[9]; + /* '/in_Act_Err2_Communication_Ch0' */ + uint8_t in_Act_Err3_Temperature_Ch0[9]; + /* '/in_Act_Err3_Temperature_Ch0' */ + uint8_t in_Act_Err4_Permanent_Electrical_Ch0[9]; + /* '/in_Act_Err4_Permanent_Electrical_Ch0' */ + uint8_t in_Act_Stall_Slave_Ch0[9]; /* '/in_Act_Stall_Slave_Ch0' */ + uint8_t in_Act_Reset_Ch0[9]; /* '/in_Act_Reset_Ch0' */ + uint8_t in_Busy_Ch0; /* '/in_Busy_Ch0' */ + uint8_t in_Error_Connect_Ch0; /* '/in_Error_Connect_Ch0' */ +} ExtU; + +/* External outputs (root outports fed by signals with default storage) */ +typedef struct { + ActuatorCmdBus Out1; /* '/Out1' */ +} ExtY; + +/* Real-time Model Data Structure */ +struct tag_RTM { + const char * volatile errorStatus; +}; + +/* Block signals (default storage) */ +extern B rtB; + +/* Block states (default storage) */ +extern DW rtDW; + +/* External inputs (root inport signals with default storage) */ +extern ExtU rtU; + +/* External outputs (root outports fed by signals with default storage) */ +extern ExtY rtY; + +/* + * Exported States + * + * Note: Exported states are block states with an exported global + * storage class designation. Code generation will declare the memory for these + * states and exports their symbols. + * + */ +extern ActuatorCmdBus controllerData; /* '/Data Store Memory15' */ + +/* Model entry point functions */ +extern void Model_actuator_initialize(void); +extern void Model_actuator_step(void); +extern void Model_actuator_terminate(void); + +/* Real-time Model object */ +extern RT_MODEL *const rtM; + +/*- + * These blocks were eliminated from the model due to optimizations: + * + * Block '/Display1' : Unused code path elimination + * Block '/Display2' : Unused code path elimination + * Block '/Display3' : Unused code path elimination + * Block '/Display3' : Unused code path elimination + */ + +/*- + * The generated code includes comments that allow you to trace directly + * back to the appropriate location in the model. The basic format + * is /block_name, where system is the system number (uniquely + * assigned by Simulink) and block_name is the name of the block. + * + * Use the MATLAB hilite_system command to trace the generated code back + * to the model. For example, + * + * hilite_system('') - opens system 3 + * hilite_system('/Kp') - opens and selects block Kp which resides in S3 + * + * Here is the system hierarchy for this model + * + * '' : 'Model_actuator' + * '' : 'Model_actuator/Check Stall Max' + * '' : 'Model_actuator/Check Stall Min' + * '' : 'Model_actuator/Finish case' + * '' : 'Model_actuator/Homing' + * '' : 'Model_actuator/Homing1' + * '' : 'Model_actuator/Initial CPOS Max' + * '' : 'Model_actuator/Initial CPOS Min' + * '' : 'Model_actuator/Move to position Max' + * '' : 'Model_actuator/Move to position Min' + * '' : 'Model_actuator/Normal Mode' + * '' : 'Model_actuator/Start case' + * '' : 'Model_actuator/Stop Mode' + * '' : 'Model_actuator/Check Stall Max/Check Stall Max' + * '' : 'Model_actuator/Check Stall Max/If Action Subsystem2' + * '' : 'Model_actuator/Check Stall Max/If Action Subsystem3' + * '' : 'Model_actuator/Check Stall Min/Check Stall Min' + * '' : 'Model_actuator/Check Stall Min/If Action Subsystem2' + * '' : 'Model_actuator/Check Stall Min/If Action Subsystem3' + * '' : 'Model_actuator/Homing/MAX POSITION' + * '' : 'Model_actuator/Homing/MIN POSITION' + * '' : 'Model_actuator/Initial CPOS Max/If Action Subsystem2' + * '' : 'Model_actuator/Initial CPOS Max/If Action Subsystem3' + * '' : 'Model_actuator/Initial CPOS Max/Initial CPOS Max' + * '' : 'Model_actuator/Initial CPOS Min/If Action Subsystem' + * '' : 'Model_actuator/Initial CPOS Min/If Action Subsystem3' + * '' : 'Model_actuator/Initial CPOS Min/Initial CPOS Min' + * '' : 'Model_actuator/Initial CPOS Min/If Action Subsystem3/Log Ambient Lv3' + * '' : 'Model_actuator/Move to position Max/If Action Subsystem2' + * '' : 'Model_actuator/Move to position Max/If Action Subsystem3' + * '' : 'Model_actuator/Move to position Max/Move to position Max' + * '' : 'Model_actuator/Move to position Min/If Action Subsystem2' + * '' : 'Model_actuator/Move to position Min/If Action Subsystem3' + * '' : 'Model_actuator/Move to position Min/Move to position Min' + * '' : 'Model_actuator/Normal Mode/If Action Subsystem2' + * '' : 'Model_actuator/Normal Mode/If Action Subsystem3' + * '' : 'Model_actuator/Normal Mode/Normal Mode' + * '' : 'Model_actuator/Stop Mode/If Action Subsystem2' + * '' : 'Model_actuator/Stop Mode/If Action Subsystem3' + * '' : 'Model_actuator/Stop Mode/stop mode' + */ +#endif /* Model_actuator_h_ */ + +/* + * File trailer for generated code. + * + * [EOF] + */ diff --git a/Model_actuator_private.h b/Model_actuator_private.h new file mode 100644 index 0000000..65ff137 --- /dev/null +++ b/Model_actuator_private.h @@ -0,0 +1,36 @@ +/* + * File: Model_actuator_private.h + * + * Code generated for Simulink model 'Model_actuator'. + * + * Model version : 1.538 + * Simulink Coder version : 24.1 (R2024a) 19-Nov-2023 + * C/C++ source code generated on : Fri Dec 19 14:23:04 2025 + * + * Target selection: ert.tlc + * Embedded hardware selection: ARM Compatible->ARM Cortex-M + * Emulation hardware selection: + * Differs from embedded hardware (MATLAB Host) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef Model_actuator_private_h_ +#define Model_actuator_private_h_ +#include +#include +#include "Model_actuator_types.h" +#include "Model_actuator.h" + +extern void IfActionSubsystem2(int8_t rtu_stepIn, int8_t *rty_step, uint8_t + rtd_autos_set_loc[9], uint8_t rtd_coils_stop_set_loc[9], uint8_t rtd_com_loc[9], + uint8_t rtd_lnoise_set_loc[9], uint8_t rtd_speed_set_loc[9], uint8_t + rtd_stall_set_loc[9]); + +#endif /* Model_actuator_private_h_ */ + +/* + * File trailer for generated code. + * + * [EOF] + */ diff --git a/Model_actuator_types.h b/Model_actuator_types.h new file mode 100644 index 0000000..352f036 --- /dev/null +++ b/Model_actuator_types.h @@ -0,0 +1,47 @@ +/* + * File: Model_actuator_types.h + * + * Code generated for Simulink model 'Model_actuator'. + * + * Model version : 1.538 + * Simulink Coder version : 24.1 (R2024a) 19-Nov-2023 + * C/C++ source code generated on : Fri Dec 19 14:23:04 2025 + * + * Target selection: ert.tlc + * Embedded hardware selection: ARM Compatible->ARM Cortex-M + * Emulation hardware selection: + * Differs from embedded hardware (MATLAB Host) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef Model_actuator_types_h_ +#define Model_actuator_types_h_ +#include +#ifndef DEFINED_TYPEDEF_FOR_ActuatorCmdBus_ +#define DEFINED_TYPEDEF_FOR_ActuatorCmdBus_ + +typedef struct { + uint16_t POS[9]; + uint8_t BUS_ADR[9]; + uint8_t MODE[9]; + uint8_t COM[9]; + uint8_t Stall_SET[9]; + uint8_t Lnoise_SET[9]; + uint8_t Autos_SET[9]; + uint8_t Speed_SET[9]; + uint8_t Coils_Stop_SET[9]; +} ActuatorCmdBus; + +#endif + +/* Forward declaration for rtModel */ +typedef struct tag_RTM RT_MODEL; + +#endif /* Model_actuator_types_h_ */ + +/* + * File trailer for generated code. + * + * [EOF] + */ diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..9589ff8 --- /dev/null +++ b/modular.json @@ -0,0 +1,13 @@ +{ + "dep": [ + + ], + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +} \ No newline at end of file