电梯调度系统(界面由C图形库编绘)

电梯调度系统编程

1、编程题目

电梯调度。

2、结对编程组员

黄冠译,刘畅。

3、编程语言

C语言图形库。

4、题目要求:

5、代码运行及结果调试:

① 运行界面为C++图形库支持,开始运行的初始界面如图,且默认所有电梯初始状态都为1楼,此时不分奇偶层:

② 我设置了鼠标响应事件,左边上下箭头为当前楼层有人要上或下的按钮,可以用鼠标直接点击响应,点击后要输入有多少人在此楼层等待,示例点击5楼,输入15人,如图所示:

③ 输入完毕后,电梯会根据单双层或全部楼层4个电梯的忙碌状态调度一个电梯过去,第一个调度1号电梯,因为1号电梯只能容纳10人,剩余5人还在等待,此时会再调度另一个电     梯过去接人,优先调度全部楼层的,所以调度4号电梯,如图所示:

④ 当两个电梯都接完人后,右侧电梯状态的1号和4号显示如图,1号10人,满状态,4号5人:

⑤ 1号和4号电梯此时可以点击右侧电梯内部按钮,若有人在电梯内才可以点击,否则无法点击,我们对1号电梯选择12楼,此时会出现输入12楼下电梯的人数,我们输入4人,电       梯就会到12楼去送人,如图所示:

⑥ 1号电梯送完人后的状态如图,我们将1号和4号电梯人全部送到,1号到19楼送6人,4号到20楼送4人,地下室送1人,如图所示:

⑦ 电梯的大致功能如此,最后实现所有电梯一起运转,如图所示:

6、exe文件博客内地址下载:

http://files.cnblogs.com/files/hgcrown/%E7%94%B5%E6%A2%AF%E8%B0%83%E5%BA%A6%E7%B3%BB%E7%BB%9F.zip

