In logic controller design *sequence* is very important. So is *context*. A logic controller is essentially something that responds to inputs by altering outputs in the right sequence, where the sequence may vary with context. (Use the terms "history" or "past events" instead of "context", if that is more comfortable.

My job includes studying and designing programming methods that can express sequence and context.

So here is my question: How would you code the following in the language(s) you use ...

A controller has one push button switch wired to an input, and one lamp wired to an output. The first time the button is pressed the lamp must come on. The next time the button is pressed, the lamp must turn off. On the next press the lamp comes on, etc. etc. Don't forget to allow for the button to be released before it is pressed again.

This is not a trick question or "test". I am simply interested in how a simple example involving sequence and context is handled by different professionals in various languages. I would also be interested in opinions as to how easily a given solution would be to explain to a colleague who is not familiar with the specific language (or operating system)

Simple solution would be to set the manufacturers "toggle" - pretty much most of them have one in some form.
Complicated solution would be setting up a debounced, fully interlocked setup using an embedded system.
I would be against using ladder logic in such a simple system, as the poor registers would get overwritten before certain commands (external to the ladder, but internal to the bios) would happen. You need at least 5 rungs for ladder to not jam or miss stuff. Would be ideal for an FPGA where you could process the task as a multithread with another task.
Easiest solution of course would be to have a toggle switch hardwired to the lamp with no controller of course.

Here is an example (SCL - Structured Control Language (Siemens))
As a note, I could do it in less instructions, however this is clean and gives the "next" user comments to follow:

-------------------
FUNCTION_BLOCK toggle_lamp;

TITLE = 'Momentary Pushbutton Control to Toggle a Lamp'
VERSION : '1.0'
AUTHOR : 'SGB'
NAME : 'toggle_lamp'
FAMILY : 'LINKEDIN.COM'

VAR_INPUT
PB : BOOL; //MOMENTARY PUSHBUTTON INPUT
END_VAR;

VAR_OUTPUT
LAMP : BOOL; //LAMP OUTPUT CONTROL
END_VAR;

VAR
pb_old : BOOL; //VALUE OF PUSHBUTTON AT THE END OF THE SCAN
lamp_old : BOOL; //VALUE OF THE LAMP AT THE END OF THE SCAN
END_VAR;

BEGIN

// CHECK FOR A CHANGE IN THE PUSHBUTTON STATE
IF (PB AND NOT pb_old) THEN
LAMP := NOT(lamp_old);
END_IF;

// SET THE VALUE OF pb_old TO COMPARE WITH PB ON NEXT SCAN
pb_old := PB;

// SET THE VALUE OF lamp_old IN PREPARATION FOR A CHANGE IN PB
lamp_old := LAMP;

END_FUNCTION_BLOCK

Here is a way to do this in Ladder using a one shot on the pushbutton and a simple latching circuit. Pbout is an internal memory bit or tag. I have applied this to GE and AB PLC's on many occasions.


pb1 pbout
----I I-----------[ons]-------------------( )---

pbout Lamp1 Lamp1
----I I----------I/I-------------------------( )-----
I I
I Lamp1 PBout I
I---I I----------I/I-------I

I am going to use the link at the very bottom of this page to ask the LI people to provide at least basic formatting control!! Who will join me?

This type of problems (events, state and context) is screaming for State Machines. No programming language can compare to the graphical state machine diagram with "your programming language" implementing guards and actions. (Can't post pictures here, but you are welcome to check it at www.as1tech.com) Add some complexities to your example and prepare to write pages of code or start using State Machines

David - Curious that you use such a simple example to enquire about sequence control. I am a plc man, so i would think of something on Mark's lines for this. however, in much more complex systems, it is possible to design a plc program such that it acts like a true multi-tasking sequencing system, that can be reprogrammed to perform entirely different sequences merely by altering a datatable list. The beauty of it is that the tasks within the sequence are fully tested, and provided the sequences are valid, no validation is needed for the new sequences. (Systems on this principle have been running in UK factories for 25 years now).
As to your question, I'd use latched outputs
XIC pb, XIO lamp, XIO os, OTL lamp OTL os
XIC pb XIC lamp XIO os OTU lamp OTL os
XIO pb OTU os
-| |- is XIC, -|\|- is XIO, -(L)- is OTL, -(U)- is OTU

Thanks David - I like what I have seen so far - well thought out.
Novel marketing ploy - but justified!
Paul

In TwinCAT PLC using Structured Text:

(* Create a rising edge trigger to handle button *)
fbR_TRIG( (* rising edge trigger function block (one-shot) *)
CLK:= diPushbutton); (* input or 'clock' to function block is linked to PB *)

(* If the button is pressed then invert the state of the output *)
IF fbR_TRIG.Q = TRUE THEN doLamp:= NOT(doLamp);

I think this would be difficult to explain to someone who is unfamiliar with TwinCAT. There's some overhead to take care of first. A POU (Program Organizon Unit ( a program) ) or Action (a subroutine) has to be created that is continually scanned to check for a change in the push button state. Your tutorial represented the solution in a simple and effective form. The logic is simple. Translating it to another language is the challenge. Syntax and program structure vary from one language/platform to the next. There are so many variables to consider.

I'm not sure if that's kind of feedback you're looking for. I enjoyed the tutorial.

-Geoff