CN1166911A

CN1166911A - 根据计划能耗标准优化楼宇系统能效的系统与方法

Info

Publication number: CN1166911A
Application number: CN96191297A
Authority: CN
Inventors: D·M·利昂斯
Original assignee: Philips Electronics NV
Current assignee: Koninklijke Philips NV
Priority date: 1995-09-07
Filing date: 1996-09-06
Publication date: 1997-12-03
Anticipated expiration: 2016-09-06
Also published as: EP0791280B1; KR970707704A; DE69621768T2; EP0791280A1; JPH10509274A; US5812422A; CN1143603C; DE69621768D1; WO1997009869A1

Abstract

一种优化楼宇系统能效的方法，例如一个带有多台类似光源耗能设备的照明系统，可用此方法来优化系统的能效。该方法包括以下步骤：定义楼宇系统的一组参数，典型地利用线性编程技术，分析处理这组参数，最后得到能量分配输出数据，这些能量分配输出数据满足配给楼宇的总能量不超过计算消耗标准这一条件，同时也体现了每台耗能设备的能量最佳分配。通常，能量最优化问题可演变为一线性编程问题，即通过构造一组系统能量分配的约束条件，把这些约束条件转化为一组约束方程和一成本函数，再将这组约束方程转化为联立的线性方程，然后解这组线性方程使成本函数达到最小值，由此求得的能量分配输出数据便为每个照明光源最优化的亮度值。这些步骤优选地在计算机软件中得以实现，这些软件则优选地安装在智能照明控制系统或楼宇系统的可编程中央控制器中，由它来响应能量分配输出数据，自动调节每台耗能设备的能耗值。在满足每个房间能量需要最小值后，至少是部分地根据每个房间指定的优先级和/或根据耗能设备的能效来优选分配剩余可用的能量。

Description

根据计划能耗标准优化楼宇系统能效的系统与方法

发明背景

本发明总体涉及到楼宇自动化系统，专门涉及到楼宇自动化照明系统，更具体地讲，它涉及一种用在智能化大楼和/或照明控制系统中的方法，考虑楼宇的拓扑图，运用此方法可根据用户给定的参数来优化耗能设备的能效及利用率。

目前使用的楼宇照明自动控制系统至少有两大类。第一大类楼宇照明自动控制系统由多个分立的、内置的照明自动控制模块组成，这些模块基本上相互独立工作去控制楼宇各个房间或局部区域的照明情况。第二大类楼宇照明自动控制系统是采用一种传感器分布网来检测每个房间(或选定的一些房间，或楼宇的其它局部区域)的照度水平和/或是否有人活动。该系统还采用一可编程中央控制器，根据照明控制程序分析处理传感器返回的信号，然后输出控制信号去调节楼宇内被监测房间的照度水平。在此，每个房间或局部区域的照明自动控制模块由可编程中央控制器控制运行。因此，通过可编程中央控制器的控制，楼宇内的模块便形成一个有机的整体网，不再彼此独立运行。

欧洲专利申请0447136于1991年9月18日公布了一属于第一大类的照明自动控制系统。该系统中，给每个光源配备一自动控制装置，该装置带有一现场探测器(如移动探测器或无源红外探测器)和一光强探测器(如光电管探测器)。操作时，每个自动控制装置一旦检测其作用范围内有人活动，便打开其相应控制的光源，并且根据其作用的四周或背景亮度的变化调节其控制光源的强弱(亮度)。运用该方法，不管周围亮度条件怎么改变，均能保证控制的区域有足够的照度。

美国专利第5250799号公布了又一属于第一大类的典型的照明自动控制系统，该专利于1993年10月5日授权予瓦尔特·华纳(WalterWerner)。此系统包含一个或多个单减光控制器，每个控制器控制楼宇一个房间或局部区域的一个或多个光源的强弱(亮度)，而该楼宇是采用室内和室外采光进行照明的。具体地讲，每个减光控制器根据室外采光情况来调节室内光线强度，而室外光强是随日照变化和大气条件变化而变化的。室外光线的强度与方向由室外光传感器检测。楼宇内房间或局部区域里的每个光源均配置一独立的减光器，由此可单独调节各个光源的光强，以提供均匀或不均匀的照度。通常，室内光强同室外光强基本上成反比例控制，譬如，如果室外光线减弱则室内光线需要加强。

欧洲专利申请第0482680号公开了一套属于第一大类的比较先进的照明自动控制系统，公布日期是1992年4月29号。该资料公开了一种可编程照明系统，系统包括多个独立的照明单元，每个单元配置一可编程控制器，并由这些可编程控制器自动调整其相应的照明单元至一指定的(设计好的)亮度输出标准，以满足不同的照明方式。在一些地方，如居室、办公室或商场等，根据不同作业需要不同的照度条件，该系统就特别适用。所谓照明方式，是指对一定的照明区域，所有照明单元输出一定的光强，以给特定的作业(或一理想环境)提供理想的照明效果。通过系统初始化编程，系统可以自动调整每个照明单元为一选定的照明方式以提供适当的照度水平。菲利普MCS-100系统(Philips MCS-100 system)商业性地采用了该可编程照明系统。在这个系统中，可采用无线或硬拉线的遥控器对每个独立的照明单元进行编程。

PCT申请号WO89/05536公开了一属于第二大类的照明自动控制系统，公布日期为1989年6月15日。该系统含有一带微处理机的可编程中央控制器，由中央控制器根据分布在整个楼宇内的现场探测器网和光传感器产生的返回信号来自动控制不同房间和/或区域照明单元的亮度输出水平。该系统具有一种越级特性，就是用户可以忽视自动照明系统的一个或多个特性，譬如，为了使架空探照灯(OHP)正常运行，不管检测到房间有没有人，都可以将灯关掉。

美国专利申请系列号08/326,823公开了一套属于第二大类的比较先进的照明自动控制系统，并于1994年10月19日申请。该系统在整个楼宇内布置多个亮度传感器，但传感器与楼宇内的光源并非一对一的关系，这样比较有好处，况且一一对应也是不必要的。在这种系统中，楼宇内通常安装一些比光源数目少的亮度传感器，以产生一组非冗余的室内亮度测量数据。然后由一中央自动控制器集中处理这些测量数据。该中央自动控制器优选地包含一神经网络或一模糊逻辑单元，并根据一系列满足用户要求和/或能效标准的规则来进行编程。操作时，该自动控制器根据用户定义的规则自动控制楼宇内光源的亮度输出，以满足用户需要和/或一能效标准。通过编程，可构成多种用户可选的使用方式，这样，只要通过选择合适的使用方式，用户便可根据不同的使用要求来调整某一房间或区域的照度水平了。