7、源代码

  1 # include <stdio.h>
  2 # include <graphics.h>
  3 # include <conio.h>
  4 # include <time.h>
  5 # include <memory.h>
  6
  7 int x[4] = {570,570,570,570},k[4]={0,0,0,0},t[4]={0,0,0,0},di[4]={0,0,0,0};
  8 int cro,col;
  9 char s[10];
 10 int refresh_rate = 10;//刷新率
 11 MOUSEMSG M;
 12 IMAGE ima,ima1,ima2,back,block;
 13
 14 struct elevator
 15 {
 16     int num,msum,dir,flo,mflo,numm,summ,elein[21],eleof[21],peom[21];
 17 }ele[5]={{0,0,2,1,1,10,800},{0,0,2,1,1,10,800},{0,0,2,1,1,20,1600},{0,0,2,1,1,20,2000}};
 18
 19 struct floors
 20 {
 21     int num[3],go,emin;
 22 }floor[21];
 23
 24 void Draw1(int e)
 25 {
 26     if(t[e]==0)
 27     {
 28         if (ele[e].dir==0)
 29         {
 30             putimage(140+e*100,(20-ele[e].flo)*30-k[e],&ima);
 31             k[e]++;
 32             if (k[e]==30)
 33             {
 34                 ele[e].flo++;
 35                 k[e]=0;
 36             }
 37         }
 38         if (ele[e].dir==1)
 39         {
 40             putimage(140+e*100,(20-ele[e].flo)*30+k[e],&ima);
 41             k[e]++;
 42             if (k[e]==30)
 43             {
 44                 ele[e].flo--;
 45                 k[e]=0;
 46             }
 47         }
 48         if (ele[e].dir==2)
 49             putimage(140+e*100,(20-ele[e].flo)*30,&ima);
 50         if ((ele[e].flo==ele[e].mflo)&&(ele[e].dir!=2))
 51         {
 52             int h;
 53             ele[e].dir=2;
 54             floor[ele[e].flo].emin=22;
 55             t[e]=60;
 56             k[e]=0;
 57             while (floor[ele[e].mflo].num[0]!=0)
 58             {
 59                 h=rand()%41+50;
 60                 if ((ele[e].num+1<=ele[e].numm)&&(ele[e].msum+h<=ele[e].summ))
 61                 {
 62                     ele[e].num++;
 63                     ele[e].peom[ele[e].num-1]=h;
 64                     ele[e].msum=ele[e].msum+h;
 65                     floor[ele[e].flo].num[0]--;
 66                 }
 67                 else
 68                     break;
 69             }
 70             while (floor[ele[e].mflo].num[1]!=0)
 71             {
 72                 h=rand()%41+50;
 73                 if ((ele[e].num+1<=ele[e].numm)&&(ele[e].msum+h<=ele[e].summ))
 74                 {
 75                     ele[e].num++;
 76                     ele[e].peom[ele[e].num-1]=h;
 77                     ele[e].msum=ele[e].msum+h;
 78                     floor[ele[e].flo].num[1]--;
 79                 }
 80                 else
 81                     break;
 82             }
 83         }
 84     }
 85     if (t[e]!=0)
 86     {
 87         if (t[e]>50)
 88         {
 89             putimage(140+e*100-60+t[e]+5,(20-ele[e].flo)*30,&ima1);
 90             putimage(140+e*100+60-t[e]+5,(20-ele[e].flo)*30,&ima2);
 91             t[e]--;
 92         }
 93         else if (t[e]>10)
 94         {
 95             putimage(140+e*100-10+5,(20-ele[e].flo)*30,&ima1);
 96             putimage(140+e*100+11+5,(20-ele[e].flo)*30,&ima2);
 97             t[e]--;
 98         }
 99         else if (t[e]>0)
100         {
101             putimage(140+e*100-t[e]+5,(20-ele[e].flo)*30,&ima1);
102             putimage(140+e*100+t[e]+5,(20-ele[e].flo)*30,&ima2);
103             t[e]--;
104         }
105     }
106 }
107
108 void Draw2(int e)
109 {
110     for (int v=0;v<=20;v++)
111     {
112         if ((v==0)&&(ele[e].elein[v]==1))
113             putimage(528+20%5*55,47+20/5*19.3+e*150,&block);
114         else if (ele[e].elein[v]==1)
115             putimage(528+(v-1)%5*55,47+(v-1)/5*19+e*150,&block);
116     }
117     if(t[e]==0)
118     {
119         if (ele[e].dir==0)
120         {
121             putimage(140+e*100,(20-ele[e].flo)*30-k[e],&ima);
122             k[e]++;
123             if (k[e]==30)
124             {
125                 ele[e].flo++;
126                 k[e]=0;
127             }
128         }
129         if (ele[e].dir==1)
130         {
131             putimage(140+e*100,(20-ele[e].flo)*30+k[e],&ima);
132             k[e]++;
133             if (k[e]==30)
134             {
135                 ele[e].flo--;
136                 k[e]=0;
137             }
138         }
139         if (ele[e].flo==ele[e].mflo)
140         {
141             ele[e].elein[ele[e].flo]=0;
142             di[e]=0;
143             for (int v=0;v<=20;v++)
144                 if (ele[e].elein[v]==1)
145                     di[e]=1;
146             k[e]=0;
147             ele[e].dir=2;
148             while(ele[e].eleof[ele[e].flo]!=0)
149             {
150                 ele[e].num--;
151                 ele[e].msum=ele[e].msum-ele[e].peom[ele[e].num];
152                 ele[e].eleof[ele[e].flo]--;
153                 if (ele[e].num==0)
154                     break;
155             }
156             t[e]=60;
157         }
158     }
159     if (t[e]!=0)
160     {
161         if (t[e]>50)
162         {
163             putimage(140+e*100-60+t[e]+5,(20-ele[e].flo)*30,&ima1);
164             putimage(140+e*100+60-t[e]+5,(20-ele[e].flo)*30,&ima2);
165             t[e]--;
166         }
167         else if (t[e]>10)
168         {
169             putimage(140+e*100-10+5,(20-ele[e].flo)*30,&ima1);
170             putimage(140+e*100+10+5,(20-ele[e].flo)*30,&ima2);
171             t[e]--;
172         }
173         else if (t[e]>0)
174         {
175             putimage(140+e*100-t[e]+5,(20-ele[e].flo)*30,&ima1);
176             putimage(140+e*100+t[e]+5,(20-ele[e].flo)*30,&ima2);
177             t[e]--;
178         }
179     }
180 }
181
182 void run ()
183 {
184     int o,p,mine;
185     setcolor(BLACK);
186     while(1)
187     {
188         if(MouseHit())
189         {
190             M = GetMouseMsg();
191             if (M.uMsg == WM_LBUTTONDOWN)
192             {
193                 if (M.x>=5&&M.x<=24)
194                 {
195                     o=20-(M.y+1)/30;
196                     InputBox(s, 10, "请输入进电梯的人数");
197                     sscanf(s,"%d",&p);
198                     floor[o].num[0]=p;
199                 }
200                 if (M.x>=25&&M.x<=45)
201                 {
202                     o=20-(M.y+1)/30;
203                     InputBox(s, 10, "请输入进电梯的人数");
204                     sscanf(s,"%d",&p);
205                     floor[o].num[1]=p;
206                 }
207                 if ((ele[0].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=46&&M.y<=142))
208                 {
209                     int r;
210                     cro=(M.x-528)/55;
211                     col=(M.y-46)/20;
212                     r=cro+col*5+1;
213                     if (r==21)
214                         r=0;
215                     di[0]=1;
216                     ele[0].mflo=r;
217                     ele[0].elein[ele[0].mflo]=1;
218                     InputBox(s, 10, "请输入此楼层要下电梯的人数");
219                     sscanf(s,"%d",&p);
220                     ele[0].eleof[ele[0].mflo]=p;
221                 }
222                 if ((ele[1].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=196&&M.y<=292))
223                 {
224                     int r;
225                     cro=(M.x-528)/55;
226                     col=(M.y-197)/20;
227                     r=cro+col*5+1;
228                     if (r==21)
229                         r=0;
230                     if (r%2==1)
231                     {
232                         di[1]=1;
233                         ele[1].mflo=r;
234                         ele[1].elein[ele[1].mflo]=1;
235                         InputBox(s, 10, "请输入此楼层要下电梯的人数");
236                         sscanf(s,"%d",&p);
237                         ele[1].eleof[ele[1].mflo]=p;
238                     }
239                 }
240                 if ((ele[2].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=346&&M.y<=442))
241                 {
242                     int r;
243                     cro=(M.x-528)/55;
244                     col=(M.y-346)/20;
245                     r=cro+col*5+1;
246                     if (r==21)
247                         r=0;
248                     if (r%2==0)
249                     {
250                         di[2]=1;
251                         ele[2].mflo=r;
252                         ele[2].elein[ele[2].mflo]=1;
253                         InputBox(s, 10, "请输入此楼层要下电梯的人数");
254                         sscanf(s,"%d",&p);
255                         ele[2].eleof[ele[2].mflo]=p;
256                     }
257                 }
258                 if ((ele[3].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=496&&M.y<=592))
259                 {
260                     int r;
261                     cro=(M.x-528)/55;
262                     col=(M.y-496)/20;
263                     r=cro+col*5+1;
264                     if (r==21)
265                         r=0;
266                     di[3]=1;
267                     ele[3].mflo=r;
268                     ele[3].elein[ele[3].mflo]=1;
269                     InputBox(s, 10, "请输入此楼层要下电梯的人数");
270                     sscanf(s,"%d",&p);
271                     ele[3].eleof[ele[3].mflo]=p;
272                 }
273             }
274         }
275         for(int j=20;j>=0;j--)
276         {
277             mine=4;
278             if (floor[j].num[0]!=0)
279             {
280                 if ((ele[0].num<10)&&(ele[0].msum<800))
281                 {
282                     if ((j>=ele[0].flo)&&(ele[0].dir!=1))
283                         if (floor[j].emin>(j-ele[0].flo))
284                         {
285                             floor[j].emin=j-ele[0].flo;
286                             mine=0;
287                         }
288                     if ((j<ele[0].flo)&&(ele[0].dir==2))
289                         if (floor[j].emin>(ele[0].flo-j))
290                         {
291                             floor[j].emin=ele[0].flo-j;
292                             mine=0;
293                         }
294                 }
295                 if ((ele[3].num<20)&&(ele[3].msum<2000))
296                 {
297                     if ((j>=ele[3].flo)&&(ele[3].dir!=1))
298                         if (floor[j].emin>(j-ele[3].flo))
299                         {
300                             floor[j].emin=j-ele[3].flo;
301                             mine=3;
302                         }
303                     if ((j<ele[3].flo)&&(ele[3].dir==2))
304                         if (floor[j].emin>(ele[3].flo-j))
305                         {
306                             floor[j].emin=ele[3].flo-j;
307                             mine=3;
308                         }
309                 }
310                 if (j%2==0)
311                 {
312                     if ((ele[2].num<20)&&(ele[2].msum<1600))
313                     {
314                         if ((j>=ele[2].flo)&&(ele[2].dir!=1))
315                             if (floor[j].emin>(j-ele[2].flo))
316                             {
317                                 floor[j].emin=j-ele[2].flo;
318                                 mine=2;
319                             }
320                         if ((j<ele[2].flo)&&(ele[2].dir==2))
321                             if (floor[j].emin>(ele[2].flo-j))
322                             {
323                                 floor[j].emin=ele[2].flo-j;
324                                 mine=2;
325                             }
326                     }
327                 }
328                 if (j%2==1)
329                 {
330                     if ((ele[1].num<10)&&(ele[1].msum<800))
331                     {
332                         if ((j>=ele[1].flo)&&(ele[1].dir!=1))
333                             if (floor[j].emin>(j-ele[1].flo))
334                             {
335                                 floor[j].emin=j-ele[1].flo;
336                                 mine=1;
337                             }
338                         if ((j<ele[1].flo)&&(ele[1].dir==2))
339                             if (floor[j].emin>(ele[1].flo-j))
340                             {
341                                 floor[j].emin=ele[1].flo-j;
342                                 mine=1;
343                             }
344                     }
345                 }
346                 if (j>=ele[mine].flo)
347                     ele[mine].dir=0;
348                 else
349                     ele[mine].dir=1;
350                 ele[mine].mflo=j;
351             }
352             if (floor[j].num[1]!=0)
353             {
354                 if ((ele[0].num<10)&&(ele[0].msum<800))
355                 {
356                     if ((j<=ele[0].flo)&&(ele[0].dir!=1))
357                         if (floor[j].emin>(ele[0].flo-j))
358                         {
359                             floor[j].emin=ele[0].flo-j;
360                             mine=0;
361                         }
362                     if ((j>ele[0].flo)&&(ele[0].dir==2))
363                         if (floor[j].emin>(j-ele[0].flo))
364                         {
365                             floor[j].emin=j-ele[0].flo;
366                             mine=0;
367                         }
368                 }
369                 if ((ele[3].num<20)&&(ele[3].msum<2000))
370                 {
371                     if ((j<=ele[3].flo)&&(ele[3].dir!=1))
372                         if (floor[j].emin>(ele[3].flo-j))
373                         {
374                             floor[j].emin=ele[3].flo-j;
375                             mine=3;
376                         }
377                     if ((j>ele[3].flo)&&(ele[3].dir==2))
378                         if (floor[j].emin>(j-ele[3].flo))
379                         {
380                             floor[j].emin=j-ele[3].flo;
381                             mine=3;
382                         }
383                 }
384                 if (j%2==0)
385                 {
386                     if ((ele[2].num<20)&&(ele[2].msum<1600))
387                     {
388                         if ((j<=ele[2].flo)&&(ele[2].dir!=1))
389                             if (floor[j].emin>(ele[2].flo-j))
390                             {
391                                 floor[j].emin=ele[2].flo-j;
392                                 mine=2;
393                             }
394                         if ((j>ele[2].flo)&&(ele[2].dir==2))
395                             if (floor[j].emin>(j-ele[2].flo))
396                             {
397                                 floor[j].emin=j-ele[2].flo;
398                                 mine=2;
399                             }
400                     }
401                 }
402                 if (j%2==1)
403                 {
404                     if ((ele[1].num<10)&&(ele[1].msum<800))
405                     {
406                         if ((j<=ele[1].flo)&&(ele[1].dir!=1))
407                             if (floor[j].emin>(ele[1].flo-j))
408                             {
409                                 floor[j].emin=ele[1].flo-j;
410                                 mine=1;
411                             }
412                         if ((j>ele[1].flo)&&(ele[1].dir==2))
413                             if (floor[j].emin>(j-ele[1].flo))
414                             {
415                                 floor[j].emin=j-ele[1].flo;
416                                 mine=1;
417                             }
418                     }
419                 }
420                 if (j>=ele[mine].flo)
421                     ele[mine].dir=0;
422                 else
423                     ele[mine].dir=1;
424                 ele[mine].mflo=j;
425             }
426         }
427         BeginBatchDraw();
428         putimage(0,0,&back);
429         for (int i=0;i<4;i++)
430         {
431             if (di[i]==0)
432                 Draw1(i);
433             if (di[i]==1)
434             {
435                 if (ele[i].mflo>=ele[i].flo)
436                 {
437                     ele[i].dir=0;
438                     for (int w=ele[i].flo;w<=20;w++)
439                     {
440                         if (ele[i].elein[w]==1)
441                         {
442                             ele[i].mflo=w;
443                             break;
444                         }
445                     }
446                 }
447                 else
448                 {
449                     ele[i].dir=1;
450                     for (int w=ele[i].flo;w>=0;w--)
451                     {
452                         if (ele[i].elein[w]==1)
453                         {
454                             ele[i].mflo=w;
455                             break;
456                         }
457                     }
458                 }
459                 Draw2(i);
460             }
461             setbkmode(TRANSPARENT);
462             sprintf(s,"%d",ele[i].num);
463             outtextxy(890,49+i*150,s);
464             sprintf(s,"%d",ele[i].msum);
465             outtextxy(890,74+i*150,s);
466             sprintf(s,"%d",ele[i].flo);
467             outtextxy(890,99+i*150,s);
468         }
469         EndBatchDraw();
470         Sleep(refresh_rate);//延时
471     }
472
473 }
474
475 void main()
476 {
477     for (int i=0;i<21;i++)
478     {
479         floor[i].num[0]=0;
480         floor[i].num[1]=0;
481         floor[i].emin=22;
482     }
483     initgraph(1000,630);//窗口大小
484     loadimage(&back,"pic//2.jpg");
485     putimage(0,0,&back);
486     loadimage(&ima,"pic//1.jpg");
487     loadimage(&ima1,"pic//3.jpg");
488     loadimage(&ima2,"pic//4.jpg");
489     loadimage(&block,"pic//5.jpg");
490     BeginBatchDraw();
491     for (int j=0;j<4;j++)
492         putimage(140+j*100,(20-ele[j].flo)*30 ,&ima);
493     EndBatchDraw();
494     run();
495     closegraph();
496 }
时间: 2024-12-29 11:06:38

