Challenges getting 8 RELAY board to work in Ope...

Jake Freese

I can not seem to get an a relay energized with my 8 relay boards. I have a functioning input that when it is connected to LED1 on the industrial board I can turn that LED on and off. I disconnect from that LED and move over to the 8 relay and nothing. I have also setup a output connected directly to the pin and set the initial value to 1 (tried it on both 8 relay boards in the stack.)

I dropped a 16 relay board in there to try it also.

It must be something with my addressing in OPLC for the one that I have that works that lights up the LED1 on the IND board it is addressed %IX1.0 I have tried IX and QX just for the heck of it on the relay cards with no luck.

I can not seem to get any of the relays to pickup no matter what I have tried. I have tried the 8relay boards a 16, and a 4 smart. I am stumped on this one.

9
Posts

104
Views

alexburcea Admin Staff member

2/27/26, 7:49 PM

Hi,

Could you share the project you created in the Editor so I can take a look?

This problem could also be generated by the port of Sequent drivers to the new runtime.

JF

Jake Freese

2/27/26, 7:58 PM

garagedo/program.st at main · jakefreese/garagedo

I did just reinstsall wiringPI, and turned off SPI in interfaces. The only ones on are I2C, Serial port, and Serial console.

I am using the new editor, I have not tried the v4 runtime with it yet. (I was having enough challenges that I was not ready to jump on that yet. ) This weekend hopefully.

TYPE
  LIGHTING_STATE : (HOBBY_ON, HOBBY_OFF, OFFICE_ON, OFFICE_OFF);
END_TYPE

FUNCTION_BLOCK LIGHTING
  VAR
    OFFICE_ON : LIGHTING_STATE;
    OFFICE_OFF : LIGHTING_STATE;
    HOBBY_ON : LIGHTING_STATE;
    HOBBY_OFF : LIGHTING_STATE;
    TON3 : TON;
    TON4 : TON;
    DEB_TIME : TIME := T#500ms;
  END_VAR
  VAR_INPUT
    HOBBY_IN : BOOL;
    OFFICE_IN : BOOL;
  END_VAR
  VAR_OUTPUT
    HOBBY_OUT : BOOL;
    OFFICE_OUT : BOOL;
  END_VAR

  TON3(IN := HOBBY_IN, PT := DEB_TIME);
  HOBBY_OUT := TON3.Q;
  TON4(IN := OFFICE_IN, PT := DEB_TIME);
  OFFICE_OUT := TON4.Q;
END_FUNCTION_BLOCK