目前所知的照明自动控制系统，说得更宽点，就是目前的楼宇自动化控制系统，它们有一较大的缺点，即它们当中没有一种能够根据计划能耗水平和系统指定的参数及条件来优化楼宇照明系统或楼宇系统的能效。因此，目前在本领域内需要有一种自动控制系统能克服现有系统这样或那样的局限、弱点和缺点。该发明便填补了这个需要。

发明概述

本发明包含一种控制楼宇系统能量分配的方法，该楼宇系统带有多个能耗值可选择性调节的耗能设备。该方法包括以下步骤：

生成能量分配数据，这些数据体现了给每台耗能设备的优化能量分配，同时满足条件-在一定时间间隔内，配给楼宇系统的总能量不超过指定的消耗标准，和根据能量分配数据相应调节每台耗能设备的能耗值。

该方法例如可用来控制楼宇系统的一些耗能设备，如空调，照明灯具和供热设备等。家庭也可用该方法来控制耗能设备的能耗，例如大的家用器具如洗衣机、烘干机、电热水器等，或小的家用器具如微波炉、电冰箱、冷冻柜等。也可专门采用该方法来优化含多个光源的照明系统的能效，步骤如下：定义一组照明系统参数，运用一种编程技术，分析处理这组参数，最后得到能量分配输出数据，这些能量分配输出数据满足配给照明系统的总能量不超过计算消耗标准这一条件，同时也体现了每个光源的能量最佳分配。在很多系统中都可采用线性编程技术。这种照明系统安装在有多个房间的楼宇中，且每个房间至少应有一个光源。

通常，照明优化问题可演变为一线性编程问题，即通过构造一组照明系统能量分配约束条件，把这些条件转化为一组约束方程和一成本函数，再将这组约束方程转化为一组联立的线性方程，然后解这组联立线性方程使成本函数达到最小值，由此求得的能量分配输出数据，便为每个照明光源的优选亮度值。这些步骤优选地在计算机软件中得以实现，这些软件则优选地安装在智能照明控制系统的可编程中央控制器中，由它来响应能量分配输出数据，自动将每个光源调整至最佳亮度标准。应当理解，运用本发明的系统与方法处理非线性问题时，可采用处理线性问题算法外的其它合适算法。

本发明的其余部分，讲述了一例照明系统及构造和解决线性问题的详细办法。

在满足每个房间照度最低值后，至少是部分地根据每个房间指定的优先级和/或根据光源的能效来优选地分配剩余可用的能量。另外，相等优先级的房间优选分布配相等数量的可用能量，该方法也优选包括一后处理滤光步骤，以确定由一或多个公共房间(utility room)服务的每个房间的最佳照明水平是否等于一最小照明水平，并且如果是的，调节公共房间的最佳照明水平到一最小照明水平。附图简述

参照下面附图的详述，很容易就能明白本发明的各种特性及优点。

图1就是本发明的图解，讲述了这套照明自动控制系统。

发明详述

现参考图l，该发明将其计算机软件装入楼宇16的智能(自动化)照明控制系统12的可编程中央控制器10中，以方便其操作编程。在该系统中，计算机软件根据其能实现的照明优化算法/能量分配算法来生成输出数据，并由智能照明控制系统12利用这些输出数据来自动调节楼宇16的每个被监测房间14(或其它局部区域、地带)的光源18的亮度，关于这个算法，下文将有详细叙述。而且，该发明可作为一单独的计算机软件，为楼宇/设备经理提供一有用的信息，即根据计划的能耗标准和给定的一组照明参数及使用条件来最有效地分配楼宇的照明能源。然后，就可利用该信息人工地调节楼宇各区内的光源，或者利用该信息为楼宇智能照明集中控制系统编程，也可用来给楼内的内置照明自动控制模块进行编程。应当理解，可用相同的方法来管理更普遍的楼宇系统的能量分配，就是家庭里也可采用，也这种控制系统控制耗能设备的能耗。

本发明的基本方法就是将照明优化问题转化为线性编程问题，而线性编程可用现有的任何一种线性编程软件模块来实现。下面作两个基本的假设，即：(1)楼宇16内每个房间14(或一局部区域)都有一盏受监测的灯(光源)18；(2)每个光源18的亮度与其功率成线性关系。第一个假设只是为了简化该发明的叙述，而不会限制本发明的范围。第二个假设是为了使照明优化问题演变为一线性编程问题，事实上这个假设是正确的，这点可由各种调光光源，如调光镇流管的亮度-功率对应数据得到证明。

构造照明优化算法的第一步，就是定义照明系统的一组参数及约束条件。尽管下面在叙述本发明时采用了一组优选的参数及条件，但是应当理解，在实现本发明中采用的确定参数、条件及其值不会局限本发明的范围，广义上，这些参数、条件及值实际主要处决于用户的要求。因此，针对任何特定的用途，都可以修改和规范化该照明优化算法。

下面介绍有关本发明优选实施方案的一些参数及条件。首先定义每个房间亮度的最小值与最大值。每个房间14的亮度最大值可由住房需要决定，或者按照默认值处理。每个房间14的亮度最小值也可由住房需要决定，或者按默认值(如0)处理；或者按照官方最低标准，如OSHA所规定的；或者按照地方的、市政的条例决定，等等。无论如何，为最小和最大亮度确定怎样的值是不会局限本发明的范围。

对楼宇16的每个房间14，其亮度约束条件可由下面不等式(1)表达：

(1)对所有r_i∈R，l_ri≤b_ri≤u_ri其中，R代表楼宇16的房间14的全集，r_i代表集R中的一给定房间，u_ri代表房间r_i的最大亮度值，l_ri代表房间r_i的最小亮度值，而b_ri代表房间r_i的亮度(即房间r_i内可控光源或灯的亮度)。全集R中房间r_i的个数由n表示。因此i的取值是从1到n。

既然假定每盏灯的亮度与功耗有一线性关系，那么楼宇内每盏灯(每个房间)所消耗的功率可由下式(2)表示：

