1. IntroductionThis section of the paper describes the design
and development of control system of an elevator model with
following requirements: Serve passengers quickly Highest
proficiency and safety Low cost
2. Specification2.1. FeaturesThe problem concern the logic
required to move elevator between floors according to the following
constrains: Each floor, except the first floor and top floor has
two buttons, one to request an up-elevator and one to request a
down-elevator. These buttons illuminate when pressed. The
illumination is canceled when an elevator visits the floor and then
moves in the desired direction. Inside the cabin, there is panel
consisting of 8 buttons, these buttons illuminate when pressed. The
illumination is canceled when an elevator visits the floor and then
moves in the desired direction. Continue traveling in the same
direction while there are remaining requests in that same
direction. When an elevator has no requests, it remains at its
current floor with its doors closed.2.2. ConceptExpending on our
list of attribute, we speculate that the elevator circuit would
consists of five modules: Users inputs Elevator button panel:
consists of 6 buttons corresponding to 6 floors, in addition to
close door button and hold button which take the request to the
visited floor. Each floor, except the first floor and top floor has
two buttons, one to request an up-elevator and one to request a
down-elevator. Display module Indicating the position of the cabin
on 7 segments LEDs Showing the direction of the elevator car on an
8x8 Matrix LED Illuminate the buttons when pressed using Red LEDs.
Sensors Floor sensors: each floor has a limit switch to indicate
which floor that the cabin has reached Secondary floor sensors:
located at the haft way between floors, also use limit switch
Opened and closed door sensors which signal that the doors have
completely opened or closed Motors driver: control two motors, one
to lift the elevator cabin and one to drive the doors. Power
supply
2.3. Basic block diagram
2.4. LimitationsBecause we are dealing with a simulation meaning
that not all features of the real world can be implemented, these
limitations can be summarized as follows: The door system includes
several safety devices. Sensors detect passengers or objects in the
door opening, preventing the continued closing of the doors. A
special fire emergency system has been installed. It may be
manually activated, or may respond to smoke sensors in the
building. Exact operation varies by local codes, but generally such
systems return the elevator to the main floor, open the doors to
allow passengers to exit, and make the elevators available to
emergency personnel.
3. Hardware design3.1. AVR MicrocontrollerThe ATMegal6 was
chosen for the prototype development. The Mega16 is pin-for-pin
compatible with the smaller-memory model ATMega8535 as well as with
the larger-memory model ATMega32. This allows some freedom during
the design phase. The option of increasing the memory model may be
needed, since we do not know exactly how much code space is
required in either unit. At the end of the project, and after the
features have ceased to creep, if the code would fit into a
potentially less expensive component with a smaller memory size,
that choice is available as well.
3.2. Power supplyThe supply power of the implemented circuit
need to have a capability of maintaining a steady voltage level
despite vary current demands and input voltage variations. For this
purpose, we use IC 7805.
We use the power supply of the PC to generate the 12V sources
from the 220V AC at the input of IC7805. The role of capacitors is
to store and release electricity to smooth out noise, surges, and
sags. Without the capacitors, the 7805 would still output 5 V but
wouldnt react as quickly to changes in supply and demand, and thus
it wouldnt provide as clean of a regulated output.
3.3. Users input and Floor sensorsBecause ATmega16 has a limited
number of pins and this system requires quite many buttons to
operate, except the button panel inside the cabin using four pins
of microcontroller, we use each of three pins to take the input of
each group of buttons and sensors. We can see the circuit of matrix
3x8 in the following figure
3.4. Display moduleIndicating the position of the cabin using 7
segments LEDs, showing the direction of the elevator car using an
8x8 Matrix LED and to illuminate the buttons when pressed we use
Red LEDs. Finally, to control all of these LEDs, we use six ICs
74HC595
The 74HC595 shift register has an 8 bit storage register and an
8 bit shift register. Data is written to the shift register
serially, then, latched onto the storage register. The storage
register then controls 8 output lines.
Pin 14 (DS) is the Data pin. When pin 11 (SH_CP) goes from Low
to High, the value of DS is stored into the shift register and the
existing values of the register are shifted to make room for the
new bit. Pin 12(ST_CP) is held low whilst data is being written to
the shift register. When it goes High, the values of the shift
register are latched to the storage register which are then
outputted to pin Q0-Q7.Thus, to control all of the LEDs, we just
have to use three pins of the Microcontroller which is an advantage
of this method.3.5. Motors DriverThe motors driver circuit is
required in order to drive the motors, for pulling or lowering the
elevator car, and for opening or closing the doors. The digital
control signal provided by ATMega16 Microcontroller does not
deliver sufficient current to drive the motors. Hence, a driver
circuit, which is capable of changing the direction of motors using
the logic signals and is capable of being driven at high current,
is used.
4. Software Design4.1. System EventsThe system events can be
summarized as follows: Process Elevator Calls: These scenarios
includes that the elevator receives calls from the passengers
outside the cabin, turns on or turns off the light of elevator call
buttons, updates the record of elevator calls stored in system
queues, etc. Process Floor Calls: Similar to Elevator Call
processing, this use case includes that the elevator receives Floor
calls from the passengers inside the cabin, turns on or turns off
the light of Floor calls buttons, updates the record of floor calls
in system queues, etc. Move/Stop elevator: The main function of an
elevator, how to make the decision of stop, and driving directions
of the elevator. Indicating Moving Direction: This mechanism let
the passengers know the current moving direction of the elevator
such that the passenger might decide whether to enter the elevator
or not. Indicating Elevator Position: Similarly, the elevator let
the passengers know whether his/her destination floor is reached so
that the passenger may decide to leave the elevator. Open/Close the
Doors: The elevator is able to open and close the doors for the
passengers to get in and out of the elevator. The door function
also enables the passengers to make door reversals when the doors
are closing and the passenger wants to get in the elevator or close
door sooner than usual when there is no other passengers entering
cabin. On/Off illumination: The elevator and floor buttons are able
inform the passenger that his call has been scheduled and inform
him that his call has been requested, in which button illumination
will be needed.
4.2. ImplementationThe basic concept of the software is to
collect the inputs from users and sensors (floor sensors and door
sensors); base on these inputs, program will drive the motors to
serve every request, one after another, while displaying the
present status of the elevator to the users.The task list is as
follow:1. Scan all the input ports of the Microcontroller to
collect request from users and signal from sensors every 200
milliseconds.2. Display the elevator status every 14
milliseconds.3. Have algorithm to process the inputs, and then
drive the motors correspondingly.The first two tasks are handled on
an interrupt basis, and the third task will be put into the main
operating loop of the software.4.3. Functions4.3.1. Queue
FunctionsThe following functions are used to interact with queues:
Create a new queuevoid QueueCreate(Queue *q); Check if the queue is
empty or not int QueueEmpty(Queue *q); Put the requested floor into
queue void QueueEnter(const unsigned char c, Queue *q, unsigned
char x); Take out the first queue element unsigned char
QueueRemove(Queue *q); Sort the queue elements in ascending order
void QueueSort_Up(Queue *q); Sort the queue elements in descending
order void QueueSort_Down(Queue *q); Copy all of element from
source queue to destination queuevoid QueueCopy(const unsigned char
c,Queue *sourceQueue, Queue *destQueue); Check the value of queue
elements int CheckSecQueue(const int c,Queue *qs,Queue *qd); int
CheckDup(Queue *q,unsigned char x); int CheckDir(const int c,Queue
*q,unsigned char currentFloor);
4.3.2. Elevator Algorithm FunctionsThe elevator algorithm will
be based on the following functions: Scan all buttons and sensors
to take the input from users and sensors (called every 200 ms)void
scan(void); Display function using 74HC595 (called every 14 ms)
void display(void); Control the door void Door(void); Main function
implements the elevator algorithm void Elevator(void); Turn off the
light of buttons void Turnoff(void);
4.3.3. Secondary Functions Initialize TIMER1 and TIMER2
interrupt and TIMER0 PWM void Init_Timer(void); Assign the first
elevator state void Elevator_init(void); Function put data into IC
74HC595 used in Display function void PutData(unsigned char data);
Swap the position of two queue elements void swap(unsigned char *a,
unsigned char *b);
4.4. Flow Charts4.4.1. Door Function
4.4.2. Elevator Algorithm4.4.2.1. Activity Diagram 1: User calls
elevator
4.4.2.2. Activity Diagram 2: User travel in elevator
4.4.2.3. Activity Diagram 3: User presses a floor button while
traveling
4.5. Elevator Algorithm4.5.1. Problem StatementThere are
different algorithms that could be used for designing the elevator
controller: Shortest seek first: Serve the request closest to the
present floor.This algorithm is irrespective of the time at which
request is placed, it only caters to the request closest to the
present floor.E.g. If someone places a request for 6th floor, there
are a lot of other requests for nearby floor as it is a busy
section, also if they keep coming, then that persons request is not
served for a long time. First come first serve: Serve the request
as they arrive.This is inefficient as far as power requirements are
concerned and more time will be taken on an average to reach the
required destination. Elevator algorithm: Serve the entire request
in one direction and then reverse the direction.After considering
the advantage of all algorithms, we finally choose the elevator
algorithm to implement in this project.4.5.2. ImplementationTo
implement the elevator algorithm, we use three queues (upQueue to
store requests going up, downQueue to store requests going down and
secQueue to store the requests that have not processed yet) and the
elevator has three states: IDLE State: Cabin is not movingIn this
state, the elevator keeps checking the upQueue or downQueue, if one
of these queues is not empty, the elevator will change to GO_UP
state or GO_DOWN state, correspondingly. GO_UP State: Cabin goes
upIn this state, the elevator will take the destination floor from
the upQueue, and then goes to this floor. While moving, if there is
request going up to the floor that is closer to the cabin than the
destination floor, the previous destination will be put into
upQueue, and destination floor will be assigned to this request.
Other requests will be put into corresponding Queue. GO_DOWN State:
Cabin goes downIn this state, the elevator will take the
destination floor from the downQueue, and then goes to this floor.
While moving, if there is request going down to the floor that is
closer to the cabin than the destination floor, the previous
destination will be put into downQueue, and destination floor will
be assigned to this request. Other requests will be put into
corresponding Queue.4.5.3.
Coding/**************************************************** *
Main.c ****************************************************/
#include "Main.H"#include "Port.H" #include "Elevator.H"#include
"Queue.H" unsigned char currentFloor=1, button, callUp, callDown,
destFloor, secSensor;unsigned char buttonLed, upLed, downLed,
direction, index=0, column = 1;
Elevator_State E_State;Queue upQueue, downQueue, secQueue;
void main() { Port_Init(); // Initialize Port
QueueCreate(&upQueue); QueueCreate(&downQueue);
QueueCreate(&secQueue); Init_Timer(); // Initialize TIMER
Elevator_init(); while(1) { Elevator(); } }
/**************************************************** * Elevator
Function ****************************************************/void
Elevator(void){ switch(E_State) { case IDLE: TCCR0=0x05; //Turn off
PWM PORTB.4=0; PORTB.3=0; direction = 0;
if(!QueueEmpty(&upQueue)) E_State = GoUp; else
if(!QueueEmpty(&downQueue)) E_State = GoDown; break; case GoUp:
if(secSensor == currentFloor) secSensor = currentFloor - 1;
destFloor = QueueRemove(&upQueue); direction = 1; TCCR0=0x6D;
//Turn on PWM // Car goes up while(destFloor != currentFloor) {
if(secSensor == (destFloor - 1)) { PORTB.4=1; OCR0=170; } else {
PORTB.4=1; OCR0=0; } }; TCCR0=0x05; PORTB.4 = 0; PORTB.3 = 0;
Turnoff(); Door(); // If there is no command going up and there are
commands // going down, change state to GoDown
if(QueueEmpty(&upQueue)&&!QueueEmpty(&downQueue)){//
If the highest floor in downQueue is above the current // floor,
add it to upQueue if(CheckDir(2,&downQueue,currentFloor)) {
uChar temp; temp = QueueRemove(&downQueue);
QueueEnter(1,&upQueue,temp); } else { E_State = GoDown;
if(!QueueEmpty(&secQueue)) { // If the lowest floor in the
temporary queue is below // the lowest floor in downQueue, add it
to downQueue, // and copy the rest to upQueue
if(CheckSecQueue(1,&secQueue,&downQueue)){ uChar temp; temp
= QueueRemove(&secQueue); QueueEnter(2,&downQueue,temp);
QueueCopy(1,&secQueue,&upQueue); }
// If the lowest floor in temporary queue equals the // lowest
floor in downQueue, remove it, and copy the // rest to upQueue
else if(CheckSecQueue(3,&secQueue,&downQueue)) {
QueueRemove(&secQueue);
QueueCopy(1,&secQueue,&upQueue);}else
QueueCopy(1,&secQueue,&upQueue); }}} //If there is no
command going up and downelse
if(QueueEmpty(&upQueue)&&QueueEmpty(&downQueue)){
if(!QueueEmpty(&secQueue)) { uChar temp =
QueueRemove(&secQueue); QueueEnter(2,&downQueue,temp);
E_State = GoDown; QueueCopy(1,&secQueue,&upQueue); } else
E_State = IDLE; } break; case GoDown: if(secSensor <
currentFloor) secSensor = currentFloor; destFloor =
QueueRemove(&downQueue); direction = 2; TCCR0=0x6D; // Car goes
down while(destFloor != currentFloor) { if(secSensor == destFloor)
{ PORTB.4 = 0; OCR0= 85; } else { PORTB.4 = 0; OCR0 = 255; } };
TCCR0=0x05; PORTB.4 = 0; PORTB.3 = 0; Turnoff(); Door(); //If there
is no command going down and there are commands going up, change
state to GoUp
if(QueueEmpty(&downQueue)&&!QueueEmpty(&upQueue)){//
If the lowest floor in the upQueue is below the // current floor,
add it to downQueue
if(CheckDir(1,&upQueue,currentFloor)) { uChar temp; temp =
QueueRemove(&upQueue); QueueEnter(2,&downQueue,temp); }
else { E_State = GoUp;// If the highest floor in the temporary
queue is above // the highest floor in upQueue, add it to upQueue,
and // copy the rest to downQueue
if(!QueueEmpty(&secQueue)) {
if(CheckSecQueue(2,&secQueue,&upQueue)) { uChar temp =
QueueRemove(&secQueue); QueueEnter(1,&upQueue,temp);
QueueCopy(2,&secQueue,&downQueue); }
// If the highest floor in temporary queue equals the // highest
floor in upQueue, remove it, and copy the rest // to downQueue
else if(CheckSecQueue(3,&secQueue,&upQueue)) {
QueueRemove(&secQueue);
QueueCopy(2,&secQueue,&downQueue); }
else QueueCopy(2,&secQueue,&downQueue); }}}
//If there is no command going up and down
else
if(QueueEmpty(&upQueue)&&QueueEmpty(&downQueue)) {
if(!QueueEmpty(&secQueue)) { uChar temp =
QueueRemove(&secQueue); QueueEnter(1,&upQueue,temp);
E_State = GoUp; QueueCopy(2,&secQueue,&downQueue); } else
E_State = IDLE; } break; } }
