code qui ne compile pas bien

Bonjour a tous,
Étant nouveau sur ce forum, j’espère être sur le forum français , bien que ça soit écrit en anglais ( mais il est marqué Arduino Forum >International>Français>Start new topic ).
Ma difficulté est que voulant faire une petite machine CNC avec des moteurs pas à pas 28BYJ-48 et ULN2003,
j’ai recherché un fichier GRBL dans le GitHub, et je l’ai mis dans le sketch Arduino.
mais lors de la compilation du croquis, il ne compile pas ( erreur )

#include "grbl.h"

int costyx=1;

int costyy=1;

int costyz=1;

#define DT_SEGMENT (1.0/(ACCELERATION_TICKS_PER_SECOND*60.0)) // min/segment

#define REQ_MM_INCREMENT_SCALAR 1.25

#define RAMP_ACCEL 0

#define RAMP_CRUISE 1

#define RAMP_DECEL 2

#define RAMP_DECEL_OVERRIDE 3

#define PREP_FLAG_RECALCULATE bit(0)

#define PREP_FLAG_HOLD_PARTIAL_BLOCK bit(1)

#define PREP_FLAG_PARKING bit(2)

#define PREP_FLAG_DECEL_OVERRIDE bit(3)

#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

#define MAX_AMASS_LEVEL 3

#define AMASS_LEVEL1 (F_CPU/8000) // Over-drives ISR (x2). Defined as F_CPU/(Cutoff frequency in Hz)

#define AMASS_LEVEL2 (F_CPU/4000) // Over-drives ISR (x4)

#define AMASS_LEVEL3 (F_CPU/2000) // Over-drives ISR (x8)



#if MAX_AMASS_LEVEL <= 0

error "AMASS must have 1 or more levels to operate correctly."

#endif

#endif

typedef struct {

uint32_t steps[N_AXIS];

uint32_t step_event_count;

uint8_t direction_bits;

#ifdef VARIABLE_SPINDLE

uint8_t is_pwm_rate_adjusted; // Tracks motions that require constant laser power/rate

#endif

} st_block_t;

static st_block_t st_block_buffer[SEGMENT_BUFFER_SIZE-1];

typedef struct {

uint16_t n_step; // Number of step events to be executed for this segment

uint16_t cycles_per_tick; // Step distance traveled per ISR tick, aka step rate.

uint8_t st_block_index; // Stepper block data index. Uses this information to execute this segment.

#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

uint8_t amass_level; // Indicates AMASS level for the ISR to execute this segment

#else

uint8_t prescaler; // Without AMASS, a prescaler is required to adjust for slow timing.

#endif

#ifdef VARIABLE_SPINDLE

uint8_t spindle_pwm;

#endif

} segment_t;

static segment_t segment_buffer[SEGMENT_BUFFER_SIZE];

typedef struct {


uint32_t counter_x, // Counter variables for the bresenham line tracer

counter_y,

counter_z;

#ifdef STEP_PULSE_DELAY

uint8_t step_bits; // Stores out_bits output to complete the step pulse delay

#endif

uint8_t execute_step; // Flags step execution for each interrupt.

uint8_t step_pulse_time; // Step pulse reset time after step rise

uint8_t step_outbits; // The next stepping-bits to be output

uint8_t dir_outbits;


#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

uint32_t steps[N_AXIS];

#endif

uint16_t step_count; // Steps remaining in line segment motion

uint8_t exec_block_index; // Tracks the current st_block index. Change indicates new block.

st_block_t *exec_block; // Pointer to the block data for the segment being executed

segment_t *exec_segment; // Pointer to the segment being executed

} stepper_t;

static stepper_t st;

static volatile uint8_t segment_buffer_tail;

static uint8_t segment_buffer_head;

static uint8_t segment_next_head;

static uint8_t step_port_invert_mask;

static uint8_t dir_port_invert_mask;

static volatile uint8_t busy;

static plan_block_t *pl_block; // Pointer to the planner block being prepped

static st_block_t *st_prep_block; // Pointer to the stepper block data being prepped


typedef struct {

uint8_t st_block_index; // Index of stepper common data block being prepped

uint8_t recalculate_flag;



float dt_remainder;

float steps_remaining;

float step_per_mm;

float req_mm_increment;

#ifdef PARKING_ENABLE

uint8_t last_st_block_index;

float last_steps_remaining;

float last_step_per_mm;

float last_dt_remainder;

#endif

uint8_t ramp_type; // Current segment ramp state

float mm_complete; // End of velocity profile from end of current planner block in (mm).


float current_speed; // Current speed at the end of the segment buffer (mm/min)

float maximum_speed; // Maximum speed of executing block. Not always nominal speed. (mm/min)

float exit_speed; // Exit speed of executing block (mm/min)

float accelerate_until; // Acceleration ramp end measured from end of block (mm)

float decelerate_after; // Deceleration ramp start measured from end of block (mm)



#ifdef VARIABLE_SPINDLE

float inv_rate; // Used by PWM laser mode to speed up segment calculations.

uint8_t current_spindle_pwm; 

#endif

} st_prep_t;

static st_prep_t prep;


void st_wake_up()

{

if (bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE)) { STEPPERS_DISABLE_PORT |= (1<<STEPPERS_DISABLE_BIT); }

else { STEPPERS_DISABLE_PORT &= ~(1<<STEPPERS_DISABLE_BIT); }