(2)P_ri＝p_rib_ri+c_ri其中，P_ri代表每个房间r_i的线性功效系数，而c_ri为一偏移常量。就是说，每个房间r_i照明所消耗的功率P_ri等于灯的线性功效系数p_ri乘以其亮度b_ri再加上偏移常量c_ri。尽管对于每个房间r_i，线性功效系数p_ri为一常量，但灯与灯之间该常量的值可能是不一样的，它取决于灯的能量利用系数或能效。在灯的功率-亮度曲线中，曲线坡度越小，则灯的效率越高，因此灯的线性功率系数p_ri也越小。

整个楼宇照明系统的总功耗P_T可由下式(3)表示：

(3) P_{T} = Σ_{i = 1}^{n} (p_{ri} b_{ri} + c_{ri})

如果假定在时间间隔t内功率为一恒量，则时间t内总的耗能量E_T等于总功率P_T乘以t。在单位时间内，消耗的功率与能量值是相等的，即E_T＝P_T。出于简化的原因，假设一单位时间间隔，把它看作楼宇照明时间表的一个时间段。在把功率转化为能量单位时，需乘以该时间段内能量的持续时间。

线性编程问题的标准形式为：

(4)给定Ax＝B，求出x，使Cx为最小值，这里A为一个n×m矩阵，B为一个n维行向量，而C则为一个m维列向量。所有系数必须大于或等于零。总之，目的就是解该线性编程问题，求出控制变量(因变量)x使成本函数Cx达到最小值。此处，成本C为楼宇系统的能耗，而控制变量x为楼宇照明系统灯的亮度值(光输出水平)。

为使照明优化问题转化或演变为一线性编程问题，表达式(1)或(3)须作以下修正。即：需引入余裕变量S_uri(对房间r_i亮度上限的余裕变量)和余裕变量S_lri(对房间r_i亮度下限的余裕变量)，使表达式(1)由一个不等式转化为下面两个等式：(5)与(6)

(5)存在一S_uri，使b_ri+S_uri＝u_ri

(6)存在一S_lri，使得b_ri-S_lri＝l_ri。于是线性编程问题的A矩阵，可由适合楼宇16每个房间r_i的等式(5)和(6)的左边组成，向量B则由等式(5)和(6)的右边组成。

成本向量C是通过修正等式(3)的左边得到的，其中加上等式(5)和(6)所引入的余裕变量(前面带上零系数)，而且引入一计划能耗标准值E，由此得到如下表达式(7)：

(7) = Σ_{i = 1}^{n} (p_{ri} b_{ri} + c_{ri} + {O . s}_{uri} + {O . s}_{lri}) - E .

因此，照明优化问题便演变为由等式(5)、(6)和(7)所给出的线性编程问题了。利用一种方便好用的线性编程软件工具，该线性编程问题就可以用软件来实现了，然后利用一种方便好用的线性编程解算软件模块来解算这个编程问题，下文将对此作更详细的叙述。

给定等式(5)、(6)和(7)的结束条件，便可以根据它们来进行构造和解算线性编程问题了，解算后得到楼宇16每个房间14的一系列亮度数据(即b_ri值)，对一计划能耗标准E，这些亮度数据就能使楼宇16的照明能源得到最有效地分配。更具体地讲，在楼宇16内两个或两个以上的房间14，如果房间灯18彼此间线性功效系数P_ri不同，那么给灯18能效比较高的房间18分配的能量与其它房间分配的能量是不成比例的，原因作如下解释：既然高能效灯的线性功效系数P_ri较低能效灯的线性功率系数P_ri来得小，而且在成本方程中，线性功效系数P_ri为亮度b_ri的系数，那么在成本方程中，配给灯效率低的房间所需的能量要比灯效率高的房间多。为此，既然该线性编程是为了解由式(7)表达的成本向量最小值，那么，给灯效率高的房间分配的能量就比给灯效率低的房间多了。

不管怎样，如果每个房间14内灯18的功效系数相同P_ri(如，楼宇16内每个房间14都是采用同类型的灯18)，那么，在满足每个房间14的最低亮度值后，楼宇16所剩余的“额外”或“多余”能量便随意分配给这些房间14了。所以，应该将每个房间14内灯18的线性功效系数P_ri都相等地设定为1，这样在分配楼宇16的光源能量时，可以消除灯18的功效系数或能效系数。因此，在这种情况下，只能给楼宇/设备经理提供一条有用的信息，即在相关时间间隔内，计划的能耗值E是否能够满足每个房间14的最低亮度值。

尽管在有的地方，该有限的信息能够完全满足需要，但是，为了简便提供关于优化照明系统能量分配的更有用的信息，即关于优化楼宇16内每个房间14亮度的信息，还希望引入有关楼宇拓扑的其他约束条件。

在此，根据等式(5)、(6)和(7)进行构造和解算编程问题时，没有考虑楼宇16内房间14的优先级。譬如，根据相同的能量分配优先级，分给行政办公室光源(灯)的能量与分给很少用的看门室光源(灯)能量是一样的。这是因为，每个房间r_i内灯18的线性功效常数P_ri只是考虑了灯的相关能量利用系数或能效，而没有考虑每个房间对楼宇用户的相对重要性。显然，从使用着眼点出发，楼宇照明系统在给各个房间分配能源时，把楼宇16内房间14的相对重要性考虑进去是有利的。在实行该办法时，可根据各个房间14对楼宇用户的重要性，来分配满足最低亮度条件后所剩“多余”或“额外”的能量，也可(或用这办法替代前者)根据楼宇16内各房间14采用灯18的能效来进行分配。

这样一个房间优先级条件可以合并到如下的亮度优化/线性编程问题中去。第一步，给每个房间分配一个大于或等于零的优先级值Pr_ri，房间优先级越高，则该房间的Pr_ri值越小。因此，假如房间r₁的优先级比房间r₂的优先级高，则pr_r1＜pr_r2。第二步，通过修正，得到以下成本向量C′。即在式(7)中引入一附加余裕变量Se，以替代原来成本向量C，由此得到如下等式(8)：

(8) Σ_{i = 1}^{n} (p_{ri} b_{ri} + O . s_{uri} + {O . s}_{lri}) - s_{e} = E - Σ_{i = 1}^{n} C_{ri} .

