| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
When trying to execute a command via raw REPL and expected "OK" reply
not received, show what was received instead.
|
|
When working with a "virtual" port, like PTY. The issue described in
http://stackoverflow.com/questions/34831131/pyserial-does-not-play-well-with-virtual-port
|
|
Without this, Zephyr's port "make test" doesn't work.
|
|
This allows to execute a command and communicate with its stdin/stdout
via pipes ("exec") or with command-created pseudo-terminal ("execpty"),
to emulate serial access. Immediate usecase is controlling a QEMU process
which emulates board's serial via normal console, but it could be used
e.g. with helper binaries to access real board over other hadware
protocols, etc.
An example of device specification for these cases is:
--device exec:../zephyr/qemu.sh
--device execpty:../zephyr/qemu2.sh
Where qemu.sh contains long-long qemu startup line, or calls another
command. There's a special support in this patch for running the command
in a new terminal session, to support shell wrappers like that (without
new terminal session, only wrapper script would be terminated, but its
child processes would continue to run).
|
|
Some "device" implementations may be sensitive to this.
|
|
Previous to this patch pyboard.py would open a new serial connection to
the target for each script that was run, and for any command that was run.
Apart from being inefficient, this meant that the board was soft-reset
between scripts/commands, which precludes scripts from accessing variables
set in a previous one.
This patch changes the behaviour of pyboard.py so that the connection to
the target is created only once, and it's not reset between scripts or any
command that is sent with the -c option.
|
|
|
|
Also prints a nicer error message if the serial connection could not be
established.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
The adapter class "TelnetToSerial" is used to access the Telnet
connection using the same API as with the serial connection. The
function pyboard.run-test() has been removed to made the module
generic and because this small test is no longer needed.
|
|
|
|
When looking for chars to indicate raw repl is active, look for the full
string of chars to improve reliability of entering raw repl correctly.
Previous to this patch there was the possibility that raw repl was
entered in a dirty state, where not all input chars from previous
invocation were drained.
|
|
|
|
In raw REPL ">" indicates the prompt. We originally read this character
upon entering the raw REPL, and after reading the last bit of the
output. This patch changes the logic so the ">" is read only just
before trying to send the next command. To make this work (and as an
added feature) the input buffer is now flushed upon entering raw REPL.
The main reason for this change is so that pyboard.py recognises the EOF
when sys.exit() is called on the pyboard. Ie, if you run pyboard.py
with a script that calls sys.exit(), then pyboard.py will exit after
the sys.exit() is called.
|
|
This allows pyboard.py to be used over a UART interface
rather than just over a USB serial interface.
|
|
|
|
Also flush stdout so you can see output as it comes.
|
|
Addresses issue #1190.
|
|
This speeds up writes significantly.
|
|
This makes pyboard.py much more useful for long running scripts. When
running a script via pyboard.py, it now waits until the script finishes,
with no timeout. CTRL-C can be used to break out of the waiting if
needed.
|
|
Improvements are:
2 ctrl-C's are now needed to truly kill running script on pyboard, so
make CDC interface allow multiple ctrl-C's through at once (ie sending
b'\x03\x03' to pyboard now counts as 2 ctrl-C's).
ctrl-C in friendly-repl can now stop multi-line input.
In raw-repl mode, use ctrl-D to indicate end of running script, and also
end of any error message. Thus, output of raw-repl is always at least 2
ctrl-D's and it's much easier to parse.
pyboard.py is now a bit faster, handles exceptions from pyboard better
(prints them and exits with exit code 1), prints out the pyboard output
while the script is running (instead of waiting till the end), and
allows to follow the output of a previous script when run with no
arguments.
|
|
|
|
--pyboard
|
|
You can run a local script on the pyboard using:
python pyboard.py test.py
where test.py is the local script you want to run.
|
|
Make pyboard.enter_raw_repl more robust
|
|
|
|
In case there's a program in the microcontroller's main.py running in an infinite loop
|
|
|
|
|
|
|
|
|
|
|
|
Using pyboard.py you can use Python running on your PC to execute
commands on the connected pyboard. See examples in that file.
|
