Branch data     Line data    Source code

       1                 :            : // Include MicroPython API.
       2                 :            : #include "py/runtime.h"
       3                 :            : 
       4                 :            : // Used to get the time in the Timer class example.
       5                 :            : #include "py/mphal.h"
       6                 :            : 
       7                 :            : // This is the function which will be called from Python as cexample.add_ints(a, b).
       8                 :          2 : STATIC mp_obj_t example_add_ints(mp_obj_t a_obj, mp_obj_t b_obj) {
       9                 :            :     // Extract the ints from the micropython input objects.
      10                 :          2 :     int a = mp_obj_get_int(a_obj);
      11                 :          2 :     int b = mp_obj_get_int(b_obj);
      12                 :            : 
      13                 :            :     // Calculate the addition and convert to MicroPython object.
      14                 :          2 :     return mp_obj_new_int(a + b);
      15                 :            : }
      16                 :            : // Define a Python reference to the function above.
      17                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_2(example_add_ints_obj, example_add_ints);
      18                 :            : 
      19                 :            : // This structure represents Timer instance objects.
      20                 :            : typedef struct _example_Timer_obj_t {
      21                 :            :     // All objects start with the base.
      22                 :            :     mp_obj_base_t base;
      23                 :            :     // Everything below can be thought of as instance attributes, but they
      24                 :            :     // cannot be accessed by MicroPython code directly. In this example we
      25                 :            :     // store the time at which the object was created.
      26                 :            :     mp_uint_t start_time;
      27                 :            : } example_Timer_obj_t;
      28                 :            : 
      29                 :            : // This is the Timer.time() method. After creating a Timer object, this
      30                 :            : // can be called to get the time elapsed since creating the Timer.
      31                 :          4 : STATIC mp_obj_t example_Timer_time(mp_obj_t self_in) {
      32                 :            :     // The first argument is self. It is cast to the *example_Timer_obj_t
      33                 :            :     // type so we can read its attributes.
      34                 :          4 :     example_Timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
      35                 :            : 
      36                 :            :     // Get the elapsed time and return it as a MicroPython integer.
      37                 :          4 :     mp_uint_t elapsed = mp_hal_ticks_ms() - self->start_time;
      38                 :          4 :     return mp_obj_new_int_from_uint(elapsed);
      39                 :            : }
      40                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_1(example_Timer_time_obj, example_Timer_time);
      41                 :            : 
      42                 :            : // This represents Timer.__new__ and Timer.__init__, which is called when
      43                 :            : // the user instantiates a Timer object.
      44                 :          2 : STATIC mp_obj_t example_Timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
      45                 :            :     // Allocates the new object and sets the type.
      46                 :          2 :     example_Timer_obj_t *self = mp_obj_malloc(example_Timer_obj_t, type);
      47                 :            : 
      48                 :            :     // Initializes the time for this Timer instance.
      49                 :          2 :     self->start_time = mp_hal_ticks_ms();
      50                 :            : 
      51                 :            :     // The make_new function always returns self.
      52                 :          2 :     return MP_OBJ_FROM_PTR(self);
      53                 :            : }
      54                 :            : 
      55                 :            : // This collects all methods and other static class attributes of the Timer.
      56                 :            : // The table structure is similar to the module table, as detailed below.
      57                 :            : STATIC const mp_rom_map_elem_t example_Timer_locals_dict_table[] = {
      58                 :            :     { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&example_Timer_time_obj) },
      59                 :            : };
      60                 :            : STATIC MP_DEFINE_CONST_DICT(example_Timer_locals_dict, example_Timer_locals_dict_table);
      61                 :            : 
      62                 :            : // This defines the type(Timer) object.
      63                 :            : MP_DEFINE_CONST_OBJ_TYPE(
      64                 :            :     example_type_Timer,
      65                 :            :     MP_QSTR_Timer,
      66                 :            :     MP_TYPE_FLAG_NONE,
      67                 :            :     make_new, example_Timer_make_new,
      68                 :            :     locals_dict, &example_Timer_locals_dict
      69                 :            :     );
      70                 :            : 
      71                 :            : // Define all attributes of the module.
      72                 :            : // Table entries are key/value pairs of the attribute name (a string)
      73                 :            : // and the MicroPython object reference.
      74                 :            : // All identifiers and strings are written as MP_QSTR_xxx and will be
      75                 :            : // optimized to word-sized integers by the build system (interned strings).
      76                 :            : STATIC const mp_rom_map_elem_t example_module_globals_table[] = {
      77                 :            :     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_cexample) },
      78                 :            :     { MP_ROM_QSTR(MP_QSTR_add_ints), MP_ROM_PTR(&example_add_ints_obj) },
      79                 :            :     { MP_ROM_QSTR(MP_QSTR_Timer),    MP_ROM_PTR(&example_type_Timer) },
      80                 :            : };
      81                 :            : STATIC MP_DEFINE_CONST_DICT(example_module_globals, example_module_globals_table);
      82                 :            : 
      83                 :            : // Define module object.
      84                 :            : const mp_obj_module_t example_user_cmodule = {
      85                 :            :     .base = { &mp_type_module },
      86                 :            :     .globals = (mp_obj_dict_t *)&example_module_globals,
      87                 :            : };
      88                 :            : 
      89                 :            : // Register the module to make it available in Python.
      90                 :            : MP_REGISTER_MODULE(MP_QSTR_cexample, example_user_cmodule);