Alexander Sayapin Teacher's site

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.dc(0)
right_motor.dc(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)  # останавливаем правый мотор

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)