-// Yep, this is actually -*- c++ -*-

- {X_STEP_PIN, X_DIR_PIN, X_MIN_PIN, X_MAX_PIN, X_ENABLE_PIN, INVERT_X_DIR, REFERENCE_X_DIR, ENDSTOP_X_MIN_ENABLED, ENDSTOP_X_MAX_ENABLED, X_STEPS_PER_INCH, X_STEPS_PER_MM, X_MOTOR_STEPS},

- {Y_STEP_PIN, Y_DIR_PIN, Y_MIN_PIN, Y_MAX_PIN, Y_ENABLE_PIN, INVERT_Y_DIR, REFERENCE_Y_DIR, ENDSTOP_Y_MIN_ENABLED, ENDSTOP_Y_MAX_ENABLED, Y_STEPS_PER_INCH, Y_STEPS_PER_MM, Y_MOTOR_STEPS},

- {Z_STEP_PIN, Z_DIR_PIN, Z_MIN_PIN, Z_MAX_PIN, Z_ENABLE_PIN, INVERT_Z_DIR, REFERENCE_Z_DIR, ENDSTOP_Z_MIN_ENABLED, ENDSTOP_Z_MAX_ENABLED, Z_STEPS_PER_INCH, Z_STEPS_PER_MM, Z_MOTOR_STEPS}

- //Do startup stuff here

- Serial.begin(19200);

- Serial.println("start");

- //other initialization.

- init_steppers();

- init_extruder();

- clear_process_string();

- //init our command buffer

- for (uint8_t i=0; i<COMMAND_SIZE; i++) word[i] = 0;

- serial_count = 0;

- bytes_received = false;

- idle_time = millis();

- char c;

-

- extruder_manage_temperature(); //keep it hot!

-

- //read in characters if we got them.

- if (Serial.available() > 0) {

- c = Serial.read();

-

- // Reset no_data timer

- no_data = 0;

- idle_time = millis();

-

- // commands end with newlines

- if (c != '\n') {

- // Start of comment - ignore any bytes received from now on

- if (c == '(') comment = true;

-

- // If we're not in comment mode, add it to our array.

- if (!comment) {

- word[serial_count] = c;

- serial_count++;

- }

-

- if (c == ')') comment = false; // End of comment - start listening again

- }

-

- bytes_received = true;

- }

- else {

- // mark no_data if nothing heard for 100 milliseconds

- if ((millis() - idle_time) >= 100) {

- no_data++;

- idle_time = millis();

- }

- }

-

- // if there's a pause or we got a real command, do it

- if (bytes_received && (c == '\n' || no_data)) {

-// if (no_data) Serial.print("NODATA ");

-// Serial.print("debug: ");

-// Serial.println(word);

-

- //process our command!

- process_string(word, serial_count);

-

- //clear command.

- clear_process_string();

- }

-

- //no data for > 1 sec -> turn off steppers

- if (no_data > 10) disable_steppers();

-// Yep, this is actually -*- c++ -*-

- //default to room temp.

- extruder_set_temperature(21);

- //setup our pins

- pinMode(EXTRUDER_MOTOR_DIR_PIN, OUTPUT);

- pinMode(EXTRUDER_MOTOR_SPEED_PIN, OUTPUT);

- pinMode(EXTRUDER_HEATER_PIN, OUTPUT);

- pinMode(EXTRUDER_FAN_PIN, OUTPUT);

- //initialize values

- digitalWrite(EXTRUDER_MOTOR_DIR_PIN, EXTRUDER_FORWARD);

- analogWrite(EXTRUDER_FAN_PIN, 0);

- analogWrite(EXTRUDER_HEATER_PIN, 0);

- analogWrite(EXTRUDER_MOTOR_SPEED_PIN, 0);

- extruder_direction = direction;

- digitalWrite(EXTRUDER_MOTOR_DIR_PIN, direction);

- analogWrite(EXTRUDER_MOTOR_SPEED_PIN, speed);

