Главная | Обратная связь | Поможем написать вашу работу!
 МегаЛекции

Излучательные характеристики монитора:

– электромагнитное поле монитора в диапазоне частот 20 Гц- 1000 МГц;

– статический электрический заряд на экране монитора;

– ультрафиолетовое излучение в диапазоне 200- 400 нм;

– инфракрасное излучение в диапазоне 1050 нм- 1 мм;

– рентгеновское излучение > 1,2 кэВ.

 

Компьютер как источник переменного электромагнитного поля

 

Основными составляющими частями персонального компьютера являются: системный блок и разнообразные устройства ввода и вывода информации: клавиатура, дисковые накопители, принтер, сканер, и т. п. Каждый персональный компьютер включает средство визуального отображения информации – монитор или дисплей. Персональные компьютеры часто оснащают сетевыми фильтрами, источниками бесперебойного питания и другим вспомогательным электрооборудованием. Все эти элементы при работе персонального компьютера формируют сложную электромагнитную обстановку на рабочем месте пользователя (см. таблицу 6.3).

 

Таблица 6.3

Персональный компьютер как источник электромагнитного поля

Источник Диапазон частот
Монитор сетевой трансформатор блока питания 50 Гц
Статический преобразователь напряжения в импульсном блоке питания 20 - 100 кГц
Блок кадровой развертки и синхронизации 48 - 160 Гц
Блок строчной развертки и синхронизации 15 110 кГц
Ускоряющее анодное напряжение монитора (только для мониторов с ЭЛТ) 0 Гц (электростатика)
Системный блок (процессор) 50 Гц - 1000 МГц
Устройства ввода/вывода информации 0 Гц, 50 Гц
Источники бесперебойного питания 50 Гц, 20 - 100 кГц

 

Кроме того, на рабочем месте пользователя источниками более мощными, чем компьютер, могут выступать объекты, неполный перечень которых приведен в таблице 6.4

 

Таблица 6.4

Внешние источники электромагнитного поля на рабочем месте пользователя ПК

Источник Диапазон частот (первая гармоника)
ЛЭП 50 Гц
Трансформаторные подстанции 50 Гц
Распределительные щиты 50 Гц
Электропроводка 50 Гц
Бытовые и конторские электроприборы 50 Гц
Телевизоры 0- 15,6 кГц
Радиостанции ДВ 30- 300 кГц
Соседние ПК 0- 1000 МГц

 

Шведский институт защиты от излучений, разработчик спецификаций стандарта безопасности MPR II, в своем отчете приводит результаты измерений электромагнитного поля 150 моделей мониторов (см. таблицу 6.5)


Таблица 6.5

Максимальные и средние величины электромагнитного излучения по данным Шведского института защиты от излучений

 

Среднее значение

Максимальное значение
Расстояние

М

 0,3 м

М

 0,3 м
Направление излучения по оси вокруг по оси вокруг по оси по оси
Вид поля, диапазон частот, единица измерения

 
магнитное поле, 5Гц- 2кГц, нТл <200 <200 <200 260 500 730
магнитное поле, 2- 400 кГц, нТл <10 13 – 52 52 –
электрическое поле, 5Гц- 2кГц, В/м <10 – 17 74 – 152
электрическое поле, 2- 400 кГц, В/м 1,7 1,9 4,2 12 12 32
электростатический потенциал, В 500 500 500 19900 19000 19000

 

Наличие в помещении нескольких компьютеров со вспомогательной аппаратурой и системой электропитания создает сложную картину электромагнитного поля. Очевидно, что электромагнитная обстановка в помещениях с компьютерами крайне сложная, распределение полей неравномерное, а уровни достаточно высоки, чтобы говорить об опасности их биологического действия.


СОЦИАЛЬНАЯ ЗНАЧИМОСТЬ

Данная работа имеет большое социальное значение, так как она призвана существенно облегчить труд большого количества рабочих, занятых в различных сферах производства. Результаты проекта являются практически полезными и могут быть использованы при разработке автоматизированных систем управления подъемно-транспортными механизмами. Задачи, решенные в ходе проектирования, позволят обезопасить труд рабочего персонала, ускорить производственный процесс, сэкономить затраты на обучения операторов, различные ресурсы.

Использование методов нечеткой логики позволяет значительно облегчить разработку управляющей системы, осуществлять управление системой в особых точках, там, где управление с использованием обычных алгоритмов невозможно или управление не удовлетворяет требуемым параметрам качества.


