Provided by: pyboard-rshell_0.0.31-0ubuntu1_all bug

NAME

       rshell - Remote Shell for a MicroPython board

SYNOPSIS

       rshell [-b baud] [-p port] [--rts 1|0] [--dtr 1|0] [-u user] [-w password] [-e editor] [-f filename] [-d]
              [-n] [-l] [-a] [--buffer-size bytes] [--wait seconds] [--timing] [--quiet] [cmd]

       rshell -h

       rshell -V

DESCRIPTION

       rshell  is  a simple shell which runs on the host and uses MicroPython's raw-REPL to send python snippets
       to the pyboard in order to get filesystem information, and  to  copy  files  to  and  from  MicroPython's
       filesystem.

       It also has the ability to invoke the regular REPL, so rshell can be used as a terminal emulator as well.

       NOTE: With rshell you can disable USB Mass Storage and still copy files into and out of your pyboard.

       When  using  the commands, the /flash directory, and the /sdcard directory (if an sdcard is inserted) are
       considered to be on the pyboard, and all other directories are considered to be on the host. For  an  ESP
       based board you can only reference its directory by using the board name e.g.  /pyboard etc.

       NOTE:  rshell  requires  a  fairly  recent  version  of  the MicroPython firmware, specifically one which
       contains the ubinascii.unhexlify command which was added May 19, 2015 (v1.4.3-28-ga3a14b9 or newer).

       If your version of the firmware isn't new enough, then you'll see an error message something like this:

              $ rshell
              rshell needs MicroPython firmware with ubinascii.unhexlify

OPTIONS

       -h, --help
              Show a help message and exit

       -a, --ascii
              On certain platforms the  raw  REPL  mode  is  unreliable  with  particular  sequences  of  binary
              characters.  Specifying  --ascii  enables  the transfer of binary files to such platforms. It does
              this by encoding the data as ASCII hex.

       -b, --baud=BAUD
              Sets the baud rate to use when talking to the pyboard over a serial port. If no baud is specified,
              then the  baudrate  from  the  RSHELL_BAUD  environment  variable  is  used.  If  the  RSHELL_BAUD
              environment variable is not defined then the default baudrate of 115200 is used.

       --buffer-size=BUFFER_SIZE
              Sets  the  buffer size used when transferring files between the host and the pyboard. If no buffer
              size is specified, then the value from the RSHELL_BUFFER_SIZE environment variable is used. If the
              RSHELL_BUFFER_SIZE environment variable is not defined, then the default of 512 is used.

       -d, --debug
              Turns on debugging. This allows you to see the script which is sent over  the  raw  REPL  and  the
              response received.

       --dtr=[0|1|True|False]
              Sets  the  state of the DTR line when opening the serial port. This may also be defaulted from the
              RSHELL_DTR environment variable.

       -e, --editor=EDITOR
              Specifies the editor to use with the edit command. If no editor is specified, then  the  following
              environment  variables  will  be  searched:  RSHELL_EDITOR,VISUAL,  and  EDITOR.  If none of those
              environment variables is set then vi will be used.

       -f, --file=FILENAME
              Specifies a file of rshell commands to process. This allows you to create a script which  executes
              any valid rshell commands.

       -n, --nocolor
              By  default,  rshell  uses  ANSI color escape codes when displaying the prompt and ls output. This
              option allows colorized output to be disabled.

       -p, --port=PORT
              Specifies the serial port which should be used to talk to the MicroPython board. You can  set  the
              RSHELL_PORT  environment  variable  to  specify  the  default  port  to  be used, if --port is not
              specified on the command line.

       --quiet
              This option causes the Connecting messages printed when rshell starts to be  suppressed.  This  is
              mostly useful for the test scripts.

       --rts=[0|1|True|False]
              Sets  the  state of the RTS line when opening the serial port. This may also be defaulted from the
              RSHELL_RTS environment variable.

       --timing
              If the timing option is specified then rshell will print the amount  of  time  that  each  command
              takes to execute.

       -u, --user=USER
              Specifies  the  username to use when logging into a WiPy over telnet. If no username is specified,
              then the  username  from  the  RSHELL_USER  environment  variable  is  used.  If  the  RSHELL_USER
              environment variable doesn't exist then the default username 'micro' is used.

       -w, --password=PASSWORD
              Specified  the  password to use when logging into a WiPy over telnet. If no password is specified,
              then the password from the RSHELL_PASSWORD environment variable is used.  If  the  RSHELL_PASSWORD
              environment variable doesn't exist then the default password 'python' is used.

       --wait If  a  port  is  specified  defines  how  long  rshell  will  wait for the port to exist and for a
              connection to be established. The default is 0 seconds specifying an immediate return.

       cmd    If a command is specified, then that command will be executed and rshell will exit.

FILE SYSTEM

       rshell can be connected to multiple pyboards simultaneously. If the board module exists  on  the  pyboard
       (i.e. a file named board.py somewhere in the module search path) and it contains an attribute called name
       (e.g.  name  = "myboard") then the pyboard will use that name. If the board module can't be imported then
       the board will be named, pyboard or wipy. Names will have -1 (or some other number)  to  make  the  board
       name unique.

       You  can access the internal flash on the first board connected using /flash and the sd card on the first
       board connected can be accessed using /sd.

       For all other connected pyboards, you can use /board-name/flash or /board-name/sd (you can see the  board
       names using the boards command).

       The  boards  command will show all of the connected pyboards, along with all of the directories which map
       onto that pyboard.