st.step_outbits = step_port_invert_mask;

#ifdef STEP_PULSE_DELAY

st.step_pulse_time = -(((settings.pulse_microseconds+STEP_PULSE_DELAY-2)*TICKS_PER_MICROSECOND) >> 3);


OCR0A = -(((settings.pulse_microseconds)*TICKS_PER_MICROSECOND) >> 3);

#else // Normal operation

st.step_pulse_time = -(((settings.pulse_microseconds-2)*TICKS_PER_MICROSECOND) >> 3);

#endif


TIMSK1 |= (1<<OCIE1A);

}


void st_go_idle()

{


TIMSK1 &= ~(1<<OCIE1A); // Disable Timer1 interrupt

TCCR1B = (TCCR1B & ~((1<<CS12) | (1<<CS11))) | (1<<CS10); // Reset clock to no prescaling.

busy = false;

bool pin_state = false; // Keep enabled.

if (((settings.stepper_idle_lock_time != 0xff) || sys_rt_exec_alarm || sys.state == STATE_SLEEP) && sys.state != STATE_HOMING) {


delay_ms(settings.stepper_idle_lock_time);

pin_state = true; // Override. Disable steppers.

}

if (bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE)) { pin_state = !pin_state; } // Apply pin invert.

if (pin_state) { STEPPERS_DISABLE_PORT |= (1<<STEPPERS_DISABLE_BIT); }

else { STEPPERS_DISABLE_PORT &= ~(1<<STEPPERS_DISABLE_BIT); }

}

ISR(TIMER1_COMPA_vect)