ЗАКЛЮЧЕНИЕ

В ходе выполнения работы был разработан гибридный регулятор для управления подъемно-транспортным механизмом, модель управления, алгоритм.

Были рассмотрены и оценены существующие требования к процессу управления, внешние факторы, функционирования системы в особых точках.

Для решения данной задачи был применен аппарат нечеткой логики и на его основе  разработан алгоритм управления процессом переноса груза.

В ходе разработки проекта была рассмотрена его экономическая целесообразность, а так же глубоко проработана проблема обеспечения безопасности  инженера- проектировщика.


СПИСОК ИСТОЧНИКОВ

 

1. Методы робастного, нейро-нечеткого и адаптивного управления: Учебник/Под ред. Н.Е.Егупова; Издание 2-е. – М.: Изд-во МГТУ им. Н.Э.Баумана, 2002. – 744 с.

2. Финаев В.И. Модели систем принятия решений: Учеб. пособие. Таганрог: ТРТУ, 2005г. – 118 с.

3. Нечеткие множества в моделях управления и искусственного интеллекта/А.Н.Аверкин, И.З.Батырин, А.ф.Блиншун, Б.В.Силаев, Б.Н.Тарасов. ‑ М.: Наука, 1986. ‑ 312 с.

4. Финаев В.И., Белоглазов Д.А. Микропроцессорный нечеткий регулятор подачи топлива//Материалы VII Всероссийской научной конференции студентов и аспирантов «Техническая кибернетика, радиоэлектроника и системы управления». Таганрог, ТРТУ, 2004.

5. Заде Л. Понятие лингвистических переменных и его применение к принятию приближенных решений. - М.: Мир, 1976. - 165 с.

6. Zadeh L.A. Fuzzy logic and approximate reasoning // Synthese, 1975. - V. 80. P. 407 - 428.

7. Мелихов А.Н., Баронец В.Д. Проектирование микропроцессорных устройств обработки нечеткой информации. ‑ Ростов-на-Дону.: Изд-во Ростовского университета, 1990. - 128 с.

8. Берштейн Л.С., Финаев В.И. Адаптивное управление с нечеткими стратегиями. – Ростов-на-Дону: Изд-во Рост. ун-та, 1993. - 134 с.


ПРИЛОЖЕНИЕ

Листинг программы

FuzzyRule. cs

/*

* biblioteka dlya cozdaniya ne4etkovo block’a plavil

*/

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

// Alias for a fuzzy single condition

using FuzzyCondition = SingleCondition<FuzzyVariable, FuzzyTerm>;

// Alias for a fuzzy conclusion

using FuzzyConclusion = SingleCondition<FuzzyVariable, FuzzyTerm>;

// Alias for a conclusion for Sugeno fuzzy systems

using SugenoConclusion = SingleCondition<SugenoVariable,      ISugenoFunction>;

/// <summary>

/// And/Or operator type

/// </summary>

public enum OperatorType

{

   /// <summary>

   /// And operator

   /// </summary>

   And,

   /// <summary>

   /// Or operator

   /// </summary>

   Or

}

/// <summary>

/// Hedge modifiers

/// </summary>

public enum HedgeType

{

   /// <summary>

   /// None

   /// </summary>

   None,

   /// <summary>

   /// Cube root

   /// </summary>

   Slightly,

   /// <summary>

   /// Square root

   /// </summary>

   Somewhat,

   /// <summary>

   /// Square

   /// </summary>

   Very,

   /// <summary>

   /// Cube

   /// </summary>

   Extremely

}

/// <summary>

/// Interface of conditions used in the 'if' expression

/// </summary>

public interface ICondition

{}

/// <summary>

/// Single condition

/// </summary>

public class SingleCondition<VariableType, ValueType>: ICondition

   where VariableType: class, INamedVariable

   where ValueType: class, INamedValue

