Slic3r::GCodeSender Class Reference

#include <src/libslic3r/GCodeSender.hpp>

Inheritance diagram for Slic3r::GCodeSender:

Collaboration diagram for Slic3r::GCodeSender:

Public Member Functions
	GCodeSender ()
	~GCodeSender ()
bool	connect (std::string devname, unsigned int baud_rate)
void	send (const std::vector< std::string > &lines, bool priority=false)
void	send (const std::string &s, bool priority=false)
void	disconnect ()
bool	error_status () const
bool	is_connected () const
bool	wait_connected (unsigned int timeout=3) const
size_t	queue_size () const
void	pause_queue ()
void	resume_queue ()
void	purge_queue (bool priority=false)
std::vector< std::string >	purge_log ()
std::string	getT () const
std::string	getB () const
void	set_DTR (bool on)
void	reset ()

Private Member Functions
void	set_baud_rate (unsigned int baud_rate)
void	set_error_status (bool e)
void	do_send ()
void	on_write (const boost::system::error_code &error, size_t bytes_transferred)
void	do_close ()
void	do_read ()
void	on_read (const boost::system::error_code &error, size_t bytes_transferred)
void	send ()

Private Attributes
asio::io_service	io
asio::serial_port	serial
boost::thread	background_thread
boost::asio::streambuf	read_buffer
boost::asio::streambuf	write_buffer
bool	open
bool	connected
bool	error
boost::mutex	error_mutex
boost::mutex	queue_mutex
std::queue< std::string >	queue
std::list< std::string >	priqueue
bool	can_send
bool	queue_paused
size_t	sent
std::deque< std::string >	last_sent
boost::mutex	log_mutex
std::queue< std::string >	log
std::string	T
std::string	B

Detailed Description

Constructor & Destructor Documentation

GCodeSender()

Slic3r::GCodeSender::GCodeSender

(

)

    : io(), serial(io), can_send(false), sent(0), open(false), error(false),
      connected(false), queue_paused(false)
{
#ifdef DEBUG_SERIAL
    std::srand(std::time(nullptr));
#endif
}

~GCodeSender()

Slic3r::GCodeSender::~GCodeSender

(

)

{
    this->disconnect();
}

References disconnect().

Here is the call graph for this function:

Member Function Documentation

connect()

bool Slic3r::GCodeSender::connect	(	std::string	devname,
		unsigned int	baud_rate
	)

{
    this->disconnect();
    
    this->set_error_status(false);
    try {
        this->serial.open(devname);
        
        this->serial.set_option(boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::odd));
        this->serial.set_option(boost::asio::serial_port_base::character_size(boost::asio::serial_port_base::character_size(8)));
        this->serial.set_option(boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none));
        this->serial.set_option(boost::asio::serial_port_base::stop_bits(boost::asio::serial_port_base::stop_bits::one));
        this->set_baud_rate(baud_rate);
    
        this->serial.close();
        this->serial.open(devname);
        this->serial.set_option(boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none));
    
        // set baud rate again because set_option overwrote it
        this->set_baud_rate(baud_rate);
        this->open = true;
        this->reset();
    } catch (boost::system::system_error &) {
        this->set_error_status(true);
        return false;
    }
    
    // a reset firmware expect line numbers to start again from 1
    this->sent = 0;
    this->last_sent.clear();
 
    /* Initialize debugger */
#ifdef DEBUG_SERIAL
    fs.open("serial.txt", std::fstream::out | std::fstream::trunc);
#endif
    
    // this gives some work to the io_service before it is started
    // (post() runs the supplied function in its thread)
    this->io.post(boost::bind(&GCodeSender::do_read, this));
    
    // start reading in the background thread
    boost::thread t(boost::bind(&boost::asio::io_service::run, &this->io));
    this->background_thread.swap(t);
    
    // always send a M105 to check for connection because firmware might be silent on connect
    //FIXME Vojtech: This is being sent too early, leading to line number synchronization issues,
    // from which the GCodeSender never recovers.
    // this->send("M105", true);
    
    return true;
}

References background_thread, disconnect(), do_read(), io, last_sent, open, reset(), sent, serial, set_baud_rate(), and set_error_status().

Here is the call graph for this function:

disconnect()

void Slic3r::GCodeSender::disconnect

(

)

{
    if (!this->open) return;
    this->open = false;
    this->connected = false;
    this->io.post(boost::bind(&GCodeSender::do_close, this));
    this->background_thread.join();
    this->io.reset();
    /*
    if (this->error_status()) {
        throw(boost::system::system_error(boost::system::error_code(),
            "Error while closing the device"));
    }
    */
    
#ifdef DEBUG_SERIAL
    fs << "DISCONNECTED" << std::endl << std::flush;
    fs.close();
#endif
}