{

if (busy) { return; } 


DIRECTION_PORT = (DIRECTION_PORT & ~DIRECTION_MASK) | (st.dir_outbits & DIRECTION_MASK);


#ifdef STEP_PULSE_DELAY

st.step_bits = (STEP_PORT & ~STEP_MASK) | st.step_outbits; // Store out_bits to prevent overwriting.

#else 

STEP_PORT = (STEP_PORT & ~STEP_MASK) | st.step_outbits;

#endif

TCNT0 = st.step_pulse_time; // Reload Timer0 counter

TCCR0B = (1<<CS01); // Begin Timer0. Full speed, 1/8 prescaler



busy = true;

sei(); // Re-enable interrupts to allow Stepper Port Reset Interrupt to fire on-time.

if (st.exec_segment == NULL) {

if (segment_buffer_head != segment_buffer_tail) {


st.exec_segment = &segment_buffer[segment_buffer_tail];

#ifndef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING


TCCR1B = (TCCR1B & ~(0x07<<CS10)) | (st.exec_segment->prescaler<<CS10);

#endif


OCR1A = st.exec_segment->cycles_per_tick;

st.step_count = st.exec_segment->n_step; // NOTE: Can sometimes be zero when moving slow.


if ( st.exec_block_index != st.exec_segment->st_block_index ) {

st.exec_block_index = st.exec_segment->st_block_index;

st.exec_block = &st_block_buffer[st.exec_block_index];

st.counter_x = st.counter_y = st.counter_z = (st.exec_block->step_event_count >> 1);

}

st.dir_outbits = st.exec_block->direction_bits ^ dir_port_invert_mask;


#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING


st.steps[X_AXIS] = st.exec_block->steps[X_AXIS] >> st.exec_segment->amass_level;

st.steps[Y_AXIS] = st.exec_block->steps[Y_AXIS] >> st.exec_segment->amass_level;

st.steps[Z_AXIS] = st.exec_block->steps[Z_AXIS] >> st.exec_segment->amass_level;

#endif

#ifdef VARIABLE_SPINDLE

spindle_set_speed(st.exec_segment->spindle_pwm);

#endif

} else {


st_go_idle();

#ifdef VARIABLE_SPINDLE


if (st.exec_block->is_pwm_rate_adjusted) { spindle_set_speed(SPINDLE_PWM_OFF_VALUE); }

#endif

system_set_exec_state_flag(EXEC_CYCLE_STOP); // Flag main program for cycle end

return; 

}

}


// Check probing state.

if (sys_probe_state == PROBE_ACTIVE) { probe_state_monitor(); }

st.step_outbits = 0;


st.exec_block->direction_bits = st.exec_block->direction_bits ^ dir_port_invert_mask;


#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

st.counter_x += st.steps[X_AXIS];

#else

st.counter_x += st.exec_block->steps[X_AXIS];

#endif

if (st.counter_x > st.exec_block->step_event_count) {

st.step_outbits |= (1<<X_STEP_BIT);

st.counter_x -= st.exec_block->step_event_count;

if (st.exec_block->direction_bits & (1<<X_DIRECTION_BIT)) {

le code ne passant pas ( plus que 9000 caractères) je l’écris en plusieurs messages
Merci pour l’aide que vous pourrez m’apporter
Amicalement
Urgurth

sur un besoin du message d’erreur complet

sys_position[X_AXIS]--; 

costyx=costyx-1;

if (costyx < 1) costyx=8;

if (costyx==1) PORTD=0B100000;

if (costyx==2) PORTD=0B110000;

if (costyx==3) PORTD=0B010000;

if (costyx==4) PORTD=0B011000;

if (costyx==5) PORTD=0B001000;

if (costyx==6) PORTD=0B001100;

if (costyx==7) PORTD=0B000100;

if (costyx==8) PORTD=0B100100;

} else { 

sys_position[X_AXIS]++; 

costyx=costyx+1;

if (costyx > 8) costyx=1;

if (costyx==1) PORTD=0B100000;

if (costyx==2) PORTD=0B110000;

if (costyx==3) PORTD=0B010000;

if (costyx==4) PORTD=0B011000;

if (costyx==5) PORTD=0B001000;

if (costyx==6) PORTD=0B001100;

if (costyx==7) PORTD=0B000100;

if (costyx==8) PORTD=0B100100;

}

}

#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

st.counter_y += st.steps[Y_AXIS];

#else

st.counter_y += st.exec_block->steps[Y_AXIS];

#endif

if (st.counter_y > st.exec_block->step_event_count) {

st.step_outbits |= (1<<Y_STEP_BIT);

st.counter_y -= st.exec_block->step_event_count;

if (st.exec_block->direction_bits & (1<<Y_DIRECTION_BIT)) { 

sys_position[Y_AXIS]--; 

costyy=costyy-1;

if (costyy < 1) costyy=8;

if (costyy==1) PORTC=0B1000;

if (costyy==2) PORTC=0B1100;

if (costyy==3) PORTC=0B0100;

if (costyy==4) PORTC=0B0110;

if (costyy==5) PORTC=0B0010;

if (costyy==6) PORTC=0B0011;

if (costyy==7) PORTC=0B0001;

if (costyy==8) PORTC=0B1001;

} else { 

sys_position[Y_AXIS]++;

costyy=costyy+1;

if (costyy > 8) costyy=1;

if (costyy==1) PORTC=0B1000;

if (costyy==2) PORTC=0B1100;

if (costyy==3) PORTC=0B0100;

if (costyy==4) PORTC=0B0110;

if (costyy==5) PORTC=0B0010;

if (costyy==6) PORTC=0B0011;

if (costyy==7) PORTC=0B0001;

if (costyy==8) PORTC=0B1001;

}

}

#ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

st.counter_z += st.steps[Z_AXIS];

#else

st.counter_z += st.exec_block->steps[Z_AXIS];

#endif

if (st.counter_z > st.exec_block->step_event_count) {

st.step_outbits |= (1<<Z_STEP_BIT);

st.counter_z -= st.exec_block->step_event_count;

if (st.exec_block->direction_bits & (1<<Z_DIRECTION_BIT)) { 

sys_position[Z_AXIS]--; 

costyz=costyz-1;

if (costyz < 1) costyz=8;

if (costyz==1) PORTB=0B100000;

if (costyz==2) PORTB=0B110000;

if (costyz==3) PORTB=0B010000;

if (costyz==4) PORTB=0B010010;

if (costyz==5) PORTB=0B000010;

if (costyz==6) PORTB=0B000011;

if (costyz==7) PORTB=0B000001;

if (costyz==8) PORTB=0B100001;

} else { 

sys_position[Z_AXIS]++;

costyz=costyz+1;

if (costyz > 8) costyz=1;

if (costyz==1) PORTB=0B100000;

if (costyz==2) PORTB=0B110000;

if (costyz==3) PORTB=0B010000;

if (costyz==4) PORTB=0B010010;

if (costyz==5) PORTB=0B000010;

if (costyz==6) PORTB=0B000011;

if (costyz==7) PORTB=0B000001;

if (costyz==8) PORTB=0B100001; 

}

}


if (sys.state == STATE_HOMING) { st.step_outbits &= sys.homing_axis_lock; }



st.step_count--; // Decrement step events count

if (st.step_count == 0) {


st.exec_segment = NULL;

if ( ++segment_buffer_tail == SEGMENT_BUFFER_SIZE) { segment_buffer_tail = 0; }

}



st.step_outbits ^= step_port_invert_mask; // Apply step port invert mask

busy = false;

}





ISR(TIMER0_OVF_vect)

{


STEP_PORT = (STEP_PORT & ~STEP_MASK) | (step_port_invert_mask & STEP_MASK);

TCCR0B = 0; // Disable Timer0 to prevent re-entering this interrupt when it's not needed.

}

#ifdef STEP_PULSE_DELAY


ISR(TIMER0_COMPA_vect)

{

STEP_PORT = st.step_bits; // Begin step pulse.

}

#endif


void st_generate_step_dir_invert_masks()

{

uint8_t idx;

step_port_invert_mask = 0;

dir_port_invert_mask = 0;

for (idx=0; idx<N_AXIS; idx++) {

if (bit_istrue(settings.step_invert_mask,bit(idx))) { step_port_invert_mask |= get_step_pin_mask(idx); }

if (bit_istrue(settings.dir_invert_mask,bit(idx))) { dir_port_invert_mask |= get_direction_pin_mask(idx); }

}

}


void st_reset()

{


st_go_idle();



memset(&prep, 0, sizeof(st_prep_t));

memset(&st, 0, sizeof(stepper_t));

st.exec_segment = NULL;

pl_block = NULL; // Planner block pointer used by segment buffer

segment_buffer_tail = 0;

segment_buffer_head = 0; // empty = tail

segment_next_head = 1;

busy = false;


st_generate_step_dir_invert_masks();

st.dir_outbits = dir_port_invert_mask; 



STEP_PORT = (STEP_PORT & ~STEP_MASK) | step_port_invert_mask;

DIRECTION_PORT = (DIRECTION_PORT & ~DIRECTION_MASK) | dir_port_invert_mask;


}