- analogWrite(EXTRUDER_FAN_PIN, speed);

- extruder_target_celsius = temp;

- extruder_max_celsius = (int)((float)temp * 1.1);

- return extruder_read_thermistor();

- return extruder_read_thermocouple();

- int raw = extruder_sample_temperature(EXTRUDER_THERMISTOR_PIN);

-

- int celsius = 0;

- byte i;

-

- for (i=1; i<NUMTEMPS; i++)

- {

- if (temptable[i][0] > raw)

- {

- celsius = temptable[i-1][1] +

- (raw - temptable[i-1][0]) *

- (temptable[i][1] - temptable[i-1][1]) /

- (temptable[i][0] - temptable[i-1][0]);

-

- break;

- }

- }

-

- // Overflow: Set to last value in the table

- if (i == NUMTEMPS) celsius = temptable[i-1][1];

- // Clamp to byte

- if (celsius > 255) celsius = 255;

- else if (celsius < 0) celsius = 0;

-

- return celsius;

- return ( 5.0 * extruder_sample_temperature(EXTRUDER_THERMOCOUPLE_PIN) * 100.0) / 1024.0;

- int raw = 0;

- //read in a certain number of samples

- for (byte i=0; i<TEMPERATURE_SAMPLES; i++)

- raw += analogRead(pin);

- //average the samples

- raw = raw/TEMPERATURE_SAMPLES;

- //send it back.

- return raw;

- static long lastread = 0;

- if (millis() - lastread > 200) {

- lastread = millis();

- //make sure we know what our temp is.

- int current_celsius = extruder_get_temperature();

- byte newheat = 0;

- //put the heater into high mode if we're not at our target.

- if (current_celsius < extruder_target_celsius)

- newheat = extruder_heater_high;

- //put the heater on low if we're at our target.

- else if (current_celsius < extruder_max_celsius)

- newheat = extruder_heater_low;

- // Only update heat if it changed

- if (extruder_heater_current != newheat) {

- extruder_heater_current = newheat;

- analogWrite(EXTRUDER_HEATER_PIN, extruder_heater_current);

- }

- }

-// Yep, this is actually -*- c++ -*-

-// Yep, this is actually -*- c++ -*-

- //turn them off to start.

- disable_steppers();

-

- for (uint8_t i=0;i<3;i++) {

- current_units.p[i] = 0.0;

- target_units.p[i] = 0.0;

- const AxisConfig &a = axes[i];

- pinMode(a.step_pin, OUTPUT);

- pinMode(a.dir_pin, OUTPUT);

- pinMode(a.enable_pin, OUTPUT);

- if (a.min_endstop_enabled) pinMode(a.min_pin, INPUT);

- if (a.max_endstop_enabled) pinMode(a.max_pin, INPUT);

- }

- //figure our stuff.

- calculate_deltas();

- //turn on steppers to start moving =)

- enable_steppers();

- //figure out our deltas

- max_delta = max(delta_steps.p[X_AXIS], delta_steps.p[Y_AXIS]);

- max_delta = max(delta_steps.p[Z_AXIS], max_delta);

- //init stuff.

- counter[0] = -max_delta/2;

- counter[1] = -max_delta/2;

- counter[2] = -max_delta/2;

- //our step flags

- bool can_step_flags[3] = {false, false, false};

- //how long do we delay for?

- // We subtract the expected overhead of the loop to make the real speed

- // closer to our target feedrate. FIXME: This is just a hack and should

- // be handled properly.

- micro_delay -= 100;

- if (micro_delay >= 16383) milli_delay = micro_delay / 1000;

- else milli_delay = 0;

- //do our DDA line!

