Tengo un diagrama de flujo que tiene componentes como una máquina de estado. No puedo decodificar cómo comenzar a escribir esto en Python. El TMS es una lista de entrada como [1,1,1,1,1,0,1,1,0]

enter image description here

Comencé escribiendo un código, pero me quedo atascado en pensar más.

TMS = [1,1,1,1,1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0]

next_step = False
def test_logic_reset():
  if tms == 1:
    print("reset")
  elif tms == 0:
    run_test_idle()

for i in TMS:
  tms = i
  print(tms)
  test_logic_reset()

¿Alguien puede ayudarme a comprender el paradigma que debo utilizar?

1
Rohit Kumar Singh 27 feb. 2021 a las 08:19

2 respuestas

La mejor respuesta

Esto parece propicio para la implementación de una máquina de estados. Puede implementar esto desde cero o puede usar una biblioteca de Python como pytransitions. Esta biblioteca tiene muchas características, como llamar a un método antes o después de una transición, ejecutar una transición solo si se cumple una condición, manejar errores para estados / transiciones no válidas, etc. Una solución básica se vería así:

from transitions import Machine

class StateMachine:

    states = ['test_logic_reset', 'run_test_idle', 'another_state']

    def __init__(self):
        self.machine = Machine(model=self, states=StateMachine.states, initial='test_logic_reset')

        # you can also use named arguments: trigger, source, dest
        self.machine.add_transition('input_0', 'test_logic_reset', 'run_test_idle')
        self.machine.add_transition('input_1', 'test_logic_reset', '=')
        self.machine.add_transition('input_0', 'run_test_idle', '=')
        self.machine.add_transition('input_1', 'run_test_idle', 'another_state')

    def trigger(value):
        if value == 0:
            self.input_0()
        elif value == 1:
            self.input_1()
        else:
            raise NotImplementedError

Entonces puedes llamarlo así:

TMS = [1,1,1,1,1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0]
sm = StateMachine()

for i in TMS:
  sm.trigger(i)
1
DV82XL 27 feb. 2021 a las 06:21

Esto puede ayudarlo en el camino correcto. Según la parte del diagrama que es visible, podría ser mejor modelar la máquina de estados finitos con una clase, donde la clave requerida para que la máquina alcance el siguiente estado está determinada por el estado actual.

class FSM:
    TEST_LOGIC_REST = 'TEST_LOGIC_REST'
    RUN_TEST_IDLE = 'RUN_TEST_IDLE'
    FINAL_STATE = 'FINAL_STATE'

    states = {
        TEST_LOGIC_REST: (0, RUN_TEST_IDLE),
        RUN_TEST_IDLE: (1, FINAL_STATE),
        FINAL_STATE: (None, None)
    }

    def __init__(self):
        self.state = FSM.TEST_LOGIC_REST
     

    def input(self, n):
        keyValue, nextState = FSM.states[self.state]
        if keyValue == n:
            self.state = nextState


    def __str__(self):
        return f'FSM(state={self.state})'


if __name__ == '__main__':
    TMS = [1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0]
    fsm = FSM()

    for i in TMS:
        fsm.input(i)
        print(f'input: {i},', fsm)
1
greenBox 27 feb. 2021 a las 06:00