void stepper_init()

{


STEP_DDR |= STEP_MASK;

STEPPERS_DISABLE_DDR |= 1<<STEPPERS_DISABLE_BIT;

DIRECTION_DDR |= DIRECTION_MASK;


TCCR1B &= ~(1<<WGM13); // waveform generation = 0100 = CTC

TCCR1B |= (1<<WGM12);

TCCR1A &= ~((1<<WGM11) | (1<<WGM10));

TCCR1A &= ~((1<<COM1A1) | (1<<COM1A0) | (1<<COM1B1) | (1<<COM1B0)); // Disconnect OC1 output


TIMSK0 &= ~((1<<OCIE0B) | (1<<OCIE0A) | (1<<TOIE0)); // Disconnect OC0 outputs and OVF interrupt.

TCCR0A = 0; // Normal operation

TCCR0B = 0; // Disable Timer0 until needed

TIMSK0 |= (1<<TOIE0); // Enable Timer0 overflow interrupt

#ifdef STEP_PULSE_DELAY

TIMSK0 |= (1<<OCIE0A); // Enable Timer0 Compare Match A interrupt

#endif



DDRB=0B110011;

DDRC=0B00001111;

DDRD=0B111100;

}


void st_update_plan_block_parameters()

{

if (pl_block != NULL) { // Ignore if at start of a new block.

prep.recalculate_flag |= PREP_FLAG_RECALCULATE;

pl_block->entry_speed_sqr = prep.current_speed*prep.current_speed; // Update entry speed.

pl_block = NULL; // Flag st_prep_segment() to load and check active velocity profile.

}

}


static uint8_t st_next_block_index(uint8_t block_index)

{

block_index++;

if ( block_index == (SEGMENT_BUFFER_SIZE-1) ) { return(0); }

return(block_index);

}


#ifdef PARKING_ENABLE


void st_parking_setup_buffer()

{



if (prep.recalculate_flag & PREP_FLAG_HOLD_PARTIAL_BLOCK) {

prep.last_st_block_index = prep.st_block_index;

prep.last_steps_remaining = prep.steps_remaining;

prep.last_dt_remainder = prep.dt_remainder;

prep.last_step_per_mm = prep.step_per_mm;

}


prep.recalculate_flag |= PREP_FLAG_PARKING;

prep.recalculate_flag &= ~(PREP_FLAG_RECALCULATE);

pl_block = NULL; // Always reset parking motion to reload new block.

}


void st_parking_restore_buffer()

{


if (prep.recalculate_flag & PREP_FLAG_HOLD_PARTIAL_BLOCK) {

st_prep_block = &st_block_buffer[prep.last_st_block_index];

prep.st_block_index = prep.last_st_block_index;

prep.steps_remaining = prep.last_steps_remaining;

prep.dt_remainder = prep.last_dt_remainder;

prep.step_per_mm = prep.last_step_per_mm;

prep.recalculate_flag = (PREP_FLAG_HOLD_PARTIAL_BLOCK | PREP_FLAG_RECALCULATE);

prep.req_mm_increment = REQ_MM_INCREMENT_SCALAR/prep.step_per_mm; // Recompute this value.

} else {

prep.recalculate_flag = false;

}

pl_block = NULL; // Set to reload next block.

}

#endif





void st_prep_buffer()

