GCodeQueue Class Reference

#include <queue.h>

Collaboration diagram for GCodeQueue:

Public Member Functions
	GCodeQueue ()

Static Public Member Functions
static void	stop ()
static void	clear ()
static void	inject_P (PGM_P const pgcode)
static void	enqueue_one_now (const char *cmd)
static void	enqueue_now_P (PGM_P const cmd)
static bool	has_commands_queued ()
static void	advance ()
static void	get_available_commands ()
static void	ok_to_send ()
static void	flush_and_request_resend ()
static bool	enqueue_one (const char *cmd)

Static Public Attributes
static long	last_N
static long	stopped_N = 0
static uint8_t	length = 0
static uint8_t	index_r = 0
static char	command_buffer [BUFSIZE][MAX_CMD_SIZE]

Detailed Description

Marlin 3D Printer Firmware Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]

Based on Sprinter and grbl. Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

This program 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.

This program 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 this program. If not, see http://www.gnu.org/licenses/. queue.h - The G-code command queue, which holds commands before they go to the parser and dispatcher.

Constructor & Destructor Documentation

GCodeQueue()

GCodeQueue::GCodeQueue

(

)

                       {
  // Send "ok" after commands by default
  for (uint8_t i = 0; i < COUNT(send_ok); i++) send_ok[i] = true;
}

Member Function Documentation

stop()

static void GCodeQueue::stop ( )

static

{ stopped_N = last_N; }

Here is the caller graph for this function:

clear()

void GCodeQueue::clear ( )

static

Clear the Marlin command queue

                       {
  index_r = index_w = length = 0;
}

Here is the caller graph for this function:

inject_P()

void GCodeQueue::inject_P ( PGM_P const  pgcode )

static

Enqueue one or many commands to run from program memory. Aborts the current queue, if any. Note: process_injected_command() will process them.

Enqueue one or many commands to run from program memory. Do not inject a comment or use leading spaces! Aborts the current queue, if any. Note: process_injected_command() will be called to drain any commands afterwards

{ injected_commands_P = pgcode; }

Here is the caller graph for this function:

enqueue_one_now()

void GCodeQueue::enqueue_one_now ( const char *  cmd )

static

Enqueue and return only when commands are actually enqueued

Enqueue and return only when commands are actually enqueued. Never call this from a G-code handler!

{ while (!enqueue_one(cmd)) idle(); }

Here is the call graph for this function:

Here is the caller graph for this function:

enqueue_now_P()

void GCodeQueue::enqueue_now_P ( PGM_P const  pgcode )

static

Enqueue from program memory and return only when commands are actually enqueued