References background_thread, connected, do_close(), io, and open.

Referenced by ~GCodeSender(), and connect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_close()

void Slic3r::GCodeSender::do_close ( )

private

{
    this->set_error_status(false);
    boost::system::error_code ec;
    this->serial.cancel(ec);
    if (ec) this->set_error_status(true);
    this->serial.close(ec);
    if (ec) this->set_error_status(true);
}

References serial, and set_error_status().

Referenced by disconnect(), on_read(), and on_write().

Here is the call graph for this function:

Here is the caller graph for this function:

do_read()

void Slic3r::GCodeSender::do_read ( )

private

{
    // read one line
    boost::asio::async_read_until(
        this->serial,
        this->read_buffer,
        '\n',
        boost::bind(
            &GCodeSender::on_read,
            this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred
        )
    );
}

References on_read(), read_buffer, and serial.

Referenced by connect(), and on_read().

Here is the call graph for this function:

Here is the caller graph for this function:

do_send()

void Slic3r::GCodeSender::do_send ( )

private

{
    boost::lock_guard<boost::mutex> l(this->queue_mutex);
    
    // printer is not connected or we're still waiting for the previous ack
    if (!this->can_send) return;
    
    std::string line;
    while (!this->priqueue.empty() || (!this->queue.empty() && !this->queue_paused)) {
        if (!this->priqueue.empty()) {
            line = this->priqueue.front();
            this->priqueue.pop_front();
        } else {
            line = this->queue.front();
            this->queue.pop();
        }
        
        // strip comments
        size_t comment_pos = line.find_first_of(';');
        if (comment_pos != std::string::npos)
            line.erase(comment_pos, std::string::npos);
        boost::algorithm::trim(line);
        
        // if line is not empty, send it
        if (!line.empty()) break;
        // if line is empty, process next item in queue
    }
    if (line.empty()) return;
    
    // compute full line
    ++ this->sent;
#ifndef DEBUG_SERIAL
    const auto line_num = this->sent;
#else
    // In DEBUG_SERIAL mode, test line re-synchronization by sending bad line number 1/4 of the time
    const auto line_num = std::rand() < RAND_MAX/4 ? 0 : this->sent;
#endif
    std::string full_line = "N" + boost::lexical_cast<std::string>(line_num) + " " + line;
    
    // calculate checksum
    int cs = 0;
    for (std::string::const_iterator it = full_line.begin(); it != full_line.end(); ++it)
       cs = cs ^ *it;
    
    // write line to device
    full_line += "*";
    full_line += boost::lexical_cast<std::string>(cs);
    full_line += "\n";
    
#ifdef DEBUG_SERIAL
    fs << ">> " << full_line << std::flush;
#endif
    
    this->last_sent.push_back(line);
    this->can_send = false;
    
    while (this->last_sent.size() > KEEP_SENT) {
        this->last_sent.pop_front();
    }
    
    // we can't supply boost::asio::buffer(full_line) to async_write() because full_line is on the
    // stack and the buffer would lose its underlying storage causing memory corruption
    std::ostream os(&this->write_buffer);
    os << full_line;
    boost::asio::async_write(this->serial, this->write_buffer, boost::bind(&GCodeSender::on_write, this, boost::asio::placeholders::error,
                boost::asio::placeholders::bytes_transferred));
}

References can_send, KEEP_SENT, last_sent, on_write(), priqueue, queue, queue_mutex, sent, serial, and write_buffer.

Referenced by on_write(), and send().

Here is the call graph for this function:

Here is the caller graph for this function:

error_status()

bool Slic3r::GCodeSender::error_status

(

)

const

{
    boost::lock_guard<boost::mutex> l(this->error_mutex);
    return this->error;
}

References error, and error_mutex.

getB()

std::string Slic3r::GCodeSender::getB

(

)

const

{
    boost::lock_guard<boost::mutex> l(this->log_mutex);
    return this->B;
}

References B, and log_mutex.

getT()

std::string Slic3r::GCodeSender::getT

(

)

const

{
    boost::lock_guard<boost::mutex> l(this->log_mutex);
    return this->T;
}

References log_mutex, and T.

is_connected()

bool Slic3r::GCodeSender::is_connected

(

)

const

{
    return this->connected;
}

References connected.

on_read()

void Slic3r::GCodeSender::on_read ( const boost::system::error_code &  error, size_t  bytes_transferred  )

private

