There are two three kinds of people; One is like you, replying with simplified answers. Another is someone like me, going fully insane for fun -- I don't want to mention the last. LOL
In programming, there are five or more types of programming process.
- Translate
- Relocate
- Insert
- Modify
- Remove
Six or more important programming design to look out for.
- Comparison
- Compability
- Efficiency
- Productivity
- Performance
- Structure
To even start with auto-programming, the system must understand what it is trying to achieve. To do that, there are three or more ways -- one is through visualization, second is through natural language, third is through pseudo-logic, and so on.
But the biggest problem is that, the system is required to know how to even program anything. It needs to understand programming language.
We have the following objects:
- Floors
- Lobby Button Panel
- Up Call-Button
- Down Call-Button
- Elevator
- Elevator Door
- Elevator Button Panel
- Elevator Floor Buttons
- Elevator Door-Open-Button
- Elevator Door-Close-Button
Before the system were to delve into programming the Elevator, the system is required to understand the basics of an Elevator mechanism, given some time and thought, let's say this is what the system deduced:
- Elevator
- A platform or compartment housed in a shaft for raising and lowering people or things to different floors or levels.
- The Elevator has three States; Ascend, Descend, and Idle.
- The Elevator State will change into Idle from its moving state once it has reached its destination, and changing its Elevator State from Closed-Idle into Opening State.
- Lobby Up and Down Call-Buttons
- The Lobby Up Call-Button stops only a rising elevator, this is for efficiency.
- The Down Call-Button stops only a descending elevator.
- Elevator Floor Buttons
- Queues floor presses to move the elevator to that floor, once the elevator has reached its destination, that floor will be dequeued, freeing the button to be pressed again.
- If there are no Queue, the Elevator will move, and retains at Idle State with its Elevator Door as Closed-Idling state.
- Elevator Door
- The Elevator has a safety mechanism to ensure no one gets crushed when closing, anyone can probe the door open and it will change its Closing-state into Opening-State.
- The Elevator's door has four states; Opening, Closing, Opened-Idling, and Closed-Idling.
- Let's start at Opening State.
- The door can detect once the door has been fully opened, it will change its state into Open-Idling State, additionally resetting the countdown timer for automatically closing the door, the timer will start.
- Once the timer ends, or the Door-Close button has been pressed, the door state will change into Closing State.
- In this state, probing the door open or pressing the Open-Door Button will change its state to Opening-State.
- As the door fully closed, it will reset and initiate a second countdown. Once the countdown ends, Elevator State will change from Idle State to either one of the Ascend state or Descend state, depending on which destination floor relative to the location floor of the elevator.
- The door can still be reopened by either probing between the elevator door or pressing the Open-Door Button before the countdown timer ends.
- The Elevator Door presumably has two timers
- One is to automatically closing the Elevator Door.
- Another is a short pause before initiating Elevator movement after the door has been closed.
- Elevator Door-Close and Door-Open buttons
- The Elevator Door-Close Button forces Elevator Door into Closing State, regardless of probing the door.
- The Elevator Door-Open Button only forces the Closed-State of elevator into Opening State.
- Elevator Weight
- If the Elevator Weight exceeds a certain threshold, the Elevator Door will always be stuck at Open-Idling state, rendering the Elevator unusable.
- Elevator Floor Detection
- The Floor where the Elevator Car is can be detected by sensors between the Elevator Car and the Shaft.
Now we have all information we need (Not really, I've left out a few things). To begin auto programming, one would need to start from somewhere. One would, perhaps, begin by preparing the fields and properties. The preparation isn't easy, it will have to go through its logic over and over until it is found completed, which requires to insert, modify, and/or remove the codes.
All of these are done in Notepad++, language used as presentation: C#
///<summary>Elevator Direction.</summary>
public enum ElevatorDirection : byte
{
Null
, Ascend
, Descend
}
///<summary>Elevator State.</summary>
public enum ElevatorState : byte
{
Idle
, Move
, Align
}
///<summary>Elevator Door State.</summary>
public enum ElevatorDoorState : byte
{
Opening
, Closing
, OpenedIdle
, ClosedIdle
}
///<summary>IElevator Interface.</summary>
public interface IElevator
{
//interface declaration
}
///<summary>Elevator.</summary>
public partial sealed class Elevator : ElevatorSystem, IElevator
{
private static Elevator instance; ///<summary>Array of FloorLobby Instances.</summary>
public static Elevator Instance { get { return floors; } }
private FloorLobby[] floors; ///<summary>FloorLobby Instances.</summary>
public FloorLobby[] Floors { get { return floors; } }
private float currentIndex; ///<summary>Current Index of where the Elevator Car is.</summary>
public float CurrentIndex { get { return currentFloor; } }
private ElevatorDirection elevatorDirection; ///<summary>Elevator Direction of travel.</summary>
public ElevatorDirection ElevatorDirection { get { return elevatorDirection; } }
private FloorLobby floorDestination; ///<summary>Floor Lobby Destination.</summary>
public FloorLobby FloorDestination { get { return floorDestination; } }
private FloorLobby floorDestination2; ///<summary>Floor Lobby Destination 2.</summary>
public FloorLobby FloorDestination2 { get { return floorDestination2; } }
private Dictionary<ElevatorFloorButton> floorButtons; ///<summary>ElevatorFloorbutton Instances.</summary>
public Dictionary<ElevatorFloorButto> FloorButtons { get { return floorButtons; } }
private Timer moveTimer; ///<summary>Maximum Countdown Time Interval in miliseconds for moving the Elevator.</summary>
public Timer MoveTimer { get { return cancelButtonTimer; } }
private Timer doorCloseTimer; ///<summary>Maximum Countdown Time Interval in miliseconds for moving the Elevator.</summary>
public Timer CloseDoorTimer { get { return doorCloseTimer; } }
private ElevatorState elevatorState; ///<summary>Elevator State.</summary>
public ElevatorState ElevatorState { set { elevatorState = value; } get { return elevatorState; } }
private ElevatorDoorState doorState; ///<summary>Elevator Door State.</summary>
public ElevatorDoorState DoorState { set { doorState = value; } get { return doorState; } }
private OrderedDictionary<FloorLobby> floorQueue; ///<summary>Elevator Floor Queue.</summary>
public OrderedDictionary<FloorLobby> FloorQueue { get { return floorQueue; } }
///<summary>Initializer.</summary>
public void Initialize(ElevatorSystem elevatorSystem, int floorMax, long moveTimer, long doorCloseTimer, long cancelTimer, ElevatorState elevatorState, ElevatorDoorState doorState)
{
this.elevatorSystem = elevatorSystem;
this.moveTimer = new Timer(moveTimer);
this.doorCloseTimer = new Timer(doorCloseTimer);
this.elevatorState = elevatorState;
this.doorState = doorState;
this.floorQueue = new OrderedDictionary<FloorLobby>();
this.floorButtons = new Dictionary<ElevatorFloorButton>();
this.floors = new FloorLobby[floorMax];
for (int i = 0; i < floorMax; i++)
{
this.floors[i] = new FloorLobby(this, i);
this.floorButtons.Add(new ElevatorFloorButton(this, cancelTimer));
}
MoveTimer.Tick += new EventHandler(MoveTimerTick);
CloseDoorTimer.Tick += new EventHandler(CloseDoorTimerTick);
}
}
///<summary>Floor Lobby.</summary>
public partial class FloorLobby
{
private IElevator iElevator; ///<summary>IElevator.</summary>
public IElevator IElevator { get { return iElevator; } }
private int index; ///<summary>Floor Index.</summary>
public int Index { set { index = value; } get { return index; } }
private LobbyButton lobbyButton; ///<summary>Lobby Button.</summary>
public LobbyButton LobbyButton { get { return lobbyButton; } }
///<summary>Constuctor.</summary>
public FloorLobby(Elevator elevator, int index)
{
this.iElevator = elevator;
this.index = index;
this.lobbyButton = new LobbyButton(elevator, this);
}
}
///<summary>Lobby Button.</summary>
public partial class LobbyButton
{
private IElevator iElevator; ///<summary>IElevator.</summary>
public IElevator IElevator { get { return iElevator; } }
private FloorLobby floorLobby; ///<summary>Floor Lobby that the Lobby Button is linked to.</summary>
public FloorLobby FloorLobby { get { return floorLobby; } }
private bool upButtonState; ///<summary>Up Button State.</summary>
public bool UpButtonState { set { upButtonState = value; } get { return upButtonState; } }
private bool downButtonState; ///<summary>Down Button State.</summary>
public bool DownButtonState { set { downButtonState = value; } get { return downButtonState; } }
///<summary>Constuctor.</summary>
public LobbyButton(Elevator elevator, FloorLobby floorLobby)
{
this.iElevator = elevator;
this.floorLobby = floorLobby;
}
}
///<summary>Elevator Floor Button.</summary>
public partial class ElevatorFloorButton
{
private IElevator iElevator; ///<summary>IElevator.</summary>
public IElevator IElevator { get { return iElevator; } }
private FloorLobby floorLobby; ///<summary>Floor Lobby that the Elevator Floor Button is linked to.</summary>
public FloorLobby FloorLobby { get { return floorLobby; } }
private Timer cancelButtonTimer; ///<summary>Cancel Button Timer.</summary>
public Timer CancelButtonTimer { get { return cancelButtonTimer; } }
///<summary>Constuctor.</summary>
public ElevatorFloorButton(Elevator elevator, FloorLobby floorLobby, int cancelButtonTimerInterval)
{
this.iElevator = elevator;
this.floorLobby = floorLobby;
this.cancelButtonTimer = new Timer(cancelButtonTimerInterval);
myTimer.Tick += new EventHandler(FloorsButtonDoublePressTimerTick);
}
}
Alright, good, good. Now the system can define all the logics required for everything to work based on the information.
///<summary>Elevator.</summary?
public partial class Elevator
{
///<summary>Open Door Button Press.</summary>
public override void OpenDoorButtonPress(object sender, EventArgs e)
{
if (ElevatorState == ElevatorState.Idle)
{
DoorState = ElevatorDoorState.Opening;
}
}
///<summary>Close Door Button Press.</summary>
public override void CloseDoorButtonPress(object sender, EventArgs e)
{
if (ElevatorState == ElevatorState.Idle)
{
DoorState = ElevatorDoorState.Opening;
}
}
///<summary>Button Obstruction detection.</summary>
public override void DoorObstruction(object sender, EventArgs e)
{
DoorState = ElevatorDoorState.Opening;
}
///<summary>Button Close Door Press.</summary>
public override bool DoorOpen(int speed)
{
//door open logic goes here
}
///<summary>Button Close Door Press.</summary>
public override bool DoorClose(int speed)
{
//door open logic goes here
}
///<summary>Elevator Move.</summary>
public override bool ElevatorMove(int speed)
{
//elevator move logic goes here
}
///<summary>Elevator Floor Locate.</summary>
public override bool ElevatorFloorLocate(object sender, EventArgs e)
{
CurrentIndex = e.CurrentIndex;
}
///<summary>Close Door Timer Reset.</summary>
private bool CloseDoorTimerReset(object sender, EventArgs e)
{
if (CloseDoorTimer.Enabled)
CloseDoorTimer.Stop();
CloseDoorTimer.Start();
}
///<summary>Move ElevatorTimer Reset.</summary>
private bool MoveTimerReset(object sender, EventArgs e)
{
if (MoveTimer.Enabled)
MoveTimer.Stop();
MoveTimer.Start();
}
///<summary>Close Door Timer Tick.</summary>
public void CloseDoorTimerTick(object sender, ElapsedEventArgs e)
{
if (CloseDoorTimer.Enabled)
{
CloseDoorTimer.Stop();
DoorState = ElevatorDoorState.Closing;
}
}
///<summary>Move Timer Tick.</summary>
public void MoveTimerTick(object sender, ElapsedEventArgs e)
{
if (MoveTimer.Enabled)
{
MoveTimer.Stop();
ElevatorState = ElevatorState.Move;
}
}
}
///<summary>Lobby Button.</summary>
public partial class LobbyButton
{
///<summary>Reset State.</summary>
public void ResetButtonState()
{
UpButtonState = false;
DownButtonState = false;
}
}
///<summary>Elevator Floor Button.</summary>
public partial class ElevatorFloorButton
{
///<summary>Cancel Button Timer Reset.</summary>
private bool CancelButtonTimerReset(object sender, EventArgs e)
{
if (CancelButtonTimer.Enabled)
CancelButtonTimer.Stop();
CancelButtonTimer.Start();
}
///<summary>Floors Button Press.</summary>
public bool FloorsButtonPress(object sender, EventArgs e)
{
if (!CancelButtonTimer.Enabled && !FloorQueue.Contains(this))
FloorQueue.Add(this);
CancelButtonTimerReset();
}
///<summary>Floors Button Double Press.</summary>
public bool FloorsButtonDoublePress(object sender, EventArgs e)
{
if (CancelButtonTimer.Enabled && IElevator.FloorDestination != this)
FloorQueue.Remove(this);
}
///<summary>Floors Button Double Press Timer Tick.</summary>
public void FloorsButtonDoublePressTimerTick(object sender, ElapsedEventArgs e)
{
if (CancelButtonTimer.Enabled)
CancelButtonTimer.Stop();
}
}
