Test refactored

.vscode/settings.json

@@ -79,5 +79,8 @@
     "cinttypes": "cpp",
     "typeinfo": "cpp",
     "variant": "cpp"
-  }
+  },
+  "python.analysis.extraPaths": [
+    "./Tests/VirtualMCU/src"
+  ]
 }

Tests/PCU.py

@@ -4,49 +4,45 @@
 from vmcu.pin.pinout import Pinout
 from vmcu.services.DualPWM import DualPWM
 from vmcu.services.communications.Packets import Packets
-from enum import Enum
-import enum
+from enum import IntEnum
 
 
 class PCU:
-    class StateMachine(Enum):
+    class StateMachine(IntEnum):
         GENERAL = 1
         OPERATIONAL = 2
 
-    class General_SM(Enum):
+    class General_SM(IntEnum):
         CONNECTING = 0
         OPERATIONAL = 1
         FAULT = 2
 
-    class Operational_SM(Enum):
+    class Operational_SM(IntEnum):
         IDLE = 0
         PWM = 1
 
-    class PWM(Enum):
+    class PWM(IntEnum):
         U = 0
         V = 1
         W = 2
 
     def __init__(self):
         self._shm = SharedMemory("gpio_PCU", "state_machine_PCU")
-        self._client = Socket("192.168.0.9", 50400, "192.168.0.5", 50500)
+        self._client = Socket("localhost", 50400, "localhost", 50500)
         packet_definitions = {
             500: [],  # enable_buffer
             501: [],  # disable_buffer
-            502: [enum("NONE", "U", "V", "W"), "uint32", "float32"],  # send_pwm
+            502: ["enum(NONE,U,V,W)", "uint32", "float32"],  # send_pwm
             503: [],  # stop_pwm
         }
         self.packets = Packets(packet_definitions)
-        self._enable = DigitalOutService(self.shm, Pinout.PF4)
-        self._pwmU = DualPWM(Pinout.PE9, Pinout.PE8)
-        self._pwmV = DualPWM(Pinout.PE11, Pinout.PE10)
-        self._pwmW = DualPWM(Pinout.PE13, Pinout.PE12)
+        self._enable = DigitalOutService(self._shm, Pinout.PF4)
         self._pwms = {
-            PCU.PWM.U: self._pwmU,
-            PCU.PWM.V: self._pwmV,
-            PCU.PWM.W: self._pwmW,
+            PCU.PWM.U: DualPWM(Pinout.PE9, Pinout.PE8, self._shm),
+            PCU.PWM.V: DualPWM(Pinout.PE11, Pinout.PE10, self._shm),
+            PCU.PWM.W: DualPWM(Pinout.PE13, Pinout.PE12, self._shm),
         }
-        self._mcu = None
+        print("PCU initialized succesfully")
 
     def connect_gui(self):
         self._client.connect()
@@ -55,7 +51,20 @@ def disconnect_gui(self):
         self._client.stop()
 
     def is_state(self, state_machine: StateMachine, state: int) -> bool:
-        self._shm.get_state_machine_state(state_machine) == state
+        # print("State machine where are checking: ", state_machine)
+        # print("MCU state: ", self._shm.get_state_machine_state(state_machine))
+        # print("State it should be: ", state)
+        # print("There are ", self._shm.get_state_machine_count(), "state machines")
+        current_state = self._shm.get_state_machine_state(state_machine)
+        if current_state < 0:
+            print(
+                "You are trying to get the state machine number",
+                state_machine,
+                "but there are",
+                self._shm.get_state_machine_count(),
+                "state machines in the PCU",
+            )
+        return current_state == state
 
     def check_pwm(self, pwm: PWM, freq: int, duty: float):
         selected_pwm = self._pwms[pwm]
@@ -66,7 +75,11 @@ def check_pwm(self, pwm: PWM, freq: int, duty: float):
         )
 
     def transmit(self, packet):
-        self._server.transmit(packet, self._mcu)
+        self._client.transmit(packet)
 
     def get_enable(self) -> bool:
-        return not self._enable.get_pin_state
+        return not self._enable.get_pin_state()
+
+    def __del__(self):
+        self._client.stop()
+

Tests/test.py

@@ -1,96 +1,119 @@
-import enum
-import sys, os
-
-from Tests import PCU
+from PCU import PCU
 from runner import runner
 from vmcu.assertions import *
 
-sys.path.append(os.path.join(os.path.dirname(__file__), "VirtualMCU", "src"))
-
 
 @runner.test()
 def PCU_test():
     pcu = PCU()
 