- do {

- for (uint8_t i=0;i<3;i++) {

- const AxisConfig &a = axes[i];

- can_step_flags[i] = can_step(a.min_endstop_enabled, a.max_endstop_enabled,

- a.min_pin, a.max_pin,

- current_steps.p[i], target_steps.p[i], direction[i]);

- if (can_step_flags[i]) {

- counter[i] += delta_steps.p[i];

- if (counter[i] > 0) {

- do_step(a.step_pin);

- counter[i] -= max_delta;

- if (direction[i]) current_steps.p[i]++;

- else current_steps.p[i]--;

- }

- }

- }

- //keep it hot =)

- extruder_manage_temperature();

- //wait for next step.

- if (milli_delay > 0)

- delay(milli_delay);

- else

- delayMicrosecondsInterruptible(micro_delay);

- }

- while (can_step_flags[X_AXIS] || can_step_flags[Y_AXIS] || can_step_flags[Z_AXIS]);

- //set our points to be the same

- current_units.p[X_AXIS] = target_units.p[X_AXIS];

- current_units.p[Y_AXIS] = target_units.p[Y_AXIS];

- current_units.p[Z_AXIS] = target_units.p[Z_AXIS];

- calculate_deltas();

- //stop us if we're on target

- if (target == current) return false;

- //stop us if we're at home and still going

- else if (minenabled && read_switch(min_pin) && !direction) return false;

- //stop us if we're at max and still going

- else if (maxenabled && read_switch(max_pin) && direction) return false;

- //default to being able to step

- return true;

- digitalWrite(step_pin, HIGH);

- delayMicroseconds(5);

- digitalWrite(step_pin, LOW);

- //dual read as crude debounce

- return !digitalRead(pin) && !digitalRead(pin);

- return digitalRead(pin) && digitalRead(pin);

- return steps_per_unit * units;

- target_units.p[X_AXIS] = x;

- target_units.p[Y_AXIS] = y;

- target_units.p[Z_AXIS] = z;

- calculate_deltas();

- current_units.p[X_AXIS] = x;

- current_units.p[Y_AXIS] = y;

- current_units.p[Z_AXIS] = z;

- calculate_deltas();

- for (uint8_t i=0;i<3;i++) {

- const AxisConfig &a = axes[i];

- //figure our deltas.

- delta_units.p[i] = abs(target_units.p[i] - current_units.p[i]);

- //set our steps current, target, and delta

- current_steps.p[i] = to_steps(units[i], current_units.p[i]);

- target_steps.p[i] = to_steps(units[i], target_units.p[i]);

- delta_steps.p[i] = abs(target_steps.p[i] - current_steps.p[i]);

- //what is our direction

- direction[i] = (target_units.p[i] >= current_units.p[i]);

- //set our direction pins as well

- digitalWrite(a.dir_pin, a.invert_dir ^ direction[i]);

- }

- //how long is our line length?

- float distance = sqrt(delta_units.p[X_AXIS]*delta_units.p[X_AXIS] +

- delta_units.p[Y_AXIS]*delta_units.p[Y_AXIS] +

- delta_units.p[Z_AXIS]*delta_units.p[Z_AXIS]);

- long master_steps = 0;

- //find the dominant axis.

- if (delta_steps.p[X_AXIS] > delta_steps.p[Y_AXIS]) {

- if (delta_steps.p[Z_AXIS] > delta_steps.p[X_AXIS])

- master_steps = delta_steps.p[Z_AXIS];

- else

- master_steps = delta_steps.p[X_AXIS];

- }

- else {

- if (delta_steps.p[Z_AXIS] > delta_steps.p[Y_AXIS])

- master_steps = delta_steps.p[Z_AXIS];

- else

- master_steps = delta_steps.p[Y_AXIS];

- }

- //calculate delay between steps in microseconds. this is sort of tricky, but not too bad.

- //the formula has been condensed to save space. here it is in english:

- // (feedrate is in mm/minute)

- // distance / feedrate * 60000000.0 = move duration in microseconds

- // move duration / master_steps = time between steps for master axis.

- return ((distance * 60000000.0) / feedrate) / master_steps;

- if (delta_steps.p[Z_AXIS] > 0)

