You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
146 lines
6.2 KiB
146 lines
6.2 KiB
/**
|
|
* Marlin 3D Printer Firmware
|
|
* Copyright (c) 2020 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 <https://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "../inc/MarlinConfigPre.h"
|
|
|
|
#if ENABLED(EMERGENCY_PARSER)
|
|
#include "../feature/e_parser.h"
|
|
#endif
|
|
|
|
#ifndef DEC
|
|
#define DEC 10
|
|
#define HEX 16
|
|
#define OCT 8
|
|
#define BIN 2
|
|
#endif
|
|
|
|
// flushTX is not implemented in all HAL, so use SFINAE to call the method where it is.
|
|
CALL_IF_EXISTS_IMPL(void, flushTX );
|
|
CALL_IF_EXISTS_IMPL(bool, connected, true);
|
|
|
|
// Using Curiously Recurring Template Pattern here to avoid virtual table cost when compiling.
|
|
// Since the real serial class is known at compile time, this results in compiler writing a completely
|
|
// efficient code
|
|
template <class Child>
|
|
struct SerialBase {
|
|
#if ENABLED(EMERGENCY_PARSER)
|
|
const bool ep_enabled;
|
|
EmergencyParser::State emergency_state;
|
|
inline bool emergency_parser_enabled() { return ep_enabled; }
|
|
SerialBase(bool ep_capable) : ep_enabled(ep_capable), emergency_state(EmergencyParser::State::EP_RESET) {}
|
|
#else
|
|
SerialBase(const bool) {}
|
|
#endif
|
|
|
|
// Static dispatch methods below:
|
|
// The most important method here is where it all ends to:
|
|
size_t write(uint8_t c) { return static_cast<Child*>(this)->write(c); }
|
|
// Called when the parser finished processing an instruction, usually build to nothing
|
|
void msgDone() { static_cast<Child*>(this)->msgDone(); }
|
|
// Called upon initialization
|
|
void begin(const long baudRate) { static_cast<Child*>(this)->begin(baudRate); }
|
|
// Called upon destruction
|
|
void end() { static_cast<Child*>(this)->end(); }
|
|
/** Check for available data from the port
|
|
@param index The port index, usually 0 */
|
|
bool available(uint8_t index = 0) { return static_cast<Child*>(this)->available(index); }
|
|
/** Read a value from the port
|
|
@param index The port index, usually 0 */
|
|
int read(uint8_t index = 0) { return static_cast<Child*>(this)->read(index); }
|
|
// Check if the serial port is connected (usually bypassed)
|
|
bool connected() { return static_cast<Child*>(this)->connected(); }
|
|
// Redirect flush
|
|
void flush() { static_cast<Child*>(this)->flush(); }
|
|
// Not all implementation have a flushTX, so let's call them only if the child has the implementation
|
|
void flushTX() { CALL_IF_EXISTS(void, static_cast<Child*>(this), flushTX); }
|
|
|
|
// Glue code here
|
|
FORCE_INLINE void write(const char* str) { while (*str) write(*str++); }
|
|
FORCE_INLINE void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
|
|
FORCE_INLINE void print(const char* str) { write(str); }
|
|
FORCE_INLINE void print(char c, int base = 0) { print((long)c, base); }
|
|
FORCE_INLINE void print(unsigned char c, int base = 0) { print((unsigned long)c, base); }
|
|
FORCE_INLINE void print(int c, int base = DEC) { print((long)c, base); }
|
|
FORCE_INLINE void print(unsigned int c, int base = DEC) { print((unsigned long)c, base); }
|
|
void print(long c, int base = DEC) { if (!base) write(c); write((const uint8_t*)"-", c < 0); printNumber(c < 0 ? -c : c, base); }
|
|
void print(unsigned long c, int base = DEC) { printNumber(c, base); }
|
|
void print(double c, int digits = 2) { printFloat(c, digits); }
|
|
|
|
FORCE_INLINE void println(const char s[]) { print(s); println(); }
|
|
FORCE_INLINE void println(char c, int base = 0) { print(c, base); println(); }
|
|
FORCE_INLINE void println(unsigned char c, int base = 0) { print(c, base); println(); }
|
|
FORCE_INLINE void println(int c, int base = DEC) { print(c, base); println(); }
|
|
FORCE_INLINE void println(unsigned int c, int base = DEC) { print(c, base); println(); }
|
|
FORCE_INLINE void println(long c, int base = DEC) { print(c, base); println(); }
|
|
FORCE_INLINE void println(unsigned long c, int base = DEC) { print(c, base); println(); }
|
|
FORCE_INLINE void println(double c, int digits = 2) { print(c, digits); println(); }
|
|
void println() { write("\r\n"); }
|
|
|
|
// Print a number with the given base
|
|
void printNumber(unsigned long n, const uint8_t base) {
|
|
if (n) {
|
|
unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
|
|
int8_t i = 0;
|
|
while (n) {
|
|
buf[i++] = n % base;
|
|
n /= base;
|
|
}
|
|
while (i--) write((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
|
|
}
|
|
else write('0');
|
|
}
|
|
|
|
// Print a decimal number
|
|
void printFloat(double number, uint8_t digits) {
|
|
// Handle negative numbers
|
|
if (number < 0.0) {
|
|
write('-');
|
|
number = -number;
|
|
}
|
|
|
|
// Round correctly so that print(1.999, 2) prints as "2.00"
|
|
double rounding = 0.5;
|
|
LOOP_L_N(i, digits) rounding *= 0.1;
|
|
number += rounding;
|
|
|
|
// Extract the integer part of the number and print it
|
|
unsigned long int_part = (unsigned long)number;
|
|
double remainder = number - (double)int_part;
|
|
printNumber(int_part, 10);
|
|
|
|
// Print the decimal point, but only if there are digits beyond
|
|
if (digits) {
|
|
write('.');
|
|
// Extract digits from the remainder one at a time
|
|
while (digits--) {
|
|
remainder *= 10.0;
|
|
int toPrint = int(remainder);
|
|
printNumber(toPrint, 10);
|
|
remainder -= toPrint;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// All serial instances will be built by chaining the features required for the function in a form of a template
|
|
// type definition
|
|
|