5.4. PikaStdTask multitasking

The PikaStdTask multitasking library provides asynchronous multitasking capabilities of Task (task loop).

5.4.1. Install

Add the dependency of PikaStdLib to requestment.txt. The version number of PikaStdLib should be the same as the version number of the kernel.

  1. PikaStdLib==v1.10.0

Run pikaPackage.exe

5.4.2. class Task():

The Task class provides the task loop function, and a task loop can be created by creating an object of the Task class.

5.4.2.1. Methods of the Task class

  1. import PikaStdData
  4. class Task:
  5.     calls = PikaStdData.List()
  7.     def __init__(self):
  8.         pass
  10.     # regist a function to be called always
  11.     def call_always(self, fun_todo: any):
  12.         pass
  14.     # regist a function to be called when fun_when() return 'True'
  15.     def call_when(self, fun_todo: any, fun_when: any):
  16.         pass
  18.     # register a function to be called periodically
  19.     def call_period_ms(self, fun_todo: any, period_ms: int):
  20.         pass
  22.     # run all registered function once
  23.     def run_once(self):
  24.         pass
  26.     # run all registered function forever
  27.     def run_forever(self):
  28.         pass
  30.     # run all registered function until time is up
  31.     def run_until_ms(self, until_ms: int):
  32.         pass
  34.     # need be overried to supply the system tick
  35.     def platformGetTick(self):
  36.         pass

5.4.2.2. Instructions:

Use the call_xxx() method to specify the calling method, and register the function to be executed in the task object.

Use the run_xxx() methods to specify how the task loops and execute all functions in the task object.

Time-related functions, such as call_period_ms() and run_until_ms(), need to provide the system clock by creating a new class that inherits from PikaStdTask, and then override the platformGetTick() method.

5.4.2.3. Notice:

All registered functions should be non-blocking, otherwise the entire task loop will be blocked.

The task loop is not real-time.

5.4.2.4. Example:

Create a new class that inherits from PikaStdTask.

  1. # STM32G0.py
  2. class Task(PikaStdTask.Task):
  3.     # override
  4.     def platformGetTick():
  5.         pass

Override the platformGetTick() method.

  1. /* STM32G0_Task.c */
  3. void STM32G0_Task_platformGetTick(PikaObj* self) {
  4.     obj_setInt(self, "tick", HAL_GetTick());
  5. }

Python use cases

  1. import STM32G0
  2. import PikaPiZero
  3. import PikaStdLib
  5. pin = STM32G0.GPIO()
  6. rgb = PikaPiZero.RGB()
  7. mem = PikaStdLib.MemChecker()
  9. pin.setPin('PA8')
  10. pin.setMode('out')
  11. pin.enalbe()
  13. rgb.init()
  14. rgb.enable()
  16. print('task demo')
  17. print('mem used max:')
  18. mem.max()
  21. def rgb_task():
  22.     rgb.flow()
  25. def led_task():
  26.     if pin.read():
  27.         pin.low()
  28.     else:
  29.         pin.high()
  32. task = STM32G0.Task()
  34. task.call_period_ms(rgb_task, 50)
  35. task.call_period_ms(led_task, 500)
  37. task.run_forever()