{
    this->set_error_status(false);
    if (error) {
        #ifdef __APPLE__
        if (error.value() == 45) {
            // OS X bug: http://osdir.com/ml/lib.boost.asio.user/2008-08/msg00004.html
            this->do_read();
            return;
        }
        #endif
    
        // printf("ERROR: [%d] %s\n", error.value(), error.message().c_str());
        // error can be true even because the serial port was closed.
        // In this case it is not a real error, so ignore.
        if (this->open) {
            this->do_close();
            this->set_error_status(true);
        }
        return;
    }
    
    std::istream is(&this->read_buffer);
    std::string line;
    std::getline(is, line);
    if (!line.empty()) {
#ifdef DEBUG_SERIAL
    fs << "<< " << line << std::endl << std::flush;
#endif
        
        // note that line might contain \r at its end
        // parse incoming line
        if (!this->connected
            && (boost::starts_with(line, "start")
             || boost::starts_with(line, "Grbl ")
             || boost::starts_with(line, "ok")
             || boost::contains(line, "T:"))) {
            this->connected = true;
            {
                boost::lock_guard<boost::mutex> l(this->queue_mutex);
                this->can_send = true;
            }
            this->send();
        } else if (boost::starts_with(line, "ok")) {
            {
                boost::lock_guard<boost::mutex> l(this->queue_mutex);
                this->can_send = true;
            }
            this->send();
        } else if (boost::istarts_with(line, "resend")  // Marlin uses "Resend: "
                || boost::istarts_with(line, "rs")) {
            // extract the first number from line
            boost::algorithm::trim_left_if(line, !boost::algorithm::is_digit());
            size_t toresend = boost::lexical_cast<size_t>(line.substr(0, line.find_first_not_of("0123456789")));
            
#ifdef DEBUG_SERIAL
            fs << "!! line num out of sync: toresend = " << toresend << ", sent = " << sent << ", last_sent.size = " << last_sent.size() << std::endl;
#endif
 
            if (toresend > this->sent - this->last_sent.size() && toresend <= this->sent) {
                {
                    boost::lock_guard<boost::mutex> l(this->queue_mutex);
                    
                    const auto lines_to_resend = this->sent - toresend + 1;
#ifdef DEBUG_SERIAL
            fs << "!! resending " << lines_to_resend << " lines" << std::endl;
#endif
                    // move the unsent lines to priqueue
                    this->priqueue.insert(
                        this->priqueue.begin(),  // insert at the beginning
                        this->last_sent.begin() + this->last_sent.size() - lines_to_resend,
                        this->last_sent.end()
                    );
                    
                    // we can empty last_sent because it's not useful anymore
                    this->last_sent.clear();
                    
                    // start resending with the requested line number
                    this->sent = toresend - 1;
                    this->can_send = true;
                }
                this->send();
            } else {
                printf("Cannot resend %zu (oldest we have is %zu)\n", toresend, this->sent - this->last_sent.size());
            }
        } else if (boost::starts_with(line, "wait")) {
            // ignore
        } else {
            // push any other line into the log
            boost::lock_guard<boost::mutex> l(this->log_mutex);
            this->log.push(line);
        }
    
        // parse temperature info
        {
            size_t pos = line.find("T:");
            if (pos != std::string::npos && line.size() > pos + 2) {
                // we got temperature info
                boost::lock_guard<boost::mutex> l(this->log_mutex);
                this->T = line.substr(pos+2, line.find_first_not_of("0123456789.", pos+2) - (pos+2));
        
                pos = line.find("B:");
                if (pos != std::string::npos && line.size() > pos + 2) {
                    // we got bed temperature info
                    this->B = line.substr(pos+2, line.find_first_not_of("0123456789.", pos+2) - (pos+2));
                }
            }
        }
    }
    this->do_read();
}

References B, can_send, connected, do_close(), do_read(), error, last_sent, log, log_mutex, open, priqueue, queue_mutex, read_buffer, send(), sent, set_error_status(), and T.

Referenced by do_read().

Here is the call graph for this function:

Here is the caller graph for this function:

on_write()

void Slic3r::GCodeSender::on_write ( const boost::system::error_code &  error, size_t  bytes_transferred  )

private

{
    this->set_error_status(false);
    if (error) {
        if (this->open) {
            this->do_close();
            this->set_error_status(true);
        }
        return;
    }
    
    this->do_send();
}

References do_close(), do_send(), open, and set_error_status().

Referenced by do_send().

Here is the call graph for this function:

Here is the caller graph for this function:

pause_queue()

void Slic3r::GCodeSender::pause_queue

(

)

{
    boost::lock_guard<boost::mutex> l(this->queue_mutex);
    this->queue_paused = true;
}