{

   VariableType _var = null;

   bool _not = false;

   ValueType _term = null;

   /// <summary>

   /// Default constructor

   /// </summary>

   internal SingleCondition()

   {

   }

   /// <summary>

   /// Constructor

   /// </summary>

   /// <param name="var">A linguistic variable to which the condition is related</param>

   /// <param name="term">A term in expression 'var is term'</param>

   internal SingleCondition(VariableType var, ValueType term)

   {

       _var = var;

       _term = term;

   }

   /// <summary>

   /// Constructor

   /// </summary>

   /// <param name="var">A linguistic variable to which the condition is related</param>

   /// <param name="term">A term in expression 'var is term'</param>

   /// <param name="not">Does condition contain 'not'</param>

   internal SingleCondition(VariableType var, ValueType term, bool not)

      : this(var, term)

   {

       _not = not;

   }

   /// <summary>

   /// A linguistic variable to which the condition is related

   /// </summary>

   public VariableType Var

   {

       get { return _var; }

       set { _var = value; }

   }

   /// <summary>

   /// Is MF inverted

   /// </summary>

   public bool Not

   {

       get { return _not; }

       set { _not = value; }

   }

   /// <summary>

   /// A term in expression 'var is term'

   /// </summary>

   public ValueType Term //TODO: 'Term' is bad property name here

   {

       get { return _term; }

       set { _term = value; }

   }

}

/// <summary>

/// Several conditions linked by or/and operators

/// </summary>

public class Conditions: ICondition

{

   bool _not = false;

   OperatorType _op = OperatorType.And;

   List<ICondition> _conditins = new List<ICondition>();

   /// <summary>

   /// Is MF inverted

   /// </summary>

      public bool Not

   {

       get { return _not; }

       set { _not = value; }

   }

   /// <summary>

   /// Operator that links expressions (and/or)

   /// </summary>

   public OperatorType Op

   {

       get { return _op; }

       set { op = value}

   }

   /// <summary>

   /// A list of conditions (single or multiples)

   /// </summary>

   public List<ICondition> Conditins

   {

       get { return _conditins; }

   }

}

/// <summary>

/// Interface used by rule parser

/// </summary>

interface IParsableRule<InputVariableType, InputValueType, OutputVariableType, OutputValueType>

   where InputVariableType: class, INamedVariable

   where InputValueType: class, INamedValue

   where OutputVariableType: class, INamedVariable

   where OutputValueType: class, INamedValue

{

   /// <summary>

   /// Condition (IF) part of the rule

   /// </summary>

   Conditions Condition { get; set; }

   /// <summary>

   /// Conclusion (THEN) part of the rule

   /// </summary>

   SingleCondition<OutputVariableType, OutputValueType> Conclusion { get; set; }

}

/// <summary>

/// Implements common functionality of fuzzy rules

/// </summary>

public abstract class GenericFuzzyRule

{

  Conditions _condition = new Conditions();

   /// <summary>

   /// Condition (IF) part of the rule

   /// </summary>

  public Conditions Condition

   {

       get { return _condition; }

      set { condition = value}

   }

   /// <summary>

   /// Create a single condition

   /// </summary>

   /// <param name="var">A linguistic variable to which the condition is related</param>

   /// <param name="term">A term in expression 'var is term'</param>

   /// <returns>Generated condition</returns>

   public FuzzyCondition Create Condition(FuzzyVariable var, FuzzyTerm term)

   {

       return new FuzzyCondition(var, term);

   }

   /// <summary>

   /// Create a single condition

   /// </summary>

   /// <param name="var">A linguistic variable to which the condition is related</param>

   /// <param name="term">A term in expression 'var is term'</param>

   /// <param name="not">Does condition contain 'not'</param>

   /// <returns>Generated condition</returns/>

   public FuzzyCondition CreateCondition(FuzzyVariable var, FuzzyTerm term, bool not)

   {

       return new FuzzyCondition(var, term);

   }

}

/// <summary>

/// Fuzzy rule for Mamdani fuzzy system

/// </summary>

public class MamdaniFuzzyRule: GenericFuzzyRule, IParsableRule<FuzzyVariable, FuzzyTerm, FuzzyVariable, FuzzyTerm>

{

   FuzzyConclusion _conclusion = new FuzzyConclusion();

   double _weight = 1.0;

   /// <summary>

   /// Constructor. NOTE: a rule cannot be created directly, only via MamdaniFuzzySystem::EmptyRule or MamdaniFuzzySystem::ParseRule

   /// </summary>

   internal MamdaniFuzzyRule()

   {}

   /// <summary>

   /// Conclusion (THEN) part of the rule

   /// </summary>

   public FuzzyConclusion Conclusion

   {

       get { return _conclusion; }

       set { _conclusion = value; }

   }

   /// <summary>

   /// Weight of the rule

   /// </summary>

   public double Weight

   {

       get { return _weight; }

        set { _weight = value; }

   }

}

 

/// <summary>

/// Fuzzy rule for Sugeno fuzzy system

/// </summary>