- return calculate_feedrate_delay(FAST_Z_FEEDRATE);

- else

- return calculate_feedrate_delay(FAST_XY_FEEDRATE);

- // Enable steppers only for axes which are moving

- // taking account of the fact that some or all axes

- // may share an enable line (check using macros at

- // compile time to avoid needless code)

- if (target_units.p[X_AXIS] == current_units.p[X_AXIS]

- && target_units.p[Y_AXIS] == current_units.p[Y_AXIS]

- && target_units.p[Z_AXIS] == current_units.p[Z_AXIS]

- )

- digitalWrite(X_ENABLE_PIN, !ENABLE_ON);

- else

- digitalWrite(X_ENABLE_PIN, ENABLE_ON);

- if (target_units.p[Y_AXIS] == current_units.p[Y_AXIS]

- && target_units.p[X_AXIS] == current_units.p[X_AXIS]

- && target_units.p[Z_AXIS] == current_units.p[Z_AXIS]

- )

- digitalWrite(Y_ENABLE_PIN, !ENABLE_ON);

- else

- digitalWrite(Y_ENABLE_PIN, ENABLE_ON);

- if (target_units.p[Z_AXIS] == current_units.p[Z_AXIS]

- && target_units.p[X_AXIS] == current_units.p[X_AXIS]

- && target_units.p[Y_AXIS] == current_units.p[Y_AXIS]

- )

- digitalWrite(Z_ENABLE_PIN, !ENABLE_ON);

- else

- digitalWrite(Z_ENABLE_PIN, ENABLE_ON);

- //disable our steppers

- digitalWrite(X_ENABLE_PIN, !ENABLE_ON);

- digitalWrite(Y_ENABLE_PIN, !ENABLE_ON);

- digitalWrite(Z_ENABLE_PIN, !ENABLE_ON);

- const AxisConfig &a = axes[axis];

- // Seek to home

- FloatPoint fp = {current_units.p[X_AXIS], current_units.p[Y_AXIS], current_units.p[Z_AXIS]};

- // Go to a position guaranteed to be outside the axis

- fp.p[axis] = 1000.0*(a.reference_dir?1.0:-1.0);

- set_target(fp.p[X_AXIS], fp.p[Y_AXIS], fp.p[Z_AXIS]);

- feedrate_micros = calculate_feedrate_delay(feedrate);

- dda_move(feedrate_micros);

- // Move slowly until reference switch is off again, to move to the exact reference

- enable_steppers();

- digitalWrite(a.dir_pin, !(a.reference_dir ^ a.invert_dir));

- while (read_switch(a.reference_dir?a.max_pin:a.min_pin)) {

- do_step(a.step_pin);

- delay(10); // Really slow. FIXME: This machine dependant

- }

- // for the 16 MHz clock on most Arduino boards

- // for a one-microsecond delay, simply return. the overhead

- // of the function call yields a delay of approximately 1 1/8 us.

- if (--us == 0) return;

- // the following loop takes a quarter of a microsecond (4 cycles)

- // per iteration, so execute it four times for each microsecond of

- // delay requested.

- us <<= 2;

- // account for the time taken in the preceeding commands.

- us -= 2;

- // for the 8 MHz internal clock on the ATmega168

- // for a one- or two-microsecond delay, simply return. the overhead of

- // the function calls takes more than two microseconds. can't just

- // subtract two, since us is unsigned; we'd overflow.

- if (--us == 0) return;

- if (--us == 0) return;

- // the following loop takes half of a microsecond (4 cycles)

- // per iteration, so execute it twice for each microsecond of

- // delay requested.

- us <<= 1;

- // partially compensate for the time taken by the preceeding commands.

- // we can't subtract any more than this or we'd overflow w/ small delays.

- us--;

- // busy wait

- __asm__ __volatile__ (

- "1: sbiw %0,1" "\n\t" // 2 cycles

- "brne 1b" : "=w" (us) : "0" (us) // 2 cycles

- );