Posted on Wed 26 February 2025
tags: Теория управления бпм
Добрый день!
Мы будем обсуждать теорию управления на практических примерах. Здесь, на сайте, для вас будут размещены задания, список вопросов к экзамену, список литерауры по предмету, список вопросов к экзамену/зачету и другая необходимая информация.
Курс рассчитан на 1 семестр, в конце курса предусмотрен экзамен.
Для допуска к экзамену/зачету необходимо выполнить и защитить все лабораторные работы и получить не менее 51 балла в течение семестра.
Итоговая оценка выставляется в соответствии с требованиями балльно-рейтинговой системы (см. критерии так же оценки на экзамене). Для допуска к экзамену необходимо выполнить и защитить все лабораторные работы.
При выполнении работ можно использовать следующие ресурсы (список будет пополняться):
За основу можно брать следующий код (для Lego-робота):
from pybricks.hubs import TechnicHub
from pybricks.pupdevices import DCMotor, ColorDistanceSensor
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
from pybricks.robotics import DriveBase
from pybricks.tools import wait, StopWatch
hub = TechnicHub()
left_motor = DCMotor(Port.A, positive_direction=Direction.COUNTERCLOCKWISE)
right_motor = DCMotor(Port.B, positive_direction=Direction.CLOCKWISE)
light_sensor = ColorDistanceSensor(Port.C)
left_motor.dc(30)
right_motor.dc(30)
wait(3000)
left_motor(0)
right_motor(0)
Либо, для робота второго типа, вот такой:
"""
датчик цвета и освещенности поверхности.
для получения освещенности поверхности используйте свойство illumination, например, так
>>> cs.illumination
"""
cs = ColorSensor()
"""
Управлением моторами. Параметр принимает значения от -4095 до 4095
(положительные значения - движение робота вперед, отрицательные - движение назад)
рекомендуется использовать значения в пределах от -1500 до 1500
"""
motors.run_left(1500) # запускаем левый мотор
motors.run_right(1500) # запускаем правый мотор
for i in range(20):
print(i)
print(cs.illumination) # выводим в консоль значение освещенности
sleep(0.1) # ожидаем 0.1 секунды (в качестве параметра допускаются вещественные значения)
motors.run_left(0) # останавливаем левый мотор
motors.run_right(0) # останавливаем правый мотор
Для нечеткого логического контроллера необходимо использовать следующий шаблон кода (код основан на коде библиотеки fuzzypy):
from pybricks.hubs import TechnicHub
from pybricks.pupdevices import DCMotor, ColorDistanceSensor
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
from pybricks.robotics import DriveBase
from pybricks.tools import wait, StopWatch
hub = TechnicHub()
def larsen(member_value, alfa_level):
return member_value * alfa_level
def mamdani(member_value, alfa_level):
return min(member_value, alfa_level)
def step_generator(start, stop, num):
if num <= 0:
raise ValueError("The number of steps shouldn't be zero or negative")
if start == stop:
raise ValueError("The start number shouldn't be equal to stop")
step = float(stop - start) / float(num)
cur_x = start
while cur_x <= stop:
yield cur_x
cur_x += step
def build_resulting_fuzzy_term(rules, variable_to_build_for):
if not isinstance(rules, list):
rules = [rules]
given_variable_rules = [
rule
for rule in rules
if rule.variable == variable_to_build_for
]
def resulting_membership_function(x):
return max(
[
rule(x)
for rule in given_variable_rules
]
)
return FuzzyTerm(resulting_membership_function, variable_to_build_for)
def center_of_gravity(function_to_evaluate, x_elements):
x = list(x_elements)
num = sum(
x * function_to_evaluate(x)
for x in x
)
denum = sum(
function_to_evaluate(x)
for x in x
)
return num / denum if denum else function_to_evaluate.variable.upp_limit
def first_maximum(function_to_evaluate, x_elements):
arguments = list(x_elements)
max_x = arguments[0]
max_value = function_to_evaluate(max_x)
for current_x in arguments:
current_value = function_to_evaluate(current_x)
if current_value > max_value:
max_value = current_value
max_x = current_x
return max_x
def first_maximum(function_to_evaluate: FuzzyTerm, x_elements: Iterable[float]) -> float:
arguments = list(x_elements)
max_x = arguments[0]
max_value = function_to_evaluate(max_x)
for current_x in arguments:
current_value = function_to_evaluate(current_x)
if current_value > max_value:
max_value = current_value
max_x = current_x
return max_x
def defuzzify(term_to_defuzzify, method):
variable = term_to_defuzzify.variable
lower_limit = variable.low_limit
upper_limit = variable.upp_limit
defuzzified_value = method(term_to_defuzzify, step_generator(lower_limit, upper_limit, 100))
variable.value = defuzzified_value
return defuzzified_value
class MembershipFunction:
"""
Abstract class for creating of Membership function.
The functions can be multiplied, also "and" and "or" operators are applicable
"""
def __init__(self, *args):
self.__points = sorted(args[0] if isinstance(args, tuple) and len(args) == 1 else args)
self.left_border = min(self.__points)
self.right_border = max(self.__points)
def __and__(self, other):
ret = MembershipFunction(list(set(self.__points).union(set(other.__points))))
def ret_func(*d, **mp):
return min(float(self(*d, **mp)), float(other(*d, **mp)))
ret.func = ret_func
return ret
def __or__(self, other):
ret = MembershipFunction(list(set(self.__points).union(set(other.__points))))
def ret_func(*d, **mp):
return max(float(self(*d, **mp)), float(other(*d, **mp)))
ret.func = ret_func
return ret
def __mul__(self, other):
ret = MembershipFunction(list(set(self.__points).union(set(other.__points))))
def ret_func(*d, **mp):
return float(self(*d, **mp)) * float(other(*d, **mp))
ret.func = ret_func
return ret
def __call__(self, x):
return self.func(x)
class TriFunc(MembershipFunction):
"""
The triangle membership function.
"""
def __init__(self, *args):
super(TriFunc, self).__init__(*args)
def trifunc(x):
if x < args[0]:
ret = 0.0
elif x <= args[1] != args[0]:
ret = (x - args[0]) / (args[1] - args[0])
elif x <= args[2]:
ret = 1 - (x - args[1]) / (args[2] - args[1])
else:
ret = 0.0
return ret
self.func = trifunc
class TrapecFunc(MembershipFunction):
"""
The triangle membership function.
"""
def __init__(self, *args):
super(TrapecFunc, self).__init__(*args)
def trapfunc(x):
if x < args[0]:
ret = 0.0
elif x <= args[1]:
ret = (x - args[0]) / (args[1] - args[0])
elif x <= args[2]:
ret = 1
elif x <= args[3]:
ret = 1 - (x - args[2]) / (args[3]- args[2])
else:
ret = 0.0
return ret
self.func = trapfunc
class FuzzyTerm:
"""
A fuzzy term like the weather is hot or the speed is slow
"""
def __init__(self, membership, variable):
"""
Create new fuzzy term
:param membership: The membership function to describe the value of the variable as a fuzzy set
:param variable: The variable to describe the linguistic term of
"""
self.membership = membership
self.variable = variable
def __call__(self, optional_x = None):
"""
Compute the level
:return: level
"""
return self.membership(optional_x if optional_x is not None else self.variable.value)
def __and__(self, other):
"""
Combine two terms with "and" condition
:param other: the term to combine with
:return: new membership function
"""
def ret_func(*d, **mp):
return min(float(self.membership(*d, **mp)), float(other.membership(*d, **mp)))
ret_term = FuzzyTerm(ret_func, self.variable)
return ret_term
def __or__(self, other):
"""
Combine two terms with "or" condition
:param other: the term to combine with
:return: new membership function
"""
def ret_func(*d, **mp):
return max(float(self.membership(*d, **mp)), float(other.membership(*d, **mp)))
ret_term = FuzzyTerm(ret_func, self.variable)
return ret_term
class FuzzyRule:
"""
A fuzzy rule that works as a membership function
"""
def __init__(self, antecedents, variable, membership, implication=larsen):
"""
Create new fuzzy rule
:param antecedents: A list of (or just the one) antecedents for the rule. Can be associated with different variables
:param variable: The output variable
:param membership: The membership function that corresponds to the rule
:param implication: The implication function that corresponds to the rule
"""
if isinstance(antecedents, list):
self.antecedents = antecedents
else:
self.antecedents = [antecedents]
variable.low_limit = min(variable.low_limit, membership.left_border)
variable.upp_limit = max(variable.upp_limit, membership.right_border)
self.membership = membership
self.variable = variable
self.implication = implication
def __call__(self, x):
"""
Compute the ruth level for the given x
:param x:
:return:
"""
value_by_rules = min([cur_ant() for cur_ant in self.antecedents])
membership = self.membership(x)
self.variable.value = self.implication(value_by_rules, membership)
return self.variable.value
class FuzzyVariable:
"""
A fuzzy varibale
"""
def __init__(self):
self.value = 0.0
self.low_limit = float("inf")
self.upp_limit = -float("inf")
def is_(self, membership):
"""
Create the fuzzy term associated with the variable
:param membership: The membership functions that describes the term
:return: The created fuzzy term
"""
self.low_limit = min(self.low_limit, membership.left_border)
self.upp_limit = max(self.upp_limit, membership.right_border)
return FuzzyTerm(membership, self)
left_motor_drive = DCMotor(Port.A, positive_direction=Direction.COUNTERCLOCKWISE)
right_motor_drive = DCMotor(Port.B, positive_direction=Direction.CLOCKWISE)
light_sensor = ColorDistanceSensor(Port.C)
# Create the input fuzzy variable
brightness = FuzzyVariable()
# Create output fuzzy variables
left_motor = FuzzyVariable()
right_motor = FuzzyVariable()
# Determine the fuzzy terms
pass
# Create output variables membership functions
pass
# Determine the rules
pass
dt = 10
while True:
pass # implement your code here
wait(dt)
Курс состоит из теоретического материала и заданий:
Оценка устойчивости системы управления Нечеткий логический контроллер
Примерный список вопросов к экзамену (состав и количество вопросов могут быть откорректированы):
Posted on Tue 28 January 2025
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Tue 21 January 2025
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Wed 15 January 2025
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Thu 09 January 2025
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Sun 25 August 2024
In Архив.
tags: архитектура ЭВМ бпм
Архитектура ЭВМ для БПМ, список литературы, ссылки и.т.д.
Read MorePosted on Mon 15 January 2024
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Thu 11 January 2024
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Mon 25 December 2023
In Архив.
tags: объявления мпм бпм мит мим миа мио миз миу
Консультации/проставление зачетов
Read MorePosted on Fri 01 September 2023
In Архив.
tags: архитектура ЭВМ бпм
Архитектура ЭВМ для БПМ, список литературы, ссылки и.т.д.
Read MorePage 1 / 3 »