由原成本向量C得到的式(8)便成了另一个线性编程约束条件。附加余裕变量Se是用来保证所有可用的(配给的)能量E能够得到使用。不管怎样，为保证不超过可用的能量E，在新成本向量C′中，该余裕变量值要降到最小的程度。

在原成本向量C的表达式(7)中，将线性功效系数P_ri由每房间的优先级值pr_ri代替，这样就把优先级条件合并到线性编程问题中去了，由此得到如下新成本向量C′的表达式(9)：

(9) Σ_{i = 1}^{n} ({pr}_{ri} b_{ri} + {O . s}_{uri} + {O . s}_{lri}) + s_{e}

现在线性编程问题可由式(5)、(6)、(8)及(9)来表示，A矩阵由式(5)、(6)和(8)的左边组成，B向量由等式(5)，(6)和(8)的右边组成，而新成本向量C′由式(9)表示。既然，优先级低的房间较优先级高的房间优先级值pr_ri来得大，而且在新成本向量C′式(9)中优先级值pr_ri为亮度b_ri的系数，那么，在成本方程中，需分给优先级低的房间较分给优先级高的房间能量要多。因此，既然该线性编程问题是为了解算成本向量C′的最小值，那么，优先级高的房间就比优先级低的房间分配的能量要多了。

因此，根据式(5)、(6)、(8)及(9)进行构造和解算线性编程问题，为楼宇16的每个房间14提供了一组亮度值b_ri，而这些亮度值已完全考虑了各房间的相对重要性。因此，在满足房间最低亮度要求后，所剩余的“额外”及“多余”能量是根据其相对重要性或优先级来分配给楼宇照明系统内房间14的，例如根据楼宇用户定义的重要性或优先级，也可(或用它替代前者)根据楼宇系明系统内房间14所采用灯的能效来进行分配。本发明的这个特性可用来提高智能照明自动控制系统的智能化程度。

在构造线性编程问题时，既然所剩余能量是随意分配给等亮度房间的，那么等优先级的房间可能得到不同的亮度。如果等优先级的房间需要得到相同的亮度，那么在该线性编程问题中须引入一组附加的约束条件。譬如，若配给房间r₁与r₂两相同的优先级(即pr_ri＝pr_r2)，那么需引入如下条件(10)：

(10)pr_r1＝pr_r2br_r1＝br_r2

通常，为保证所有等优先级的房间分配相同的亮度，就必须给每组等优先级房间引入上面这个条件。这只是给线性编程问题增加了一组附加约束方程，而没有引入更多的变量。最坏的情形是给所有房间14分配一个相同的优先级，此时需要N-1个附加条件。最好的情形是没有房间是相同的优先级，此时则不需再引入其它附加条件。

既然照明优化问题已经演变为一个标准形式的线性编程问题(即给定AX＝B，求得x使Cx为最小值)，那么，应用一种方便好用的软件编程工具来实现该照明优化软件算法便是一个常规性问题了。所需的就是定义参数(即自变量与因变量，以及常量)，然后对线性编程约束方程进行编码，而这些编码必须是所用的专门线性编程解算软件模块认识的，例如任何一种所知的(商用的)线性编程解算模块。

在这种情况下，假定线性编程问题是由(5)、(6)、(8)及(9)构造而成，且定义了A矩阵、B向量和C向量，那么所需的就是用适当的形式对这些方程进行编码以及定义其中的参数(即自变量、因变量和常量)。更具体地说，此处要定义的自变量有：每个房间的亮度最大值和最小值(即u_ri及l_ri)，楼宇照明系统内每盏灯(每个房间)的线性功效系数(即P_ri)，每个房间的优先级值(即pr_ri)，以及计划能耗标准(即E)。尽管可以将这些变量值写入软件中去，但此处这些值准备由用户自己定义(如，由楼宇/设备经理来定义这些值)。在这方面，软件可设计一用户界面，让用户根据屏幕提示输入每个自变量(和偏移常量C_ri)的值。同时，还必须定义楼宇照明系统中房间14的数目。需要定义的因变量是余裕变量(即S_uri，S_lri及Se)。其它的因变量为每个房间的亮度值(即b_ri)，它是一个控制变量，就是说，每个房间的该变量值便是程序的输出数据。在此，该发明的基本目的就是生成这些输出数据，在单位时间内，对于一定义的计划能耗标准E，这些数据便考虑了上文讨论过的线性编程方程表达的参数及使用条件，而且体现了楼宇照明控制系统中每个房间的最优化亮度值。

定义了参数及线性编程方程的源码可作为“照明优化模块”应用。把这些线性编程方程转化为一组联立线性方程并解它们，这样的源码可作为“线性编程模块”应用。前文所及，把线性编程方程演变为线性编程模块能适用的编码，对稍微熟悉计算机编程的人来说，是一个常规性问题，当然对本发明所属领域的一般人来说，也只是个常规性问题。前文也提到，线性编程模块很容易从许多地方得到，如：计算机基础编程教科书、商业软件卖主、计算机软件图书馆等。

照明优化模块及线性编程模块共同组成了该发明的计算机软件。本发明的一个示范实施方案所采用的线性编程模块源码附在附录2。照明优化模块与线性编程模块都采用C语言编写。该线性编程模块为一个线性编程解算程序，程序取自名为《采用Pascal程序的分立优化算法《一书(“Discrete Optimization Algorithms with Pascal Programs”)，作者是Syslo，Deo，和Kowalik(Prentice Hall，1983年)，此程序采用了著名的“Simplex”方法来解决线性编程问题。关于照明优化模块，其线性编程问题是根据前文定义的式(5)、(6)、(8)及(9)来进行构造的。构造时，既然楼宇有n个房间，则将有2n个边界条件，再加上一个能量标准的约束条件，就是说，在线性编程问题中共有2n+1个约束方程。在线性编程问题中，将有n个房间变量，加上每个房间的两个余裕变量以及一个余裕能量变量，即一共是3n+1个变量。A矩阵的维数2n+1(n)×3n+1(m)。列向量B有2n+1行，行向量C有3n+1列。