PROGRAM main
  VAR_INPUT
    SM_IND_STK : SINT := 0;
    SM_8RELAY0_STK : SINT := 1;
    SM_RTD_STK : SINT := 3;
    SM_HOME0_STK : SINT := 5;
    SM_16DIN0_STK : SINT := 6;
  END_VAR
  VAR
    SM_8RELAY1_STK : SINT := 2;
    SM_INDUSTRIAL0 : SM_INDUSTRIAL;
    SM_8RELAY0 : SM_8RELAY;
    SM_8RELAY1 : SM_8RELAY;
    SM_RTD0 : SM_RTD;
    SM_HOME0 : SM_HOME;
    SM_16DIN0 : SM_16DIN;
    TON0 : TON;
    LIGHTING0 : LIGHTING;
  END_VAR
  VAR
    DIN1 AT %QX0.0 : BOOL;
    DIN2 AT %QX0.1 : BOOL;
    OFFICE_LTS AT %QX1.0 : BOOL;
    OFFICE_LT AT %IX1.0 : BOOL;
    HOBBY_LTS AT %QX1.1 : BOOL;
    HOBBY_LT AT %IX1.1 : BOOL;
    L1 AT %IX0.0 : BOOL;
    L2 AT %IX0.1 : BOOL;
    L3 AT %IX0.2 : BOOL;
    L4 AT %IX0.4 : BOOL;
    R4 AT %IX1.3 : BOOL;
    R09 AT %IX2.0 : BOOL;
    OFFICE_TEMP AT %MD0 : REAL;
    GARAGE_TEMP AT %MD1 : REAL;
    ATTIC_TEMP AT %MD2 : REAL;
    HVAC_SUPPLY AT %MD3 : REAL;
    H_IN_1 AT %QX3.0 : BOOL;
    H_IN_2 AT %QX3.1 : BOOL;
    H_IN_3 AT %QX3.2 : BOOL;
    H_IN_4 AT %QX3.3 : BOOL;
    H_RLY_1 AT %IX3.0 : BOOL;
    H_RLY_2 AT %IX3.1 : BOOL;
    H_RLY_3 AT %IX3.2 : BOOL;
    H_RLY_4 AT %IX3.3 : BOOL;
    RLY1_4 AT %IX4.3 : BOOL;
    RLY2_4 AT %IX5.3 : BOOL;
  END_VAR

  SM_HOME0(STACK := SM_HOME0_STK, RELAY1 := H_RLY_1, RELAY2 := H_RLY_2, RELAY3 := H_RLY_3, RELAY4 := H_RLY_4);
  SM_8RELAY0(STACK := SM_8RELAY0_STK);
  SM_INDUSTRIAL0(STACK := SM_IND_STK, LED1 := HOBBY_LT);
  SM_16DIN0(STACK := SM_16DIN0_STK);
  LIGHTING0(HOBBY_IN := SM_16DIN0.I1, OFFICE_IN := SM_16DIN0.I2);
  HOBBY_LTS := SM_16DIN0.I1;
  HOBBY_LT := LIGHTING0.HOBBY_OUT;
  OFFICE_LTS := SM_16DIN0.I2;
  OFFICE_LT := LIGHTING0.OFFICE_OUT;
  SM_8RELAY1(STACK := SM_8RELAY1_STK);
  SM_RTD0(STACK := SM_RTD_STK);
  OFFICE_TEMP := SM_RTD0.TEMP1;
  H_IN_1 := SM_HOME0.OPTO1;
  GARAGE_TEMP := SM_RTD0.TEMP2;
  H_IN_2 := SM_HOME0.OPTO2;
  ATTIC_TEMP := SM_RTD0.TEMP3;
  H_IN_3 := SM_HOME0.OPTO3;
  HVAC_SUPPLY := SM_RTD0.TEMP4;
  H_IN_4 := SM_HOME0.OPTO4;
END_PROGRAM


