Looking at Boolean Arrays - Logix5000

      ALARMS[0]      ANYALARM
---+-----] [- ---+------( )-----------
   |             |
   |  ALARMS[1]  |
   +-----] [-----+
   |             |
   |  ALARMS[2]  |
   +-----] [-----+
[SIZE=5][B]...[/B][/SIZE]
   |             |
   | ALARMS[414] |
   +-----] [-----+
   |             |
   | ALARMS[415] |
   +-----] [-----+

• Do it in a loop
  • unlatch the output bit
  • initialize a COUNTER to 0 for indirect addressing
  • loop over the bits
    • start with the LBL instruction; also
      • OR two branches
        • LES COUNTER 416
        • XIO OUTPUT_BIT
        • so the loop ends when either the counter reaches 416, or any bit is 1
    • latch the output bit if ALARMS[counter] is 1
    • increment the COUNTER
    • jump back to the LBL
• Whoops, Logix5000 has a FOR loop, and I have spent too much time with RSLogix Lite, so scratch that first suggestion
• Look for a Logix5000 instruction that examines multiple bits at once
  • I can't imagine you are the first to come up against this; maybe there is already a built-in instruction that can examine all bits in an array in one shot. In fact, I would do this first.
  • Again, since you are not likely the first, maybe there is an AOI somewhere on this site
  • Somehow converting (COP or CPS) that boolean array into an equivalent array of 13 32-bit DINTs, and comparing each of those 13 DINTs to 0 (NEQ DINT_ALRM[0] 0), or bitwise ORing them together into a single DINT and comparing that result to 0.
• N.B. A loop may add significantly to the time it takes to test 416 bits.
  • Perhaps a response time of up to, say, a seconds or so, to one boolean changing from 0 to 1, or back, is acceptable
  • In that case, you could test only 32 per scan, so all 416 are tested over 13 scans:
  • I.e. on each scan
    • With DINT COUNTER and boolean ANY_ALARM
    • If
      • ANY_ALARM is 1,
      • or COUNTER is less than 0
      • or COUNTER is greater than 12,
      • Then assign 0 to counter
    • Test (OR) 32 ALARMS boolean, from ALARMS[32*COUNTER] to ALARMS[32*COUNTER-1];
      • if any are 1, latch ANY_ALARM to 1, and assign 13 (or -1) to COUNTER
      • Perhaps this could be done in an AOI or separate routine?
    • Add 1 to COUNTER
    • If COUNTER equals 13, unlatch ANY_ALARM to 0

Holmux said:

I change the program around, so I only have one routine pr. array controlling everything going in and out of the array, added a few counters, counting up and down, when ever a bit is set or reset.

Click to expand...

TrashKetchum said:

You mean something like this?
{structured text}

Click to expand...

ALARMS[416] := 0;  /* Elephant in Cairo */

index := 0;

WHILE index < 416 AND NOT ALARMS[index] DO
   index := index + 1;
END_WHILE

RESULT := ALARMS[index];

ALARMS[416] := 1;  /* Elephant in Cairo */

index := 0;

WHILE NOT ALARMS[index] DO
   index := index + 1;
END_WHILE

RESULT := index < 416;

drbitboy said:

Unfortunately for the OP, that involves adding a couple-three branches wherever each alarm is set.

Click to expand...