README.md

This project is a bash script that manages automatic downloading of GCODE from a web server and printing that to a 3d print. It uses the command line GCODE sender from pronterface.

The files we have added are as follows:
AutoDrop.sh

start.sh

stop.sh

start1.gcode

start2.gcode

end.gcode

AutoDrop.sh is the script that retrives GCODe from the web server and manages the printing process.
Start.sh is the file to start the AutoDrop.sh script in the background. It will run untill the stop.sh is run.

The GCODE files are broken up to make it possible to controll the 3d printers auto ejection system.

start1.gcode opens the trap door all the way ensuring the print bead is clear befor closing and opeing it just enoughf for the 2d printer to put a sheet of paper on the print bed.

start2.gcode fully close the trap door.

The download file from the web server is run after start2.gcode. It will be simple to modify the bash script to make it work with other devices.

end.gcode fully opens the trap door.

It includes several gcode files in the root of this directory that manage the automatic retrival of jobs and the controll of a 3d printers automatic ejection mechanisom.

A regular paper printer is required to make this work with out modification.
The paper printer is used to create the dispobal print bed for the 3d printed object.
It also prints out the details for the print job such as user name and job ID.

The script can be modified and the gcode files edited to make them specific to your printer.
The top of the script contains the following variables that must be set.

You must change the name of the printer and the web server URL.
You can also set the max size for your printer.
The print queue will check the max size to dermin if there are any obs that can be given to the printer.

There is still some work to do as far as making an nice install script that can be run on the pi.
The install script will have to install the cups printer services and the HP drivers as HP printers were the only ones I was able to get working on the rasbery pi.

The rest of the readme file here is specific to printrun.
Print run is the python package that provides the actual gcode sender.
It runs on linux and is compadible with the rasbery pi.

#############################################################################
This is all pronter face print run stuff from the original clone.
I do want to thank these people for making the who command line gocode sender that works on linux including the rasbery pi.

Printrun consists of printcore, pronsole and pronterface, and a small collection of helpful scripts.

printcore.py is a library that makes writing reprap hosts easy

pronsole.py is an interactive command-line host software with tabcompletion goodness

pronterface.py is a graphical host software with the same functionality as pronsole

GETTING PRINTRUN

This section suggests using precompiled binaries, this way you get everything bundled into one single package for an easy installation.

If you want the newest, shiniest features, you can run Printrun from source using the instructions further down this README.

and you can start using Printrun from the Printrun directory created by the git clone command.

Users of Ubuntu Xenial Xerus or later and Debian Jessie or later won't find the package "python-wxgtk2.8" available, having been replaced by "python-wxgtk3.0". Running Printrun with "python-wxgtk3.0" instead, is possible but it is known to be affected by issue #615.

A Printrun preliminary package is already available in Ubuntu Yakkety Yak and Debian Stretch/Sid repositories. Please be aware that this initial package is also known to be affected by issue #615.

Chrome OS