-    check(pcu.is_state(PCU.StateMachine.GENERAL, PCU.General_SM.CONNECTING))
+    check(
+        pcu.is_state,
+        args=(PCU.StateMachine.GENERAL, PCU.General_SM.CONNECTING),
+        msg="PCU should be in CONNECTNG state!",
+    )
 
     # Now PCU is on Connecting state
 
     pcu.connect_gui()
     completes(
-        wait_until_true(
-            pcu.is_state(PCU.StateMachine.GENERAL, PCU.General_SM.OPERATIONAL)
-        ),
+        wait_until_true(pcu.is_state),
+        args=(PCU.StateMachine.GENERAL, PCU.General_SM.OPERATIONAL),
         before=seconds(1),
+        msg="PCU should be in OPERATIONAL state!",
     )
 
     # Now PCU is on Operational state
 
-    check(pcu.is_state(PCU.StateMachine.OPERATIONAL, PCU.Operational_SM.IDLE))
+    check(
+        pcu.is_state,
+        args=(PCU.StateMachine.OPERATIONAL, PCU.Operational_SM.IDLE),
+        msg="PCU should be in OPERATIONAL-IDLE state!",
+    )
 
     # Now PCU is on Operational - Idle state
 
     enable_order = pcu.packets.serialize_packet(500)
     pcu.transmit(enable_order)
 
     completes(
-        wait_until_true(pcu.get_enable()),
+        wait_until_true(pcu.get_enable),
         before=seconds(1),
+        msg="PCU enable should be enabled",
     )
 
     disable_order = pcu.packets.serialize_packet(501)
     pcu.transmit(disable_order)
 
     completes(
-        wait_until_true(not pcu.get_enable()),
+        wait_until_true(lambda: not pcu.get_enable()),
         before=seconds(1),
+        msg="PCU enable should be disabled",
     )
 
     send_pwm_U_order = pcu.packets.serialize_packet(502, "U", 1000, 90)
     pcu.transmit(send_pwm_U_order)
 
     completes(
-        wait_until_true(pcu.check_pwm(PCU.PWM.U, 1000, 90)),
+        wait_until_true(pcu.check_pwm),
         before=seconds(1),
+        args=(PCU.PWM.U, 1000, 90),
+        msg="PWM U is not at 1KHz and 90%% duty",
     )
 
-    check(pcu.is_state(PCU.StateMachine.OPERATIONAL, PCU.Operational_SM.PWM))
+    check(
+        pcu.is_state,
+        args=(PCU.StateMachine.OPERATIONAL, PCU.Operational_SM.PWM),
+        msg="PCU should be in OPERATIONAL-PWM state!",
+    )
 
     # Now PCU is on Operational - PWM state
 
     send_pwm_V_order = pcu.packets.serialize_packet(502, "V", 2000, 80)
     pcu.transmit(send_pwm_V_order)
 
     completes(
-        wait_until_true(pcu.check_pwm(PCU.PWM.V, 2000, 80)),
+        wait_until_true(pcu.check_pwm),
+        args=(PCU.PWM.V, 2000, 80),
         before=seconds(1),
+        msg="PWM V is not at 2KHz and 80%% duty",
     )
 
     send_pwm_W_order = pcu.packets.serialize_packet(502, "W", 3000, 70)
     pcu.transmit(send_pwm_W_order)
 
     completes(
-        wait_until_true(pcu.check_pwm(PCU.PWM.W, 3000, 70)),
+        wait_until_true(pcu.check_pwm),
+        args=(PCU.PWM.W, 3000, 70),
         before=seconds(1),
+        msg="PWM W is not at 3KHz and 70%% duty",
     )
 
-    stop_pwm_order = pcu.packets.serialize_packet(504)
+    stop_pwm_order = pcu.packets.serialize_packet(503)
     pcu.transmit(stop_pwm_order)
 
-    check(pcu.is_state(PCU.StateMachine.OPERATIONAL, PCU.Operational_SM.IDLE))
+    check(
+        pcu.is_state,
+        args=(PCU.StateMachine.OPERATIONAL, PCU.Operational_SM.IDLE),
+        msg="PCU should be in OPERATIONAL-IDLE state!",
+    )
 
     # TODO check pwms are powered off
 
     # Now PCU is on Operational - Idle state
 
     pcu.disconnect_gui()
 
-    check(pcu.is_state(PCU.StateMachine.GENERAL, PCU.General_SM.FAULT))
+    check(
+        pcu.is_state,
+        args=(PCU.StateMachine.GENERAL, PCU.General_SM.FAULT),
+        msg="PCU should be in FAULT state!",
+    )
 
     # Now PCU is on FAULT state
 
-    check(not pcu.get_enable())
-    # TODO check PWMs are off
+    check(lambda: not pcu.get_enable(), msg="PCU enable should be disabled")
+    # # TODO check PWMs are off
 
 
 runner.run()  # Runs the tests, do not delete!