本发明也尽可能优选地设计一照明优化模块，通过考虑房间的连通性，利用线性编程模块“过滤”处理一下房间内的最优化亮度输出值，以达到节约能量的目的。更具体地说，对于每个由大厅、休息室、公共区等“公共房间”提供服务的房间，如果线性编程模块已将其最优化亮度值置为最低值(如0)，那么，假使“公共房间”还不在其最低亮度值，照明优化模块的“过滤”部分就可以将该公共房间的最优化亮度置为最小值。附录1的“公共房间(拓扑)编码”提供了本发明上述实施方案的线性优化模块的过滤部分源码。该过滤算法简单表述如下：即，对于楼宇公共房间集U中的每个公共房间r_u，假使房间集合S中的某一房间r_s由公共房间r_u提供服务(即与公共房间r_u连通)，且b_r＝l_r，那么就设定b_ru＝l_ru。

尽管上文已详细叙述了本发明的一个优选实施方案，但根据附文定义的权利要求，在有关领域，其技术人员对本发明的基本概念可能作出的许多变动与更改仍然属于本发明的宗旨和范畴。关于此点，词“楼宇”“房间”及“光源”尽可能用作它们最广义的意思。例如，词“楼宇”的意思为带有照明系统的任何结构体，包括但不局限于以下地方：单个家庭住房，多家庭住房，公寓，办公楼，仓库，工厂，健身房，大礼堂，剧院，博物馆，商店，饭店，旅馆，购物棚及室内体育馆等。词“房间”包含的意思为任何可确定的单独照明段、带、区或楼宇的局部区域，包括但不局限于以下地方：传统的房间如办公室，浴室，盥洗室，贮存区，工厂楼层，地下室、会议室，门厅，公共区，公共房间或此类任何彼此相连的单元照明段、带、区或楼宇的局部区域，这些地方的照明要能够共同控制。词“光源”不只是包括单个的灯，也包括任何一套或一组相连的灯，它们要能共同受到控制，例如楼宇内与一房相连接的所有的灯。此外，在实现本发明的过程中所采用的专门光源、照明系统或照明控制系统，都不会局限本发明的范围。

附录1

#define MAXVARS   (3*MAXROOMS+2)    /* MAXROOMS is in optlit.h；these */
#define MAXEQS    (2*MAXROOMS+2)    /* two are proportion.l to MAXROOMS */
/* routine to calculate current energy usage */
/* INPUT-Nr is number of rooms(i.e.size of arrays)

         R  is the room brightness array；each entry is the brightness

            of the room that its index into the array represents

         P  is the room power factor array；each entry is the power factor

            of the lamp in the room represented by the index*/
/*OUTPUT-returns the energy consumed by all rooms FOR ONE TIME UNIT */
double optlit_usage(Nr，R，P)
 int Nr；
 Roomarray R，P；
(int i；
 double E＝0.0；
 for(i＝1；i＜＝Nr；i++)E+＝R[i]*p[i]；
 return E；
}
/*routine to optimize room brightnesses */
/*INPUT-Nr Nr is number of rooms(i.e.size of arrays)

        U   is the upper brightness bound for each room.

        L   is the lower brightness bound for each room.

        P   is the power factcr for the lamp in each room.

        Q   is the is priority for each room(the lower the better).

        E   is the TARGET energy level.*/
/*OUTPUT-R  is the room brightness array；each entry is the optimal

            brightness of the room represented by the index of this

            entry given all the input constraints.*/