电梯调度系统(界面由C图形库编绘)的相关文章

结对项目——电梯调度之界面粗略规划与设计

在程序运行时要显示一个菜单界面,用于用户的一些操作.分为进入菜单,总控台菜单,以及退出. 在进入菜单里我们主要就是设计模拟电梯运动. 首先先分析下现实中的电梯: 1.在外界每一楼层都能够有选择上下的按钮(最低一层只有上,最高一层只有下) 2.选择方向与电梯的运行方向不同时,只有当电梯状态变成静止时才响应 3.电梯内部有能选择楼层的按钮 4.电梯有限载 设计初想: 1.进入菜单: 在每一层的上下按钮可以直接用button控件,显示的文字是:楼层+上/下:然后通过获取控件上的文本信息的第一个字符来确

结对项目————电梯调度系统

本次作业是结对编程,是在团队项目之前的一个小型项目,旨在考验团队协作能力与锻炼个人编程能力,其实一开始我拿到这个题目还以为是一个很简单的问题,因为觉得电梯的运作方式很“傻瓜”,但是我的队友魏鑫磊(http://www.cnblogs.com/wxl530/)却并不是这么想的,在这里真的要感谢我的队友,磊姐想的太全面了!磊姐想到了这个项目最好应该是软硬件相结合,尤其是一些电梯控制超载,图形显示,传感器肯定是要有硬件实现,经过讨论,我才发现我想的真是太简单了....(差距啊= =)但是由于客观条件不

结对编程——电梯调度系统 的 感想与总结

对于这次的结对任务,因为本身自己不在学校,所以没有很好的办法和我的队友们进行沟通交流,所以我的任务是确立实现方法,和提出算法,这里非常感谢我的两个队友,他们非常的负责,作为一个TEAM,非常好的完成了这里任务,将自己的力量发挥到了最大. 对这次任务的感触就是,以前都是自己一个人做一个程序啊,任务啊,很少和一个或者几个人来进行这种合作,大家的意见非常的重要,只有互相沟通,交流才能提出最好的意见和看法. 对于我的队友张腾宵同学对于bug修改的态度,非常的让我感动,为了一个bug,反复进行研究,这种态

《团队开发二之电梯调度分析报告》

1.任务概述: 1.1任务背景:试想一下,石家庄铁道大学基础教学楼的电梯配置如下:大厦有18层, 4部电梯,很多乘客使用这些电梯的日常(旅客重量:平均70公斤最大120公斤,最小45公斤).其他常量数据:电梯速度,开/关门时间,乘客的时间要在/走出电梯.可以对这些合理的假设.    电梯调度设计要求:    (1)每一对学生将设计一套接口和类定义这样一种算法提供者可以提供他/她实现“电梯调度程序”类.    (2)避免出现 “公共汽车”最坏情况的算法.该算法把电梯作为总线,它从底部到顶部,停在每

结对作业--电梯调度

结对编程 结对成员:王长(2011040101179)CODING:https://coding.net/u/smile-wang  高庆阳(2013040101173) 博客:http://www.cnblogs.com/gaoqingyang1994/   CODING:https://coding.net/u/gaoqingyang1994 结对编程的优缺点 在结对编程模式下,一对程序员可以平等的.互补地进行开发工作:他们一起分析,一起设计,一起写测试用例,一起编码,一起做测试...这样在

结对编程之电梯调度

编程任务:电梯调度 结对人员:左少辉-12061209,杨昊兰-12061202,吕雨朗 一.此次软工作业确实是让人却步的不敢开始,不过结对编程使得我对完成作业又有了信心,开始没有积极组队的我落单了,后来只能是申请加入已经组好的队伍,所以我们其实是一个三人组,都说人多力量大,想法也就会开阔许多,做起作业来也会顺利许多.起初对作业不是很了解,光是看英文要求就已经醉了,后来还是硬着头皮开始了漫长的代码阅读,浅学c#觉得语法也就一般般,不过看到如此绚丽的代码还是各种懵~确实一个人做起来简直是困难,但是

结对编程:电梯调度

电梯调度项目: 项目分析与需求: 从题目上来看,项目要求编写一个掌控电梯的程序.电梯这个东西,大家都乘过,无非就是:乘客上电梯,判断是否超重,乘客选择想要达到的楼层,最后依次去到离需求最近的一个楼层. 项目中要求有四个电梯,其中第一号和第四号电梯是一模一样的,只需要把负载量给修改即可:第二和第三也大同小异,只需要把负载量和输入楼层的判断方式修改一下即可. 在我们的设想中,我们要达到的效果是这样的:得有一个switch语句,来控制一开始的电梯选择界面:之后在case语句之后相应搭载各种需要的语句以

LMT NEW PBS作业排队调度系统的回报与功能

LMT NEW PBS作业排队调度系统的回报与功能 LMT NEW PBS作业管理系统的开发,提出了一种适合集群环境下的高效资源分配与利用方案,并给出了详细的设计过程.深入分析了作业管理系统的内部运行机制.安全机制.调度策略等方面问题,提出了改进方案. LMT NEW PBS是计算网络和广域分布式计算的支撑技术 使用LMT NEW PBS作业排队调度系统,您可以: 提高企业生产率和市场反应速度 提高计算资源投资回报率 (ROI) 更加高效地进行计算处理分析 更快地推出新产品 确保资源利用最大化

电梯调度 结对开发项目

一:项目名称: 电梯调度模拟程序 二:项目参与人员: 周其范 胡宝月 三:项目开发语言和工具: Java语言和eclipse,涉及内容:面向对象技术.基于Swing的图形化用户界面.多线程启动和休眠 四:问题陈述: 1.电梯要正常运行,能响应内部.外部按钮 2.要怎样选择哪部电梯电梯,使乘坐者和电梯的距离更近,已达到更省电.更快.更经济. 3.同一部电梯可以响应多位乘客的请求 五:任务需求: 1.要模拟一栋6层楼中两部电梯的调度,模拟乘坐电梯的过程. 2.乘坐者在最低层楼:只能乘坐电梯上楼,在电