References queue_mutex, and queue_paused.

purge_log()

std::vector< std::string > Slic3r::GCodeSender::purge_log

(

)

{
    boost::lock_guard<boost::mutex> l(this->log_mutex);
    std::vector<std::string> retval;
    retval.reserve(this->log.size());
    while (!this->log.empty()) {
        retval.push_back(this->log.front());
        this->log.pop();
    }
    return retval;
}

References log, and log_mutex.

purge_queue()

void Slic3r::GCodeSender::purge_queue

(

bool

priority = false

)

{
    boost::lock_guard<boost::mutex> l(this->queue_mutex);
    if (priority) {
        // clear priority queue
        std::list<std::string> empty;
        std::swap(this->priqueue, empty);
    } else {
        // clear queue
        std::queue<std::string> empty;
        std::swap(this->queue, empty);
        this->queue_paused = false;
    }
}

References Slic3r::empty(), priqueue, queue, queue_mutex, and queue_paused.

Here is the call graph for this function:

queue_size()

size_t Slic3r::GCodeSender::queue_size

(

)

const

{
    boost::lock_guard<boost::mutex> l(this->queue_mutex);
    return this->queue.size();
}

References queue, and queue_mutex.

reset()

void Slic3r::GCodeSender::reset

(

)

{
    set_DTR(false);
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    set_DTR(true);
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    set_DTR(false);
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
}

References set_DTR().

Referenced by connect().

Here is the call graph for this function:

Here is the caller graph for this function:

resume_queue()

void Slic3r::GCodeSender::resume_queue

(

)

{
    {
        boost::lock_guard<boost::mutex> l(this->queue_mutex);
        this->queue_paused = false;
    }
    this->send();
}

References queue_mutex, queue_paused, and send().

Here is the call graph for this function:

send() [1/3]

void Slic3r::GCodeSender::send ( )

private

{
    this->io.post(boost::bind(&GCodeSender::do_send, this));
}

References do_send(), and io.

Referenced by on_read(), resume_queue(), send(), and send().

Here is the call graph for this function:

Here is the caller graph for this function:

send() [2/3]

void Slic3r::GCodeSender::send	(	const std::string &	s,
		bool	priority = false
	)

{
    // append line to queue
    {
        boost::lock_guard<boost::mutex> l(this->queue_mutex);
        if (priority) {
            this->priqueue.push_back(line);
        } else {
            this->queue.push(line);
        }
    }
    this->send();
}

References priqueue, queue, queue_mutex, and send().

Here is the call graph for this function:

send() [3/3]

void Slic3r::GCodeSender::send	(	const std::vector< std::string > &	lines,
		bool	priority = false
	)

{
    // append lines to queue
    {
        boost::lock_guard<boost::mutex> l(this->queue_mutex);
        for (std::vector<std::string>::const_iterator line = lines.begin(); line != lines.end(); ++line) {
            if (priority) {
                this->priqueue.push_back(*line);
            } else {
                this->queue.push(*line);
            }
        }
    }
    this->send();
}

References priqueue, queue, queue_mutex, and send().

Here is the call graph for this function:

set_baud_rate()

void Slic3r::GCodeSender::set_baud_rate ( unsigned int  baud_rate )

private

{
    try {
        // This does not support speeds > 115200
        this->serial.set_option(boost::asio::serial_port_base::baud_rate(baud_rate));
    } catch (boost::system::system_error &) {
        boost::asio::serial_port::native_handle_type handle = this->serial.native_handle();
 
#if __APPLE__
        termios ios;
        ::tcgetattr(handle, &ios);
        ::cfsetspeed(&ios, baud_rate);
        speed_t newSpeed = baud_rate;
        ioctl(handle, IOSSIOSPEED, &newSpeed);
        ::tcsetattr(handle, TCSANOW, &ios);
#elif __linux__
        termios2 ios;
        if (ioctl(handle, TCGETS2, &ios))
            printf("Error in TCGETS2: %s\n", strerror(errno));
        ios.c_ispeed = ios.c_ospeed = baud_rate;
        ios.c_cflag &= ~CBAUD;
        ios.c_cflag |= BOTHER | CLOCAL | CREAD;
        ios.c_cc[VMIN] = 1; // Minimum of characters to read, prevents eof errors when 0 bytes are read
        ios.c_cc[VTIME] = 1;
        if (ioctl(handle, TCSETS2, &ios))
            printf("Error in TCSETS2: %s\n", strerror(errno));
    
#elif __OpenBSD__
    struct termios ios;
    ::tcgetattr(handle, &ios);
    ::cfsetspeed(&ios, baud_rate);
    if (::tcsetattr(handle, TCSAFLUSH, &ios) != 0)
      printf("Failed to set baud rate: %s\n", strerror(errno));
#else
        //throw Slic3r::InvalidArgument("OS does not currently support custom bauds");
#endif
    }
}

