andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge pull request #1407 from thinkyhead/cleanup_marlinserial 

Formatting cleanup of quiet sources
pull/1/head
Scott Lahteine 10 years ago
parent
5c1814383a fd78902194
commit
23fcd1ecb2
2 changed files with 62 additions and 125 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 118
      Marlin/MarlinSerial.cpp
  2. 69
      Marlin/MarlinSerial.h

118
Marlin/MarlinSerial.cpp
View File

@ -32,8 +32,7 @@
ring_buffer rx_buffer = { { 0 }, 0, 0 }; ring_buffer rx_buffer = { { 0 }, 0, 0 };
#endif #endif
FORCE_INLINE void store_char(unsigned char c) FORCE_INLINE void store_char(unsigned char c) {
{
int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE; int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE;
// if we should be storing the received character into the location // if we should be storing the received character into the location
@ -51,8 +50,7 @@ FORCE_INLINE void store_char(unsigned char c)
#if defined(M_USARTx_RX_vect) #if defined(M_USARTx_RX_vect)
// fixed by Mark Sproul this is on the 644/644p // fixed by Mark Sproul this is on the 644/644p
//SIGNAL(SIG_USART_RECV) //SIGNAL(SIG_USART_RECV)
SIGNAL(M_USARTx_RX_vect) SIGNAL(M_USARTx_RX_vect) {
{
unsigned char c = M_UDRx; unsigned char c = M_UDRx;
store_char(c); store_char(c);
} }
@ -60,26 +58,22 @@ FORCE_INLINE void store_char(unsigned char c)
// Constructors //////////////////////////////////////////////////////////////// // Constructors ////////////////////////////////////////////////////////////////
MarlinSerial::MarlinSerial() MarlinSerial::MarlinSerial() { }
{
}
// Public Methods ////////////////////////////////////////////////////////////// // Public Methods //////////////////////////////////////////////////////////////
void MarlinSerial::begin(long baud) void MarlinSerial::begin(long baud) {
{
uint16_t baud_setting; uint16_t baud_setting;
bool useU2X = true; bool useU2X = true;
#if F_CPU == 16000000UL && SERIAL_PORT == 0 #if F_CPU == 16000000UL && SERIAL_PORT == 0
// hard-coded exception for compatibility with the bootloader shipped // hard-coded exception for compatibility with the bootloader shipped
// with the Duemilanove and previous boards and the firmware on the 8U2 // with the Duemilanove and previous boards and the firmware on the 8U2
// on the Uno and Mega 2560. // on the Uno and Mega 2560.
if (baud == 57600) { if (baud == 57600) {
useU2X = false; useU2X = false;
} }
#endif #endif
if (useU2X) { if (useU2X) {
M_UCSRxA = 1 << M_U2Xx; M_UCSRxA = 1 << M_U2Xx;
@ -98,17 +92,14 @@ void MarlinSerial::begin(long baud)
sbi(M_UCSRxB, M_RXCIEx); sbi(M_UCSRxB, M_RXCIEx);
} }
void MarlinSerial::end() void MarlinSerial::end() {
{
cbi(M_UCSRxB, M_RXENx); cbi(M_UCSRxB, M_RXENx);
cbi(M_UCSRxB, M_TXENx); cbi(M_UCSRxB, M_TXENx);
cbi(M_UCSRxB, M_RXCIEx); cbi(M_UCSRxB, M_RXCIEx);
} }
int MarlinSerial::peek(void) {
int MarlinSerial::peek(void)
{
if (rx_buffer.head == rx_buffer.tail) { if (rx_buffer.head == rx_buffer.tail) {
return -1; return -1;
} else { } else {
@ -116,20 +107,19 @@ int MarlinSerial::peek(void)
} }
} }
int MarlinSerial::read(void) int MarlinSerial::read(void) {
{
// if the head isn't ahead of the tail, we don't have any characters // if the head isn't ahead of the tail, we don't have any characters
if (rx_buffer.head == rx_buffer.tail) { if (rx_buffer.head == rx_buffer.tail) {
return -1; return -1;
} else { }
else {
unsigned char c = rx_buffer.buffer[rx_buffer.tail]; unsigned char c = rx_buffer.buffer[rx_buffer.tail];
rx_buffer.tail = (unsigned int)(rx_buffer.tail + 1) % RX_BUFFER_SIZE; rx_buffer.tail = (unsigned int)(rx_buffer.tail + 1) % RX_BUFFER_SIZE;
return c; return c;
} }
} }
void MarlinSerial::flush() void MarlinSerial::flush() {
{
// don't reverse this or there may be problems if the RX interrupt // don't reverse this or there may be problems if the RX interrupt
// occurs after reading the value of rx_buffer_head but before writing // occurs after reading the value of rx_buffer_head but before writing
// the value to rx_buffer_tail; the previous value of rx_buffer_head // the value to rx_buffer_tail; the previous value of rx_buffer_head
@ -143,38 +133,30 @@ void MarlinSerial::flush()
} }
/// imports from print.h /// imports from print.h
void MarlinSerial::print(char c, int base) {
void MarlinSerial::print(char c, int base)
{
print((long) c, base); print((long) c, base);
} }
void MarlinSerial::print(unsigned char b, int base) void MarlinSerial::print(unsigned char b, int base) {
{
print((unsigned long) b, base); print((unsigned long) b, base);
} }
void MarlinSerial::print(int n, int base) void MarlinSerial::print(int n, int base) {
{
print((long) n, base); print((long) n, base);
} }
void MarlinSerial::print(unsigned int n, int base) void MarlinSerial::print(unsigned int n, int base) {
{
print((unsigned long) n, base); print((unsigned long) n, base);
} }
void MarlinSerial::print(long n, int base) void MarlinSerial::print(long n, int base) {
{
if (base == 0) { if (base == 0) {
write(n); write(n);
} else if (base == 10) { }
else if (base == 10) {
if (n < 0) { if (n < 0) {
print('-'); print('-');
n = -n; n = -n;
@ -185,81 +167,68 @@ void MarlinSerial::print(long n, int base)
} }
} }
void MarlinSerial::print(unsigned long n, int base) void MarlinSerial::print(unsigned long n, int base) {
{
if (base == 0) write(n); if (base == 0) write(n);
else printNumber(n, base); else printNumber(n, base);
} }
void MarlinSerial::print(double n, int digits) void MarlinSerial::print(double n, int digits) {
{
printFloat(n, digits); printFloat(n, digits);
} }
void MarlinSerial::println(void) void MarlinSerial::println(void) {
{
print('\r'); print('\r');
print('\n'); print('\n');
} }
void MarlinSerial::println(const String &s) void MarlinSerial::println(const String &s) {
{
print(s); print(s);
println(); println();
} }
void MarlinSerial::println(const char c[]) void MarlinSerial::println(const char c[]) {
{
print(c); print(c);
println(); println();
} }
void MarlinSerial::println(char c, int base) void MarlinSerial::println(char c, int base) {
{
print(c, base); print(c, base);
println(); println();
} }
void MarlinSerial::println(unsigned char b, int base) void MarlinSerial::println(unsigned char b, int base) {
{
print(b, base); print(b, base);
println(); println();
} }
void MarlinSerial::println(int n, int base) void MarlinSerial::println(int n, int base) {
{
print(n, base); print(n, base);
println(); println();
} }
void MarlinSerial::println(unsigned int n, int base) void MarlinSerial::println(unsigned int n, int base) {
{
print(n, base); print(n, base);
println(); println();
} }
void MarlinSerial::println(long n, int base) void MarlinSerial::println(long n, int base) {
{
print(n, base); print(n, base);
println(); println();
} }
void MarlinSerial::println(unsigned long n, int base) void MarlinSerial::println(unsigned long n, int base) {
{
print(n, base); print(n, base);
println(); println();
} }
void MarlinSerial::println(double n, int digits) void MarlinSerial::println(double n, int digits) {
{
print(n, digits); print(n, digits);
println(); println();
} }
// Private Methods ///////////////////////////////////////////////////////////// // Private Methods /////////////////////////////////////////////////////////////
void MarlinSerial::printNumber(unsigned long n, uint8_t base) void MarlinSerial::printNumber(unsigned long n, uint8_t base) {
{
unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars. unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars.
unsigned long i = 0; unsigned long i = 0;
@ -279,18 +248,16 @@ void MarlinSerial::printNumber(unsigned long n, uint8_t base)
'A' + buf[i - 1] - 10)); 'A' + buf[i - 1] - 10));
} }
void MarlinSerial::printFloat(double number, uint8_t digits) void MarlinSerial::printFloat(double number, uint8_t digits) {
{
// Handle negative numbers // Handle negative numbers
if (number < 0.0) if (number < 0.0) {
{
print('-'); print('-');
number = -number; number = -number;
} }
// Round correctly so that print(1.999, 2) prints as "2.00" // Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5; double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i) for (uint8_t i = 0; i < digits; ++i)
rounding /= 10.0; rounding /= 10.0;
number += rounding; number += rounding;
@ -305,8 +272,7 @@ void MarlinSerial::printFloat(double number, uint8_t digits)
print("."); print(".");
// Extract digits from the remainder one at a time // Extract digits from the remainder one at a time
while (digits-- > 0) while (digits-- > 0) {
{
remainder *= 10.0; remainder *= 10.0;
int toPrint = int(remainder); int toPrint = int(remainder);
print(toPrint); print(toPrint);

69
Marlin/MarlinSerial.h
View File

@ -23,8 +23,8 @@
#define MarlinSerial_h #define MarlinSerial_h
#include "Marlin.h" #include "Marlin.h"
#if !defined(SERIAL_PORT) #ifndef SERIAL_PORT
#define SERIAL_PORT 0 #define SERIAL_PORT 0
#endif #endif
// The presence of the UBRRH register is used to detect a UART. // The presence of the UBRRH register is used to detect a UART.
@ -36,9 +36,9 @@
// requires two levels of indirection to expand macro values properly) // requires two levels of indirection to expand macro values properly)
#define SERIAL_REGNAME(registerbase,number,suffix) SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) #define SERIAL_REGNAME(registerbase,number,suffix) SERIAL_REGNAME_INTERNAL(registerbase,number,suffix)
#if SERIAL_PORT == 0 && (!defined(UBRR0H) || !defined(UDR0)) // use un-numbered registers if necessary #if SERIAL_PORT == 0 && (!defined(UBRR0H) || !defined(UDR0)) // use un-numbered registers if necessary
#define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix
#else #else
#define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
#endif #endif
// Registers used by MarlinSerial class (these are expanded // Registers used by MarlinSerial class (these are expanded
@ -57,7 +57,6 @@
#define M_U2Xx SERIAL_REGNAME(U2X,SERIAL_PORT,) #define M_U2Xx SERIAL_REGNAME(U2X,SERIAL_PORT,)
#define DEC 10 #define DEC 10
#define HEX 16 #define HEX 16
#define OCT 8 #define OCT 8
@ -73,8 +72,7 @@
#define RX_BUFFER_SIZE 128 #define RX_BUFFER_SIZE 128
struct ring_buffer struct ring_buffer {
{
unsigned char buffer[RX_BUFFER_SIZE]; unsigned char buffer[RX_BUFFER_SIZE];
int head; int head;
int tail; int tail;
@ -84,8 +82,7 @@ struct ring_buffer
extern ring_buffer rx_buffer; extern ring_buffer rx_buffer;
#endif #endif
class MarlinSerial //: public Stream class MarlinSerial { //: public Stream
{
public: public:
MarlinSerial(); MarlinSerial();
@ -94,24 +91,20 @@ class MarlinSerial //: public Stream
int peek(void); int peek(void);
int read(void); int read(void);
void flush(void); void flush(void);
FORCE_INLINE int available(void) FORCE_INLINE int available(void) {
{
return (unsigned int)(RX_BUFFER_SIZE + rx_buffer.head - rx_buffer.tail) % RX_BUFFER_SIZE; return (unsigned int)(RX_BUFFER_SIZE + rx_buffer.head - rx_buffer.tail) % RX_BUFFER_SIZE;
} }
FORCE_INLINE void write(uint8_t c) FORCE_INLINE void write(uint8_t c) {
{
while (!((M_UCSRxA) & (1 << M_UDREx))) while (!((M_UCSRxA) & (1 << M_UDREx)))
; ;
M_UDRx = c; M_UDRx = c;
} }
FORCE_INLINE void checkRx(void) {
FORCE_INLINE void checkRx(void) if ((M_UCSRxA & (1<<M_RXCx)) != 0) {
{
if((M_UCSRxA & (1<<M_RXCx)) != 0) {
unsigned char c = M_UDRx; unsigned char c = M_UDRx;
int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE; int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE;
@ -125,39 +118,17 @@ class MarlinSerial //: public Stream
} }
} }
} }
private:
private:
void printNumber(unsigned long, uint8_t); void printNumber(unsigned long, uint8_t);
void printFloat(double, uint8_t); void printFloat(double, uint8_t);
public:
FORCE_INLINE void write(const char *str)
{
while (*str)
write(*str++);
}
public:
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 String &s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
FORCE_INLINE void print(const char *str) { write(str); }
FORCE_INLINE void write(const uint8_t *buffer, size_t size)
{
while (size--)
write(*buffer++);
}
FORCE_INLINE void print(const String &s)
{
for (int i = 0; i < (int)s.length(); i++) {
write(s[i]);
}
}
FORCE_INLINE void print(const char *str)
{
write(str);
}
void print(char, int = BYTE); void print(char, int = BYTE);
void print(unsigned char, int = BYTE); void print(unsigned char, int = BYTE);
void print(int, int = DEC); void print(int, int = DEC);

Write Preview
Loading…
Cancel
Save