You can use Printrun via crouton ( https://github.com/dnschneid/crouton ). Assuming you want Ubuntu Trusty, you used probably sudo sh -e ~/Downloads/crouton -r trusty -t xfce to install Ubuntu. Fetch and install dependencies with the line given above for Ubuntu/Debian, and obtain the source via git clone.

By default you have no access to the serial port under Chrome OS crouton, so you cannot connect to your 3D printer. Add yourself to the serial group within the linux environment to fix this

sudo usermod -G serial -a <username>

where <username> should be your username. Log out and in to make this group change active and allow communication with your printer.

Fedora

You can install Printrun from official packages. Install the whole package using

sudo yum install printrun

Or get only apps you need by

sudo yum install pronsole or pronterface or plater

Adding --enablerepo updates-testing option to yum might give you newer packages (but also not very tested).

You can also run Printrun directly from source, if the packages are too old for you. Fetch and install the dependencies using

sudo yum install pyserial wxPython python-pyglet python-cairosvg

Optional: sudo yum install skeinforge simarrange

Archlinux

Packages are available in AUR. Just run

yaourt printrun

and enjoy the pronterface, pronsole, ... commands directly.

RUNNING FROM SOURCE

Run Printrun for source if you want to test out the latest features.

Dependencies

To use pronterface, you need:

python (ideally 2.6.x or 2.7.x),

pyserial (or python-serial on ubuntu/debian)

pyreadline (not needed on Linux) and

argparse (installed by default with python >= 2.7)

wxPython (some features such as Tabbed mode work better with wx 2.9)

pyglet

numpy (for 3D view)

pycairo (to use Projector feature)

cairosvg (to use Projector feature)

dbus (to inhibit sleep on some Linux systems)

Please see specific instructions for Windows and Mac OS X below. Under Linux, you should use your package manager directly (see the "GETTING PRINTRUN" section), or pip:

pip install -r requirements.txt

Cython-based G-Code parser

Printrun default G-Code parser is quite memory hungry, but we also provide a much lighter one which just needs an extra build-time dependency (Cython), plus compiling the extension with:

The tools will probably run just fine in 64bit on Lion, you don't need to mess
with any of the 32bit settings. In case they don't, try
5. export VERSIONER_PYTHON_PREFER_32_BIT=yes
in a terminal before running Pronterface

USING PRINTRUN

USING PRONTERFACE

When you're done setting up Printrun, you can start pronterface.py in the directory you unpacked it.
Select the port name you are using from the first drop-down, select your baud rate, and hit connect.
Load an STL (see the note on skeinforge below) or GCODE file, and you can upload it to SD or print it directly.
The "monitor printer" function, when enabled, checks the printer state (temperatures, SD print progress) every 3 seconds.
The command box recognizes all pronsole commands, but has no tabcompletion.

If you want to load stl files, you need to install a slicing program such as Slic3r or Skeinforge and add its path to the settings.

If the Slic3r integration option (Settings > Options > User interface > Enable Slic3r integration) is checked a new menu will appear after application restart which will allow you to choose among your previously saved Slic3r Print/Filament/Printer settings.

USING PRONSOLE

To use pronsole, you need:

python (ideally 2.6.x or 2.7.x),

pyserial (or python-serial on ubuntu/debian) and

pyreadline (not needed on Linux)

Start pronsole and you will be greeted with a command prompt. Type help to view the available commands.
All commands have internal help, which you can access by typing "help commandname", for example "help connect"

If you want to load stl files, you need to put a version of skeinforge (doesn't matter which one) in a folder called "skeinforge".
The "skeinforge" folder must be in the same folder as pronsole.py

USING PRINTCORE

To use printcore you need python (ideally 2.6.x or 2.7.x) and pyserial (or python-serial on ubuntu/debian)
See pronsole for an example of a full-featured host, the bottom of printcore.py for a simple command-line
sender, or the following code example:

#to send a file of gcode to the printerfrom printrun.printcore import printcore
from printrun import gcoder
p=printcore('/dev/ttyUSB0',115200) # or p.printcore('COM3',115200) on Windows
gcode=[i.strip() for i inopen('filename.gcode')] # or pass in your own array of gcode lines instead of reading from a file
gcode = gcoder.LightGCode(gcode)
p.startprint(gcode) # this will start a print#If you need to interact with the printer:
p.send_now("M105") # this will send M105 immediately, ahead of the rest of the print
p.pause() # use these to pause/resume the current print
p.resume()
p.disconnect() # this is how you disconnect from the printer once you are done. This will also stop running prints.

PLATERS

Printrun provides two platers: a STL plater (plater.py) and a G-Code plater (gcodeplater.py).

CONFIGURATION

Build dimensions

Build dimensions can be specified using the build_dimensions option (which can
be graphically edited in Pronterface settings). This option is formed of 9 parameters:
3 for the build volume dimensions, 3 for the build volume coordinate system
offset minimum, 3 for the endstop positions.

The default value is 200x200x100+0+0+0+0+0+0, which corresponds to a
200x200mm (width x height) bed with 100mm travel in Z (there are the first
three numbers) and no offset. The absolute coordinates system origin (0,0,0) is
at the bottom left corner on the bed surface, and the top right corner on the
bed surface is (200,200,0).

A common practice is to have the origin of the coordinate system (0,0,0) at the
center of the bed surface. This is achieved by using the next three parameters,
for instance with 200x200x100-100-100+0+0+0+0.
In this case, the bottom left corner of the bed will be at (-100,-100,0) and
the top right one at (100,100,0).

These two sets of settings should be sufficient for most people. However, for
some specific complicated setups and GCodes and some features, we might also
need the endstops positions for perfect display. These positions (which are
usually 0,0,0, so if you don't know you probably have a standard setup) are
specified in absolute coordinates, so if you have your bed starting at
(-100,-100,0) and your endstops are 10mm away from the bed left and right and
the Z endstop 5mm above the bed, you'll want to set the endstops positions to
(-110,-110,5) for this option.

USING MACROS AND CUSTOM BUTTONS

Macros in pronsole and pronterface

To send simple G-code (or pronsole command) sequence is as simple as entering them one by one in macro definition.
If you want to use parameters for your macros, substitute them with {0} {1} {2} ... etc.

All macros are saved automatically immediately after being entered.

Example 1, simple one-line alias:

PC> macro where M114

Instead of having to remember the code to query position, you can query the position:

PC> where
X:25.00Y:11.43Z:5.11E:0.00

Example 2 - macros to switch between different slicer programs, using "set" command to change options:

When python code (using ! symbol) is used in macros, it is even possible to use blocks/conditionals/loops.
It is okay to mix python code with pronsole commands, just keep the python indentation.
For example, following macro toggles the diagnostic information similarily to the previous example:

All python code is executed in the context of the pronsole (or PronterWindow) object,
so it is possible to use all internal variables and methods, which provide great deal of functionality.
However the internal variables and methods are not very well documented and may be subject of change, as the program is developed.
Therefore it is best to use pronsole commands, which easily contain majority of the functionality that might be needed.

Some useful python-mode-only variables:

!self.settings - contains all settings, e.g.
port (!self.settings.port), baudrate, xy_feedrate, e_feedrate, slicecommand, final_command, build_dimensions
You can set them also via pronsole command "set", but you can query the values only via python code.
!self.p - printcore object (see USINGPRINTCORE section for using printcore object)
!self.cur_button -if macro was invoked via custom button, the number of the custom button, e.g. for usage in"button" command
!self.gwindow - wx graphical interface objectfor pronterface (highly risky to use because the GUI implementation details may change a lot between versions)

USING HOST COMMANDS

Pronsole and the console interface in Pronterface accept a number of commands
which you can either use directly or inside your G-Code. To run a host command
from inside a G-Code, simply prefix it with ;@.

List of available commands:

pause: pauses the print until the user resumes it

run_script scriptname [arg1 ...]: runs a custom script or program on the
host computer. This can for instance be used to produce a sound to warn the
user (e.g. run_script beep -r 2 on machines were the beep util is
available), or to send an email or text message at the end of a print. The $s
token can be used in the arguments to get the current gcode file name

run_gcode_script scripname [arg1 ...]: same as run_script, except that
all lines displayed by the script will be interpreted in turn (so that G-Code
lines will be immediately sent to the printer)

shell pythoncommand: run a python command (can also be achieved by doing
!pythoncommand)

set option value: sets the value of an option, e.g. set mainviz 3D

connect

block_until_online: wait for the printer to be online. For instance you can
do python pronsole.py -e "connect" -e "block_until_online" -e "upload object.gcode" to start pronsole, connect for the printer, wait for it to be
online to start uploading the object.gcode file.

LICENSE

Printrun is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Printrun is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Printrun. If not, see <http://www.gnu.org/licenses/>.

All scripts should contain this license note, if not, feel free to ask us. Please note that files where it is difficult to state this license note (such as images) are distributed under the same terms.