20. PikaStdTask multitasking

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

20.1. Install

  1. 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.6.1
  1. Run pikaPackage.exe

20.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.

20.2.1. Methods of the Task class

  1. from PikaObj import *
  2. import PikaStdData
  5. class Task(TinyObj):
  6.     calls = PikaStdData.List()
  8.     def __init__(self):
  9.         pass
  11.     # regist a function to be called always
  12.     def call_always(self, fun_todo: any):
  13.         pass
  15.     # regist a function to be called when fun_when() return 'True'
  16.     def call_when(self, fun_todo: any, fun_when: any):
  17.         pass
  19.     # register a function to be called periodically
  20.     def call_period_ms(self, fun_todo: any, period_ms: int):
  21.         pass
  23.     # run all registered function once
  24.     def run_once(self):
  25.         pass
  27.     # run all registered function forever
  28.     def run_forever(self):
  29.         pass
  31.     # run all registered function until time is up
  32.     def run_until_ms(self, until_ms: int):
  33.         pass
  35.     # need be overried to supply the system tick
  36.     def platformGetTick(self):
  37.         pass

20.2.2. Instructions:

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

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

  3. 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.

20.2.3. Notice:

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

  2. The task loop is not real-time.

20.2.4. Example:

  1. Create a new class that inherits from PikaStdTask.
  1. # STM32G0.py
  2. class Task(PikaStdTask.Task):
  3.     # override
  4.     def platformGetTick():
  5.         pass
  1. Override the platformGetTick() method.
  1. /* STM32G0_Task.c */
  3. void STM32G0_Task_platformGetTick(PikaObj* self) {
  4.     obj_setInt(self, "tick", HAL_GetTick());
  5. }
  1. 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()