COMMANDS

       args [ARGUMENTS...]
              Debug function for verifying argument parsing. This function just prints out each argument that it
              receives. boards

       boards Lists all of the boards that rshell is currently connected to, their names, and the connection.

              You can give a custom name to a board with either copying over a board.py file or using  the  echo
              command, e.g.

                     echo 'name="myboard"' > /pyboard/board.py

              Remember to exit rshell and re-enter to see the change.

       cat FILENAME...
              Concatenates files and sends to stdout.

       cd DIRECTORY
              Changes the current directory. ~ expansion is supported, and cd - goes to the previous directory.

       connect TYPE TYPE_PARAMS
       connect serial PORT [BAUD]
       connect telnet IP-ADDR-OR-NAME
              Connects a pyboard to rshell. rshell can be connected to multiple pyboards simultaneously.

       cp SOURCE... DEST
       cp [-r|--recursive] [SOURCE|SRC_DIR]... DIRECTORY
       cp [-r|--recursive] PATTERN DIRECTORY
              Copies  the  SOURCE  file  to  DEST.  DEST may be a filename or a directory name. If more than one
              source file is specified, then the destination should be a directory.

              Directories will only be copied if --recursive is specified.

              A single pattern may be specified, in which case the destination should be  a  directory.  Pattern
              matching is performed according to a subset of the Unix rules (see below).

              Recursive  copying  uses  the  rsync  command  (see  below):  where  a  file  exists on source and
              destination, it will only be copied if the source is newer than the destination.

       echo TEXT...
              Display a line of text.

       edit FILENAME
              If the file is on a pyboard, it copies the file to host, invokes an editor and if any changes were
              made to the file, it copies it back to the pyboard.

              The editor which is used defaults to vi, but can be overridden using either the  --editor  command
              line  option  when  rshell is invoked, or by using the RSHELL_EDITOR, VISUAL or EDITOR environment
              variables (they are tried in the order listed).

       filesize FILE
              Prints the size of the file, in bytes. This function is primarily for testing.

       filetype FILE
              Prints the type of file (dir or file). This function is primarily for testing.

       help [COMMAND]
              List available commands with no arguments, or detailed help when a command is provided.

       ls [-a] [-l] [FILE|DIRECTORY|PATTERN]...
              List directory contents. If --long is specified, a long listing format  is  used.   --all  may  be
              specified  to  show  hidden files. Pattern matching is performed according to a subset of the Unix
              rules (see below).

       mkdir DIRECTORY...
              Creates one or more directories.

       repl [BOARD-NAME] [~ LINE] [~]
              Enters into the regular REPL with the MicroPython board. Use  Control-X  to  exit  REPL  mode  and
              return the shell. It may take a second or two before the REPL exits.

              If  you  provide a BOARD-NAME then rshell will connect to that board, otherwise it will connect to
              the default board (first connected board).

              If you provide a tilde followed by a space (~ ) then anything after the tilde will be  entered  as
              if you typed it on the command line.

              If you want the repl to exit, end the line with the ~ character.

              For example, you could use:

                     rshell repl \~ pyb.bootloader\(\)\~

              and it will boot the pyboard into DFU.

              If  you want to execute multiple Python commands these should be separated by the ~ character (not
              the ; character):

                     rshell repl \~ import mymodule \~ mymodule.run\(\)

              NOTE: Escaping (or quoting) of tilde (and parentheses) is likely to be necessary to prevent shell-
              expansion if you are running rshell from bash. Such escaping is not required if running repl  from
              within an rshell session.

       rm [-f|--force] FILE...
       rm [-f|--force] PATTERN
       rm -r [-f|--force] PATTERN
       rm -r [-f|--force] [FILE|DIRECTORY]...
              Removes files or directories (including their contents).

              A single pattern may be specified. Pattern matching is performed according to a subset of the Unix
              rules (see below). Directories can only be removed if the --recursive argument is provided.

              Beware of rm -r * or worse.

       rsync [-m|--mirror] [-n|--dry-run] [-q|--quiet] SRC_DIR DEST_DIR
              Recursively synchronises a source directory to a destination. Directories must exist.

              If  --mirror  is  specified, files or directories will be removed from the destination if they are
              absent in the source.  --dry-run can be specified to report what would be done without making  any
              changes.

              Synchronisation is performed by comparing the date and time of source and destination files. Files
              are copied if the source is newer than the destination.

       shell [COMMAND]
       ! [COMMAND]
              The  shell command can be abbreviated using the exclamation point. This will invoke a command, and
              return back to rshell. Example:

                     !make deploy

              will flash the pyboard.

PATTERN MATCHING

       This is performed according to a subset of the Unix rules. The limitations are that  wildcards  are  only
       allowed in the rightmost directory of a path and curly bracket {} syntax is unsupported:

       *.py   Match files in current directory with a .py extension.

       temp/x[0-9]a.*
              Match temp/x1a.bmp but not temp/x00a.bmp

       t*/*.bmp
              Invalid: will produce an error message

       {*.doc,*.pdf}
              Invalid: will produce an error message

                                                   2022-04-14                                          RSHELL(1)