CONFIGURATION Config0

  RESOURCE Res0 ON PLC
    TASK task0(INTERVAL := T#50ms,PRIORITY := 1);
    PROGRAM instance0 WITH task0 : main;
  END_RESOURCE
END_CONFIGURATION

(*DBG:char md5[] = "e14823d02f55e3cf330e4b776ca09a2a";*)
(*DBG:/**)
(*DBG: * This file is part of OpenPLC Runtime*)
(*DBG: **)
(*DBG: * Copyright (C) 2023 Autonomy, GP Orcullo*)
(*DBG: * Based on the work by GP Orcullo on Beremiz for uC*)
(*DBG: **)
(*DBG: * This program is free software; you can redistribute it and/or*)
(*DBG: * modify it under the terms of the GNU General Public License*)
(*DBG: * as published by the Free Software Foundation; either version 2*)
(*DBG: * of the License, or (at your option) any later version.*)
(*DBG: **)
(*DBG: * This program is distributed in the hope that it will be useful,*)
(*DBG: * but WITHOUT ANY WARRANTY; without even the implied warranty of*)
(*DBG: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the*)
(*DBG: * GNU General Public License for more details.*)
(*DBG: **)
(*DBG: * You should have received a copy of the GNU General Public License*)
(*DBG: * along with this program; If not, see <http://www.gnu.org/licenses/>.*)
(*DBG: **)
(*DBG: */*)
(*DBG:*)
(*DBG:#include <stdbool.h>*)
(*DBG:*)
(*DBG:// Include defines.h first for Arduino builds to set USE_*_BLOCKS macros*)
(*DBG:// before iec_std_FB.h processes its conditional includes*)
(*DBG:#ifdef ARDUINO*)
(*DBG:#include "../examples/Baremetal/defines.h"*)
(*DBG:#endif*)
(*DBG:*)
(*DBG:#include "iec_types_all.h"*)
(*DBG:#include "POUS.h"*)
(*DBG:*)
(*DBG:#define SAME_ENDIANNESS      0*)
(*DBG:#define REVERSE_ENDIANNESS   1*)
(*DBG:*)
(*DBG:char plc_program_md5[] = "e14823d02f55e3cf330e4b776ca09a2a";*)
(*DBG:*)
(*DBG:uint8_t endianness;*)
(*DBG:*)
(*DBG:*)
(*DBG:extern MAIN RES0__INSTANCE0;*)
(*DBG:*)
(*DBG:static const struct {*)
(*DBG:    void *ptr;*)
(*DBG:    __IEC_types_enum type;*)
(*DBG:} debug_vars[] = {*)
(*DBG:    {&(RES0__INSTANCE0.SM_IND_STK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0_STK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD_STK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0_STK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0_STK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1_STK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.STACK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.LED1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.LED2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.LED3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.LED4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q0_10V1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q0_10V2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q0_10V3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q0_10V4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q4_20MA1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q4_20MA2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q4_20MA3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.Q4_20MA4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.QOD1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.QOD2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.QOD3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.QOD4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OPTO1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OPTO2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OPTO3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OPTO4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I0_10V1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I0_10V2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I0_10V3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I0_10V4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I4_20MA1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I4_20MA2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I4_20MA3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.I4_20MA4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OWB_T1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OWB_T2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OWB_T3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_INDUSTRIAL0.OWB_T4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.STACK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O5), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O6), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O7), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.O8), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY0.DUMMY), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.STACK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O5), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O6), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O7), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.O8), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_8RELAY1.DUMMY), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.STACK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP5), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP6), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP7), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_RTD0.TEMP8), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.STACK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY5), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY6), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY7), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.RELAY8), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.Q0_10V1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.Q0_10V2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.Q0_10V3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.Q0_10V4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.QOD1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.QOD2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.QOD3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.QOD4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO5), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO6), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO7), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OPTO8), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC5), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC6), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC7), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.ADC8), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OWB_T1), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OWB_T2), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OWB_T3), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_HOME0.OWB_T4), REAL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.STACK), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I1), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I2), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I3), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I4), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I5), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I6), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I7), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I8), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I9), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I10), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I11), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I12), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I13), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I14), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I15), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.SM_16DIN0.I16), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.PT), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.Q), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.ET), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.STATE), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.PREV_IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.CURRENT_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.TON0.START_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.PT), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.Q), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.ET), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.STATE), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.PREV_IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.CURRENT_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON3.START_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.EN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.ENO), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.PT), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.Q), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.ET), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.STATE), SINT_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.PREV_IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.CURRENT_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.TON4.START_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.DEB_TIME), TIME_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.HOBBY_IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.OFFICE_IN), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.HOBBY_OUT), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.LIGHTING0.OFFICE_OUT), BOOL_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.DIN1), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.DIN2), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.OFFICE_LTS), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.OFFICE_LT), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.HOBBY_LTS), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.HOBBY_LT), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.L1), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.L2), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.L3), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.L4), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.R4), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.R09), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.OFFICE_TEMP), REAL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.GARAGE_TEMP), REAL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.ATTIC_TEMP), REAL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.HVAC_SUPPLY), REAL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_IN_1), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_IN_2), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_IN_3), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_IN_4), BOOL_O_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_RLY_1), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_RLY_2), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_RLY_3), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.H_RLY_4), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.RLY1_4), BOOL_P_ENUM},*)
(*DBG:    {&(RES0__INSTANCE0.RLY2_4), BOOL_P_ENUM},*)
(*DBG:};*)
(*DBG:*)
(*DBG:#define VAR_COUNT               197*)
(*DBG:*)
(*DBG:uint16_t get_var_count(void)*)
(*DBG:{*)
(*DBG:    return VAR_COUNT;*)
(*DBG:}*)
(*DBG:*)
(*DBG:size_t get_var_size(size_t idx)*)
(*DBG:{*)
(*DBG:    if (idx >= VAR_COUNT)*)
(*DBG:    {*)
(*DBG:        return 0;*)
(*DBG:    }*)
(*DBG:    switch (debug_vars[idx].type) {*)
(*DBG:    case BOOL_ENUM:*)
(*DBG:    case BOOL_O_ENUM:*)
(*DBG:    case BOOL_P_ENUM:*)
(*DBG:        return sizeof(BOOL);*)
(*DBG:    case SINT_ENUM:*)
(*DBG:        return sizeof(SINT);*)
(*DBG:    case TIME_ENUM:*)
(*DBG:        return sizeof(TIME);*)
(*DBG:    case REAL_ENUM:*)
(*DBG:    case REAL_O_ENUM:*)
(*DBG:        return sizeof(REAL);*)
(*DBG:    default:*)
(*DBG:        return 0;*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*DBG:void *get_var_addr(size_t idx)*)
(*DBG:{*)
(*DBG:    void *ptr = debug_vars[idx].ptr;*)
(*DBG:*)
(*DBG:    switch (debug_vars[idx].type) {*)
(*DBG:    case BOOL_ENUM:*)
(*DBG:        return (void *)&((__IEC_BOOL_t *) ptr)->value;*)
(*DBG:    case BOOL_O_ENUM:*)
(*DBG:    case BOOL_P_ENUM:*)
(*DBG:        return (void *)((((__IEC_BOOL_p *) ptr)->flags & __IEC_FORCE_FLAG)*)
(*DBG:                        ? &(((__IEC_BOOL_p *) ptr)->fvalue)*)
(*DBG:                        : ((__IEC_BOOL_p *) ptr)->value);*)
(*DBG:    case SINT_ENUM:*)
(*DBG:        return (void *)&((__IEC_SINT_t *) ptr)->value;*)
(*DBG:    case TIME_ENUM:*)
(*DBG:        return (void *)&((__IEC_TIME_t *) ptr)->value;*)
(*DBG:    case REAL_ENUM:*)
(*DBG:        return (void *)&((__IEC_REAL_t *) ptr)->value;*)
(*DBG:    case REAL_O_ENUM:*)
(*DBG:        return (void *)((((__IEC_REAL_p *) ptr)->flags & __IEC_FORCE_FLAG)*)
(*DBG:                        ? &(((__IEC_REAL_p *) ptr)->fvalue)*)
(*DBG:                        : ((__IEC_REAL_p *) ptr)->value);*)
(*DBG:    default:*)
(*DBG:        return 0;*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*DBG:void force_var(size_t idx, bool forced, void *val)*)
(*DBG:{*)
(*DBG:    void *ptr = debug_vars[idx].ptr;*)
(*DBG:*)
(*DBG:    if (forced) {*)
(*DBG:        size_t var_size = get_var_size(idx);*)
(*DBG:        switch (debug_vars[idx].type) {*)
(*DBG:        case BOOL_ENUM: {*)
(*DBG:            memcpy(&((__IEC_BOOL_t *) ptr)->value, val, var_size);*)
(*DBG:            ((__IEC_BOOL_t *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:    *)
(*DBG:        case BOOL_O_ENUM: {*)
(*DBG:            memcpy((((__IEC_BOOL_p *) ptr)->value), val, var_size);*)
(*DBG:            memcpy(&((__IEC_BOOL_p *) ptr)->fvalue, val, var_size);*)
(*DBG:            ((__IEC_BOOL_p *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:        case BOOL_P_ENUM: {*)
(*DBG:            memcpy(&((__IEC_BOOL_p *) ptr)->fvalue, val, var_size);*)
(*DBG:            ((__IEC_BOOL_p *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:        case SINT_ENUM: {*)
(*DBG:            memcpy(&((__IEC_SINT_t *) ptr)->value, val, var_size);*)
(*DBG:            ((__IEC_SINT_t *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:    *)
(*DBG:        case TIME_ENUM: {*)
(*DBG:            memcpy(&((__IEC_TIME_t *) ptr)->value, val, var_size);*)
(*DBG:            ((__IEC_TIME_t *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:    *)
(*DBG:        case REAL_ENUM: {*)
(*DBG:            memcpy(&((__IEC_REAL_t *) ptr)->value, val, var_size);*)
(*DBG:            ((__IEC_REAL_t *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:    *)
(*DBG:        case REAL_O_ENUM: {*)
(*DBG:            memcpy((((__IEC_REAL_p *) ptr)->value), val, var_size);*)
(*DBG:            memcpy(&((__IEC_REAL_p *) ptr)->fvalue, val, var_size);*)
(*DBG:            ((__IEC_REAL_p *) ptr)->flags |= __IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:        default:*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:    } else {*)
(*DBG:        switch (debug_vars[idx].type) {*)
(*DBG:        case BOOL_ENUM:*)
(*DBG:            ((__IEC_BOOL_t *) ptr)->flags &= ~__IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        case BOOL_O_ENUM:*)
(*DBG:        case BOOL_P_ENUM:*)
(*DBG:            ((__IEC_BOOL_p *) ptr)->flags &= ~__IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        case SINT_ENUM:*)
(*DBG:            ((__IEC_SINT_t *) ptr)->flags &= ~__IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        case TIME_ENUM:*)
(*DBG:            ((__IEC_TIME_t *) ptr)->flags &= ~__IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        case REAL_ENUM:*)
(*DBG:            ((__IEC_REAL_t *) ptr)->flags &= ~__IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        case REAL_O_ENUM:*)
(*DBG:            ((__IEC_REAL_p *) ptr)->flags &= ~__IEC_FORCE_FLAG;*)
(*DBG:            break;*)
(*DBG:        default:*)
(*DBG:            break;*)
(*DBG:        }*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*DBG:void swap_bytes(void *ptr, size_t size)*)
(*DBG:{*)
(*DBG:    uint8_t *bytePtr = (uint8_t *)ptr;*)
(*DBG:    size_t i;*)
(*DBG:    for (i = 0; i < size / 2; ++i)*)
(*DBG:    {*)
(*DBG:        uint8_t temp = bytePtr[i];*)
(*DBG:        bytePtr[i] = bytePtr[size - 1 - i];*)
(*DBG:        bytePtr[size - 1 - i] = temp;*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*DBG:void trace_reset(void)*)
(*DBG:{*)
(*DBG:    for (size_t i=0; i < VAR_COUNT; i++)*)
(*DBG:    {*)
(*DBG:        force_var(i, false, 0);*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*DBG:void set_trace(size_t idx, bool forced, void *val)*)
(*DBG:{*)
(*DBG:    if (idx >= 0 && idx < VAR_COUNT)*)
(*DBG:    {*)
(*DBG:        if (endianness == REVERSE_ENDIANNESS)*)
(*DBG:        {*)
(*DBG:            // Prevent swapping for STRING type*)
(*DBG:            if (debug_vars[idx].type == STRING_ENUM)*)
(*DBG:            {*)
(*DBG:                // Do nothing*)
(*DBG:                ;*)
(*DBG:            }*)
(*DBG:            else*)
(*DBG:            {*)
(*DBG:                swap_bytes(val, get_var_size(idx));*)
(*DBG:            }*)
(*DBG:        }*)
(*DBG:*)
(*DBG:        force_var(idx, forced, val);*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*DBG:void set_endianness(uint8_t value)*)
(*DBG:{*)
(*DBG:    if (value == SAME_ENDIANNESS || value == REVERSE_ENDIANNESS)*)
(*DBG:    {*)
(*DBG:        endianness = value;*)
(*DBG:    }*)
(*DBG:}*)
(*DBG:*)
(*FILE:c_blocks.h // Empty file *)
(*FILE:c_blocks.h  *)
(*FILE:c_blocks_code.cpp #include <stdint.h> *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp #ifdef ARDUINO *)
(*FILE:c_blocks_code.cpp #include <Arduino.h> *)
(*FILE:c_blocks_code.cpp #endif *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp /*********************/ *)
(*FILE:c_blocks_code.cpp /*  IEC Types defs   */ *)
(*FILE:c_blocks_code.cpp /*********************/ *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp typedef uint8_t  IEC_BOOL; *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp typedef int8_t    IEC_SINT; *)
(*FILE:c_blocks_code.cpp typedef int16_t   IEC_INT; *)
(*FILE:c_blocks_code.cpp typedef int32_t   IEC_DINT; *)
(*FILE:c_blocks_code.cpp typedef int64_t   IEC_LINT; *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp typedef uint8_t    IEC_USINT; *)
(*FILE:c_blocks_code.cpp typedef uint16_t   IEC_UINT; *)
(*FILE:c_blocks_code.cpp typedef uint32_t   IEC_UDINT; *)
(*FILE:c_blocks_code.cpp typedef uint64_t   IEC_ULINT; *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp typedef uint8_t    IEC_BYTE; *)
(*FILE:c_blocks_code.cpp typedef uint16_t   IEC_WORD; *)
(*FILE:c_blocks_code.cpp typedef uint32_t   IEC_DWORD; *)
(*FILE:c_blocks_code.cpp typedef uint64_t   IEC_LWORD; *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp typedef float    IEC_REAL; *)
(*FILE:c_blocks_code.cpp typedef double   IEC_LREAL; *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp #ifndef STR_MAX_LEN *)
(*FILE:c_blocks_code.cpp #define STR_MAX_LEN 126 *)
(*FILE:c_blocks_code.cpp #endif *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp #ifndef STR_LEN_TYPE *)
(*FILE:c_blocks_code.cpp #define STR_LEN_TYPE int8_t *)
(*FILE:c_blocks_code.cpp #endif *)
(*FILE:c_blocks_code.cpp  *)
(*FILE:c_blocks_code.cpp typedef STR_LEN_TYPE __strlen_t; *)
(*FILE:c_blocks_code.cpp typedef struct { *)
(*FILE:c_blocks_code.cpp     __strlen_t len; *)
(*FILE:c_blocks_code.cpp     uint8_t body[STR_MAX_LEN]; *)
(*FILE:c_blocks_code.cpp } IEC_STRING; *)
(*FILE:c_blocks_code.cpp  *)

alexburcea Admin Staff member

2/27/26, 8:45 PM

Ok, I was expecting the project on the OpenPLC editor, not the file you load to the runtime. I hope I can manage to debug it.

I understand this was tested with runtime v3, but which editor version were these created in?

JF

Jake Freese

2/27/26, 8:50 PM

sorry, I meant to upload the whole project and just the .st The whole project is in the zip document in the github link now

It is Editor v4

alexburcea Admin Staff member

2/27/26, 10:40 PM

I think that is a problem, use editor V4 with runtime V3. You should ask OpenPLC whether you can mix V3 and V4, but I think not. Otherwise, why not upgrade V3 to V4? They created separate repositories for V4 (editor and runtime).

My advice, before I struggle to debug the program (I must mention that my skills with OpenPLC or any PLC language are limited), is to use V3 or V4 for both runtime and editor.

JF

Jake Freese

2/28/26, 3:49 AM

I am going to try the matched versions in the morning and I will let you know how that goes. It is supposed to work with the V4 editor and the v3 runtime. You can select which runtime when you compile your program. Hopefully I will come up with something tommorrow.

Thanks!

JF

Jake Freese

2/28/26, 3:30 PM

ok initial test with v3 editor and runtime, I can make outputs work.

I will test the v4 editor with v4 runtime hopefully later today.

JF

Jake Freese

3/2/26, 8:26 PM

For some reason the editor is not assigning the pin outputs.

The first one is off V3 editor, the second off V4 editor. I tried to add the pin assignments manually in that line of code on the V4 version and it came up with more errors. My "TEST" variable only shows up the one time in the V4 code and never with any reference to what pin it would be attached to. I have posted this over on the OpenPLC forum. We will see!

SM_16DIN0(STACK := SM_16IN_STK);
  HOBBY_LTS := SM_16DIN0.I1;
  TON0(IN := HOBBY_LTS, PT := DB);
  HOBBY_LT := TON0.Q;
  OFFICE_LTS := SM_16DIN0.I2;
  TON1(IN := OFFICE_LTS, PT := DB);
  OFFICE_LT := TON1.Q;
  SM_8RELAY0(STACK := SM_8RLY_STK, O1 := HOBBY_LT, O4 := TEST);
  SM_INDUSTRIAL0(STACK := SM_IND_STK, LED1 := OFFICE_LT);

SM_16DIN0(STACK := SM_16DIN_STK);
  TON0(IN := SM_16DIN0.I1, PT := DB);
  SM_8RELAY0(STACK := SM_8RELAY_STK);
  SM_INDUSTRIAL0(STACK := SM_INDUSTRIAL_STK);
  HOBBY_LTS := SM_16DIN0.I1;
  OFFICE_LTS := SM_16DIN0.I2;
  TON1(IN := SM_16DIN0.I2, PT := DB);

Challenges getting 8 RELAY board to work in OpenPLC

Related topics

Sixteen LV Digital Inputs 8-Layer HAT (16inpind): AC input behavior (zero-crossing) and Home Assistant

Cards not powering from 24v input

4relind dry contact

IOPLUS card not working

OpenPLC migration to v4

Participants

alexburcea

Jake Freese