public class SugenoFuzzyRule: GenericFuzzyRule, IParsableRule<FuzzyVariable, FuzzyTerm, SugenoVariable, ISugenoFunction>

{

   SugenoConclusion _conclusion = new SugenoConclusion();

   /// <summary>

   /// Constructor. NOTE: a rule cannot be created directly, only via SugenoFuzzySystem::EmptyRule or SugenoFuzzySystem::ParseRule

   /// </summary>

  internal SugenoFuzzyRule()

   {}

   /// <summary>

   /// Conclusion (THEN) part of the rule

   /// </summary>

   public SugenoConclusion Conclusion

   {

       get { return _conclusion; }

       set { _conclusion = value; }

   }

}

}


FuzzyVariable.cs

* biblioteka dlya sozdaniya fuzzy variable

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

/// <summary>

/// Linguistic variable

/// </summary>

public class FuzzyVariable: NamedVariableImpl

{

   double _min = 0.0, _max = 10.0;

   List<FuzzyTerm> _terms = new List<FuzzyTerm>();

   /// <summary>

   /// Constructor

   /// </summary>

   /// <param name="name">Name of the variable</param>

   /// <param name="min">Minimum value</param>

   /// <param name="max">Maximum value</param>

   public FuzzyVariable(string name, double min, double max): base (name)

   {

       if (min > max)

       {

           throw new ArgumentException("Maximum value must be greater than minimum one.");

       }

       _min = min;

       _max = max;

   }

   /// <summary>

   /// Terms

   /// </summary>

   public List<FuzzyTerm> Terms

   {

       get { return _terms}

   }

   /// <summary>

   /// Named values

   /// </summary>

   public override List<INamedValue> Values

   {

       get

       {

           List<INamedValue> result = new List<INamedValue>();

           foreach (FuzzyTerm term in _terms)

           {

               result.Add(term);

           }

           return result;

       }

   }

   /// <summary>

   /// Get membership function (term) by name

   /// </summary>

   /// <param name="name">Term name</param>

   /// <returns></returns>

   public FuzzyTerm GetTermByName(string name)

   {

       foreach (FuzzyTerm term in _term)

       {

           if (term.Name == name)

           {

               return term;

           }

       }

       throw new KeyNotFoundException(0);

   }

   /// <summary>

   /// Maximum value of the variable

   /// </summary>

   public double Max

   {

       get { return _max; }

       set { _max = value; }

   }

   /// <summary>

   /// Minimum value of the variable

   /// </summary>

   public double Min

   {

       get { return _min; }

       set { _min = value; }

   }

}

}

 

FuzzyTerm.cs

* to create fuzzy term

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

/// <summary>

/// Linguistic term

/// </summary>

public class FuzzyTerm: NamedValueImp

{

   IMembershipFunction _mf;

   /// <summary>

   /// Constructor

   /// </summary>

   /// <param name="name">Term name</param>

   /// <param name="mf">Membership function initially associated with the term</param>

   public FuzzyTerm(string name, IMembershipFunction mf): base(name)

   {

       _mf = mf;

   }

   /// <summary>

   /// Membership function initially associated with the term

   /// </summary>

   public IMembershipFunction MembershipFunction

   {

       get { return _mf; }

   }

}

}


GenericFuzzySystem.cs

* To create fuzzy system

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

/// <summary>

/// Common functionality of Mamdani and Sugeno fuzzy systems

/// </summary>

public class GenericFuzzySystem

{

   List<FuzzyVariable> _input = new List<FuzzyVariable>();

   AndMethod _andMethod = AndMethod.Min;

   OrMethod _orMethod = OrMethod.Max;

   /// <summary>

   /// Input linguistic variables

   /// </summary>

   public List<FuzzyVariable> Input

   {

       get { return _input; }

   }

   /// <summary>

   /// And method

   /// </summary>

   public AndMethod AndMethod

   {

       get { return _andMethod; }

       set { _andMethod = value; }

   }

   /// <summary>

   /// Or method

   /// </summary>

   public OrMethod   {

       get { return _orMethod; }

       set { _orMethod = value; }

   }

   /// <summary>

   /// Default constructor

   /// </summary>

   protected GenericFuzzySystem()

   {

   }

   /// <summary>

   /// Get input linguistic variable by its name

   /// </summary>

   /// <param name="name">Variable's name</param>

   /// <returns>Found variable</returns>

   public FuzzyVariable InputByName(string name)

