FilesExpand file tree

 main

/

__init__.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

125 lines (111 loc) · 4.84 KB

 main

/

__init__.c

Copy path

Top

File metadata and controls

• Code
• Blame

125 lines (111 loc) · 4.84 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

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

//

// SPDX-FileCopyrightText: Copyright (c) 2021 Dan Halbert for Adafruit Industries

//

// SPDX-License-Identifier: MIT

#include <stdint.h>

#include "py/obj.h"

#include "py/runtime.h"

#include "shared-bindings/usb_cdc/__init__.h"

#include "shared-bindings/usb_cdc/Serial.h"

//| """USB CDC Serial streams

//|

//| The `usb_cdc` module allows access to USB CDC (serial) communications.

//|

//| On Windows, each `Serial` is visible as a separate COM port. The ports will often

//| be assigned consecutively, `console` first, but this is not always true.

//|

//| On Linux, the ports are typically ``/dev/ttyACM0`` and ``/dev/ttyACM1``.

//| The `console` port will usually be first.

//|

//| On MacOS, the ports are typically ``/dev/cu.usbmodem<something>``. The something

//| varies based on the USB bus and port used. The `console` port will usually be first.

//| """

//|

//| console: Optional[Serial]

//| """The `console` `Serial` object is used for the REPL, and for `sys.stdin` and `sys.stdout`.

//| `console` is ``None`` if disabled.

//|

//| However, note that `sys.stdin` and `sys.stdout` are text-based streams,

//| and the `console` object is a binary stream.

//| You do not normally need to write to `console` unless you want to write binary data.

//| """

//|

//| data: Optional[Serial]

//| """A `Serial` object that can be used to send and receive binary data to and from

//| the host.

//| Note that `data` is *disabled* by default. ``data`` is ``None`` if disabled."""

//|

//|

//| def disable() -> None:

//| """Do not present any USB CDC device to the host.

//| Can be called in ``boot.py``, before USB is connected.

//| Equivalent to ``usb_cdc.enable(console=False, data=False)``."""

//| ...

//|

//|

static mp_obj_t usb_cdc_disable(void) {

if (!common_hal_usb_cdc_disable()) {

mp_raise_RuntimeError(MP_ERROR_TEXT("Cannot change USB devices now"));

}

return mp_const_none;

}

MP_DEFINE_CONST_FUN_OBJ_0(usb_cdc_disable_obj, usb_cdc_disable);

//| def enable(*, console: bool = True, data: bool = False) -> None:

//| """Enable or disable each CDC device. Can be called in ``boot.py``, before USB is connected.

//|

//| :param console bool: Enable or disable the `console` USB serial device.

//| True to enable; False to disable. Enabled by default.

//| :param data bool: Enable or disable the `data` USB serial device.

//| True to enable; False to disable. *Disabled* by default.

//|

//| If you enable too many devices at once, you will run out of USB endpoints.

//| The number of available endpoints varies by microcontroller.

//| CircuitPython will go into safe mode after running boot.py to inform you if

//| not enough endpoints are available.

//| """

//| ...

//|

//|

static mp_obj_t usb_cdc_enable(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {

enum { ARG_console, ARG_data };

static const mp_arg_t allowed_args[] = {

{ MP_QSTR_console, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true } },

{ MP_QSTR_data, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false } },

};

mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];

mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);

if (!common_hal_usb_cdc_enable(args[ARG_console].u_bool, args[ARG_data].u_bool)) {

mp_raise_RuntimeError(MP_ERROR_TEXT("Cannot change USB devices now"));

}

return mp_const_none;

}

MP_DEFINE_CONST_FUN_OBJ_KW(usb_cdc_enable_obj, 0, usb_cdc_enable);

// The usb_cdc module dict is mutable so that .console and .data may

// be set to a Serial or to None depending on whether they are enabled or not.

static mp_map_elem_t usb_cdc_module_globals_table[] = {

{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_usb_cdc) },

{ MP_ROM_QSTR(MP_QSTR_Serial), MP_OBJ_FROM_PTR(&usb_cdc_serial_type) },

{ MP_ROM_QSTR(MP_QSTR_console), mp_const_none },

{ MP_ROM_QSTR(MP_QSTR_data), mp_const_none },

{ MP_ROM_QSTR(MP_QSTR_disable), MP_OBJ_FROM_PTR(&usb_cdc_disable_obj) },

{ MP_ROM_QSTR(MP_QSTR_enable), MP_OBJ_FROM_PTR(&usb_cdc_enable_obj) },

};

static MP_DEFINE_MUTABLE_DICT(usb_cdc_module_globals, usb_cdc_module_globals_table);

const mp_obj_module_t usb_cdc_module = {

.base = { &mp_type_module },

.globals = (mp_obj_dict_t *)&usb_cdc_module_globals,

};

static void set_module_dict_entry(mp_obj_t key_qstr, mp_obj_t serial_obj) {

mp_map_elem_t *elem = mp_map_lookup(&usb_cdc_module_globals.map, key_qstr, MP_MAP_LOOKUP);

if (elem) {

elem->value = serial_obj;

}

}

void usb_cdc_set_console(mp_obj_t serial_obj) {

set_module_dict_entry(MP_ROM_QSTR(MP_QSTR_console), serial_obj);

}

void usb_cdc_set_data(mp_obj_t serial_obj) {

set_module_dict_entry(MP_ROM_QSTR(MP_QSTR_data), serial_obj);

}

MP_REGISTER_MODULE(MP_QSTR_usb_cdc, usb_cdc_module);