{

if (bit_istrue(sys.step_control,STEP_CONTROL_END_MOTION)) { return; }



while (segment_buffer_tail != segment_next_head) { // Check if we need to fill the buffer.


if (pl_block == NULL) {


if (sys.step_control & STEP_CONTROL_EXECUTE_SYS_MOTION) { pl_block = plan_get_system_motion_block(); }

else { pl_block = plan_get_current_block(); }

if (pl_block == NULL) { return; } // No planner blocks. Exit.

if (prep.recalculate_flag & PREP_FLAG_RECALCULATE) {



#ifdef PARKING_ENABLE

if (prep.recalculate_flag & PREP_FLAG_PARKING) { prep.recalculate_flag &= ~(PREP_FLAG_RECALCULATE); }

else { prep.recalculate_flag = false; }

#else

prep.recalculate_flag = false;

#endif

} else {


prep.st_block_index = st_next_block_index(prep.st_block_index);


st_prep_block = &st_block_buffer[prep.st_block_index];

st_prep_block->direction_bits = pl_block->direction_bits;
uint8_t idx;

#ifndef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING

for (idx=0; idx<N_AXIS; idx++) { st_prep_block->steps[idx] = (pl_block->steps[idx] << 1); }

st_prep_block->step_event_count = (pl_block->step_event_count << 1);

#else


for (idx=0; idx<N_AXIS; idx++) { st_prep_block->steps[idx] = pl_block->steps[idx] << MAX_AMASS_LEVEL; }

st_prep_block->step_event_count = pl_block->step_event_count << MAX_AMASS_LEVEL;

#endif



prep.steps_remaining = (float)pl_block->step_event_count;

prep.step_per_mm = prep.steps_remaining/pl_block->millimeters;

prep.req_mm_increment = REQ_MM_INCREMENT_SCALAR/prep.step_per_mm;

prep.dt_remainder = 0.0;

if ((sys.step_control & STEP_CONTROL_EXECUTE_HOLD) || (prep.recalculate_flag & PREP_FLAG_DECEL_OVERRIDE)) {


prep.current_speed = prep.exit_speed;

pl_block->entry_speed_sqr = prep.exit_speed*prep.exit_speed;

prep.recalculate_flag &= ~(PREP_FLAG_DECEL_OVERRIDE);

} else {

prep.current_speed = sqrt(pl_block->entry_speed_sqr);

}


#ifdef VARIABLE_SPINDLE


st_prep_block->is_pwm_rate_adjusted = false;

if (settings.flags & BITFLAG_LASER_MODE) {

if (pl_block->condition & PL_COND_FLAG_SPINDLE_CCW) {


prep.inv_rate = 1.0/pl_block->programmed_rate;

st_prep_block->is_pwm_rate_adjusted = true;

}

}

#endif

}



prep.mm_complete = 0.0;

float inv_2_accel = 0.5/pl_block->acceleration;

if (sys.step_control & STEP_CONTROL_EXECUTE_HOLD) {


prep.ramp_type = RAMP_DECEL;

float decel_dist = pl_block->millimeters - inv_2_accel*pl_block->entry_speed_sqr;

if (decel_dist < 0.0) {


prep.exit_speed = sqrt(pl_block->entry_speed_sqr-2*pl_block->acceleration*pl_block->millimeters);

} else {

prep.mm_complete = decel_dist;

prep.exit_speed = 0.0;

}

} else { // [Normal Operation]


prep.ramp_type = RAMP_ACCEL;

prep.accelerate_until = pl_block->millimeters;



float exit_speed_sqr;

float nominal_speed;

if (sys.step_control & STEP_CONTROL_EXECUTE_SYS_MOTION) {

prep.exit_speed = exit_speed_sqr = 0.0;

} else {

exit_speed_sqr = plan_get_exec_block_exit_speed_sqr();

prep.exit_speed = sqrt(exit_speed_sqr);

}



nominal_speed = plan_compute_profile_nominal_speed(pl_block);

float nominal_speed_sqr = nominal_speed*nominal_speed;

float intersect_distance =

0.5*(pl_block->millimeters+inv_2_accel*(pl_block->entry_speed_sqr-exit_speed_sqr));



if (pl_block->entry_speed_sqr > nominal_speed_sqr) {

prep.accelerate_until = pl_block->millimeters - inv_2_accel*(pl_block->entry_speed_sqr-nominal_speed_sqr);

if (prep.accelerate_until <= 0.0) { // Deceleration-only.

prep.ramp_type = RAMP_DECEL;



prep.exit_speed = sqrt(pl_block->entry_speed_sqr - 2*pl_block->acceleration*pl_block->millimeters);

prep.recalculate_flag |= PREP_FLAG_DECEL_OVERRIDE;




} else {


prep.decelerate_after = inv_2_accel*(nominal_speed_sqr-exit_speed_sqr);

prep.maximum_speed = nominal_speed;

prep.ramp_type = RAMP_DECEL_OVERRIDE;

}

} else if (intersect_distance > 0.0) {

if (intersect_distance < pl_block->millimeters) {


prep.decelerate_after = inv_2_accel*(nominal_speed_sqr-exit_speed_sqr);

if (prep.decelerate_after < intersect_distance) {

prep.maximum_speed = nominal_speed;

if (pl_block->entry_speed_sqr == nominal_speed_sqr) {


prep.ramp_type = RAMP_CRUISE;

} else {


prep.accelerate_until -= inv_2_accel*(nominal_speed_sqr-pl_block->entry_speed_sqr);

}

} else {

prep.accelerate_until = intersect_distance;

prep.decelerate_after = intersect_distance;

prep.maximum_speed = sqrt(2.0*pl_block->acceleration*intersect_distance+exit_speed_sqr);

}

} else {

prep.ramp_type = RAMP_DECEL;


}

} else {

prep.accelerate_until = 0.0;


prep.maximum_speed = prep.exit_speed;

}

}



#ifdef VARIABLE_SPINDLE

bit_true(sys.step_control, STEP_CONTROL_UPDATE_SPINDLE_PWM);

#endif

}


segment_t *prep_segment = &segment_buffer[segment_buffer_head];


prep_segment->st_block_index = prep.st_block_index;



float dt_max = DT_SEGMENT;

float dt = 0.0;

float time_var = dt_max;

float mm_var;

float speed_var;

float mm_remaining = pl_block->millimeters;

float minimum_mm = mm_remaining-prep.req_mm_increment;

if (minimum_mm < 0.0) { minimum_mm = 0.0; }

do {

switch (prep.ramp_type) {

case RAMP_DECEL_OVERRIDE:

speed_var = pl_block->acceleration*time_var;

mm_var = time_var*(prep.current_speed - 0.5*speed_var);

mm_remaining -= mm_var;

if ((mm_remaining < prep.accelerate_until) || (mm_var <= 0)) {


mm_remaining = prep.accelerate_until;

time_var = 2.0*(pl_block->millimeters-mm_remaining)/(prep.current_speed+prep.maximum_speed);

prep.ramp_type = RAMP_CRUISE;

prep.current_speed = prep.maximum_speed;

} else { // Mid-deceleration override ramp.

prep.current_speed -= speed_var;

}

break;

case RAMP_ACCEL:

speed_var = pl_block->acceleration*time_var;

mm_remaining -= time_var*(prep.current_speed + 0.5*speed_var);

if (mm_remaining < prep.accelerate_until) {


mm_remaining = prep.accelerate_until;

time_var = 2.0*(pl_block->millimeters-mm_remaining)/(prep.current_speed+prep.maximum_speed);

if (mm_remaining == prep.decelerate_after) { prep.ramp_type = RAMP_DECEL; }

else { prep.ramp_type = RAMP_CRUISE; }

prep.current_speed = prep.maximum_speed;

} else {

prep.current_speed += speed_var;

}

break;

case RAMP_CRUISE:


mm_var = mm_remaining - prep.maximum_speed*time_var;

if (mm_var < prep.decelerate_after) {


time_var = (mm_remaining - prep.decelerate_after)/prep.maximum_speed;

mm_remaining = prep.decelerate_after;

prep.ramp_type = RAMP_DECEL;

} else { // Cruising only.

mm_remaining = mm_var;

}

break;

default:


speed_var = pl_block->acceleration*time_var;

if (prep.current_speed > speed_var) {


mm_var = mm_remaining - time_var*(prep.current_speed - 0.5*speed_var);

if (mm_var > prep.mm_complete) {

mm_remaining = mm_var;

prep.current_speed -= speed_var;

break;

}

}


time_var = 2.0*(mm_remaining-prep.mm_complete)/(prep.current_speed+prep.exit_speed);

mm_remaining = prep.mm_complete;

prep.current_speed = prep.exit_speed;
En attach : le message d'erreur

Pour les messages d’erreur, un couper collé du texte permet de lire. Je lis jamais les miens sur un ordi sans les sélectionner (pour avoir de contraste), ou sans le recopier ailleurs.
La copie d’écran est illisible ainsi, il vaut mieux la mettre dans une balise quote par exemple.

Voir aussi ce qui se dit de l'indentation. Les sauts de lignes c'est pas mal mais quand c'est bien utilisé cela permet de rendre le code plus lisible.
Ce n'est pas la peine de décourager ceux qui sont prêt à lire le programme.

Je prends le message d'erreur depuis l'autre message de Ugurth (il faudrait l'effacer pour éviter des réponses désordonnées sur deux fils différents) :

libraries\grbl\stepper.c.o (symbol from plugin): In function st_wake_up': (.text+0x0): multiple definition of vector_11'
sketch\GRBL
-ULN2003.ino.cpp.o (symbol from plugin):(.text+0x0): first defined here
libraries\grbl\stepper.c.o (symbol from plugin): In function st_wake_up': (.text+0x0): multiple definition of vector_16'
sketch\GRBL
-ULN2003.ino.cpp.o (symbol from plugin):(.text+0x0): first defined here
C:\Users\JEANPC~1\AppData\Local\Temp\ccDEKN1f.ltrans0.ltrans.o: In function __vector_11': C:\Users\JEAN PC PORTABLE\Documents\Arduino\GRBL_-ULN2003/GRBL_-ULN2003.ino:348: undefined reference to spindle_set_speed(unsigned char)'
C:\Users\JEAN PC PORTABLE\Documents\Arduino\GRBL
-ULN2003/GRBL
-ULN2003.ino:375: undefined reference to probe_state_monitor()' C:\Users\JEANPC~1\AppData\Local\Temp\ccDEKN1f.ltrans0.ltrans.o: In function st_go_idle':
C:\Users\JEAN PC PORTABLE\Documents\Arduino\GRBL_-ULN2003/GRBL_-ULN2003.ino:258: undefined reference to delay_ms(unsigned int)' C:\Users\JEANPC~1\AppData\Local\Temp\ccDEKN1f.ltrans0.ltrans.o: In function vector_11':
C:\Users\JEAN PC PORTABLE\Documents\Arduino\GRBL
-ULN2003/GRBL
-ULN2003.ino:360: undefined reference to spindle_set_speed(unsigned char)' C:\Users\JEAN PC PORTABLE\Documents\Arduino\GRBL_-ULN2003/GRBL_-ULN2003.ino:364: undefined reference to system_set_exec_state_flag(unsigned char)'
collect2.exe: error: ld returned 1 exit status
exit status 1
Erreur de compilation pour la carte Arduino Uno

Cette erreur 'multiple definition of `__vector_11' me fait penser à une incompatibilité entre deux bibliothèques qui veulent utiliser le même timer (on voit ça parfois avec des code qui utilisent des télécommandes IR (de mémoire)).

Mais problème : ici il n'y a qu'une seule bibliothèque grbl.h, mais elle doit en appeler d'autres (stepper peut-être ?)
Mauvaise installation ?
Ancien code, non compatible d'une nouvelle version de la bibli ?

grbl a une particularité, qui est d'utiliser l'environnement Arduino pour le téléversement, sans être un programme Arduino : le code est du pur C, qui n'utilise à aucun moment la surcouche Arduino. (mais utilise bien sûr les bibliothèques AVR que l'IDE installe par commodité, mais qui sont indépendantes et fournies par Atmel)

Une fois que vous avez ajouté la bibliothèque trouvée sur github (il y a deux versions : grbl/grbl qui est dépréciée, et gnea/grbl, qui est la version active), il vous suffit d'ouvrir le fichier d'exemple grblUpload.ino, puis de le verser sur votre carte.
Pour adapter le fonctionnement du programme à vos besoins, vous avez un fichier default.h qui permet de lister les paramètres d'initialisation, et un fichier config.h qui permet de pointer sur les bons réglages.

Merci troisiemetype,
j’ai donc téléchargé la version gnea/grbl,dans mon arduino avec le fichier d’exemple grblUpload et l’ai téléverser.
mais je ne vois pas bien ( j’ai cherché pourtant ) comment acceder aux fichier default.h et config.h à partir de l’arduino pour faire les choix .
Dans la liste des fichiers grbl, il y a bien 'default et config , mais ce sont des fichiers textes , et ils ont l’air indépendants, et quand je regarde grblUpload , il y a #include <config.h> et #include <defaults.h> mais j’ai essayer de cliquer dessus et impossible d’y accéder ( rien ne se passe ); d’autre part il est spécifier en bas ligne 51 " // Do not alter this file! " , alors je n’ose pas trop y toucher ,étant débutant, je ne voudrai pas tout déglinguer :confused: .
Pourriez vous me guider pour ne pas faire de bêtises ?

Ces fichiers sont dans le répertoire grbl de la bibliothèque

Celui-là ?

Non, celui de la bibliothèque

Merci lesept pour le lien
Ce que je vois mal, c'est pourquoi , si je modifie des valeurs dans par exemple le fichier


grbl/grbl/defaults.h
ces modifications vont être effectives dans mon code arduino ?
j'aimerai comprendre ce qui se passe

Peut-être qu'il faut que vous preniez le temps de lire les bases de la programmation. Ou bien sur le site d'Arduino, ou bien plus généralement sur un site documentant le langage C / C++.

Arduino facilite beaucoup les choses, mais un programme n'est pas un fichier. C'est un ensemble de fichier, avec un fichier principal appelant d'autres fichiers, le tout étant assemblé par un ensemble de mécanisme aboutissant au fichier compilé qui va permettre de faire fonctionner votre carte.

Si vous voulez vous en faire une idée, comme vous l'avez fait, ouvrez le fichier grbl.h, qui est le fichier d'entrée de grbl. Affichez votre dossier de travail Arduino (Croquis/afficher le dossier de croquis), vous le trouverez ensuite dans dossier/libraries/grbl/

grbl.h inclut tous les fichiers qui lui sont nécessaires.

  • Vous avez un premier groupe d'includes qui concernent les bibliothèques AVR (qui permettent de gérer le microcontrolleur lui-même), puis les bibliothèques standard C / C++, qui apportent les fonctionnalités de base du langage.

  • Puis vous avez un deuxième groupe qui inclut toutes les fonctions nécessaires au différentes parties du programme.
    La plupart du temps, à un fichier .h (header, c'est un fichier chargé de déclarer les variables, classes et fonctions utilisées) est associé un fichier .c (ou .cpp, selon les cas), qui contient la définition des variables, classes et fonctions en question.

  • Pour finir, vous avez le fichier main.c, qui par convention est le fichier racine d'un projet, celui qui appelle tous les autres.

Cela peut paraître assez complexe, et en effet quand on veut creuser, ça l'est. C'est ce qui fait la puissance et la richesse (mais aussi la limitation, parfois) d'Arduino. C'est de rendre abstrait tout cela pour pouvoir se concentrer facilement sur la création. :wink:

Merci , vous expliquez clairement, je vais creuser tout cela. :slight_smile:

Dans le :

il y a plusieurs cas , si pour commencer je choisis le cas generic, il faut que je mette tous les autres cas en 'commentaire' ?
j'ai juste ?

comment faire pour changer les valeurs dans fichier default.h du programme ? en effet le #include <defaults.h>
associé un fichier , qui contient la définition des variables me semble renvoyer à-grbl/grbl/defaults.h
hors, impossible de changer les valeurs dans grbl/grbl/defaults.h ,en tout cas je n'y arrive pas !
j'ai essayer de sélectionner et de mettre sur un fichier texte, où je peux changer les valeurs , mais le #include <defaults.h> ne renverra pas vers ce fichier texte corrigé, mais certainement au fichier grbl/grbl/defaults.h.
Comment m'en sortir ?
~~
~~

Capture include.PNG

Capture include.PNG

urgurth:
hors, impossible de changer les valeurs dans grbl/grbl/defaults.h ,en tout cas je n'y arrive pas !

Pourquoi tu n'y arrives pas ?
Il doit être possible de copier ce fichier dans le répertoire de ton sketch Arduino, tout en remplaçant le include dans ton fichier ino par celui-ci, avec des "

#include "defaults.h"

Lorsque tu ouvres ton fichier ino, tu auras un second onglet qui contiendra le fichier .h : tu pourras le modifier comme tu veux.

On peut éditer les fichiers avec n'importe quel éditeur de texte. Il y a d'ailleurs une option dans les réglages de l'IDE, qui s'appelle "utiliser un éditeur externe". Tous les fichiers rattachés à un projet (le fichier principal .ino, les fichiers annexes, les classes incluses) sont de simples fichiers texte.
Quand vous lancez la compilation ou le versement vers la carte, l'IDE va aller chercher tous les programmes nécessaires, les recompiler s'ils ont été modifiés.
Je vous conseille d'ailleurs l'utilisation d'un éditeur externe. Personnellement j'aime beaucoup SublimeText, et je viens de découvrir Atom. Ce sont des programmes qui restent des éditeurs de texte, mais qui offrent des fonctionnalités rendant la vie facile, comme la coloration syntaxique, l'ouverture de plusieurs fichiers en parallèle dans des onglets, des fonctions de recherches et de remplacement, etc.

Donc n'ayez pas d'inquiétude : à partir du moment ou vous sauvegardez le fichier, s'il est appelé par le projet (directement ou via des fichiers intermédiaires), il sera pris en compte dans sa version actuelle.
grbl.h inclus config.h
config.h inclus defaults.h

Les #include, #define*,* et toutes les instructions qui commencent par un # sont des directives préprocesseur. Elles ne font pas à proprement parler du programme, elles permette de formater les fichiers texte (.cpp et .h) qui composent le programme, en fonction de paramètres qui sont évalués avant la compilation. On pourrait comparer ça à une pré-programmation dynamique.

Dans defaults.h, vous avez effectivement différentes définitions pour différentes machines, qui donnent en gros des réglages différentes pour des mêmes paramètres. Chaque définition est encadré par un couple de directives préprocesseur :

#ifdef DEFAULT_GENERIC
  #define AAAA
  #define BBBB
  // etc
#endif

Ces deux directives disent que si DEFAULT_GENERIC, dans ce cas-là, a été défini, tout ce qui est entre les deux balises sera inclus, sinon ce sera ignoré.

Ainsi pour inclure les réglages pour une machine, il suffit de définir son nom dans config.h.

#define DEFAULT_GENERIC

Et bien sûr de commenter les autres, pour qu'un seul groupe de réglage soit appelé.
Vous pouvez ainsi ajouter autant de machines que vous voulez à votre fichier defaults.h, il suffit de changer une ligne dans config.h pour inclure cette machine-là.

Bonsoir,
J'ai essayer 'SublimeText', il a l'air bien ,
j'ai réussi à mettre mes valeurs dans 'defaults.h,'; pour l'instant juste changer un '250' pour voir si ça marche
( #define DEFAULT_X_STEPS_PER_MM 245.0 )
j'ai vérifié que DEFAULTS_GENERIC était bien dans config h

j'ai commenter ce qui n'était pas #ifdef DEFAULTS_GENERIC :
/*
#ifdef DEFAULTS_SHERLINE_5400
#endif
/
/

#ifdef DEFAULTS_POCKETNC_FR4
#endif
/
/

#ifdef DEFAULTS_SHAPEOKO
#endif
/
/

#ifdef DEFAULTS_SHAPEOKO_2
#endif
/
/

#ifdef DEFAULTS_SHAPEOKO_3
#endif
/
/

#ifdef DEFAULTS_X_CARVE_500MM
#endif
/
/

#ifdef DEFAULTS_X_CARVE_1000MM
#endif
/
/

#ifdef DEFAULTS_BOBSCNC_E3
#endif
/
/

#ifdef DEFAULTS_BOBSCNC_E4
#endif
/
/

#ifdef DEFAULTS_ZEN_TOOLWORKS_7x7
#endif
/
/

#ifdef DEFAULTS_OXCNC
#endif
/
/

#ifdef DEFAULTS_SIMULATOR
#endif
*/
#endif

Puis j'ai ouvert un sketch arduino , et y ai ajouté la bibliothèque grbl :

#include <config.h>
#include <coolant_control.h>
#include <cpu_map.h>
#include <defaults.h>
#include <eeprom.h>
#include <gcode.h>
#include <grbl.h>
#include <jog.h>
#include <limits.h>
#include <motion_control.h>
#include <nuts_bolts.h>
#include <planner.h>
#include <print.h>
#include <probe.h>
#include <protocol.h>
#include <report.h>
#include <serial.h>
#include <settings.h>
#include <spindle_control.h>
#include <stepper.h>
#include <system.h>

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

puis compiler ce petit programme
ce qui donne :

Arduino : 1.8.13 (Windows 10), Carte : "Arduino Uno"
In file included from C:\Users\JEAN PC PORTABLE\Documents\Arduino\libraries\grbl/config.h:30:0,
from C:\Users\JEAN PC PORTABLE\Documents\Arduino\sketch_nov22c\sketch_nov22c.ino:1:
C:\Users\JEAN PC PORTABLE\Documents\Arduino\libraries\grbl/grbl.h:68:4: error: #error "Required HOMING_CYCLE_0 not defined."
#error "Required HOMING_CYCLE_0 not defined."
^~~~~
C:\Users\JEAN PC PORTABLE\Documents\Arduino\libraries\grbl/grbl.h:108:4: error: #error "WCO refresh must be greater than one."
#error "WCO refresh must be greater than one."
^~~~~
C:\Users\JEAN PC PORTABLE\Documents\Arduino\libraries\grbl/grbl.h:111:4: error: #error "Override refresh must be greater than zero."
#error "Override refresh must be greater than zero."
^~~~~
exit status 1
Erreur de compilation pour la carte Arduino Uno

:frowning:

j'ai été voir dans le 'Documents\Arduino\libraries\grbl/grbl.h:' (pièce jointe)
mais il me semble que si il y a marqué error , c'est "dans le cas où" donc ça devrait pas sortir erreur à la compilation
Que se passe-il ?
Merci