References serial.

Referenced by connect().

Here is the caller graph for this function:

set_DTR()

void Slic3r::GCodeSender::set_DTR

(

bool

on

)

{
#if defined(_WIN32) && !defined(__SYMBIAN32__)
    boost::asio::serial_port_service::native_handle_type handle = this->serial.native_handle();
    if (on)
        EscapeCommFunction(handle, SETDTR);
    else
        EscapeCommFunction(handle, CLRDTR);
#else
    int fd = this->serial.native_handle();
    int status;
    ioctl(fd, TIOCMGET, &status);
    if (on)
        status |= TIOCM_DTR;
    else
        status &= ~TIOCM_DTR;
    ioctl(fd, TIOCMSET, &status);
#endif
}

References serial.

Referenced by reset().

Here is the caller graph for this function:

set_error_status()

void Slic3r::GCodeSender::set_error_status ( bool  e )

private

{
    boost::lock_guard<boost::mutex> l(this->error_mutex);
    this->error = e;
}

References error, and error_mutex.

Referenced by connect(), do_close(), on_read(), and on_write().

Here is the caller graph for this function:

wait_connected()

bool Slic3r::GCodeSender::wait_connected

(

unsigned int

timeout = 3

)

const

{
    using namespace boost::posix_time;
    ptime t0 = second_clock::local_time() + seconds(timeout);
    while (!this->connected) {
        if (second_clock::local_time() > t0) return false;
        boost::this_thread::sleep(boost::posix_time::milliseconds(100));
    }
    return true;
}

References connected.

Member Data Documentation

B

std::string Slic3r::GCodeSender::B

private

Referenced by getB(), and on_read().

background_thread

boost::thread Slic3r::GCodeSender::background_thread

private

Referenced by connect(), and disconnect().

can_send

bool Slic3r::GCodeSender::can_send

private

Referenced by do_send(), and on_read().

connected

bool Slic3r::GCodeSender::connected

private

Referenced by disconnect(), is_connected(), on_read(), and wait_connected().

error

bool Slic3r::GCodeSender::error

private

Referenced by error_status(), on_read(), and set_error_status().

error_mutex

boost::mutex Slic3r::GCodeSender::error_mutex

mutableprivate

Referenced by error_status(), and set_error_status().

io

asio::io_service Slic3r::GCodeSender::io

private

Referenced by connect(), disconnect(), and send().

last_sent

std::deque<std::string> Slic3r::GCodeSender::last_sent

private

Referenced by connect(), do_send(), and on_read().

log

std::queue<std::string> Slic3r::GCodeSender::log

private

Referenced by on_read(), and purge_log().

log_mutex

boost::mutex Slic3r::GCodeSender::log_mutex

mutableprivate

Referenced by getB(), getT(), on_read(), and purge_log().

open

bool Slic3r::GCodeSender::open

private

Referenced by connect(), disconnect(), on_read(), and on_write().

priqueue

std::list<std::string> Slic3r::GCodeSender::priqueue

private

Referenced by do_send(), on_read(), purge_queue(), send(), and send().

queue

std::queue<std::string> Slic3r::GCodeSender::queue

private

Referenced by do_send(), purge_queue(), queue_size(), send(), and send().

queue_mutex

boost::mutex Slic3r::GCodeSender::queue_mutex

mutableprivate

Referenced by do_send(), on_read(), pause_queue(), purge_queue(), queue_size(), resume_queue(), send(), and send().

queue_paused

bool Slic3r::GCodeSender::queue_paused

private

Referenced by pause_queue(), purge_queue(), and resume_queue().

read_buffer

boost::asio::streambuf Slic3r::GCodeSender::read_buffer

private

Referenced by do_read(), and on_read().

sent

size_t Slic3r::GCodeSender::sent

private

Referenced by connect(), do_send(), and on_read().

serial

asio::serial_port Slic3r::GCodeSender::serial

private

Referenced by connect(), do_close(), do_read(), do_send(), set_baud_rate(), and set_DTR().

T

std::string Slic3r::GCodeSender::T

private

Referenced by getT(), and on_read().

write_buffer

boost::asio::streambuf Slic3r::GCodeSender::write_buffer

private

Referenced by do_send().

---

The documentation for this class was generated from the following files:

• src/libslic3r/GCodeSender.hpp
• src/libslic3r/GCodeSender.cpp