Enqueue from program memory and return only when commands are actually enqueued Never call this from a G-code handler!

                                                 {
  size_t i = 0;
  PGM_P p = pgcode;
  for (;;) {
    char c;
    while ((c = pgm_read_byte(&p[i])) && c != '\n') i++;
    char cmd[i + 1];
    memcpy_P(cmd, p, i);
    cmd[i] = '\0';
    enqueue_one_now(cmd);
    if (!c) break;
    p += i + 1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

has_commands_queued()

bool GCodeQueue::has_commands_queued ( )

static

Check whether there are any commands yet to be executed

                                     {
  return queue.length || injected_commands_P;
}

advance()

void GCodeQueue::advance ( )

static

Get the next command in the queue, optionally log it to SD, then dispatch it

                         {
 
  // Process immediate commands
  if (process_injected_command()) return;
 
  // Return if the G-code buffer is empty
  if (!length) return;
 
  #if ENABLED(SDSUPPORT)
 
    if (card.flag.saving) {
      char* command = command_buffer[index_r];
      if (is_M29(command)) {
        // M29 closes the file
        card.closefile();
        SERIAL_ECHOLNPGM(MSG_FILE_SAVED);
 
        #if !defined(__AVR__) || !defined(USBCON)
          #if ENABLED(SERIAL_STATS_DROPPED_RX)
            SERIAL_ECHOLNPAIR("Dropped bytes: ", MYSERIAL0.dropped());
          #endif
 
          #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
            SERIAL_ECHOLNPAIR("Max RX Queue Size: ", MYSERIAL0.rxMaxEnqueued());
          #endif
        #endif //  !defined(__AVR__) || !defined(USBCON)
 
        ok_to_send();
      }
      else {
        // Write the string from the read buffer to SD
        card.write_command(command);
        if (card.flag.logging)
          gcode.process_next_command(); // The card is saving because it's logging
        else
          ok_to_send();
      }
    }
    else
      gcode.process_next_command();
 
  #else
 
    gcode.process_next_command();
 
  #endif // SDSUPPORT
 
  // The queue may be reset by a command handler or by code invoked by idle() within a handler
  if (length) {
    --length;
    if (++index_r >= BUFSIZE) index_r = 0;
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_available_commands()

void GCodeQueue::get_available_commands ( )

static

Add to the circular command queue the next command from:

• The command-injection queue (injected_commands_P)
• The active serial input (usually USB)
• The SD card file being actively printed

                                        {
 
  get_serial_commands();
 
  #if ENABLED(SDSUPPORT)
    get_sdcard_commands();
  #endif
}

Here is the caller graph for this function:

ok_to_send()

void GCodeQueue::ok_to_send ( )

static

Send an "ok" message to the host, indicating that a command was successfully processed.

If ADVANCED_OK is enabled also include: N<int> Line number of the command, if any P<int> Planner space remaining B<int> Block queue space remaining

                            {
  #if NUM_SERIAL > 1
    const int16_t pn = port[index_r];
    if (pn < 0) return;
    PORT_REDIRECT(pn);
  #endif
  if (!send_ok[index_r]) return;
  SERIAL_ECHOPGM(MSG_OK);
  #if ENABLED(ADVANCED_OK)
    char* p = command_buffer[index_r];
    if (*p == 'N') {
      SERIAL_ECHO(' ');
      SERIAL_ECHO(*p++);
      while (NUMERIC_SIGNED(*p))
        SERIAL_ECHO(*p++);
    }
    SERIAL_ECHOPGM(" P"); SERIAL_ECHO(int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
    SERIAL_ECHOPGM(" B"); SERIAL_ECHO(BUFSIZE - length);
  #endif
  SERIAL_EOL();
}

Here is the call graph for this function:

Here is the caller graph for this function:

flush_and_request_resend()

void GCodeQueue::flush_and_request_resend ( )

static

Clear the serial line and request a resend of the next expected line number.

Send a "Resend: nnn" message to the host to indicate that a command needs to be re-sent.

                                          {
  #if NUM_SERIAL > 1
    const int16_t p = port[index_r];
    if (p < 0) return;
    PORT_REDIRECT(p);
  #endif
  SERIAL_FLUSH();
  SERIAL_ECHOPGM(MSG_RESEND);
  SERIAL_ECHOLN(last_N + 1);
  ok_to_send();
}

Here is the call graph for this function:

enqueue_one()

bool GCodeQueue::enqueue_one ( const char *  cmd )

static

Enqueue with Serial Echo Return true on success

Enqueue with Serial Echo Return true if the command was consumed

                                            {
 
  //SERIAL_ECHOPGM("enqueue_one(\"");
  //SERIAL_ECHO(cmd);
  //SERIAL_ECHOPGM("\") \n");
 
  if (*cmd == 0 || *cmd == '\n' || *cmd == '\r') return true;
 
  if (_enqueue(cmd)) {
    SERIAL_ECHO_START();
    SERIAL_ECHOLNPAIR(MSG_ENQUEUEING, cmd, "\"");
    return true;
  }
  return false;
}

Here is the caller graph for this function:

Member Data Documentation

last_N

long GCodeQueue::last_N

static

GCode line number handling. Hosts may include line numbers when sending commands to Marlin, and lines will be checked for sequentiality. M110 N<int> sets the current line number.

stopped_N

long GCodeQueue::stopped_N = 0

static

length

uint8_t GCodeQueue::length = 0

static

GCode Command Queue A simple ring buffer of BUFSIZE command strings.

Commands are copied into this buffer by the command injectors (immediate, serial, sd card) and they are processed sequentially by the main loop. The gcode.process_next_command method parses the next command and hands off execution to individual handler functions.

index_r

uint8_t GCodeQueue::index_r = 0

static

command_buffer

char GCodeQueue::command_buffer

static