int optlit_lflt(Nr，U，L，P，Q，E，R)

     int Nr；                      /* number of rooms */

     Roomarray U，L，              /* upper and lower brightness bounds */

                  P，              /* power factor */

                  Q；              /* priority */

     double E；                    /* overall energy target */

     Roomarray    R；              /* resultant optimal brightnesses */
{ double UE，LE；                  /* summed upper and lower energy bounds */
  int i，j；    /* misc index variables*/
  int M，N，                       /*Simplex-   #const，#vars            */

      NoFeas，NoSol；              /*           result flags             */

      double Eps ；                /*            threshold               */

      ArrM2N A；                   /*            Simplex LHS A matrix    */

      ArrM2  B；                   /*            Simplex RHS B matrix    */

      ArrN   C；                   /*            Simplex cost vector     */

      ArrM2  X；                   /*            Simplex result values   */

      ArrM   W；                   /*            Simplex result pointers */

      double F；                   /*            Simplex optimal cost    */
/*  start by doing some error checking */
if  (Nr＞MAXROOMS)
　{printf{*OPTLIT：Sorry，max rooms is％d\n*，MAXROOMS}；return-1；}
/* evaluate upper&amp; lower bounds，to determine if.Eis even possible */
UE＝optlit_usage(Nr，U，P)；/*the maximum consumed energy condition */
LE＝optlit_usage(Nr，L，P)；/*the minimum consumer energu condition */
				
				<dp n="d12"/>
if ((E＞uE)‖(E＜LE))
　{printf(*OPTLIT：Sorry，energy is outof bounds.\n*)；return-1；)
/*printf(*OPTLIT-Setting up room bounds equations.\n*)；*/
/*Transier the room bounds equations into the A matrix */
for (i＝1；i＜＝Nr；i++)
　{for(j＝1；j＜＝3*Nr+1；j++)
　　　A[i+Nr][j]＝A[i][j]＝0.0；           /* zero all vars in two eqs */
　　A[i][i]   ＝1.0；   A[i][i+Nr]     ＝ 1.0； /*except this+upper slack  */
　　A[i+Nr][i]＝1.0；   A[i-Nr)[i+2*Nr]＝-1.0； /*and this+lower slack */
　}
/*printf(*OPTLIT-Calculating energy level equation.\n*)；*/
/*Now set up the total energy consumption equation */
i＝2*Nr+1；/*equation row number for this  */
for(j＝1；j＜＝Nr；j++)     A[i][j]＝P[j]；/* rooms powers */
for(j＝Nr+1；j＜3*Nr；j++)  A[i][j]＝0.0； /* u/l slacks */
A[i][3*Nr+1]＝-1.0； /* energy level slack */
/* printf(*OPTLIT-Constraint equation matrix done(no priority eqs).\n*)；*/
 /* for total-ordering of priorities，will need to add extra constraint
　　equations that enforce equal-priority＝＞equal brightness.
　　This is NOT DONE YET. */
 /*printf(*OPTLIT-Calculating LHS B matrix.\n*)；*/
  /* establish RHS for all constraint equations set up so far */
  for (i＝1；i＜＝Nr；i++)
　　{ B[i]＝U[i]；B[i+Nr]＝L[i]；} /* upper and lower rhs */
  B[2*Nr+1]＝E；                   /* energy level rhs */
  /* printf(*OPTLIT-Calculating cost vector.\n*)；*/
  /* set up the cost vector，using priorities*/
  for(i＝1；i＜＝Nr；i++}     C[i ]＝Q[i]；/*room variables*/
  for(i＝Nr+1；i＜＝3*Nr；i++)C[i]＝0.0；/*u/l slacks */
  C[3*Nr+1]＝1.0；/*energy level slack */
  /*set up the num constraints/num variables for simplex*/
  M＝2*Nr+1；/*num eqs */
  N＝3*Nr+1；/*num vars */
  Eps＝1E-04；/* zero threshold */
  /*optlit_printlp(M，N，A，B，C)；*//* print  the LP program */
  /*printf(*OPTLIT-Calling Simplex-LP for room brightness.\n*)；*/
  /*  NOw call simplex to solve this set of eguations */
  PSimplex(&amp;M，&amp;N，&amp;Eps，A，B，X，C，W，&amp;F，&amp;NoFeas，&amp;NoSol)；
  if (NoFeas＝＝TRUE)
　　{  printf(*OPTLIT：No Feasible Solution.\n*)；return-1；)
　　e1se if(NoSol＝＝TRUE)
　　　{ printf(*OPTLIT：No solution，unbounded cost.\n*)；return-1；)
　　else
　　　( /* now set R to  optimal  values */
　　　　for(i＝1；i＜＝M；i++) R[i]＝0.0；/* clean it first */
　　　　for(i＝1；i＜＝M；i++)
　　　　　if{W[i]＜＝Nr}  /*a room variable in basis */
　　　　　　 R{  W[i]  }  ＝X[i]；/*W is index，X is value of that index */
　　　　return 0；
				
				<dp n="d13"/>
}
/* routine to print out the matrices for an LP problem */
/* INPUT - M      Number of csontraint eqs

           N      Number of variables

           A，B，C Simplex：MINIMIZE(C) subj to Ax＝B */
void optlit_printlp(M，N，A，B，C)
 int M，N；
 ArrM2N A；
 ArrM2 .B；
 ArrN   C；
(int i，j ；
printf(″\nOPTLIT-LP program is as follows - \n″)；
printf(″Number of constraints：％d\n″，M)；
printf(″Number of variables：  ％d\n″，N)；
printf(″A＝\n″)；
for(i＝1；i＜＝M；i++)
　{printf(″Eq％d：″，i)；
　 for(j＝1；j＜＝N；j++)printf(″％6.2f″，A[i][j])；
　 printf(″\n″)；
　}
printf(″\nB＝\n″)；
for (i＝1；i＜＝M；i++)printf(″％6.2f″，B[i])；
printf(″\nC＝\n″)；
for (i＝1；i＜＝N；i++)printf(″％6.2f″，C[i])；
printf(″\n\n″)；
}
/**********************************************************/
/**********************************************************/
/* UTILITY ROOM (TOPOLOGY) CODE BELOW                     */
/**********************************************************/
/**********************************************************/
/* create a utility room structure from the data given */
Utilitvroom opttop_create_utility(util，numrooms，rooms)
 int util，          /* the utility room index */

     numrooms，      /* number of dependant rooms */

     *rooms；        /* array of dependent rooms */
(Utilityroom u；int i；
u＝(Utilityroom)malloc(sizeof(Utilitystruct))；
if(u＝＝NULL)
  (fprintf(stderr，″OPTTOP：Cannot allocate utility room ％d\n″，util)；
  return NULL；
}    
				
				<dp n="d14"/>
u-＞utility＝util；
u-＞num_dependants＝numrooms；
u-＞dependants＝(int *)malloc(sizeof(int)*numrooms)；
if  (u-＞dependants＝＝NULL)
　{ fprintf(stderr，*OPTTOP：Cannot allocate utility list ％d\n″，util)；
　　free(u)；
　　return NULL；
　}
for(i＝0；i＜numrooms；i++)
u-＞dependants [i]＝rooms[i]；
return u；
　　Utilityroom urooms[]；
　　int num_urooms，target；
　[int j，found＝FALSE；
　　for(j＝0；j＜num_urooms；j++)found＝(urooms[j]-＞utility＝＝target)；
 return found；
}
/* test if target is in the depndent list for any utlity room*/
int opttop_in_utility_list(urooms，num_urooms，target}
　Utilityroom urooms[]；
　int num_urooms，target；
{int j，i，found；
 found＝FALSE；
 for(j＝0；j＜num_urooms &amp;&amp;！found；j++)；
  for(i＝0；i＜urooms[j]-＞num_dependants&amp;&amp;！found；i++)

    found＝(urooms[j]-＞dependants[i]＝＝target)；
if(found)return j；
else return-1；
}
/* This routine checks each of the dependent rooms for all utility
rooms. If all the rooms are turned off，then the utility room
is  turned to its lowest lsvel，possibly saving  some energy*/
int opttop_filter_utility_rooms(urooms，num_urooms，R，L)
Utilityroom urooms[]；
int num_urooms；
Roomarray R，L；
[int i，j，allempty；Utilityroom this_uroom；
for (i＝0；i＜num_urooms；i++)
{  allempty＝TRUE；this_uroom＝urooms[i]；
   for(j＝0；j＜this_uroom-＞num_dependants &amp;&amp;！allempty；j++)

     allempty＝(R[this_uroom-＞dependants[j]]＝＝0)；
   if(allempty)
{ /*printf(″OPTTOP-FILTER：utility room％d set to min\n*，

         this_uroom-＞utillty )；*/
  R[this_uroom-＞utility ]＝L[this_uroom-＞utility]；
/*free the space assigned to the utility room structure */
Utilityroom opttop_destroy_utility(u)
Utilityroom u；
{    
if(u-＞dependantsl＝NULL) free(u-＞dependants)；
free(u)；
}
/*test if target is a utility room*/
int opttop_is_utility_room(urooms，num_urooms，target)

附录2

/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/
/*    PROCEDURE SUMMARY ：This  procedure solves the LP problems in                                                                                 */
/*                        standard form：                                                                                                           */
/*                                                                                                                                                  */
/*                   minimize    (c^T) x                                                                                                            */
/*                   subject to   Ax＝b (where bis non-negative)                                                                                    */
/*                                           x＞＝0                                                                                                 */
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/
/*    PROCEDURE PSIMPLEX INPUT       ： ---＞                                                                                                       */
/*        1. The number of constraints (M)                                                                                                          */
/*        2. The number of variables                                                                                                                */
/*        3. A small real number，assignedto the variable(Eps)，such that                                                                           */
/*              if for any real number ′a′，[a] ＜ Eps，then a＝0；                                                                               */
/*        4.  Array A[1..M，l..N]  of  the left-hand-side coefficients of Ax＝b；                                                                   */
/*               additionally the rows M+  l and M+2  ofthis array are used                                                                         */
/*               in the procedure  to  compute  the  relative  cost vector                                                                          */
/*        5.  Array B[1..M].  Additionally the elements B[M+1]  and B[M＝2]                                                                         */
/*               are  used  forintermediate computatlons                                                                                            */
/*        6.  Array C[1..N]，the costarray                                                                                                          */
/*                                                                                                                                                  */
/*                                                                                                                                                  */
/*    PROCEDUREPSIMPLEX OUTPUT    ：  ---＞                                                                                                         */
/*        1.  The boolean variable *NoFeas* equal to TRUE if there is no                                                                            */
/*               solution，and FALSE，otherwise                                                                                                     */
/*        2.  The boolean variable ″NoSol″equal to TRUE if the obj ective                                                                         */
/*               function is unbounded，and FALSE，otherwise                                                                                        */
/*        3.  W[1..M]array identifying the optimal basic values                                                                                     */
/*        4.  X[1..M2]array whose first M elements give the optimal bagic                                                                           */
/*               solution(X[I]is the value of the variable numberedW[I]).                                                                           */
/*        5.  F. which represents the optimal value of the objective function                                                                       */
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/
#include＜stdlo.h＞
#include＜string.h＞
#include″simplex.h″
void PSimplex(M，N，Eps，A，B，X，C，W，F，NoFeas，NoSol)
　　　　　　　int *M；
　　　　　　　int *N；
　　　　　　　double*Eps；
　　　　　　　ArrM2N A；
　　　　　　　ArrM2 B；
　　　　　　　ArrM2 X；
　　　　　　　ArrN C；
　　　　　　　ArrM N；
　　　　　　　double*F；
　　　　　　　int *NoFeas；
　　　　　　　int *NoSol；
　　　　{
　　　　　　int I，J，K，L，P，Q；
　　　　　　double D，R，S；
　　　　　　ArrM2M2 U；
　　　　　　ArrM2 Y；
　　　　　　int Ex，Phase，Stop；
				
				<dp n="d16"/>
*NoFeas＝FALSE ；
*NoSol＝FALSE；
P＝ *M+2；
Q＝ *M+2；
Phase＝TRUE；
K＝ *M+1；
for(J＝1；J＜＝*N；J++)
　{
　　A[K][J]＝C[J]；
　　S＝0.0；
　　for(I＝1；I＜＝*M；I++)
　　　  S＝S-A[I][J]；
　　A[P][J]＝S；
　}
S＝0.0；
for(I＝1；I＜＝*M；I++)
　{
　　W[I]＝*N+I；
　　R＝B[I]；
　　X[I]＝R；
　　S＝S-R；
　}
X[K]＝0.0；
X[P]＝S；
for(I＝1；I＜＝P；I++)
　{
　　for(J＝1；J＜＝P；J++)
　　　U[I][J]＝0.0；
　　U[I][I]＝1.0；
　}
Stop＝FALSE；
　do
　{           /*UNTIL STOP-PHASE 1 */
　if((X[P]  ＞＝ -*Eps) &amp;&amp; (Phase))
　　{
　　　Phase＝FALSE；
　　　Q＝ *M+1；
　　}
　D＝0.0；    /*  PHASE 2 */
　for(J＝1；J＜＝*N；J++)
　　{
　　　S＝0.0；
　　　for(I＝1；I＜＝P；I++)
　　　　s＝s+U[Q][I]*A[I][J]；
　　　if(D＞S){D＝S；K＝J；}
　　}
　if(D＞-*Eps)
　　{
　　　Stop＝TRUE；
　　　if(phase)*NoFeas＝TRUE；
　else*F＝-X[Q]；
}
else
　{
　　for(I＝1；I＜＝Q；I++)
　　　{
　　　　S＝0.0；
　　　　for(J＝1；J＜＝P；J++)
　　　　　S＝S+U[ I][J]*A[J][K]；
　　　　Y[I]＝S；
　　　}
				
				<dp n="d17"/>
　　　　　　　　Ex＝TRUE；
　　　　　　　　for(I＝1；I＜＝*M；I++)
　　　　　　　　　if(Y[I]＞＝*Eps)
　　　　　　　　　　{
　　　　　　　　　　　s＝X[I]/Y[I]；
　　　　　　　　　　　if((Ex)‖(s＜D)}
　　　　　　　　　　　　{D＝S；L＝I；)
　　　　　　　　　　　Ex＝FALSE；
　　　　　　　　　　}
　　　　　　　　　if(Ex)
　　　　　　　　　　{*NoSol＝TRUE；Stop＝TRUE；}
　　　　　　　　　　else
　　　　　　　　　　　{
　　　　　　　　　　　　W[L]＝K；
　　　　　　　　　　　　S＝1.0/Y[L]；
　　　　　　　　　　　　for(J＝1；J＜＝*M；J++)
　　　　　　　　　　　　　U[L][J]＝U[L][J]*S；
　　　　　　　　　　　　if(L＝＝1)I＝2；else I＝1；
　　　　　　　　　　　　do
　　　　　　　　　　　　　{
　　　　　　　　　　　　　S＝Y[I]；
　　　　　　　　　　　　　X[I]＝X[I] -D*s；
　　　　　　　　　　　　　for(J＝1；J＜＝*M；J++)
　　　　　　　　　　　　　　U[I][J]＝U[I][J]-U[L][J]*S；
　　　　　　　　　　　　　if(I＝＝L-1)I＝I+2；elseI＝I+1；
　　　　　　　　　　　　}
　　　　　　　　　　　while(I＜＝Q)；
　　　　　　　　　　　X[L]＝D；　　　　　　
　　　　　　　　　　}            /*NOT EX */
　　　　　}                      /* D＜＝-Eps */
　　}
　　while(！Stop)；
}                                /*PSimplex */
/*-------------------------------------------------------------------------*/

Claims

1.一种控制楼宇系统能量分配的方法，该楼宇系统带有多个能耗值可选择性调节的耗能设备，该方法包括以下步骤：

生成能量分配数据，这些数据体现了每台耗能设备的能量最佳分配，同时满足条件：在一定时间间隔内，配给楼宇系统的总能量不超过指定的消耗标准；

根据所述能量分配数据相应调节每台耗能设备的能耗值。

2.根据权利要求1所述的方法，其中，该方法包括以下步骤：

指定每个耗能设备的优先级；和

至少部分地根据耗能设备的指定优先级来生成所述能量分配数据。

3.根据权利要求1或2所述的方法，其中，至少有一个耗能设备采用了规定的线性功效系数，且其中能量分配数据至少是部分地根据该规定的线性功效系数来产生的。

4.根据权利要求3所述的方法，其中，生成能量分配数据的步骤包括：

根据楼宇系统一组规定的参数及使用条件，利用线性编程技术来生成能量分配数据。

5.根据权利要求4所述的方法，其中，运用线性编程技术的所述步骤包括，把该组楼宇系统的参数及使用条件转化为一组联立的线性方程和一成本函数，通过这种方法解该组联立线性方程，使成本函数达到最小值，由此产生能量分配数据。

6.根据权利要求1所述的方法，其中，楼宇系统包括一照明系统，耗能设备包括多个亮度值可选择性调节的光源，而可选择性调节包括根据能量分配数据选择性地调节每个光源的亮度输出值。

7.根据权利要求6所述的方法，其中，楼宇包括一系列房间，且每个房间至少有一个光源；也包括一系列含有公共房间的房间，且至少有一个由公共房间提供服务且与之相连的房间；其中，该方法包括以下步骤：

假如每个与公共房间相连的房间其光源亮度输出值由能量分配数据定义到最低亮度输出值，然后选择性地调节该公共房间的亮度输出值至最低值。

8.根据权利要求6或7所述的方法，其中，光源采用一种亮度可选择性调节的减光光源，并且其中：

生成能量分配数据的步骤包括定义每个减光光源的最优亮度值；

选择性调节亮度输出值的步骤包括选择性地调节每个减光光源的亮度值至能量分配数据定义的最优化亮度值。

9.一楼宇系统，该楼宇系统带有多个能耗值可选择性调节的耗能设备，还有一控制系统，用它来控制整个楼宇系统的能量分配；该控制系统包括：

一个可编程控制器；和

装在可编程控制器中的软件，用该软件来生成体现每个耗能设备能量最优分配的能量分配数据，而且这些数据满足一个总的能耗约束条件，即在一规定时间间隔内，分配给楼宇系统的总能量不超过一指定的总能耗值；

其中，可编程控制器根据该能量分配数据来自动地控制每个耗能设备的能耗值。

10.一种权利要求9所述的楼宇系统，其中，

所述能量分配数据至少是部分地根据每个耗能设备的指定优先级来生成的。

11.根据权利要求9或10所述的楼宇系统，其中，至少有一个耗能设备采用了规定的线性功效系数，而其中的能量分配数据至少是部分地根据该线性功效系数来生成的。

12.根据权利要求11所述的楼宇系统，其中，生成能量分配数据包括：

根据楼宇系统一组指定的参数及约束条件，利用线性编程技术来生成能量分配数据。

13.根据权利要求12所述的楼宇系统，其中，利用线性编程技术包括：将楼宇系统的一组参数及约束条件转化为一组联立线性方程和一成本函数，然后通过解这组联立线性方程，使所述成本函数达到最小值，由此来生成能量分配数据。

14.根据权利要求9所述的楼宇系统，其中，楼宇系统包括一照明系统，耗能设备包括亮度输出值可选择性调节的多个光源，而选择性调节包括根据所述能量分配数据选择性地调节每个光源的亮度输出值。

15.根据权利要求14所述的楼宇系统，其中，一楼宇包括一系列房间，且每个房间至少配备一个所述光源，也包括一系列含有一公共房间的房间，而且至少有一个房间由公共房间提供服务且与之相连；其中可编程控制器设想为，如果每个与公共房间相连的房间其光源亮度输出值由能量分配数据定义到最低亮度输出值，那么该可编程控制器就可以选择性地调节该公共房间的亮度输出值至最低值。

16.根据权利要求14或15所述的一楼宇系统，其中，光源采用一种亮度可选择性调节的减光光源，其中：

生成能量分配数据包括定义每个减光光源的最优亮度值；

选择性调节亮度输出值包括选择性地调节每个减光光源的亮度值至能量分配数据定义的最优化亮度值。

17.一种控制系统，用它来控制整个楼宇系统的能量分配，而这个楼宇系统带有多个能耗值可选择性调节的耗能设备，该控制系统包括：

一个可编程控制器；

其中，可编程控制器根据所述能量分配数据来自动控制每个耗能设备的能耗值。

18.根据权利要求17所述的控制系统，其中

19.根据权利要求17或18所述的控制系统，其中，至少有一个耗能设备采用了规定的线性功效系数，而其中所述的能量分配数据至少是部分地根据所述线性功效系数来生成的。

20.根据权利要求19所述的控制系统，其中，生成能量分配数据包括：

根据楼宇系统的一组规定的参数及使用条件，利用一线性编程技术来生成能量分配数据。

21.根据权利要求20所述的控制系统，其中，利用线性编程技术包括：将楼宇系统的一组规定的参数及约束条件转化为一组联立线性方程和一成本函数，然后通过解这组联立线性方程，使成本函数达到最小值，由此来生成能量分配数据。

22.根据权利要求21所述的控制系统，其中，楼宇系统包括一照明系统，且耗能设备包括亮度输出值可选择性调节的多个光源；其中，一楼宇包括一系列房间，且每个房间至少配备一个所述光源，也包括一系列含有公共房间的房间，而且至少有一个房间由公共房间提供服务并与之相连；其中，选择性调节包括根据能量分配数据选择性地调节每个光源的亮度输出值；其中，所述的可编程控制器被构想为，如果每个与公共房间相连的房间的光源亮度输出值由能量分配数据定义到最低亮度值，那么该可编程控制器是用来选择性地调节该公共房间亮度输出值至最低值的。

23.根据权利要求22所述的控制系统，其中，该光源采用一种亮度值可选择性调节的减光光源，其中：

生成能量分配数据包括定义每个减光光源的最优化亮度值；