File: PKG-INFO

package info (click to toggle)
pyocd 0.13.1+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 2,112 kB
  • sloc: python: 19,899; xml: 182; ansic: 112; makefile: 65; sh: 47
file content (221 lines) | stat: -rw-r--r-- 9,353 bytes parent folder | download | duplicates (2)
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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
Metadata-Version: 2.1
Name: pyocd
Version: 0.13.1
Summary: Cortex-M debugger for Python
Home-page: https://github.com/mbedmicro/pyOCD
Author: Chris Reed, Martin Kojtal, Russ Butler
Author-email: chris.reed@arm.com, martin.kojtal@arm.com, russ.butler@arm.com
License: Apache 2.0
Description: pyOCD
        =====
        
        pyOCD is an open source Python package for programming and debugging Arm Cortex-M microcontrollers
        using multiple supported types of USB debug probes. It is fully cross-platform, with support for
        Linux, macOS, and Windows.
        
        Several command line tools are provided that cover most use cases, or you can make use of the Python
        API to enable low-level target control. A common use for the Python API is to run and control CI
        tests.
        
        Three tools give you total control over your device:
        
        - `pyocd-gdbserver`: GDB remote server allows you to debug using gdb via either
            [GNU MCU Eclipse plug-in](https://gnu-mcu-eclipse.github.io/) or the console.
        - `pyocd-flashtool`: Program and erase an MCU's flash memory.
        - `pyocd-tool`: Interactive REPL control and inspection of the MCU.
        
        The API and tools provide these features:
        
        -  halt, step, resume control
        -  read/write memory
        -  read/write core registers
        -  set/remove hardware and software breakpoints
        -  set/remove watchpoints
        -  write to flash memory
        -  load binary, hex, or ELF files into flash
        -  reset control
        -  access CoreSight DP and APs
        -  and more!
        
        
        Requirements
        ------------
        
        - Python 2.7.9 or later, or Python 3.6.0 or later
        - macOS, Linux, or Windows 7 or newer
        - Microcontroller with an Arm Cortex-M CPU
        - Supported debug probe
          - [CMSIS-DAP](http://www.keil.com/pack/doc/CMSIS/DAP/html/index.html), such as an on-board debug
            probe using [DAPLink](https://os.mbed.com/handbook/DAPLink) firmware.
          - STLinkV2, either on-board or the standalone version.
        
        
        Status
        ------
        
        PyOCD is functionally reliable and fully useable.
        
        The API is considered unstable because we are planning some breaking changes to bring the naming
        convention into compliance with PEP8 prior to releasing version 1.0. We also plan to merge the three
        command line tools into a single tool.
        
        
        Documentation
        -------------
        
        The pyOCD documentation is located [in the docs directory](docs/).
        
        
        Installing
        ----------
        
        The latest stable version of pyOCD may be installed via [pip](https://pip.pypa.io/en/stable/index.html)
        as follows:
        
        ```
        $ pip install -U pyocd
        ```
        
        The latest pyOCD package is available [on PyPI](https://pypi.python.org/pypi/pyOCD/) as well as
        [on GitHub](https://github.com/mbedmicro/pyOCD/releases).
        
        To install the latest prerelease version from the HEAD of the master branch, you can do
        the following:
        
        ```
        $ pip install --pre -U https://github.com/mbedmicro/pyOCD/archive/master.zip
        ```
        
        You can also install directly from the source by cloning the git repository and running:
        
        ```
        $ python setup.py install
        ```
        
        Note that, depending on your operating system, you may run into permissions issues running these commands.
        You have a few options here:
        
        1. Under Linux, run with `sudo -H` to install pyOCD and dependencies globally. (Installing with sudo
           should never be required for macOS.)
        2. Specify the `--user` option to install local to your user.
        3. Run the command in a [virtualenv](https://virtualenv.pypa.io/en/latest/)
           local to a specific project working set.
        
        ### libusb installation
        
        [pyusb](https://github.com/pyusb/pyusb) and its backend library [libusb](https://libusb.info/) are
        dependencies on all supported operating systems. pyusb is a regular Python package and will be
        installed along with pyOCD. However, libusb is binary shared library that does not get installed
        automatically via pip dependency management.
        
        How to install libusb depends on your OS:
        
        - macOS: use Homebrew: `brew install libusb`
        - Linux: should already be installed.
        - Windows: download libusb from [libusb.info](https://libusb.info/) and place the DLL in your Python
          installation folder next to python.exe.
        
        ### udev rules on Linux
        
        If you encounter an issue on Linux where `pyocd-tool list` won't detect attached boards without
        sudo, the reason is most likely USB device access permissions. In Ubuntu 16.04+ these are handled
        with udev and can be solved by adding a new udev rule.
        
        An example udev rule file is included in the [udev](https://github.com/mbedmicro/pyOCD/tree/master/udev)
        folder in the pyOCD repository. Just copy this file into `etc/udev/rules.d` to enable user access
        to both [DAPLink](https://os.mbed.com/handbook/DAPLink)-based debug probes as well as STLinkV2 and
        STLinkV3.
        
        If you use different, but compatible, debug probe, you can check the IDs with ``dmesg`` command.
        
           -  Run ``dmesg``
           -  Plug in your board
           -  Run ``dmesg`` again and check what was added
           -  Look for line similar to ``usb 2-2.1: New USB device found, idVendor=0d28, idProduct=0204``
        
        
        Standalone GDB server
        ---------------------
        
        When you install pyOCD via pip or setup.py, you will be able to execute the following in order to
        start a GDB server powered by pyOCD:
        
        ```
        $ pyocd-gdbserver
        ```
        
        You can get additional help by running ``pyocd-gdbserver --help``.
        
        Example command line GDB session showing how to connect to a running `pyocd-gdbserver` and load
        firmware:
        
        ```
        $ arm-none-eabi-gdb application.elf
        
        <gdb> target remote localhost:3333
        <gdb> load
        <gdb> monitor reset
        ```
        
        The `pyocd-gdbserver` executable is also usable as a drop in place replacement for OpenOCD in
        existing setups. The primary difference is the set of gdb monitor commands.
        
        
        Recommended GDB and IDE setup
        -----------------------------
        
        The GDB server works well with [Eclipse](https://www.eclipse.org/) and the [GNU MCU Eclipse
        plug-ins](https://gnu-mcu-eclipse.github.io/). GNU MCU Eclipse fully supports pyOCD with an included
        pyOCD debugging plugin.
        
        To view peripheral register values either the built-in GNU MCU Eclipse register view can be used, or
        the Embedded System Register Viewer plugin can be installed. These can be installed from inside
        Eclipse using the following software update server addresses:
        
        - GNU MCU Eclipse: http://gnu-mcu-eclipse.sourceforge.net/updates
        - Embedded System Register Viewer: http://embsysregview.sourceforge.net/update
        
        In Eclipse, select the "Help -> Install New Software…" menu item. Then either click the "Add…"
        button and fill in the name and URL from above (once for each site), or simply copy the URL into the
        field where it says "type or select a site". Then you can select the software to install and click
        Next to start the process.
        
        
        Development setup
        -----------------
        
        Please see the [Developers' Guide](docs/DEVELOPERS_GUIDE.md) for instructions on how to set up a
        development environment for pyOCD.
        
        
        Contributions
        -------------
        
        We welcome contributions to pyOCD in any area. Please see the [contribution
        guidelines](CONTRIBUTING.md) for details.
        
        To report bugs, please [create an issue](https://github.com/mbedmicro/pyOCD/issues/new) in the
        GitHub project.
        
        
        License
        -------
        
        PyOCD is licensed with Apache 2.0. See the [LICENSE](LICENSE) file for the full text of the license.
        
        Copyright © 2006-2018 Arm Ltd
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Software Development :: Debuggers
Classifier: Topic :: Software Development :: Embedded Systems
Requires-Python: >=2.7.9, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Description-Content-Type: text/markdown
Provides-Extra: dissassembler