FilesExpand file tree

 main

/

Counter.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

159 lines (138 loc) · 6.05 KB

 main

/

Counter.c

Copy path

Top

File metadata and controls

• Code
• Blame

159 lines (138 loc) · 6.05 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

// This file is part of the CircuitPython project: https://circuitpython.org

//

// SPDX-FileCopyrightText: Copyright (c) 2020 by Daniel Pollard

//

// SPDX-License-Identifier: MIT

#include <stdint.h>

#include "shared/runtime/context_manager_helpers.h"

#include "py/objproperty.h"

#include "py/runtime.h"

#include "py/runtime0.h"

#include "shared-bindings/microcontroller/Pin.h"

#include "shared-bindings/countio/Counter.h"

#include "shared-bindings/countio/Edge.h"

#include "shared-bindings/util.h"

//| class Counter:

//| """Count the number of rising- and/or falling-edge transitions on a given pin."""

//|

//| def __init__(

//| self,

//| pin: microcontroller.Pin,

//| *,

//| edge: Edge = Edge.FALL,

//| pull: Optional[digitalio.Pull] = None,

//| ) -> None:

//| """Create a Counter object associated with the given pin that counts

//| rising- and/or falling-edge transitions. At least one of ``rise`` and ``fall`` must be True.

//| The default is to count only falling edges, and is for historical backward compatibility.

//|

//| :param ~microcontroller.Pin pin: pin to monitor

//| :param Edge edge: which edge transitions to count

//| :param Optional[digitalio.Pull] pull: enable a pull-up or pull-down if not None

//|

//|

//| For example::

//|

//| import board

//| import countio

//|

//| # Count rising edges only.

//| pin_counter = countio.Counter(board.D1, edge=countio.Edge.RISE)

//| # Reset the count after 100 counts.

//| while True:

//| if pin_counter.count >= 100:

//| pin_counter.reset()

//| print(pin_counter.count)

//|

//| **Limitations:** On RP2040, `Counter` uses the PWM peripheral, and

//| is limited to using PWM channel B pins due to hardware restrictions.

//| See the pin assignments for your board to see which pins can be used.

//| """

//| ...

//|

static mp_obj_t countio_counter_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {

enum { ARG_pin, ARG_edge, ARG_pull };

static const mp_arg_t allowed_args[] = {

{ MP_QSTR_pin, MP_ARG_REQUIRED | MP_ARG_OBJ },

{ MP_QSTR_edge, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_FROM_PTR(&edge_FALL_obj) } },

{ MP_QSTR_pull, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },

};

mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];

mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);

const mcu_pin_obj_t *pin = validate_obj_is_free_pin(args[ARG_pin].u_obj, MP_QSTR_pin);

const countio_edge_t edge = validate_edge(args[ARG_edge].u_obj, MP_QSTR_edge);

const digitalio_pull_t pull = validate_pull(args[ARG_pull].u_obj, MP_QSTR_pull);

countio_counter_obj_t *self = mp_obj_malloc_with_finaliser(countio_counter_obj_t, &countio_counter_type);

common_hal_countio_counter_construct(self, pin, edge, pull);

return MP_OBJ_FROM_PTR(self);

}

//| def deinit(self) -> None:

//| """Deinitializes the Counter and releases any hardware resources for reuse."""

//|

static mp_obj_t countio_counter_deinit(mp_obj_t self_in) {

countio_counter_obj_t *self = MP_OBJ_TO_PTR(self_in);

common_hal_countio_counter_deinit(self);

return mp_const_none;

}

static MP_DEFINE_CONST_FUN_OBJ_1(countio_counter_deinit_obj, countio_counter_deinit);

static void check_for_deinit(countio_counter_obj_t *self) {

if (common_hal_countio_counter_deinited(self)) {

raise_deinited_error();

}

}

//| def __enter__(self) -> Counter:

//| """No-op used by Context Managers."""

//|

// Provided by context manager helper.

//| def __exit__(self) -> None:

//| """Automatically deinitializes the hardware when exiting a context. See

//| :ref:`lifetime-and-contextmanagers` for more info."""

//|

// Provided by context manager helper.

//| count: int

//| """The current count in terms of pulses."""

//|

static mp_obj_t countio_counter_obj_get_count(mp_obj_t self_in) {

countio_counter_obj_t *self = MP_OBJ_TO_PTR(self_in);

check_for_deinit(self);

return mp_obj_new_int(common_hal_countio_counter_get_count(self));

}

MP_DEFINE_CONST_FUN_OBJ_1(countio_counter_get_count_obj, countio_counter_obj_get_count);

static mp_obj_t countio_counter_obj_set_count(mp_obj_t self_in, mp_obj_t new_count) {

countio_counter_obj_t *self = MP_OBJ_TO_PTR(self_in);

check_for_deinit(self);

common_hal_countio_counter_set_count(self, mp_obj_get_int(new_count));

return mp_const_none;

}

MP_DEFINE_CONST_FUN_OBJ_2(countio_counter_set_count_obj, countio_counter_obj_set_count);

MP_PROPERTY_GETSET(countio_counter_count_obj,

(mp_obj_t)&countio_counter_get_count_obj,

(mp_obj_t)&countio_counter_set_count_obj);

//| def reset(self) -> None:

//| """Resets the count back to 0."""

//|

//|

static mp_obj_t countio_counter_reset(mp_obj_t self_in) {

countio_counter_obj_t *self = MP_OBJ_TO_PTR(self_in);

check_for_deinit(self);

common_hal_countio_counter_set_count(self, 0);

return mp_const_none;

}

MP_DEFINE_CONST_FUN_OBJ_1(countio_counter_reset_obj, countio_counter_reset);

static const mp_rom_map_elem_t countio_counter_locals_dict_table[] = {

// Methods

{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&countio_counter_deinit_obj) },

{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&countio_counter_deinit_obj) },

{ MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },

{ MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&default___exit___obj) },

{ MP_ROM_QSTR(MP_QSTR_count), MP_ROM_PTR(&countio_counter_count_obj) },

{ MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&countio_counter_reset_obj) },

};

static MP_DEFINE_CONST_DICT(countio_counter_locals_dict, countio_counter_locals_dict_table);

MP_DEFINE_CONST_OBJ_TYPE(

countio_counter_type,

MP_QSTR_Counter,

MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS,

make_new, countio_counter_make_new,

locals_dict, &countio_counter_locals_dict

);