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

Tweaks to HAL codestyle

pull/1/head
Scott Lahteine 6 years ago
parent
0e0f17be30
commit
f3dbe19669
5 changed files with 76 additions and 139 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. 147
      Marlin/src/HAL/HAL_LPC1768/SoftwareSerial.cpp
  2. 4
      Marlin/src/HAL/HAL_LPC1768/arduino.cpp
  3. 34
      Marlin/src/HAL/HAL_STM32F7/EmulatedEeprom.cpp
  4. 26
      Marlin/src/HAL/I2cEeprom.cpp
  5. 4
      Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp

147
Marlin/src/HAL/HAL_LPC1768/SoftwareSerial.cpp
View File

@ -54,8 +54,7 @@ unsigned char SoftwareSerial::_receive_buffer[_SS_MAX_RX_BUFF];
volatile uint8_t SoftwareSerial::_receive_buffer_tail = 0; volatile uint8_t SoftwareSerial::_receive_buffer_tail = 0;
volatile uint8_t SoftwareSerial::_receive_buffer_head = 0; volatile uint8_t SoftwareSerial::_receive_buffer_head = 0;
typedef struct _DELAY_TABLE typedef struct _DELAY_TABLE {
{
long baud; long baud;
uint16_t rx_delay_centering; uint16_t rx_delay_centering;
uint16_t rx_delay_intrabit; uint16_t rx_delay_intrabit;
@ -64,16 +63,12 @@ typedef struct _DELAY_TABLE
} DELAY_TABLE; } DELAY_TABLE;
// rough delay estimation // rough delay estimation
static const DELAY_TABLE table[] = static const DELAY_TABLE table[] = {
{ //baud |rxcenter|rxintra |rxstop |tx { 250000, 2, 4, 4, 4, }, //Done but not good due to instruction cycle error { 115200, 4, 8, 8, 8, }, //Done but not good due to instruction cycle error
//baud |rxcenter|rxintra |rxstop |tx
{ 250000, 2, 4, 4, 4, }, //Done but not good due to instruction cycle error
{ 115200, 4, 8, 8, 8, }, //Done but not good due to instruction cycle error
//{ 74880, 69, 139, 62, 162, }, // estimation //{ 74880, 69, 139, 62, 162, }, // estimation
// { 57600, 100, 185, 1, 208, }, // Done but not good due to instruction cycle error // { 57600, 100, 185, 1, 208, }, // Done but not good due to instruction cycle error
//{ 38400, 13, 26, 26, 26, }, // Done //{ 38400, 13, 26, 26, 26, }, // Done
//{ 19200, 26, 52, 52, 52, }, // Done //{ 19200, 26, 52, 52, 52, }, // Done { 9600, 52, 104, 104, 104, }, // Done
{ 9600, 52, 104, 104, 104, }, // Done
//{ 4800, 104, 208, 208, 208, }, //{ 4800, 104, 208, 208, 208, },
//{ 2400, 208, 417, 417, 417, }, //{ 2400, 208, 417, 417, 417, },
//{ 1200, 416, 833, 833, 833,}, //{ 1200, 416, 833, 833, 833,},
@ -85,7 +80,7 @@ static const DELAY_TABLE table[] =
#if 0 #if 0
/* static */ /* static */
inline void SoftwareSerial::tunedDelay(uint32_t count) { inline void SoftwareSerial::tunedDelay(const uint32_t count) {
asm volatile( asm volatile(
@ -101,20 +96,18 @@ inline void SoftwareSerial::tunedDelay(uint32_t count) {
} }
#else #else
inline void SoftwareSerial::tunedDelay(uint32_t count) { inline void SoftwareSerial::tunedDelay(const uint32_t count) {
delayMicroseconds(count); delayMicroseconds(count);
} }
#endif #endif
// This function sets the current object as the "listening" // This function sets the current object as the "listening"
// one and returns true if it replaces another // one and returns true if it replaces another
bool SoftwareSerial::listen() bool SoftwareSerial::listen() {
{
if (!_rx_delay_stopbit) if (!_rx_delay_stopbit)
return false; return false;
if (active_object != this) if (active_object != this) {
{
if (active_object) if (active_object)
active_object->stopListening(); active_object->stopListening();
@ -130,10 +123,8 @@ bool SoftwareSerial::listen()
} }
// Stop listening. Returns true if we were actually listening. // Stop listening. Returns true if we were actually listening.
bool SoftwareSerial::stopListening() bool SoftwareSerial::stopListening() {
{ if (active_object == this) {
if (active_object == this)
{
setRxIntMsk(false); setRxIntMsk(false);
active_object = NULL; active_object = NULL;
return true; return true;
@ -144,14 +135,12 @@ bool SoftwareSerial::stopListening()
// //
// The receive routine called by the interrupt handler // The receive routine called by the interrupt handler
// //
void SoftwareSerial::recv() void SoftwareSerial::recv() {
{
uint8_t d = 0; uint8_t d = 0;
// If RX line is high, then we don't see any start bit // If RX line is high, then we don't see any start bit
// so interrupt is probably not for us // so interrupt is probably not for us
if (_inverse_logic ? rx_pin_read() : !rx_pin_read()) if (_inverse_logic ? rx_pin_read() : !rx_pin_read()) {
{
// Disable further interrupts during reception, this prevents // Disable further interrupts during reception, this prevents
// triggering another interrupt directly after we return, which can // triggering another interrupt directly after we return, which can
// cause problems at higher baudrates. // cause problems at higher baudrates.
@ -160,38 +149,31 @@ void SoftwareSerial::recv()
// Wait approximately 1/2 of a bit width to "center" the sample // Wait approximately 1/2 of a bit width to "center" the sample
tunedDelay(_rx_delay_centering); tunedDelay(_rx_delay_centering);
// Read each of the 8 bits // Read each of the 8 bits
for (uint8_t i=8; i > 0; --i) for (uint8_t i=8; i > 0; --i) {
{ tunedDelay(_rx_delay_intrabit);
tunedDelay(_rx_delay_intrabit);
d >>= 1; d >>= 1;
if (rx_pin_read()) if (rx_pin_read()) d |= 0x80;
d |= 0x80;
} }
if (_inverse_logic) if (_inverse_logic) d = ~d;
d = ~d;
// if buffer full, set the overflow flag and return // if buffer full, set the overflow flag and return
uint8_t next = (_receive_buffer_tail + 1) % _SS_MAX_RX_BUFF; uint8_t next = (_receive_buffer_tail + 1) % _SS_MAX_RX_BUFF;
if (next != _receive_buffer_head) if (next != _receive_buffer_head) {
{
// save new data in buffer: tail points to where byte goes // save new data in buffer: tail points to where byte goes
_receive_buffer[_receive_buffer_tail] = d; // save new byte _receive_buffer[_receive_buffer_tail] = d; // save new byte
_receive_buffer_tail = next; _receive_buffer_tail = next;
} }
else else {
{
_buffer_overflow = true; _buffer_overflow = true;
} }
tunedDelay(_rx_delay_stopbit); tunedDelay(_rx_delay_stopbit);
// Re-enable interrupts when we're sure to be inside the stop bit // Re-enable interrupts when we're sure to be inside the stop bit
setRxIntMsk(true);//__enable_irq();// setRxIntMsk(true); //__enable_irq();//
} }
} }
uint32_t SoftwareSerial::rx_pin_read() uint32_t SoftwareSerial::rx_pin_read() {
{
return digitalRead(_receivePin); return digitalRead(_receivePin);
} }
@ -200,12 +182,9 @@ uint32_t SoftwareSerial::rx_pin_read()
// //
/* static */ /* static */
inline void SoftwareSerial::handle_interrupt() inline void SoftwareSerial::handle_interrupt() {
{
if (active_object) if (active_object)
{
active_object->recv(); active_object->recv();
}
} }
extern "C" void intWrapper() { extern "C" void intWrapper() {
SoftwareSerial::handle_interrupt(); SoftwareSerial::handle_interrupt();
@ -219,23 +198,19 @@ SoftwareSerial::SoftwareSerial(pin_t receivePin, pin_t transmitPin, bool inverse
_rx_delay_stopbit(0), _rx_delay_stopbit(0),
_tx_delay(0), _tx_delay(0),
_buffer_overflow(false), _buffer_overflow(false),
_inverse_logic(inverse_logic) _inverse_logic(inverse_logic) {
{
setTX(transmitPin); setTX(transmitPin);
setRX(receivePin); setRX(receivePin);
} }
// //
// Destructor // Destructor
// //
SoftwareSerial::~SoftwareSerial() SoftwareSerial::~SoftwareSerial() {
{
end(); end();
} }
void SoftwareSerial::setTX(pin_t tx) void SoftwareSerial::setTX(pin_t tx) {
{
// First write, then set output. If we do this the other way around, // First write, then set output. If we do this the other way around,
// the pin would be output low for a short while before switching to // the pin would be output low for a short while before switching to
// output hihg. Now, it is input with pullup for a short while, which // output hihg. Now, it is input with pullup for a short while, which
@ -244,36 +219,30 @@ void SoftwareSerial::setTX(pin_t tx)
digitalWrite(tx, _inverse_logic ? LOW : HIGH); digitalWrite(tx, _inverse_logic ? LOW : HIGH);
pinMode(tx,OUTPUT); pinMode(tx,OUTPUT);
_transmitPin = tx; _transmitPin = tx;
} }
void SoftwareSerial::setRX(pin_t rx) void SoftwareSerial::setRX(pin_t rx) {
{
pinMode(rx, INPUT_PULLUP); // pullup for normal logic! pinMode(rx, INPUT_PULLUP); // pullup for normal logic!
//if (!_inverse_logic) //if (!_inverse_logic)
// digitalWrite(rx, HIGH); // digitalWrite(rx, HIGH);
_receivePin = rx; _receivePin = rx;
_receivePort = LPC1768_PIN_PORT(rx); _receivePort = LPC1768_PIN_PORT(rx);
_receivePortPin = LPC1768_PIN_PIN(rx); _receivePortPin = LPC1768_PIN_PIN(rx);
/* GPIO_T * rxPort = digitalPinToPort(rx); /* GPIO_T * rxPort = digitalPinToPort(rx);
_receivePortRegister = portInputRegister(rxPort); _receivePortRegister = portInputRegister(rxPort);
_receiveBitMask = digitalPinToBitMask(rx);*/ _receiveBitMask = digitalPinToBitMask(rx);*/
} }
// //
// Public methods // Public methods
// //
void SoftwareSerial::begin(long speed) void SoftwareSerial::begin(long speed) {
{
_rx_delay_centering = _rx_delay_intrabit = _rx_delay_stopbit = _tx_delay = 0; _rx_delay_centering = _rx_delay_intrabit = _rx_delay_stopbit = _tx_delay = 0;
for(uint8_t i = 0; i < sizeof(table)/sizeof(table[0]); ++i) for(uint8_t i = 0; i < sizeof(table)/sizeof(table[0]); ++i) {
{
long baud = table[i].baud; long baud = table[i].baud;
if(baud == speed) if (baud == speed) {
{
_rx_delay_centering = table[i].rx_delay_centering; _rx_delay_centering = table[i].rx_delay_centering;
_rx_delay_intrabit = table[i].rx_delay_intrabit; _rx_delay_intrabit = table[i].rx_delay_intrabit;
_rx_delay_stopbit = table[i].rx_delay_stopbit; _rx_delay_stopbit = table[i].rx_delay_stopbit;
@ -289,29 +258,24 @@ void SoftwareSerial::begin(long speed)
} }
void SoftwareSerial::setRxIntMsk(bool enable) void SoftwareSerial::setRxIntMsk(bool enable) {
{
if (enable) if (enable)
GpioEnableInt(_receivePort,_receivePin,CHANGE); GpioEnableInt(_receivePort,_receivePin,CHANGE);
else else
GpioDisableInt(_receivePort,_receivePin); GpioDisableInt(_receivePort,_receivePin);
} }
void SoftwareSerial::end() void SoftwareSerial::end() {
{
stopListening(); stopListening();
} }
// Read data from buffer // Read data from buffer
int SoftwareSerial::read() int SoftwareSerial::read() {
{ if (!isListening()) return -1;
if (!isListening())
return -1;
// Empty buffer? // Empty buffer?
if (_receive_buffer_head == _receive_buffer_tail) if (_receive_buffer_head == _receive_buffer_tail) return -1;
return -1;
// Read from "head" // Read from "head"
uint8_t d = _receive_buffer[_receive_buffer_head]; // grab next byte uint8_t d = _receive_buffer[_receive_buffer_head]; // grab next byte
@ -319,16 +283,13 @@ int SoftwareSerial::read()
return d; return d;
} }
int SoftwareSerial::available() int SoftwareSerial::available() {
{ if (!isListening()) return 0;
if (!isListening())
return 0;
return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF; return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF;
} }
size_t SoftwareSerial::write(uint8_t b) size_t SoftwareSerial::write(uint8_t b) {
{
// By declaring these as local variables, the compiler will put them // By declaring these as local variables, the compiler will put them
// in registers _before_ disabling interrupts and entering the // in registers _before_ disabling interrupts and entering the
// critical timing sections below, which makes it a lot easier to // critical timing sections below, which makes it a lot easier to
@ -337,36 +298,25 @@ size_t SoftwareSerial::write(uint8_t b)
bool inv = _inverse_logic; bool inv = _inverse_logic;
uint16_t delay = _tx_delay; uint16_t delay = _tx_delay;
if(inv) if (inv) b = ~b;
b = ~b;
cli(); // turn off interrupts for a clean txmit cli(); // turn off interrupts for a clean txmit
// Write the start bit // Write the start bit
if (inv) digitalWrite(_transmitPin, !!inv);
digitalWrite(_transmitPin, 1);
else
digitalWrite(_transmitPin, 0);
tunedDelay(delay); tunedDelay(delay);
// Write each of the 8 bits // Write each of the 8 bits
for (uint8_t i = 8; i > 0; --i) for (uint8_t i = 8; i > 0; --i) {
{ digitalWrite(_transmitPin, b & 1); // send 1 //(GPIO_Desc[_transmitPin].P)->DOUT |= GPIO_Desc[_transmitPin].bit;
if (b & 1) // choose bit // send 0 //(GPIO_Desc[_transmitPin].P)->DOUT &= ~GPIO_Desc[_transmitPin].bit;
digitalWrite(_transmitPin, 1); // send 1 //(GPIO_Desc[_transmitPin].P)->DOUT |= GPIO_Desc[_transmitPin].bit;
else
digitalWrite(_transmitPin, 0); // send 0 //(GPIO_Desc[_transmitPin].P)->DOUT &= ~GPIO_Desc[_transmitPin].bit;
tunedDelay(delay); tunedDelay(delay);
b >>= 1; b >>= 1;
} }
// restore pin to natural state // restore pin to natural state
if (inv) digitalWrite(_transmitPin, !inv);
digitalWrite(_transmitPin, 0);
else
digitalWrite(_transmitPin, 1);
sei(); // turn interrupts back on sei(); // turn interrupts back on
tunedDelay(delay); tunedDelay(delay);
@ -374,18 +324,15 @@ size_t SoftwareSerial::write(uint8_t b)
return 1; return 1;
} }
void SoftwareSerial::flush() void SoftwareSerial::flush() {
{ if (!isListening()) return;
if (!isListening())
return;
cli(); cli();
_receive_buffer_head = _receive_buffer_tail = 0; _receive_buffer_head = _receive_buffer_tail = 0;
sei(); sei();
} }
int SoftwareSerial::peek() int SoftwareSerial::peek() {
{
if (!isListening()) if (!isListening())
return -1; return -1;

4
Marlin/src/HAL/HAL_LPC1768/arduino.cpp
View File

@ -165,9 +165,9 @@ void eeprom_write_byte(unsigned char *pos, unsigned char value) {
unsigned char eeprom_read_byte(uint8_t * pos) { return '\0'; } unsigned char eeprom_read_byte(uint8_t * pos) { return '\0'; }
void eeprom_read_block (void *__dst, const void *__src, size_t __n) { } void eeprom_read_block(void *__dst, const void *__src, size_t __n) { }
void eeprom_update_block (const void *__src, void *__dst, size_t __n) { } void eeprom_update_block(const void *__src, void *__dst, size_t __n) { }
char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s) { char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s) {
char format_string[20]; char format_string[20];

34
Marlin/src/HAL/HAL_STM32F7/EmulatedEeprom.cpp
View File

@ -80,23 +80,18 @@ static bool eeprom_initialised = false;
void eeprom_init() { void eeprom_init() {
if(!eeprom_initialised) { if (!eeprom_initialised) {
HAL_FLASH_Unlock(); HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
/* EEPROM Init */ /* EEPROM Init */
if(EE_Initialise() != EE_OK) if (EE_Initialise() != EE_OK)
{ for (;;) HAL_Delay(1); // Spin forever until watchdog reset
while(1) {
HAL_Delay(1);
}
}
HAL_FLASH_Lock(); HAL_FLASH_Lock();
eeprom_initialised = true; eeprom_initialised = true;
} }
} }
void eeprom_write_byte(unsigned char *pos, unsigned char value) { void eeprom_write_byte(unsigned char *pos, unsigned char value) {
@ -106,39 +101,38 @@ void eeprom_write_byte(unsigned char *pos, unsigned char value) {
HAL_FLASH_Unlock(); HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
if(EE_WriteVariable(eeprom_address, (uint16_t) value) != EE_OK) {
while(1) { if (EE_WriteVariable(eeprom_address, (uint16_t) value) != EE_OK)
HAL_Delay(1); for (;;) HAL_Delay(1); // Spin forever until watchdog reset
}
}
HAL_FLASH_Lock(); HAL_FLASH_Lock();
} }
unsigned char eeprom_read_byte(unsigned char *pos) { unsigned char eeprom_read_byte(unsigned char *pos) {
uint16_t data = 0xFF; uint16_t data = 0xFF;
uint16_t eeprom_address = (unsigned) pos; uint16_t eeprom_address = (unsigned)pos;
eeprom_init(); eeprom_init();
if(EE_ReadVariable(eeprom_address, &data) != EE_OK) { if (EE_ReadVariable(eeprom_address, &data) != EE_OK) {
return (char) data; return (unsigned char)data;
} }
return (char)data; return (unsigned char)data;
} }
void eeprom_read_block (void *__dst, const void *__src, size_t __n) { void eeprom_read_block(void *__dst, const void *__src, size_t __n) {
uint16_t data = 0xFF; uint16_t data = 0xFF;
uint16_t eeprom_address = (unsigned) __src; uint16_t eeprom_address = (unsigned) __src;
eeprom_init(); eeprom_init();
for(uint8_t c = 0; c < __n; c++) { for (uint8_t c = 0; c < __n; c++) {
EE_ReadVariable(eeprom_address+c, &data); EE_ReadVariable(eeprom_address+c, &data);
*((uint8_t*)__dst + c) = data; *((uint8_t*)__dst + c) = data;
} }
} }
void eeprom_update_block (const void *__src, void *__dst, size_t __n) { void eeprom_update_block(const void *__src, void *__dst, size_t __n) {
} }

26
Marlin/src/HAL/I2cEeprom.cpp
View File

@ -72,10 +72,10 @@
// Public functions // Public functions
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
static bool eeprom_initialised = false;
static uint8_t eeprom_device_address = 0x50; static uint8_t eeprom_device_address = 0x50;
static void eeprom_init(void) { static void eeprom_init(void) {
static bool eeprom_initialised = false;
if (!eeprom_initialised) { if (!eeprom_initialised) {
Wire.begin(); Wire.begin();
eeprom_initialised = true; eeprom_initialised = true;
@ -100,27 +100,25 @@ void eeprom_write_byte(unsigned char *pos, unsigned char value) {
// WARNING: address is a page address, 6-bit end will wrap around // WARNING: address is a page address, 6-bit end will wrap around
// also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
void eeprom_update_block(const void* pos, void* eeprom_address, size_t n) { void eeprom_update_block(const void *pos, void* eeprom_address, size_t n) {
uint8_t eeprom_temp[32] = {0};
uint8_t flag = 0;
eeprom_init(); eeprom_init();
Wire.beginTransmission(eeprom_device_address); Wire.beginTransmission(eeprom_device_address);
Wire.write((int)((unsigned)eeprom_address >> 8)); // MSB Wire.write((int)((unsigned)eeprom_address >> 8)); // MSB
Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB
Wire.endTransmission(); Wire.endTransmission();
uint8_t *ptr = (uint8_t*)pos;
uint8_t flag = 0;
Wire.requestFrom(eeprom_device_address, (byte)n); Wire.requestFrom(eeprom_device_address, (byte)n);
for (byte c = 0; c < n; c++) { for (byte c = 0; c < n && Wire.available(); c++)
if (Wire.available()) eeprom_temp[c] = Wire.read(); flag |= Wire.read() ^ ptr[c];
flag |= (eeprom_temp[c] ^ *((uint8_t*)pos + c));
}
if (flag) { if (flag) {
Wire.beginTransmission(eeprom_device_address); Wire.beginTransmission(eeprom_device_address);
Wire.write((int)((unsigned)eeprom_address >> 8)); // MSB Wire.write((int)((unsigned)eeprom_address >> 8)); // MSB
Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB
Wire.write((uint8_t*)(pos), n); Wire.write((uint8_t*)pos, n);
Wire.endTransmission(); Wire.endTransmission();
// wait for write cycle to complete // wait for write cycle to complete
@ -132,18 +130,16 @@ void eeprom_update_block(const void* pos, void* eeprom_address, size_t n) {
unsigned char eeprom_read_byte(unsigned char *pos) { unsigned char eeprom_read_byte(unsigned char *pos) {
byte data = 0xFF; byte data = 0xFF;
unsigned eeprom_address = (unsigned) pos; unsigned eeprom_address = (unsigned)pos;
eeprom_init (); eeprom_init();
Wire.beginTransmission(eeprom_device_address); Wire.beginTransmission(eeprom_device_address);
Wire.write((int)(eeprom_address >> 8)); // MSB Wire.write((int)(eeprom_address >> 8)); // MSB
Wire.write((int)(eeprom_address & 0xFF)); // LSB Wire.write((int)(eeprom_address & 0xFF)); // LSB
Wire.endTransmission(); Wire.endTransmission();
Wire.requestFrom(eeprom_device_address, (byte)1); Wire.requestFrom(eeprom_device_address, (byte)1);
if (Wire.available()) return Wire.available() ? Wire.read() : 0xFF;
data = Wire.read();
return data;
} }
// maybe let's not read more than 30 or 32 bytes at a time! // maybe let's not read more than 30 or 32 bytes at a time!

4
Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp
View File

@ -541,7 +541,7 @@
// increment to first segment destination // increment to first segment destination
LOOP_XYZE(i) raw[i] += diff[i]; LOOP_XYZE(i) raw[i] += diff[i];
for(;;) { // for each mesh cell encountered during the move for (;;) { // for each mesh cell encountered during the move
// Compute mesh cell invariants that remain constant for all segments within cell. // Compute mesh cell invariants that remain constant for all segments within cell.
// Note for cell index, if point is outside the mesh grid (in MESH_INSET perimeter) // Note for cell index, if point is outside the mesh grid (in MESH_INSET perimeter)
@ -591,7 +591,7 @@
const float z_sxy0 = z_xmy0 * diff[X_AXIS], // per-segment adjustment to z_cxy0 const float z_sxy0 = z_xmy0 * diff[X_AXIS], // per-segment adjustment to z_cxy0
z_sxym = (z_xmy1 - z_xmy0) * (1.0 / (MESH_Y_DIST)) * diff[X_AXIS]; // per-segment adjustment to z_cxym z_sxym = (z_xmy1 - z_xmy0) * (1.0 / (MESH_Y_DIST)) * diff[X_AXIS]; // per-segment adjustment to z_cxym
for(;;) { // for all segments within this mesh cell for (;;) { // for all segments within this mesh cell
if (--segments == 0) // if this is last segment, use rtarget for exact if (--segments == 0) // if this is last segment, use rtarget for exact
COPY(raw, rtarget); COPY(raw, rtarget);

Write Preview
Loading…
Cancel
Save