GRBL学习

Posted 2022-12-01 Sola_Ex

GRBL学习

最后我还是断更了一段时间哈哈哈哈。

nuts_bolts.c/.h

#define MAX_INT_DIGITS 8 // Maximum number of digits in int32 (and float)


// Extracts a floating point value from a string. The following code is based loosely on
// the avr-libc strtod() function by Michael Stumpf and Dmitry Xmelkov and many freely
// available conversion method examples, but has been highly optimized for Grbl. For known
// CNC applications, the typical decimal value is expected to be in the range of E0 to E-4.
// Scientific notation is officially not supported by g-code, and the 'E' character may
// be a g-code word on some CNC systems. So, 'E' notation will not be recognized.
// NOTE: Thanks to Radu-Eosif Mihailescu for identifying the issues with using strtod().
uint8_t read_float(char *line, uint8_t *char_counter, float *float_ptr)

  char *ptr = line + *char_counter;
  unsigned char c;

  // Grab first character and increment pointer. No spaces assumed in line.
  c = *ptr++;

  // Capture initial positive/minus character
  bool isnegative = false;
  if (c == '-') 
    isnegative = true;
    c = *ptr++;
   else if (c == '+') 
    c = *ptr++;
  

  // Extract number into fast integer. Track decimal in terms of exponent value.
  uint32_t intval = 0;
  int8_t exp = 0;
  uint8_t ndigit = 0;
  bool isdecimal = false;
  while(1) 
    c -= '0';
    if (c <= 9) 
      ndigit++;
      if (ndigit <= MAX_INT_DIGITS) 
        if (isdecimal)  exp--; 
        intval = (((intval << 2) + intval) << 1) + c; // intval*10 + c
       else 
        if (!(isdecimal))  exp++;   // Drop overflow digits
      
     else if (c == (('.'-'0') & 0xff)  &&  !(isdecimal)) 
      isdecimal = true;
     else 
      break;
    
    c = *ptr++;
  

  // Return if no digits have been read.
  if (!ndigit)  return(false); ;

  // Convert integer into floating point.
  float fval;
  fval = (float)intval;

  // Apply decimal. Should perform no more than two floating point multiplications for the
  // expected range of E0 to E-4.
  if (fval != 0) 
    while (exp <= -2) 
      fval *= 0.01;
      exp += 2;
    
    if (exp < 0) 
      fval *= 0.1;
     else if (exp > 0) 
      do 
        fval *= 10.0;
       while (--exp > 0);
    
  

  // Assign floating point value with correct sign.
  if (isnegative) 
    *float_ptr = -fval;
   else 
    *float_ptr = fval;
  

  *char_counter = ptr - line - 1; // Set char_counter to next statement

  return(true);



// Non-blocking delay function used for general operation and suspend features.
void delay_sec(float seconds, uint8_t mode)

 	uint16_t i = ceil(1000/DWELL_TIME_STEP*seconds);
	while (i-- > 0) 
		if (sys.abort)  return; 
		if (mode == DELAY_MODE_DWELL) 
			protocol_execute_realtime();
		 else  // DELAY_MODE_SYS_SUSPEND
		  // Execute rt_system() only to avoid nesting suspend loops.
		  protocol_exec_rt_system();
		  if (sys.suspend & SUSPEND_RESTART_RETRACT)  return;  // Bail, if safety door reopens.
		
		_delay_ms(DWELL_TIME_STEP); // Delay DWELL_TIME_STEP increment
	



// Delays variable defined milliseconds. Compiler compatibility fix for _delay_ms(),
// which only accepts constants in future compiler releases.
void delay_ms(uint16_t ms)

  while ( ms-- )  _delay_ms(1); 



// Delays variable defined microseconds. Compiler compatibility fix for _delay_us(),
// which only accepts constants in future compiler releases. Written to perform more
// efficiently with larger delays, as the counter adds parasitic time in each iteration.
void delay_us(uint32_t us)

  while (us) 
    if (us < 10) 
      _delay_us(1);
      us--;
     else if (us < 100) 
      _delay_us(10);
      us -= 10;
     else if (us < 1000) 
      _delay_us(100);
      us -= 100;
     else 
      _delay_ms(1);
      us -= 1000;
    
  



// Simple hypotenuse computation function.
float hypot_f(float x, float y)  return(sqrt(x*x + y*y)); 


float convert_delta_vector_to_unit_vector(float *vector)

  uint8_t idx;
  float magnitude = 0.0;
  for (idx=0; idx<N_AXIS; idx++) 
    if (vector[idx] != 0.0) 
      magnitude += vector[idx]*vector[idx];
    
  
  magnitude = sqrt(magnitude);
  float inv_magnitude = 1.0/magnitude;
  for (idx=0; idx<N_AXIS; idx++)  vector[idx] *= inv_magnitude; 
  return(magnitude);



float limit_value_by_axis_maximum(float *max_value, float *unit_vec)

  uint8_t idx;
  float limit_value = SOME_LARGE_VALUE;
  for (idx=0; idx<N_AXIS; idx++) 
    if (unit_vec[idx] != 0)   // Avoid divide by zero.
      limit_value = min(limit_value,fabs(max_value[idx]/unit_vec[idx]));
    
  
  return(limit_value);

这个文件看上去简单多了，其实就是一些会常用上的延时函数还有一些运算函数，在头文件中，还会定义一些轴的信息，如使用了多少个轴等等，系统时钟也需要定义在则会

#define false 0
#define true 1

#define SOME_LARGE_VALUE 1.0E+38

// Axis array index values. Must start with 0 and be continuous.
#define N_AXIS 3 // Number of axes
#define X_AXIS 0 // Axis indexing value.
#define Y_AXIS 1
#define Z_AXIS 2
// #define A_AXIS 3

// CoreXY motor assignments. DO NOT ALTER.
// NOTE: If the A and B motor axis bindings are changed, this effects the CoreXY equations.
#ifdef COREXY
 #define A_MOTOR X_AXIS // Must be X_AXIS
 #define B_MOTOR Y_AXIS // Must be Y_AXIS
#endif

#define F_CPU   SystemCoreClock
// Conversions
#define MM_PER_INCH (25.40)
#define INCH_PER_MM (0.0393701)
#define TICKS_PER_MICROSECOND (F_CPU/1000000)

#define DELAY_MODE_DWELL       0
#define DELAY_MODE_SYS_SUSPEND 1

当然还有CoreXY机型的选择。