POINTERs

2022-09-26T15:45:01.196000Z

use {attribute 'subsequent'}
and this problem is solved

POINTERs

2020-02-27T13:55:47.363000Z

Originally created by: ph0010421

Comingback4u hat geschrieben:
Thanks Scott,
Great suggestion. I hadn't thought of using sizeof to determine the length of a data type for iterating through memory locations.
Regards,
CB

Agree. Thanks Scott

POINTERs

2020-02-27T13:55:47.148000Z

Thanks Scott,
Great suggestion. I hadn't thought of using sizeof to determine the length of a data type for iterating through memory locations.

Regards,
CB

POINTERs

2020-02-27T13:55:46.906000Z

Originally created by: scott_cunningham

CB
A STRUCT should be one continuous space IF the struct elements are all the same (such as a struct if BOOLs). This becomes false when you mix data types (DWORDS don’t start at an odd memory location).

I also received the “warning” message when I made the online change with Bool3, but I simply did what too many people do - I quickly clicked OK and ignored it!

Your offered solution is good, with a small change - I would not use +1 in your pointer math - that assumes that a BOOL will always only use one byte of memory location... this may not be the case on all hardware platforms! (This may seem silly, but so does CoDeSys’ BOOL as 8 bits of space instead of 1 bit to a C programmer!). Instead, use + SIZEOF(BOOL) in the for loop and the pointer calculation.

It would be interesting to see some type of OOP solution, too! Seems close to a linked list.

POINTERs

2020-02-27T13:55:46.067000Z

Scott,
I understand your example of just creating a BOOL and how there is no guarantee that bool2 will be right after bool 1 but isn't that where using a structure would fix that?

For example whenever I change the structure and do an on-line change you get a warning that the variable you declared that used that structure will move to new memory locations. This moves all of the existing variables in the structure and keeps them in order. I have yet to find a device/os/compiler that doesn't put this in order when talking about CoDeSys.

I'm trying to understand how to do what the original author was asking if the way I suggested is not reliable. Just trying to learn.

Regards,
CB

POINTERs

2020-02-27T13:55:45.781000Z

Originally created by: KevinR

Wow - Scott, Thank you for this detailed description.

Gesendet von meinem LYA-L29 mit Tapatalk

POINTERs

2020-02-27T13:55:45.558000Z

Originally created by: scott_cunningham

Please take care with pointer and reference assumptions - as was warned by others regarding memory locations! The following screenshots show issues in the idea that a list of BOOLs will be where you expect them:

This was at first build and download - note the huge gap between Bool1 and Bool2 (so reading one memory location after Bool1 would be complete garbage!):

This was after I added another BOOL and performed an online change - notice Bool3 is spaced 4 bytes after Bool2:

This was after I performed a clean and download - note that Bool3 is now moved relative to the online change (and is as one would "expect" - at 1 memory location after Bool2):

If you are going to use a solution using POINTER TO or REFERENCE TO, please know that online changes can sometimes move variables and FBs around in memory, breaking those pointers (point to the old location, not the new one) - refresh the pointers to avoid online change problems (you can avoid online changes, but somebody else using your code may use online change...). I am pretty sure REFERENCE TO has the same problem with online change, since behind the scenes a REFERENCE TO is a special handling of POINTER TO.

Good luck!

POINTERs

2020-02-27T13:55:45.278000Z

First understand Codesys treats bools as one byte. So you can not pack the bits unless you locate them to physical memory. I already have many post on this so I will not repeat it here.

Also Codesys does not allow for array of pointers or references but here is work around by making an array of structures with the pointer or reference. I prefer references because you do not have to keep dereferencing them like pointers. See Example below that will the number of on bools.

TYPE DUT_REF :
STRUCT
   xBool: REFERENCE TO BOOL;
END_STRUCT
END_TYPE

PROGRAM TEST
VAR
   myref: ARRAY[0..7] OF DUT_REF;
   BIT00: BOOL;
   BIT01: BOOL;
   BIT02: BOOL;
   BIT03: BOOL;
   BIT04: BOOL;
   BIT05: BOOL;
   BIT06: BOOL;
   BIT07: BOOL;
   i: INT;
   num_of_on: UINT;
END_VAR

myref[0].xBool REF= BIT00;
myref[1].xBool REF= BIT01;
myref[2].xBool REF= BIT02;
myref[3].xBool REF= BIT03;
myref[4].xBool REF= BIT04;
myref[5].xBool REF= BIT05;
myref[6].xBool REF= BIT06;
myref[7].xBool REF= BIT07;
BIT00:=TRUE;
BIT06:=TRUE;
BIT07:=TRUE;
num_of_on:=0;
FOR i:=0 TO SIZEOF(myref)/SIZEOF(DUT_REF)-1 DO
   IF __ISVALIDREF(myref[i].xBool) THEN
      IF(myref[i].xBool) THEN 
         num_of_on:=num_of_on+1; 
      END_IF   
   END_IF
END_FOR;

POINTERs

2020-02-27T13:55:44.523000Z

Why not using an array with a constant defining the length ?
Then access may be done by an ENUM, defining each value your array index may take.

For instance,

VAR_GLOBAL
   MyBool : ARRAY [1..Const._MAXVALUE] OF BOOL;
END_VAR

TYPE MyBools_ENUM :
(
   First := 0,
   Second:= 1,
   Third:= 2,
   WhatEver := 3
) UINT;
END_TYPE

Then usage is in a loop, as a standard array or this way :

MyBool[MyBools_ENUM.WhatEver] := 99;

POINTERs

2020-02-27T13:55:44.236000Z

Originally created by: rickj

@Comingback4u's method is platform/compiler dependent. Struct members are not necessarily packed in a contiguous manner on all CPU architectures.

Recent posts to POINTERs

POINTERs

POINTERs

POINTERs

POINTERs

POINTERs

POINTERs

POINTERs

POINTERs

POINTERs

POINTERs