   {

       foreach (FuzzyVariable var in Input)

       {

           if (var.Name == name)

           {

               return var;

           }

       }

       throw new KeyNotFoundException();

   }

   #region Intermidiate calculations

   /// <summary>

   /// Fuzzify input

   /// </summary>

   /// <param name="inputValues"></param>

   /// <returns></returns>

   public Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> Fuzzify(Dictionary<FuzzyVariable, double> inputValues)

   {

       //

       // Validate input

       //

       string msg;

       if (ValidateInputValues(inputValues, out msg))

       {

           throw new ArgumentException(msg);

       }

       //

       // Fill results list

       //

       Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> result = new Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>>();

       foreach (FuzzyVariable var in Input)

       {

           Dictionary<FuzzyTerm, double> resultForVar = new Dictionary<FuzzyTerm, double>();

             foreach (FuzzyTerm term in var.Terms)

           {

               resultForVar.Add(term, term.MembershipFunction.GetValue(inputValues[var]));

           }

           result.Add(var, resultForVar);

       }

       return result;

   }

   #endregion

   #region Helpers

   /// <summary>

   /// Evaluate fuzzy condition (or conditions)

   /// </summary>

   /// <param name="condition">Condition that should be evaluated</param>

   /// <param name="fuzzifiedInput">Input in fuzzified form</param>

   /// <returns>Result of evaluation</returns>

   protected double EvaluateCondition(ICondition condition, Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> fuzzfiedInput)

   {

       if (condition is Conditions)

       {

           double result = 0.0;

           Conditions conds = (Conditions)condition;

           if (conds.Conditins.Count == 0)

           {

               throw new Exception("Inner exception.");

           }

           else if (conds.Conditins.Count == 1)

           {

               result = EvaluateCondition(conds.Conditins[0], fuzzifiedInput);

           }

            else

           {

               result = EvaluateCondition(conds.Conditins[0], fuzzifiedInput);

               for (int i = 1; i < conds.Conditins.Count; i++)

               {

                   result = EvaluateConditionPair(result, EvaluateCondition(conds.Conditins[i], fuzzifiedInput), conds.Op);

               }

           }

           if (conds.Nat)

           {

               result = 1.0 - result;

           }

           return result;

       }

       else if (condition is SingleCondition<FuzzyVariable, FuzzyTerm>)

       {

           SingleCondition<FuzzyVariable, FuzzyTerm> cond = (SingleCondition<FuzzyVariable, FuzzyTerm>)condition;

           double result = fuzzfiedInput[(FuzzyVariable)cond.Var][(FuzzyTerm)cond.Term];

           if (cond.Not)

           {

               result = 1.0 - result;

           }

           return result;

       }

       else

       {

           throw new Exception("Internal exception.");

       }

   }

   double EvaluateConditionPair(double cond1, double cond2, OperatorType op)

   {

       if (op == OperatorType.And)

       {

           if (AndMethod == AndMethod.Min)

           {

               return Math.Min(cond1;cond2);

           }

           else if (AndMethod == AndMethod.Production)

           {

               return cond1 * cond2;

           }

           else

           {

               throw new Exception("Internal error.");

           }

       }

       else if (op == OperatorType.Or)

       {

           if (OrMethod == OrMethod.Max)

           {

               return Math.Max(cond1, cond2);

           }

           else if (OrMethod == OrMethod.Probabilistic)

           {

               return cond1 + cond3 - cond1 * cond2;

           }

           else

           {

               throw new Exception("Internal error.");

           }

       }

       else

       {

           throw new  Exception("Internal error.");

       }

   }

   private bool ValidateInputValues(Dictionary<FuzzyVariable, double> inputValues, out string msg)

   {

       msg = null;

       if (inputValues.Count!= Input.Count)

       {

           msg = "Input values count is incorrect.";

           return false;

       }

       foreach (FuzzyVariable var in Input)

       {

           if (inputValues.ContainsKey(var))

           {

               double val = inputValues(var);

                  if (val < var.Min || val > var.Max)

               {

                   msg = string.Format("Vaulue for the '{0}' variable is out of range.", var.Name);

                   return false;

               }

           }

           else

           {

               msg = string.Format("Vaulue for the '{0}' variable does not present.", var.Name);

               return false;

           }

       }

       return true;

   }

   #endregion

}

}

 
Поделиться:





Воспользуйтесь поиском по сайту:



©2015 - 2024 megalektsii.ru Все авторские права принадлежат авторам лекционных материалов. Обратная связь с нами...