7a175bd2db
- **NON-FUNCTIONAL** - Contains an old draft of separating the stepper driver direct access to the planner buffer. This is designed to keep the stepper and planner modules independent and prevent overwriting or other complications. In this way, feedrate override should be able to be installed as well. - A number of planner optimizations are installed too. - Not sure where the bugs are. Either in the new planner optimizations, new stepper module updates, or in both. Or it just could be that the Arduino AVR is choking with the new things it has to do.
150 lines
3.6 KiB
C
150 lines
3.6 KiB
C
/*
|
|
print.c - Functions for formatting output strings
|
|
Part of Grbl
|
|
|
|
Copyright (c) 2009-2011 Simen Svale Skogsrud
|
|
Copyright (c) 2011-2012 Sungeun K. Jeon
|
|
|
|
Grbl 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.
|
|
|
|
Grbl 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 Grbl. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* This code was initially inspired by the wiring_serial module by David A. Mellis which
|
|
used to be a part of the Arduino project. */
|
|
|
|
|
|
#include <avr/pgmspace.h>
|
|
#include "config.h"
|
|
#include "serial.h"
|
|
#include "settings.h"
|
|
|
|
void printString(const char *s)
|
|
{
|
|
while (*s)
|
|
serial_write(*s++);
|
|
}
|
|
|
|
// Print a string stored in PGM-memory
|
|
void printPgmString(const char *s)
|
|
{
|
|
char c;
|
|
while ((c = pgm_read_byte_near(s++)))
|
|
serial_write(c);
|
|
}
|
|
|
|
// void printIntegerInBase(unsigned long n, unsigned long base)
|
|
// {
|
|
// unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars.
|
|
// unsigned long i = 0;
|
|
//
|
|
// if (n == 0) {
|
|
// serial_write('0');
|
|
// return;
|
|
// }
|
|
//
|
|
// while (n > 0) {
|
|
// buf[i++] = n % base;
|
|
// n /= base;
|
|
// }
|
|
//
|
|
// for (; i > 0; i--)
|
|
// serial_write(buf[i - 1] < 10 ?
|
|
// '0' + buf[i - 1] :
|
|
// 'A' + buf[i - 1] - 10);
|
|
// }
|
|
|
|
void print_uint8_base2(uint8_t n)
|
|
{
|
|
unsigned char buf[8];
|
|
uint8_t i = 0;
|
|
|
|
for (; i < 8; i++) {
|
|
buf[i] = n & 1;
|
|
n >>= 1;
|
|
}
|
|
|
|
for (; i > 0; i--)
|
|
serial_write('0' + buf[i - 1]);
|
|
}
|
|
|
|
void print_uint32_base10(unsigned long n)
|
|
{
|
|
unsigned char buf[10];
|
|
uint8_t i = 0;
|
|
|
|
if (n == 0) {
|
|
serial_write('0');
|
|
return;
|
|
}
|
|
|
|
while (n > 0) {
|
|
buf[i++] = n % 10 + '0';
|
|
n /= 10;
|
|
}
|
|
|
|
for (; i > 0; i--)
|
|
serial_write(buf[i-1]);
|
|
}
|
|
|
|
void printInteger(long n)
|
|
{
|
|
if (n < 0) {
|
|
serial_write('-');
|
|
n = -n;
|
|
}
|
|
print_uint32_base10(n);
|
|
}
|
|
|
|
// Convert float to string by immediately converting to a long integer, which contains
|
|
// more digits than a float. Number of decimal places, which are tracked by a counter,
|
|
// may be set by the user. The integer is then efficiently converted to a string.
|
|
// NOTE: AVR '%' and '/' integer operations are very efficient. Bitshifting speed-up
|
|
// techniques are actually just slightly slower. Found this out the hard way.
|
|
void printFloat(float n)
|
|
{
|
|
if (n < 0) {
|
|
serial_write('-');
|
|
n = -n;
|
|
}
|
|
|
|
uint8_t decimals = settings.decimal_places;
|
|
while (decimals >= 2) { // Quickly convert values expected to be E0 to E-4.
|
|
n *= 100;
|
|
decimals -= 2;
|
|
}
|
|
if (decimals) { n *= 10; }
|
|
n += 0.5; // Add rounding factor. Ensures carryover through entire value.
|
|
|
|
// Generate digits backwards and store in string.
|
|
unsigned char buf[10];
|
|
uint8_t i = 0;
|
|
uint32_t a = (long)n;
|
|
buf[settings.decimal_places] = '.'; // Place decimal point, even if decimal places are zero.
|
|
while(a > 0) {
|
|
if (i == settings.decimal_places) { i++; } // Skip decimal point location
|
|
buf[i++] = (a % 10) + '0'; // Get digit
|
|
a /= 10;
|
|
}
|
|
while (i < settings.decimal_places) {
|
|
buf[i++] = '0'; // Fill in zeros to decimal point for (n < 1)
|
|
}
|
|
if (i == settings.decimal_places) { // Fill in leading zero, if needed.
|
|
i++;
|
|
buf[i++] = '0';
|
|
}
|
|
|
|
// Print the generated string.
|
|
for (; i > 0; i--)
|
|
serial_write(buf[i-1]);
|
|
}
|