reformating and some minor bugs/things found on the way.
This commit is contained in:
Bernhard Kubicek
parent
900e0c9bf2
commit
1d171e9e52
@ -1,5 +1,5 @@
|
||||
#ifndef CONFIGURATION_H
|
||||
#define CONFIGURATION_H
|
||||
#ifndef __CONFIGURATION_H
|
||||
#define __CONFIGURATION_H
|
||||
|
||||
//#define DEBUG_STEPS
|
||||
|
||||
@ -118,10 +118,7 @@ const int dropsegments=5; //everything with this number of steps will be ignore
|
||||
#define NUM_AXIS 4 // The axis order in all axis related arrays is X, Y, Z, E
|
||||
//note: on bernhards ultimaker 200 200 12 are working well.
|
||||
#define HOMING_FEEDRATE {50*60, 50*60, 12*60, 0} // set the homing speeds
|
||||
//the followint checks if an extrusion is existent in the move. if _not_, the speed of the move is set to the maximum speed.
|
||||
//!!!!!!Use only if you know that your printer works at the maximum declared speeds.
|
||||
// works around the skeinforge cool-bug. There all moves are slowed to have a minimum layer time. However slow travel moves= ooze
|
||||
#define TRAVELING_AT_MAXSPEED
|
||||
|
||||
#define AXIS_RELATIVE_MODES {false, false, false, false}
|
||||
|
||||
#define MAX_STEP_FREQUENCY 40000 // Max step frequency for Ultimaker (5000 pps / half step)
|
||||
@ -177,41 +174,50 @@ const int dropsegments=5; //everything with this number of steps will be ignore
|
||||
//#define_HEATER_1_MAXTEMP 275
|
||||
//#define BED_MAXTEMP 150
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/// PID settings:
|
||||
// Uncomment the following line to enable PID support.
|
||||
|
||||
#define PIDTEMP
|
||||
#ifdef PIDTEMP
|
||||
/// PID settings:
|
||||
// Uncomment the following line to enable PID support.
|
||||
//#define SMOOTHING
|
||||
//#define SMOOTHFACTOR 5.0
|
||||
//float current_raw_average=0;
|
||||
#define K1 0.95 //smoothing of the PID
|
||||
//#define PID_DEBUG // Sends debug data to the serial port.
|
||||
//#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in %
|
||||
#define PID_MAX 255 // limits current to nozzle
|
||||
#define PID_INTEGRAL_DRIVE_MAX 255
|
||||
#define PID_dT 0.1
|
||||
//machine with red silicon: 1950:45 second ; with fan fully blowin 3000:47
|
||||
|
||||
#define PID_MAX 255 // limits current to nozzle; 255=full current
|
||||
#define PID_INTEGRAL_DRIVE_MAX 255 //limit for the integral term
|
||||
#define K1 0.95 //smoothing factor withing the PID
|
||||
#define PID_dT 0.1 //sampling period of the PID
|
||||
|
||||
//To develop some PID settings for your machine, you can initiall follow
|
||||
// the Ziegler-Nichols method.
|
||||
// set Ki and Kd to zero.
|
||||
// heat with a defined Kp and see if the temperature stabilizes
|
||||
// ideally you do this graphically with repg.
|
||||
// the PID_CRITIAL_GAIN should be the Kp at which temperature oscillatins are not dampned out/decreas in amplitutde
|
||||
// PID_SWING_AT_CRITIAL is the time for a full period of the oscillations at the critical Gain
|
||||
// usually further manual tunine is necessary.
|
||||
|
||||
#define PID_CRITIAL_GAIN 3000
|
||||
#define PID_SWING_AT_CRITIAL 45 //seconds
|
||||
#define PIDIADD 5
|
||||
/*
|
||||
|
||||
#define PID_PI //no differentail term
|
||||
//#define PID_PID //normal PID
|
||||
|
||||
#ifdef PID_PID
|
||||
//PID according to Ziegler-Nichols method
|
||||
float Kp = 0.6*PID_CRITIAL_GAIN;
|
||||
float Ki =PIDIADD+2*Kp/PID_SWING_AT_CRITIAL*PID_dT;
|
||||
float Kd = Kp*PID_SWING_AT_CRITIAL/8./PID_dT;
|
||||
*/
|
||||
#define DEFAULT_Kp (0.6*PID_CRITIAL_GAIN)
|
||||
#define DEFAULT_Ki (2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
|
||||
#define DEFAULT_Kd (PID_SWING_AT_CRITIAL/8./PID_dT)
|
||||
#endif
|
||||
|
||||
#ifdef PID_PI
|
||||
//PI according to Ziegler-Nichols method
|
||||
#define DEFAULT_Kp (PID_CRITIAL_GAIN/2.2)
|
||||
#define DEFAULT_Ki (1.2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
|
||||
#define DEFAULT_Kd (0)
|
||||
#endif
|
||||
|
||||
// this adds an experimental additional term to the heatingpower, proportional to the extrusion speed.
|
||||
// if Kc is choosen well, the additional required power due to increased melting should be compensated.
|
||||
#define PID_ADD_EXTRUSION_RATE
|
||||
#ifdef PID_ADD_EXTRUSION_RATE
|
||||
#define DEFAULT_Kc (5) //heatingpower=Kc*(e_speed)
|
||||
@ -228,22 +234,21 @@ const int dropsegments=5; //everything with this number of steps will be ignore
|
||||
//#define ADVANCE
|
||||
|
||||
#ifdef ADVANCE
|
||||
#define EXTRUDER_ADVANCE_K .3
|
||||
#define EXTRUDER_ADVANCE_K .3
|
||||
|
||||
#define D_FILAMENT 1.7
|
||||
#define STEPS_MM_E 65
|
||||
#define EXTRUTION_AREA (0.25 * D_FILAMENT * D_FILAMENT * 3.14159)
|
||||
#define STEPS_PER_CUBIC_MM_E (axis_steps_per_unit[E_AXIS]/ EXTRUTION_AREA)
|
||||
#define D_FILAMENT 1.7
|
||||
#define STEPS_MM_E 65
|
||||
#define EXTRUTION_AREA (0.25 * D_FILAMENT * D_FILAMENT * 3.14159)
|
||||
#define STEPS_PER_CUBIC_MM_E (axis_steps_per_unit[E_AXIS]/ EXTRUTION_AREA)
|
||||
|
||||
#endif // ADVANCE
|
||||
|
||||
// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, e.g. 8,16,32
|
||||
#if defined SDSUPPORT
|
||||
// The number of linear motions that can be in the plan at any give time.
|
||||
// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ringbuffering.
|
||||
#if defined SDSUPPORT
|
||||
#define BLOCK_BUFFER_SIZE 16 // SD,LCD,Buttons take more memory, block buffer needs to be smaller
|
||||
#else
|
||||
#define BLOCK_BUFFER_SIZE 16 // maximize block buffer
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
#endif //__CONFIGURATION_H
|
||||
|
||||
@ -1,12 +1,11 @@
|
||||
#ifndef __EEPROMH
|
||||
#define __EEPROMH
|
||||
|
||||
#include "Marlin.h"
|
||||
#include "planner.h"
|
||||
#include "temperature.h"
|
||||
#include <EEPROM.h>
|
||||
#include "Marlin.h"
|
||||
#include "streaming.h"
|
||||
|
||||
//======================================================================================
|
||||
template <class T> int EEPROM_writeAnything(int &ee, const T& value)
|
||||
{
|
||||
const byte* p = (const byte*)(const void*)&value;
|
||||
@ -15,7 +14,7 @@ template <class T> int EEPROM_writeAnything(int &ee, const T& value)
|
||||
EEPROM.write(ee++, *p++);
|
||||
return i;
|
||||
}
|
||||
//======================================================================================
|
||||
|
||||
template <class T> int EEPROM_readAnything(int &ee, T& value)
|
||||
{
|
||||
byte* p = (byte*)(void*)&value;
|
||||
@ -28,12 +27,16 @@ template <class T> int EEPROM_readAnything(int &ee, T& value)
|
||||
|
||||
#define EEPROM_OFFSET 100
|
||||
|
||||
#define EEPROM_VERSION "V04" // IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
|
||||
// in the functions below, also increment the version number. This makes sure that
|
||||
// the default values are used whenever there is a change to the data, to prevent
|
||||
// wrong data being written to the variables.
|
||||
// ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
|
||||
void StoreSettings() {
|
||||
|
||||
// IMPORTANT: Whenever there are changes made to the variables stored in EEPROM
|
||||
// in the functions below, also increment the version number. This makes sure that
|
||||
// the default values are used whenever there is a change to the data, to prevent
|
||||
// wrong data being written to the variables.
|
||||
// ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
|
||||
#define EEPROM_VERSION "V04"
|
||||
|
||||
void StoreSettings()
|
||||
{
|
||||
char ver[4]= "000";
|
||||
int i=EEPROM_OFFSET;
|
||||
EEPROM_writeAnything(i,ver); // invalidate data first
|
||||
@ -51,25 +54,26 @@ void StoreSettings() {
|
||||
EEPROM_writeAnything(i,Kp);
|
||||
EEPROM_writeAnything(i,Ki);
|
||||
EEPROM_writeAnything(i,Kd);
|
||||
#else
|
||||
#else
|
||||
EEPROM_writeAnything(i,3000);
|
||||
EEPROM_writeAnything(i,0);
|
||||
EEPROM_writeAnything(i,0);
|
||||
#endif
|
||||
#endif
|
||||
char ver2[4]=EEPROM_VERSION;
|
||||
i=EEPROM_OFFSET;
|
||||
EEPROM_writeAnything(i,ver2); // validate data
|
||||
SERIAL_ECHOLN("Settings Stored");
|
||||
|
||||
}
|
||||
|
||||
void RetrieveSettings(bool def=false){ // if def=true, the default values will be used
|
||||
void RetrieveSettings(bool def=false)
|
||||
{ // if def=true, the default values will be used
|
||||
int i=EEPROM_OFFSET;
|
||||
char stored_ver[4];
|
||||
char ver[4]=EEPROM_VERSION;
|
||||
EEPROM_readAnything(i,stored_ver); //read stored version
|
||||
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
|
||||
if ((!def)&&(strncmp(ver,stored_ver,3)==0)) { // version number match
|
||||
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
|
||||
if ((!def)&&(strncmp(ver,stored_ver,3)==0))
|
||||
{ // version number match
|
||||
EEPROM_readAnything(i,axis_steps_per_unit);
|
||||
EEPROM_readAnything(i,max_feedrate);
|
||||
EEPROM_readAnything(i,max_acceleration_units_per_sq_second);
|
||||
@ -80,20 +84,22 @@ void RetrieveSettings(bool def=false){ // if def=true, the default values will
|
||||
EEPROM_readAnything(i,minsegmenttime);
|
||||
EEPROM_readAnything(i,max_xy_jerk);
|
||||
EEPROM_readAnything(i,max_z_jerk);
|
||||
#ifndef PIDTEMP
|
||||
#ifndef PIDTEMP
|
||||
float Kp,Ki,Kd;
|
||||
#endif
|
||||
#endif
|
||||
EEPROM_readAnything(i,Kp);
|
||||
EEPROM_readAnything(i,Ki);
|
||||
EEPROM_readAnything(i,Kd);
|
||||
|
||||
SERIAL_ECHOLN("Stored settings retreived:");
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
|
||||
float tmp2[]=DEFAULT_MAX_FEEDRATE;
|
||||
long tmp3[]=DEFAULT_MAX_ACCELERATION;
|
||||
for (int i=0;i<4;i++) {
|
||||
for (short i=0;i<4;i++)
|
||||
{
|
||||
axis_steps_per_unit[i]=tmp1[i];
|
||||
max_feedrate[i]=tmp2[i];
|
||||
max_acceleration_units_per_sq_second[i]=tmp3[i];
|
||||
@ -117,11 +123,10 @@ void RetrieveSettings(bool def=false){ // if def=true, the default values will
|
||||
SERIAL_ECHOLN(" M204 S" <<_FLOAT(acceleration,2) << " T" << _FLOAT(retract_acceleration,2));
|
||||
SERIAL_ECHOLN("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum xY jerk (mm/s), Z=maximum Z jerk (mm/s)");
|
||||
SERIAL_ECHOLN(" M205 S" <<_FLOAT(minimumfeedrate/60,2) << " T" << _FLOAT(mintravelfeedrate/60,2) << " B" << _FLOAT(minsegmenttime,2) << " X" << _FLOAT(max_xy_jerk/60,2) << " Z" << _FLOAT(max_z_jerk/60,2));
|
||||
#ifdef PIDTEMP
|
||||
#ifdef PIDTEMP
|
||||
SERIAL_ECHOLN("PID settings:");
|
||||
SERIAL_ECHOLN(" M301 P" << _FLOAT(Kp,3) << " I" << _FLOAT(Ki,3) << " D" << _FLOAT(Kd,3));
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -18,41 +18,39 @@ void process_commands();
|
||||
void manage_inactivity(byte debug);
|
||||
|
||||
#if X_ENABLE_PIN > -1
|
||||
#define enable_x() WRITE(X_ENABLE_PIN, X_ENABLE_ON)
|
||||
#define disable_x() WRITE(X_ENABLE_PIN,!X_ENABLE_ON)
|
||||
#define enable_x() WRITE(X_ENABLE_PIN, X_ENABLE_ON)
|
||||
#define disable_x() WRITE(X_ENABLE_PIN,!X_ENABLE_ON)
|
||||
#else
|
||||
#define enable_x() ;
|
||||
#define disable_x() ;
|
||||
#define enable_x() ;
|
||||
#define disable_x() ;
|
||||
#endif
|
||||
|
||||
#if Y_ENABLE_PIN > -1
|
||||
#define enable_y() WRITE(Y_ENABLE_PIN, Y_ENABLE_ON)
|
||||
#define disable_y() WRITE(Y_ENABLE_PIN,!Y_ENABLE_ON)
|
||||
#define enable_y() WRITE(Y_ENABLE_PIN, Y_ENABLE_ON)
|
||||
#define disable_y() WRITE(Y_ENABLE_PIN,!Y_ENABLE_ON)
|
||||
#else
|
||||
#define enable_y() ;
|
||||
#define disable_y() ;
|
||||
#define enable_y() ;
|
||||
#define disable_y() ;
|
||||
#endif
|
||||
|
||||
#if Z_ENABLE_PIN > -1
|
||||
#define enable_z() WRITE(Z_ENABLE_PIN, Z_ENABLE_ON)
|
||||
#define disable_z() WRITE(Z_ENABLE_PIN,!Z_ENABLE_ON)
|
||||
#define enable_z() WRITE(Z_ENABLE_PIN, Z_ENABLE_ON)
|
||||
#define disable_z() WRITE(Z_ENABLE_PIN,!Z_ENABLE_ON)
|
||||
#else
|
||||
#define enable_z() ;
|
||||
#define disable_z() ;
|
||||
#define enable_z() ;
|
||||
#define disable_z() ;
|
||||
#endif
|
||||
|
||||
#if E_ENABLE_PIN > -1
|
||||
|
||||
#define enable_e() WRITE(E_ENABLE_PIN, E_ENABLE_ON)
|
||||
#define disable_e() WRITE(E_ENABLE_PIN,!E_ENABLE_ON)
|
||||
|
||||
#else
|
||||
#define enable_e() ;
|
||||
#define disable_e() ;
|
||||
#define enable_e() ;
|
||||
#define disable_e() ;
|
||||
#endif
|
||||
|
||||
#define X_AXIS 0
|
||||
#define Y_AXIS 1
|
||||
#define Z_AXIS 2
|
||||
#define E_AXIS 3
|
||||
enum AxisEnum {X_AXIS=0, Y_AXIS=1, Z_AXIS=2, E_AXIS=3};
|
||||
|
||||
|
||||
void FlushSerialRequestResend();
|
||||
void ClearToSend();
|
||||
@ -61,26 +59,15 @@ void get_coordinates();
|
||||
void prepare_move();
|
||||
void kill();
|
||||
|
||||
//void check_axes_activity();
|
||||
//void plan_init();
|
||||
//void st_init();
|
||||
//void tp_init();
|
||||
//void plan_buffer_line(float x, float y, float z, float e, float feed_rate);
|
||||
//void plan_set_position(float x, float y, float z, float e);
|
||||
//void st_wake_up();
|
||||
//void st_synchronize();
|
||||
void enquecommand(const char *cmd); //put an ascii command at the end of the current buffer.
|
||||
|
||||
|
||||
#ifndef CRITICAL_SECTION_START
|
||||
#define CRITICAL_SECTION_START unsigned char _sreg = SREG; cli();
|
||||
#define CRITICAL_SECTION_END SREG = _sreg;
|
||||
#define CRITICAL_SECTION_START unsigned char _sreg = SREG; cli();
|
||||
#define CRITICAL_SECTION_END SREG = _sreg;
|
||||
#endif //CRITICAL_SECTION_START
|
||||
|
||||
extern float homing_feedrate[];
|
||||
extern bool axis_relative_modes[];
|
||||
|
||||
|
||||
void kill();
|
||||
|
||||
#endif
|
||||
|
||||
@ -25,6 +25,7 @@
|
||||
http://reprap.org/pipermail/reprap-dev/2011-May/003323.html
|
||||
*/
|
||||
|
||||
#include <EEPROM.h>
|
||||
#include "EEPROMwrite.h"
|
||||
#include "fastio.h"
|
||||
#include "Configuration.h"
|
||||
@ -37,14 +38,11 @@
|
||||
#include "temperature.h"
|
||||
#include "motion_control.h"
|
||||
|
||||
#ifdef SIMPLE_LCD
|
||||
#include "Simplelcd.h"
|
||||
#endif
|
||||
|
||||
char version_string[] = "1.0.0 Alpha 1";
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
#include "SdFat.h"
|
||||
#include "SdFat.h"
|
||||
#endif //SDSUPPORT
|
||||
|
||||
|
||||
@ -109,12 +107,9 @@ char version_string[] = "1.0.0 Alpha 1";
|
||||
|
||||
//Stepper Movement Variables
|
||||
|
||||
char axis_codes[NUM_AXIS] = {
|
||||
'X', 'Y', 'Z', 'E'};
|
||||
float destination[NUM_AXIS] = {
|
||||
0.0, 0.0, 0.0, 0.0};
|
||||
float current_position[NUM_AXIS] = {
|
||||
0.0, 0.0, 0.0, 0.0};
|
||||
const char axis_codes[NUM_AXIS] = {'X', 'Y', 'Z', 'E'};
|
||||
float destination[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0};
|
||||
float current_position[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0};
|
||||
float offset[3] = {0.0, 0.0, 0.0};
|
||||
bool home_all_axis = true;
|
||||
float feedrate = 1500.0, next_feedrate, saved_feedrate;
|
||||
@ -131,6 +126,7 @@ uint8_t fanpwm=0;
|
||||
volatile int feedmultiply=100; //100->1 200->2
|
||||
int saved_feedmultiply;
|
||||
volatile bool feedmultiplychanged=false;
|
||||
|
||||
// comm variables
|
||||
#define MAX_CMD_SIZE 96
|
||||
#define BUFSIZE 4
|
||||
@ -146,13 +142,10 @@ boolean comment_mode = false;
|
||||
char *strchr_pointer; // just a pointer to find chars in the cmd string like X, Y, Z, E, etc
|
||||
extern float HeaterPower;
|
||||
|
||||
#include "EEPROM.h"
|
||||
|
||||
const int sensitive_pins[] = SENSITIVE_PINS; // Sensitive pin list for M42
|
||||
|
||||
float tt = 0, bt = 0;
|
||||
|
||||
|
||||
//Inactivity shutdown variables
|
||||
unsigned long previous_millis_cmd = 0;
|
||||
unsigned long max_inactive_time = 0;
|
||||
@ -161,22 +154,25 @@ unsigned long stepper_inactive_time = 0;
|
||||
unsigned long starttime=0;
|
||||
unsigned long stoptime=0;
|
||||
#ifdef SDSUPPORT
|
||||
Sd2Card card;
|
||||
SdVolume volume;
|
||||
SdFile root;
|
||||
SdFile file;
|
||||
uint32_t filesize = 0;
|
||||
uint32_t sdpos = 0;
|
||||
bool sdmode = false;
|
||||
bool sdactive = false;
|
||||
bool savetosd = false;
|
||||
int16_t n;
|
||||
unsigned long autostart_atmillis=0;
|
||||
Sd2Card card;
|
||||
SdVolume volume;
|
||||
SdFile root;
|
||||
SdFile file;
|
||||
uint32_t filesize = 0;
|
||||
uint32_t sdpos = 0;
|
||||
bool sdmode = false;
|
||||
bool sdactive = false;
|
||||
bool savetosd = false;
|
||||
int16_t n;
|
||||
unsigned long autostart_atmillis=0;
|
||||
|
||||
void initsd()
|
||||
{
|
||||
bool autostart_stilltocheck=true; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware.
|
||||
|
||||
|
||||
void initsd()
|
||||
{
|
||||
sdactive = false;
|
||||
#if SDSS >- 1
|
||||
#if SDSS >- 1
|
||||
if(root.isOpen())
|
||||
root.close();
|
||||
if (!card.init(SPI_FULL_SPEED,SDSS))
|
||||
@ -197,37 +193,42 @@ void initsd()
|
||||
sdactive = true;
|
||||
SERIAL_ECHOLN("SD card ok");
|
||||
}
|
||||
#endif //SDSS
|
||||
}
|
||||
#endif //SDSS
|
||||
}
|
||||
|
||||
void quickinitsd(){
|
||||
void quickinitsd()
|
||||
{
|
||||
sdactive=false;
|
||||
autostart_atmillis=millis()+5000;
|
||||
}
|
||||
}
|
||||
|
||||
inline void write_command(char *buf){
|
||||
inline void write_command(char *buf)
|
||||
{
|
||||
char* begin = buf;
|
||||
char* npos = 0;
|
||||
char* end = buf + strlen(buf) - 1;
|
||||
|
||||
file.writeError = false;
|
||||
if((npos = strchr(buf, 'N')) != NULL){
|
||||
if((npos = strchr(buf, 'N')) != NULL)
|
||||
{
|
||||
begin = strchr(npos, ' ') + 1;
|
||||
end = strchr(npos, '*') - 1;
|
||||
}
|
||||
end[1] = '\r';
|
||||
end[2] = '\n';
|
||||
end[3] = '\0';
|
||||
//Serial.println(begin);
|
||||
file.write(begin);
|
||||
if (file.writeError){
|
||||
if (file.writeError)
|
||||
{
|
||||
SERIAL_ERRORLN("error writing to file");
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif //SDSUPPORT
|
||||
|
||||
|
||||
///adds an command to the main command buffer
|
||||
//adds an command to the main command buffer
|
||||
//thats really done in a non-safe way.
|
||||
//needs overworking someday
|
||||
void enquecommand(const char *cmd)
|
||||
{
|
||||
if(buflen < BUFSIZE)
|
||||
@ -242,46 +243,40 @@ void enquecommand(const char *cmd)
|
||||
|
||||
void setup()
|
||||
{
|
||||
|
||||
Serial.begin(BAUDRATE);
|
||||
SERIAL_ECHOLN("Marlin "<<version_string);
|
||||
Serial.println("start");
|
||||
#if defined FANCY_LCD || defined SIMPLE_LCD
|
||||
lcd_init();
|
||||
#endif
|
||||
for(int i = 0; i < BUFSIZE; i++){
|
||||
for(int i = 0; i < BUFSIZE; i++)
|
||||
{
|
||||
fromsd[i] = false;
|
||||
}
|
||||
|
||||
RetrieveSettings(); // loads data from EEPROM if available
|
||||
|
||||
|
||||
for(int i=0; i < NUM_AXIS; i++){
|
||||
for(int i=0; i < NUM_AXIS; i++)
|
||||
{
|
||||
axis_steps_per_sqr_second[i] = max_acceleration_units_per_sq_second[i] * axis_steps_per_unit[i];
|
||||
}
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
#ifdef SDSUPPORT
|
||||
//power to SD reader
|
||||
#if SDPOWER > -1
|
||||
#if SDPOWER > -1
|
||||
SET_OUTPUT(SDPOWER);
|
||||
WRITE(SDPOWER,HIGH);
|
||||
#endif //SDPOWER
|
||||
#endif //SDPOWER
|
||||
quickinitsd();
|
||||
#endif //SDSUPPORT
|
||||
|
||||
#endif //SDSUPPORT
|
||||
plan_init(); // Initialize planner;
|
||||
st_init(); // Initialize stepper;
|
||||
tp_init(); // Initialize temperature loop
|
||||
//checkautostart();
|
||||
}
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
bool autostart_stilltocheck=true;
|
||||
|
||||
|
||||
void checkautostart(bool force)
|
||||
{
|
||||
//this is to delay autostart and hence the initialisaiton of the sd card to some seconds after the normal init, so the device is available quick after a reset
|
||||
//this is to delay autostart and hence the initialisaiton of the sd card to some seconds after the normal init, so the device is available quick after a reset
|
||||
if(!force)
|
||||
{
|
||||
if(!autostart_stilltocheck)
|
||||
@ -304,8 +299,6 @@ void checkautostart(bool force)
|
||||
dir_t p;
|
||||
|
||||
root.rewind();
|
||||
//char filename[11];
|
||||
//int cnt=0;
|
||||
|
||||
bool found=false;
|
||||
while (root.readDir(p) > 0)
|
||||
@ -328,20 +321,15 @@ void checkautostart(bool force)
|
||||
enquecommand(cmd);
|
||||
enquecommand("M24");
|
||||
found=true;
|
||||
|
||||
}
|
||||
}
|
||||
if(!found)
|
||||
lastnr=-1;
|
||||
else
|
||||
lastnr++;
|
||||
|
||||
}
|
||||
#else
|
||||
|
||||
inline void checkautostart(bool x)
|
||||
{
|
||||
}
|
||||
#else //NO SD SUPORT
|
||||
inline void checkautostart(bool x){}
|
||||
#endif
|
||||
|
||||
|
||||
@ -352,25 +340,29 @@ void loop()
|
||||
checkautostart(false);
|
||||
if(buflen)
|
||||
{
|
||||
#ifdef SDSUPPORT
|
||||
if(savetosd){
|
||||
if(strstr(cmdbuffer[bufindr],"M29") == NULL){
|
||||
#ifdef SDSUPPORT
|
||||
if(savetosd)
|
||||
{
|
||||
if(strstr(cmdbuffer[bufindr],"M29") == NULL)
|
||||
{
|
||||
write_command(cmdbuffer[bufindr]);
|
||||
Serial.println("ok");
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
file.sync();
|
||||
file.close();
|
||||
savetosd = false;
|
||||
Serial.println("Done saving file.");
|
||||
}
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
process_commands();
|
||||
}
|
||||
#else
|
||||
#else
|
||||
process_commands();
|
||||
#endif //SDSUPPORT
|
||||
#endif //SDSUPPORT
|
||||
buflen = (buflen-1);
|
||||
bufindr = (bufindr + 1)%BUFSIZE;
|
||||
}
|
||||
@ -449,10 +441,10 @@ inline void get_command()
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
#ifdef SDSUPPORT
|
||||
#ifdef SDSUPPORT
|
||||
if(savetosd)
|
||||
break;
|
||||
#endif //SDSUPPORT
|
||||
#endif //SDSUPPORT
|
||||
Serial.println("ok");
|
||||
break;
|
||||
default:
|
||||
@ -473,7 +465,7 @@ inline void get_command()
|
||||
if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
|
||||
}
|
||||
}
|
||||
#ifdef SDSUPPORT
|
||||
#ifdef SDSUPPORT
|
||||
if(!sdmode || serial_count!=0){
|
||||
return;
|
||||
}
|
||||
@ -497,7 +489,8 @@ inline void get_command()
|
||||
LCD_MESSAGE(time);
|
||||
checkautostart(true);
|
||||
}
|
||||
if(!serial_count) return; //if empty line
|
||||
if(!serial_count)
|
||||
return; //if empty line
|
||||
cmdbuffer[bufindw][serial_count] = 0; //terminate string
|
||||
if(!comment_mode){
|
||||
fromsd[bufindw] = true;
|
||||
@ -513,20 +506,23 @@ inline void get_command()
|
||||
if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
|
||||
}
|
||||
}
|
||||
#endif //SDSUPPORT
|
||||
#endif //SDSUPPORT
|
||||
|
||||
}
|
||||
|
||||
|
||||
inline float code_value() {
|
||||
inline float code_value()
|
||||
{
|
||||
return (strtod(&cmdbuffer[bufindr][strchr_pointer - cmdbuffer[bufindr] + 1], NULL));
|
||||
}
|
||||
inline long code_value_long() {
|
||||
inline long code_value_long()
|
||||
{
|
||||
return (strtol(&cmdbuffer[bufindr][strchr_pointer - cmdbuffer[bufindr] + 1], NULL, 10));
|
||||
}
|
||||
inline bool code_seen(char code_string[]) {
|
||||
inline bool code_seen(char code_string[]) //Return True if the string was found
|
||||
{
|
||||
return (strstr(cmdbuffer[bufindr], code_string) != NULL);
|
||||
} //Return True if the string was found
|
||||
}
|
||||
|
||||
inline bool code_seen(char code)
|
||||
{
|
||||
@ -579,10 +575,10 @@ inline void process_commands()
|
||||
destination[i] = current_position[i];
|
||||
}
|
||||
feedrate = 0.0;
|
||||
|
||||
home_all_axis = !((code_seen(axis_codes[0])) || (code_seen(axis_codes[1])) || (code_seen(axis_codes[2])));
|
||||
|
||||
if((home_all_axis) || (code_seen(axis_codes[X_AXIS]))) {
|
||||
if((home_all_axis) || (code_seen(axis_codes[X_AXIS])))
|
||||
{
|
||||
if ((X_MIN_PIN > -1 && X_HOME_DIR==-1) || (X_MAX_PIN > -1 && X_HOME_DIR==1)){
|
||||
// st_synchronize();
|
||||
current_position[X_AXIS] = 0;
|
||||
@ -689,7 +685,7 @@ inline void process_commands()
|
||||
|
||||
switch( (int)code_value() )
|
||||
{
|
||||
#ifdef SDSUPPORT
|
||||
#ifdef SDSUPPORT
|
||||
|
||||
case 20: // M20 - list SD card
|
||||
Serial.println("Begin file list");
|
||||
@ -781,6 +777,8 @@ inline void process_commands()
|
||||
//processed in write to file routine above
|
||||
//savetosd = false;
|
||||
break;
|
||||
#endif //SDSUPPORT
|
||||
|
||||
case 30: //M30 take time since the start of the SD print or an M109 command
|
||||
{
|
||||
stoptime=millis();
|
||||
@ -794,7 +792,6 @@ inline void process_commands()
|
||||
LCD_MESSAGE(time);
|
||||
}
|
||||
break;
|
||||
#endif //SDSUPPORT
|
||||
case 42: //M42 -Change pin status via gcode
|
||||
if (code_seen('S'))
|
||||
{
|
||||
@ -837,28 +834,27 @@ inline void process_commands()
|
||||
#if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595)
|
||||
Serial.print("ok T:");
|
||||
Serial.print(tt);
|
||||
// Serial.print(", raw:");
|
||||
// Serial.print(current_raw);
|
||||
#if TEMP_1_PIN > -1
|
||||
#ifdef PIDTEMP
|
||||
#ifdef PIDTEMP
|
||||
Serial.print(" B:");
|
||||
#if TEMP_1_PIN > -1
|
||||
Serial.println(bt);
|
||||
#else
|
||||
Serial.println(HeaterPower);
|
||||
#endif
|
||||
#else
|
||||
#else //not PIDTEMP
|
||||
Serial.println();
|
||||
#endif
|
||||
#endif //PIDTEMP
|
||||
#else
|
||||
Serial.println();
|
||||
#endif
|
||||
#endif //TEMP_1_PIN
|
||||
#else
|
||||
Serial.println("echo: No thermistors - no temp");
|
||||
#endif
|
||||
return;
|
||||
//break;
|
||||
case 109: {// M109 - Wait for extruder heater to reach target.
|
||||
break;
|
||||
case 109:
|
||||
{// M109 - Wait for extruder heater to reach target.
|
||||
LCD_MESSAGE("Heating...");
|
||||
if (code_seen('S')) setTargetHotend0(code_value());
|
||||
|
||||
@ -878,7 +874,8 @@ inline void process_commands()
|
||||
#else
|
||||
while ( target_direction ? (isHeatingHotend0()) : (isCoolingHotend0()) ) {
|
||||
#endif //TEMP_RESIDENCY_TIME
|
||||
if( (millis() - codenum) > 1000 ) { //Print Temp Reading every 1 second while heating up/cooling down
|
||||
if( (millis() - codenum) > 1000 )
|
||||
{ //Print Temp Reading every 1 second while heating up/cooling down
|
||||
Serial.print("T:");
|
||||
Serial.println( degHotend0() );
|
||||
codenum = millis();
|
||||
@ -890,7 +887,8 @@ inline void process_commands()
|
||||
or when current temp falls outside the hysteresis after target temp was reached */
|
||||
if ((residencyStart == -1 && target_direction && !isHeatingHotend0()) ||
|
||||
(residencyStart == -1 && !target_direction && !isCoolingHotend0()) ||
|
||||
(residencyStart > -1 && labs(degHotend0() - degTargetHotend0()) > TEMP_HYSTERESIS) ) {
|
||||
(residencyStart > -1 && labs(degHotend0() - degTargetHotend0()) > TEMP_HYSTERESIS) )
|
||||
{
|
||||
residencyStart = millis();
|
||||
}
|
||||
#endif //TEMP_RESIDENCY_TIME
|
||||
@ -920,7 +918,8 @@ inline void process_commands()
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
#if FAN_PIN > -1
|
||||
|
||||
#if FAN_PIN > -1
|
||||
case 106: //M106 Fan On
|
||||
if (code_seen('S')){
|
||||
WRITE(FAN_PIN,HIGH);
|
||||
@ -937,27 +936,29 @@ inline void process_commands()
|
||||
WRITE(FAN_PIN,LOW);
|
||||
analogWrite(FAN_PIN, 0);
|
||||
break;
|
||||
#endif
|
||||
#if (PS_ON_PIN > -1)
|
||||
#endif //FAN_PIN
|
||||
|
||||
#if (PS_ON_PIN > -1)
|
||||
case 80: // M80 - ATX Power On
|
||||
SET_OUTPUT(PS_ON_PIN); //GND
|
||||
break;
|
||||
case 81: // M81 - ATX Power Off
|
||||
SET_INPUT(PS_ON_PIN); //Floating
|
||||
break;
|
||||
#endif
|
||||
#endif
|
||||
case 82:
|
||||
axis_relative_modes[3] = false;
|
||||
break;
|
||||
case 83:
|
||||
axis_relative_modes[3] = true;
|
||||
break;
|
||||
case 18:
|
||||
case 18: //compatibility
|
||||
case 84:
|
||||
if(code_seen('S')){
|
||||
stepper_inactive_time = code_value() * 1000;
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
st_synchronize();
|
||||
disable_x();
|
||||
disable_y();
|
||||
@ -970,13 +971,14 @@ inline void process_commands()
|
||||
max_inactive_time = code_value() * 1000;
|
||||
break;
|
||||
case 92: // M92
|
||||
for(int i=0; i < NUM_AXIS; i++) {
|
||||
if(code_seen(axis_codes[i])) axis_steps_per_unit[i] = code_value();
|
||||
for(int i=0; i < NUM_AXIS; i++)
|
||||
{
|
||||
if(code_seen(axis_codes[i]))
|
||||
axis_steps_per_unit[i] = code_value();
|
||||
}
|
||||
|
||||
break;
|
||||
case 115: // M115
|
||||
Serial.println("FIRMWARE_NAME:Sprinter/grbl mashup for gen6 FIRMWARE_URL:http://www.mendel-parts.com PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:1");
|
||||
Serial.println("FIRMWARE_NAME:Marlin; Sprinter/grbl mashup for gen6 FIRMWARE_URL:http://www.mendel-parts.com PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:1");
|
||||
break;
|
||||
case 114: // M114
|
||||
Serial.print("X:");
|
||||
@ -998,45 +1000,46 @@ inline void process_commands()
|
||||
Serial.println("");
|
||||
break;
|
||||
case 119: // M119
|
||||
#if (X_MIN_PIN > -1)
|
||||
#if (X_MIN_PIN > -1)
|
||||
Serial.print("x_min:");
|
||||
Serial.print((READ(X_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
|
||||
#endif
|
||||
#if (X_MAX_PIN > -1)
|
||||
#endif
|
||||
#if (X_MAX_PIN > -1)
|
||||
Serial.print("x_max:");
|
||||
Serial.print((READ(X_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
|
||||
#endif
|
||||
#if (Y_MIN_PIN > -1)
|
||||
#endif
|
||||
#if (Y_MIN_PIN > -1)
|
||||
Serial.print("y_min:");
|
||||
Serial.print((READ(Y_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
|
||||
#endif
|
||||
#if (Y_MAX_PIN > -1)
|
||||
#endif
|
||||
#if (Y_MAX_PIN > -1)
|
||||
Serial.print("y_max:");
|
||||
Serial.print((READ(Y_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
|
||||
#endif
|
||||
#if (Z_MIN_PIN > -1)
|
||||
#endif
|
||||
#if (Z_MIN_PIN > -1)
|
||||
Serial.print("z_min:");
|
||||
Serial.print((READ(Z_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
|
||||
#endif
|
||||
#if (Z_MAX_PIN > -1)
|
||||
#endif
|
||||
#if (Z_MAX_PIN > -1)
|
||||
Serial.print("z_max:");
|
||||
Serial.print((READ(Z_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L ");
|
||||
#endif
|
||||
#endif
|
||||
Serial.println("");
|
||||
break;
|
||||
//TODO: update for all axis, use for loop
|
||||
case 201: // M201
|
||||
for(int i=0; i < NUM_AXIS; i++) {
|
||||
for(int i=0; i < NUM_AXIS; i++)
|
||||
{
|
||||
if(code_seen(axis_codes[i])) axis_steps_per_sqr_second[i] = code_value() * axis_steps_per_unit[i];
|
||||
}
|
||||
break;
|
||||
#if 0 // Not used for Sprinter/grbl gen6
|
||||
#if 0 // Not used for Sprinter/grbl gen6
|
||||
case 202: // M202
|
||||
for(int i=0; i < NUM_AXIS; i++) {
|
||||
if(code_seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = code_value() * axis_steps_per_unit[i];
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
#endif
|
||||
case 203: // M203 max feedrate mm/sec
|
||||
for(int i=0; i < NUM_AXIS; i++) {
|
||||
if(code_seen(axis_codes[i])) max_feedrate[i] = code_value()*60 ;
|
||||
@ -1066,22 +1069,14 @@ inline void process_commands()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#ifdef PIDTEMP
|
||||
|
||||
#ifdef PIDTEMP
|
||||
case 301: // M301
|
||||
if(code_seen('P')) Kp = code_value();
|
||||
if(code_seen('I')) Ki = code_value()*PID_dT;
|
||||
if(code_seen('D')) Kd = code_value()/PID_dT;
|
||||
// SERIAL_ECHOLN("Kp "<<_FLOAT(Kp,2));
|
||||
// SERIAL_ECHOLN("Ki "<<_FLOAT(Ki/PID_dT,2));
|
||||
// SERIAL_ECHOLN("Kd "<<_FLOAT(Kd*PID_dT,2));
|
||||
|
||||
// temp_iState_min = 0.0;
|
||||
// if (Ki!=0) {
|
||||
// temp_iState_max = PID_INTEGRAL_DRIVE_MAX / (Ki/100.0);
|
||||
// }
|
||||
// else temp_iState_max = 1.0e10;
|
||||
break;
|
||||
#endif //PIDTEMP
|
||||
#endif //PIDTEMP
|
||||
case 500: // Store settings in EEPROM
|
||||
{
|
||||
StoreSettings();
|
||||
@ -1100,7 +1095,8 @@ inline void process_commands()
|
||||
|
||||
}
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
Serial.print("echo: Unknown command:\"");
|
||||
Serial.print(cmdbuffer[bufindr]);
|
||||
Serial.println("\"");
|
||||
@ -1121,10 +1117,10 @@ void FlushSerialRequestResend()
|
||||
void ClearToSend()
|
||||
{
|
||||
previous_millis_cmd = millis();
|
||||
#ifdef SDSUPPORT
|
||||
#ifdef SDSUPPORT
|
||||
if(fromsd[bufindr])
|
||||
return;
|
||||
#endif //SDSUPPORT
|
||||
#endif //SDSUPPORT
|
||||
Serial.println("ok");
|
||||
}
|
||||
|
||||
@ -1276,9 +1272,14 @@ void prepare_arc_move(char isclockwise) {
|
||||
|
||||
|
||||
|
||||
void manage_inactivity(byte debug) {
|
||||
if( (millis()-previous_millis_cmd) > max_inactive_time ) if(max_inactive_time) kill();
|
||||
if( (millis()-previous_millis_cmd) > stepper_inactive_time ) if(stepper_inactive_time) {
|
||||
void manage_inactivity(byte debug)
|
||||
{
|
||||
if( (millis()-previous_millis_cmd) > max_inactive_time )
|
||||
if(max_inactive_time)
|
||||
kill();
|
||||
if( (millis()-previous_millis_cmd) > stepper_inactive_time )
|
||||
if(stepper_inactive_time)
|
||||
{
|
||||
disable_x();
|
||||
disable_y();
|
||||
disable_z();
|
||||
|
||||
@ -33,8 +33,8 @@
|
||||
void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8_t axis_1,
|
||||
uint8_t axis_linear, float feed_rate, float radius, uint8_t isclockwise)
|
||||
{
|
||||
// int acceleration_manager_was_enabled = plan_is_acceleration_manager_enabled();
|
||||
// plan_set_acceleration_manager_enabled(false); // disable acceleration management for the duration of the arc
|
||||
// int acceleration_manager_was_enabled = plan_is_acceleration_manager_enabled();
|
||||
// plan_set_acceleration_manager_enabled(false); // disable acceleration management for the duration of the arc
|
||||
SERIAL_ECHOLN("mc_arc.");
|
||||
float center_axis0 = position[axis_0] + offset[axis_0];
|
||||
float center_axis1 = position[axis_1] + offset[axis_1];
|
||||
@ -52,12 +52,12 @@ void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8
|
||||
float millimeters_of_travel = hypot(angular_travel*radius, fabs(linear_travel));
|
||||
if (millimeters_of_travel == 0.0) { return; }
|
||||
uint16_t segments = floor(millimeters_of_travel/MM_PER_ARC_SEGMENT);
|
||||
/*
|
||||
/*
|
||||
// Multiply inverse feed_rate to compensate for the fact that this movement is approximated
|
||||
// by a number of discrete segments. The inverse feed_rate should be correct for the sum of
|
||||
// all segments.
|
||||
if (invert_feed_rate) { feed_rate *= segments; }
|
||||
*/
|
||||
*/
|
||||
float theta_per_segment = angular_travel/segments;
|
||||
float linear_per_segment = linear_travel/segments;
|
||||
|
||||
@ -128,6 +128,6 @@ void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8
|
||||
// Ensure last segment arrives at target location.
|
||||
plan_buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate);
|
||||
|
||||
// plan_set_acceleration_manager_enabled(acceleration_manager_was_enabled);
|
||||
// plan_set_acceleration_manager_enabled(acceleration_manager_was_enabled);
|
||||
}
|
||||
|
||||
|
||||
@ -557,6 +557,74 @@
|
||||
#define FAN_PIN 7
|
||||
#define PS_ON_PIN 12
|
||||
#define KILL_PIN -1
|
||||
|
||||
#ifdef ULTRA_LCD
|
||||
|
||||
#ifdef NEWPANEL
|
||||
//arduino pin witch triggers an piezzo beeper
|
||||
#define BEEPER 18
|
||||
|
||||
#define LCD_PINS_RS 20
|
||||
#define LCD_PINS_ENABLE 17
|
||||
#define LCD_PINS_D4 16
|
||||
#define LCD_PINS_D5 21
|
||||
#define LCD_PINS_D6 5
|
||||
#define LCD_PINS_D7 6
|
||||
|
||||
//buttons are directly attached
|
||||
#define BTN_EN1 40
|
||||
#define BTN_EN2 42
|
||||
#define BTN_ENC 19 //the click
|
||||
|
||||
#define BLEN_C 2
|
||||
#define BLEN_B 1
|
||||
#define BLEN_A 0
|
||||
|
||||
#define SDCARDDETECT 38
|
||||
|
||||
//encoder rotation values
|
||||
#define encrot0 0
|
||||
#define encrot1 2
|
||||
#define encrot2 3
|
||||
#define encrot3 1
|
||||
#else //old style panel with shift register
|
||||
//arduino pin witch triggers an piezzo beeper
|
||||
#define BEEPER 18
|
||||
|
||||
//buttons are attached to a shift register
|
||||
#define SHIFT_CLK 38
|
||||
#define SHIFT_LD 42
|
||||
#define SHIFT_OUT 40
|
||||
#define SHIFT_EN 17
|
||||
|
||||
#define LCD_PINS_RS 16
|
||||
#define LCD_PINS_ENABLE 5
|
||||
#define LCD_PINS_D4 6
|
||||
#define LCD_PINS_D5 21
|
||||
#define LCD_PINS_D6 20
|
||||
#define LCD_PINS_D7 19
|
||||
|
||||
//encoder rotation values
|
||||
#define encrot0 0
|
||||
#define encrot1 2
|
||||
#define encrot2 3
|
||||
#define encrot3 1
|
||||
|
||||
|
||||
//bits in the shift register that carry the buttons for:
|
||||
// left up center down right red
|
||||
#define BL_LE 7
|
||||
#define BL_UP 6
|
||||
#define BL_MI 5
|
||||
#define BL_DW 4
|
||||
#define BL_RI 3
|
||||
#define BL_ST 2
|
||||
|
||||
#define BLEN_B 1
|
||||
#define BLEN_A 0
|
||||
#endif
|
||||
#endif //ULTRA_LCD
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
@ -83,7 +83,7 @@ static volatile unsigned char block_buffer_head; // Index of the next
|
||||
static volatile unsigned char block_buffer_tail; // Index of the block to process now
|
||||
|
||||
// The current position of the tool in absolute steps
|
||||
long position[4];
|
||||
long position[4];
|
||||
|
||||
#define ONE_MINUTE_OF_MICROSECONDS 60000000.0
|
||||
|
||||
@ -123,10 +123,10 @@ void calculate_trapezoid_for_block(block_t *block, float entry_speed, float exit
|
||||
long initial_rate = ceil(block->nominal_rate*entry_factor);
|
||||
long final_rate = ceil(block->nominal_rate*exit_factor);
|
||||
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
long initial_advance = block->advance*entry_factor*entry_factor;
|
||||
long final_advance = block->advance*exit_factor*exit_factor;
|
||||
#endif // ADVANCE
|
||||
#endif // ADVANCE
|
||||
|
||||
// Limit minimal step rate (Otherwise the timer will overflow.)
|
||||
if(initial_rate <120) initial_rate=120;
|
||||
@ -155,10 +155,10 @@ void calculate_trapezoid_for_block(block_t *block, float entry_speed, float exit
|
||||
block->decelerate_after = decelerate_after;
|
||||
block->initial_rate = initial_rate;
|
||||
block->final_rate = final_rate;
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
block->initial_advance = initial_advance;
|
||||
block->final_advance = final_advance;
|
||||
#endif //ADVANCE
|
||||
#endif //ADVANCE
|
||||
}
|
||||
CRITICAL_SECTION_END;
|
||||
}
|
||||
@ -166,18 +166,15 @@ void calculate_trapezoid_for_block(block_t *block, float entry_speed, float exit
|
||||
// Calculates the maximum allowable speed at this point when you must be able to reach target_velocity using the
|
||||
// acceleration within the allotted distance.
|
||||
inline float max_allowable_speed(float acceleration, float target_velocity, float distance) {
|
||||
return(
|
||||
sqrt(target_velocity*target_velocity-2*acceleration*60*60*distance)
|
||||
);
|
||||
return sqrt(target_velocity*target_velocity-2*acceleration*60*60*distance);
|
||||
}
|
||||
|
||||
// "Junction jerk" in this context is the immediate change in speed at the junction of two blocks.
|
||||
// This method will calculate the junction jerk as the euclidean distance between the nominal
|
||||
// velocities of the respective blocks.
|
||||
inline float junction_jerk(block_t *before, block_t *after) {
|
||||
return(sqrt(
|
||||
pow((before->speed_x-after->speed_x), 2)+
|
||||
pow((before->speed_y-after->speed_y), 2)));
|
||||
return sqrt(
|
||||
pow((before->speed_x-after->speed_x), 2)+pow((before->speed_y-after->speed_y), 2));
|
||||
}
|
||||
|
||||
// Return the safe speed which is max_jerk/2, e.g. the
|
||||
@ -185,8 +182,10 @@ inline float junction_jerk(block_t *before, block_t *after) {
|
||||
float safe_speed(block_t *block) {
|
||||
float safe_speed;
|
||||
safe_speed = max_xy_jerk/2;
|
||||
if(abs(block->speed_z) > max_z_jerk/2) safe_speed = max_z_jerk/2;
|
||||
if (safe_speed > block->nominal_speed) safe_speed = block->nominal_speed;
|
||||
if(abs(block->speed_z) > max_z_jerk/2)
|
||||
safe_speed = max_z_jerk/2;
|
||||
if (safe_speed > block->nominal_speed)
|
||||
safe_speed = block->nominal_speed;
|
||||
return safe_speed;
|
||||
}
|
||||
|
||||
@ -379,9 +378,8 @@ void check_axes_activity() {
|
||||
// Add a new linear movement to the buffer. steps_x, _y and _z is the absolute position in
|
||||
// mm. Microseconds specify how many microseconds the move should take to perform. To aid acceleration
|
||||
// calculation the caller must also provide the physical length of the line in millimeters.
|
||||
void plan_buffer_line(float x, float y, float z, float e, float feed_rate) {
|
||||
|
||||
|
||||
void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate)
|
||||
{
|
||||
// Calculate the buffer head after we push this byte
|
||||
int next_buffer_head = (block_buffer_head + 1) & (BLOCK_BUFFER_SIZE - 1);
|
||||
|
||||
@ -469,11 +467,8 @@ void plan_buffer_line(float x, float y, float z, float e, float feed_rate) {
|
||||
// Limit speed per axis
|
||||
float speed_factor = 1; //factor <=1 do decrease speed
|
||||
if(abs(block->speed_x) > max_feedrate[X_AXIS]) {
|
||||
//// [ErikDeBruijn] IS THIS THE BUG WE'RE LOOING FOR????
|
||||
//// [bernhard] No its not, according to Zalm.
|
||||
//// the if would always be true, since tmp_speedfactor <=0 due the inial if, so its safe to set. the next lines actually compare.
|
||||
speed_factor = max_feedrate[X_AXIS] / abs(block->speed_x);
|
||||
//if(speed_factor > tmp_speed_factor) speed_factor = tmp_speed_factor;
|
||||
//if(speed_factor > tmp_speed_factor) speed_factor = tmp_speed_factor; /is not need here because auf the init above
|
||||
}
|
||||
if(abs(block->speed_y) > max_feedrate[Y_AXIS]){
|
||||
float tmp_speed_factor = max_feedrate[Y_AXIS] / abs(block->speed_y);
|
||||
@ -495,7 +490,8 @@ void plan_buffer_line(float x, float y, float z, float e, float feed_rate) {
|
||||
block->nominal_speed = block->millimeters * multiplier;
|
||||
block->nominal_rate = ceil(block->step_event_count * multiplier / 60);
|
||||
|
||||
if(block->nominal_rate < 120) block->nominal_rate = 120;
|
||||
if(block->nominal_rate < 120)
|
||||
block->nominal_rate = 120;
|
||||
block->entry_speed = safe_speed(block);
|
||||
|
||||
// Compute the acceleration rate for the trapezoid generator.
|
||||
@ -527,7 +523,7 @@ void plan_buffer_line(float x, float y, float z, float e, float feed_rate) {
|
||||
block->acceleration = block->acceleration_st * travel_per_step;
|
||||
block->acceleration_rate = (long)((float)block->acceleration_st * 8.388608);
|
||||
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
// Calculate advance rate
|
||||
if((block->steps_e == 0) || (block->steps_x == 0 && block->steps_y == 0 && block->steps_z == 0)) {
|
||||
block->advance_rate = 0;
|
||||
@ -545,7 +541,7 @@ void plan_buffer_line(float x, float y, float z, float e, float feed_rate) {
|
||||
block->advance_rate = advance / (float)acc_dist;
|
||||
}
|
||||
}
|
||||
#endif // ADVANCE
|
||||
#endif // ADVANCE
|
||||
|
||||
// compute a preliminary conservative acceleration trapezoid
|
||||
float safespeed = safe_speed(block);
|
||||
@ -576,7 +572,7 @@ void plan_buffer_line(float x, float y, float z, float e, float feed_rate) {
|
||||
st_wake_up();
|
||||
}
|
||||
|
||||
void plan_set_position(float x, float y, float z, float e)
|
||||
void plan_set_position(const float &x, const float &y, const float &z, const float &e)
|
||||
{
|
||||
position[X_AXIS] = lround(x*axis_steps_per_unit[X_AXIS]);
|
||||
position[Y_AXIS] = lround(y*axis_steps_per_unit[Y_AXIS]);
|
||||
|
||||
@ -36,12 +36,12 @@ typedef struct {
|
||||
volatile long decelerate_after; // The index of the step event on which to start decelerating
|
||||
volatile long acceleration_rate; // The acceleration rate used for acceleration calculation
|
||||
unsigned char direction_bits; // The direction bit set for this block (refers to *_DIRECTION_BIT in config.h)
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
long advance_rate;
|
||||
volatile long initial_advance;
|
||||
volatile long final_advance;
|
||||
float advance;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Fields used by the motion planner to manage acceleration
|
||||
float speed_x, speed_y, speed_z, speed_e; // Nominal mm/minute for each axis
|
||||
@ -63,10 +63,11 @@ void plan_init();
|
||||
|
||||
// Add a new linear movement to the buffer. x, y and z is the signed, absolute target position in
|
||||
// millimaters. Feed rate specifies the speed of the motion.
|
||||
void plan_buffer_line(float x, float y, float z, float e, float feed_rate);
|
||||
void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate);
|
||||
|
||||
// Set position. Used for G92 instructions.
|
||||
void plan_set_position(float x, float y, float z, float e);
|
||||
void plan_set_position(const float &x, const float &y, const float &z, const float &e);
|
||||
|
||||
|
||||
// Called when the current block is no longer needed. Discards the block and makes the memory
|
||||
// availible for new blocks.
|
||||
|
||||
@ -37,6 +37,7 @@ uint16_t speed_lookuptable_fast[256][2] PROGMEM = {\
|
||||
{ 32, 0}, { 32, 0}, { 32, 0}, { 32, 0}, { 32, 1}, { 31, 0}, { 31, 0}, { 31, 0},
|
||||
{ 31, 0}, { 31, 0}, { 31, 0}, { 31, 1}, { 30, 0}, { 30, 0}, { 30, 0}, { 30, 0}
|
||||
};
|
||||
|
||||
uint16_t speed_lookuptable_slow[256][2] PROGMEM = {\
|
||||
{ 62500, 12500}, { 50000, 8334}, { 41666, 5952}, { 35714, 4464}, { 31250, 3473}, { 27777, 2777}, { 25000, 2273}, { 22727, 1894},
|
||||
{ 20833, 1603}, { 19230, 1373}, { 17857, 1191}, { 16666, 1041}, { 15625, 920}, { 14705, 817}, { 13888, 731}, { 13157, 657},
|
||||
|
||||
@ -35,8 +35,8 @@
|
||||
// if DEBUG_STEPS is enabled, M114 can be used to compare two methods of determining the X,Y,Z position of the printer.
|
||||
// for debugging purposes only, should be disabled by default
|
||||
#ifdef DEBUG_STEPS
|
||||
volatile long count_position[NUM_AXIS] = { 0, 0, 0, 0};
|
||||
volatile int count_direction[NUM_AXIS] = { 1, 1, 1, 1};
|
||||
volatile long count_position[NUM_AXIS] = { 0, 0, 0, 0};
|
||||
volatile int count_direction[NUM_AXIS] = { 1, 1, 1, 1};
|
||||
#endif
|
||||
|
||||
|
||||
@ -117,6 +117,8 @@ asm volatile ( \
|
||||
|
||||
block_t *current_block; // A pointer to the block currently being traced
|
||||
|
||||
//static makes it inpossible to be called from outside of this file by extern.!
|
||||
|
||||
// Variables used by The Stepper Driver Interrupt
|
||||
static unsigned char out_bits; // The next stepping-bits to be output
|
||||
static long counter_x, // Counter variables for the bresenham line tracer
|
||||
@ -125,9 +127,9 @@ static long counter_x, // Counter variables for the bresenham line tracer
|
||||
counter_e;
|
||||
static unsigned long step_events_completed; // The number of step events executed in the current block
|
||||
#ifdef ADVANCE
|
||||
static long advance_rate, advance, final_advance = 0;
|
||||
static short old_advance = 0;
|
||||
static short e_steps;
|
||||
static long advance_rate, advance, final_advance = 0;
|
||||
static short old_advance = 0;
|
||||
static short e_steps;
|
||||
#endif
|
||||
static unsigned char busy = false; // TRUE when SIG_OUTPUT_COMPARE1A is being serviced. Used to avoid retriggering that handler.
|
||||
static long acceleration_time, deceleration_time;
|
||||
@ -195,10 +197,10 @@ inline unsigned short calc_timer(unsigned short step_rate) {
|
||||
// Initializes the trapezoid generator from the current block. Called whenever a new
|
||||
// block begins.
|
||||
inline void trapezoid_generator_reset() {
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
advance = current_block->initial_advance;
|
||||
final_advance = current_block->final_advance;
|
||||
#endif
|
||||
#endif
|
||||
deceleration_time = 0;
|
||||
// advance_rate = current_block->advance_rate;
|
||||
// step_rate to timer interval
|
||||
@ -211,7 +213,8 @@ inline void trapezoid_generator_reset() {
|
||||
// It pops blocks from the block_buffer and executes them by pulsing the stepper pins appropriately.
|
||||
ISR(TIMER1_COMPA_vect)
|
||||
{
|
||||
if(busy){ SERIAL_ERRORLN(*(unsigned short *)OCR1A<< " ISR overtaking itself.");
|
||||
if(busy){
|
||||
SERIAL_ERRORLN(*(unsigned short *)OCR1A<< " ISR overtaking itself.");
|
||||
return;
|
||||
} // The busy-flag is used to avoid reentering this interrupt
|
||||
|
||||
@ -242,7 +245,7 @@ ISR(TIMER1_COMPA_vect)
|
||||
// Set directions TO DO This should be done once during init of trapezoid. Endstops -> interrupt
|
||||
out_bits = current_block->direction_bits;
|
||||
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
// Calculate E early.
|
||||
counter_e += current_block->steps_e;
|
||||
if (counter_e > 0) {
|
||||
@ -263,30 +266,30 @@ ISR(TIMER1_COMPA_vect)
|
||||
e_steps += ((advance >> 16) - old_advance);
|
||||
CRITICAL_SECTION_END;
|
||||
old_advance = advance >> 16;
|
||||
#endif //ADVANCE
|
||||
#endif //ADVANCE
|
||||
|
||||
// Set direction en check limit switches
|
||||
if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
WRITE(X_DIR_PIN, INVERT_X_DIR);
|
||||
#ifdef DEBUG_STEPS
|
||||
count_direction[X_AXIS]=-1;
|
||||
#endif
|
||||
#if X_MIN_PIN > -1
|
||||
#if X_MIN_PIN > -1
|
||||
if(READ(X_MIN_PIN) != ENDSTOPS_INVERTING) {
|
||||
step_events_completed = current_block->step_event_count;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else { // +direction
|
||||
WRITE(X_DIR_PIN,!INVERT_X_DIR);
|
||||
#ifdef DEBUG_STEPS
|
||||
count_direction[X_AXIS]=1;
|
||||
#endif
|
||||
#if X_MAX_PIN > -1
|
||||
#if X_MAX_PIN > -1
|
||||
if((READ(X_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_x >0)){
|
||||
step_events_completed = current_block->step_event_count;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
if ((out_bits & (1<<Y_AXIS)) != 0) { // -direction
|
||||
@ -294,22 +297,22 @@ if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
#ifdef DEBUG_STEPS
|
||||
count_direction[Y_AXIS]=-1;
|
||||
#endif
|
||||
#if Y_MIN_PIN > -1
|
||||
#if Y_MIN_PIN > -1
|
||||
if(READ(Y_MIN_PIN) != ENDSTOPS_INVERTING) {
|
||||
step_events_completed = current_block->step_event_count;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else { // +direction
|
||||
WRITE(Y_DIR_PIN,!INVERT_Y_DIR);
|
||||
#ifdef DEBUG_STEPS
|
||||
count_direction[Y_AXIS]=1;
|
||||
#endif
|
||||
#if Y_MAX_PIN > -1
|
||||
#if Y_MAX_PIN > -1
|
||||
if((READ(Y_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_y >0)){
|
||||
step_events_completed = current_block->step_event_count;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
if ((out_bits & (1<<Z_AXIS)) != 0) { // -direction
|
||||
@ -317,30 +320,30 @@ if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
#ifdef DEBUG_STEPS
|
||||
count_direction[Z_AXIS]=-1;
|
||||
#endif
|
||||
#if Z_MIN_PIN > -1
|
||||
#if Z_MIN_PIN > -1
|
||||
if(READ(Z_MIN_PIN) != ENDSTOPS_INVERTING) {
|
||||
step_events_completed = current_block->step_event_count;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else { // +direction
|
||||
WRITE(Z_DIR_PIN,!INVERT_Z_DIR);
|
||||
#ifdef DEBUG_STEPS
|
||||
count_direction[Z_AXIS]=1;
|
||||
#endif
|
||||
#if Z_MAX_PIN > -1
|
||||
#if Z_MAX_PIN > -1
|
||||
if((READ(Z_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_z >0)){
|
||||
step_events_completed = current_block->step_event_count;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef ADVANCE
|
||||
#ifndef ADVANCE
|
||||
if ((out_bits & (1<<E_AXIS)) != 0) // -direction
|
||||
WRITE(E_DIR_PIN,INVERT_E_DIR);
|
||||
else // +direction
|
||||
WRITE(E_DIR_PIN,!INVERT_E_DIR);
|
||||
#endif //!ADVANCE
|
||||
#endif //!ADVANCE
|
||||
|
||||
for(char i=0; i < step_loops; i++) { // Take multiple steps per interrupt (For high speed moves)
|
||||
counter_x += current_block->steps_x;
|
||||
@ -373,14 +376,14 @@ if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef ADVANCE
|
||||
#ifndef ADVANCE
|
||||
counter_e += current_block->steps_e;
|
||||
if (counter_e > 0) {
|
||||
WRITE(E_STEP_PIN, HIGH);
|
||||
counter_e -= current_block->step_event_count;
|
||||
WRITE(E_STEP_PIN, LOW);
|
||||
}
|
||||
#endif //!ADVANCE
|
||||
#endif //!ADVANCE
|
||||
step_events_completed += 1;
|
||||
if(step_events_completed >= current_block->step_event_count) break;
|
||||
}
|
||||
@ -397,9 +400,9 @@ if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
|
||||
// step_rate to timer interval
|
||||
timer = calc_timer(acc_step_rate);
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
advance += advance_rate;
|
||||
#endif
|
||||
#endif
|
||||
acceleration_time += timer;
|
||||
OCR1A = timer;
|
||||
}
|
||||
@ -419,11 +422,11 @@ if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
|
||||
// step_rate to timer interval
|
||||
timer = calc_timer(step_rate);
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
advance -= advance_rate;
|
||||
if(advance < final_advance)
|
||||
advance = final_advance;
|
||||
#endif //ADVANCE
|
||||
#endif //ADVANCE
|
||||
deceleration_time += timer;
|
||||
OCR1A = timer;
|
||||
}
|
||||
@ -438,12 +441,11 @@ if ((out_bits & (1<<X_AXIS)) != 0) { // -direction
|
||||
}
|
||||
|
||||
#ifdef ADVANCE
|
||||
|
||||
unsigned char old_OCR0A;
|
||||
// Timer interrupt for E. e_steps is set in the main routine;
|
||||
// Timer 0 is shared with millies
|
||||
ISR(TIMER0_COMPA_vect)
|
||||
{
|
||||
unsigned char old_OCR0A;
|
||||
// Timer interrupt for E. e_steps is set in the main routine;
|
||||
// Timer 0 is shared with millies
|
||||
ISR(TIMER0_COMPA_vect)
|
||||
{
|
||||
// Critical section needed because Timer 1 interrupt has higher priority.
|
||||
// The pin set functions are placed on trategic position to comply with the stepper driver timing.
|
||||
WRITE(E_STEP_PIN, LOW);
|
||||
@ -460,105 +462,105 @@ ISR(TIMER0_COMPA_vect)
|
||||
}
|
||||
old_OCR0A += 25; // 10kHz interrupt
|
||||
OCR0A = old_OCR0A;
|
||||
}
|
||||
}
|
||||
#endif // ADVANCE
|
||||
|
||||
void st_init()
|
||||
{
|
||||
//Initialize Dir Pins
|
||||
#if X_DIR_PIN > -1
|
||||
#if X_DIR_PIN > -1
|
||||
SET_OUTPUT(X_DIR_PIN);
|
||||
#endif
|
||||
#if Y_DIR_PIN > -1
|
||||
#endif
|
||||
#if Y_DIR_PIN > -1
|
||||
SET_OUTPUT(Y_DIR_PIN);
|
||||
#endif
|
||||
#if Z_DIR_PIN > -1
|
||||
#endif
|
||||
#if Z_DIR_PIN > -1
|
||||
SET_OUTPUT(Z_DIR_PIN);
|
||||
#endif
|
||||
#if E_DIR_PIN > -1
|
||||
#endif
|
||||
#if E_DIR_PIN > -1
|
||||
SET_OUTPUT(E_DIR_PIN);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Initialize Enable Pins - steppers default to disabled.
|
||||
|
||||
#if (X_ENABLE_PIN > -1)
|
||||
#if (X_ENABLE_PIN > -1)
|
||||
SET_OUTPUT(X_ENABLE_PIN);
|
||||
if(!X_ENABLE_ON) WRITE(X_ENABLE_PIN,HIGH);
|
||||
#endif
|
||||
#if (Y_ENABLE_PIN > -1)
|
||||
#endif
|
||||
#if (Y_ENABLE_PIN > -1)
|
||||
SET_OUTPUT(Y_ENABLE_PIN);
|
||||
if(!Y_ENABLE_ON) WRITE(Y_ENABLE_PIN,HIGH);
|
||||
#endif
|
||||
#if (Z_ENABLE_PIN > -1)
|
||||
#endif
|
||||
#if (Z_ENABLE_PIN > -1)
|
||||
SET_OUTPUT(Z_ENABLE_PIN);
|
||||
if(!Z_ENABLE_ON) WRITE(Z_ENABLE_PIN,HIGH);
|
||||
#endif
|
||||
#if (E_ENABLE_PIN > -1)
|
||||
#endif
|
||||
#if (E_ENABLE_PIN > -1)
|
||||
SET_OUTPUT(E_ENABLE_PIN);
|
||||
if(!E_ENABLE_ON) WRITE(E_ENABLE_PIN,HIGH);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//endstops and pullups
|
||||
#ifdef ENDSTOPPULLUPS
|
||||
#if X_MIN_PIN > -1
|
||||
#ifdef ENDSTOPPULLUPS
|
||||
#if X_MIN_PIN > -1
|
||||
SET_INPUT(X_MIN_PIN);
|
||||
WRITE(X_MIN_PIN,HIGH);
|
||||
#endif
|
||||
#if X_MAX_PIN > -1
|
||||
#endif
|
||||
#if X_MAX_PIN > -1
|
||||
SET_INPUT(X_MAX_PIN);
|
||||
WRITE(X_MAX_PIN,HIGH);
|
||||
#endif
|
||||
#if Y_MIN_PIN > -1
|
||||
#endif
|
||||
#if Y_MIN_PIN > -1
|
||||
SET_INPUT(Y_MIN_PIN);
|
||||
WRITE(Y_MIN_PIN,HIGH);
|
||||
#endif
|
||||
#if Y_MAX_PIN > -1
|
||||
#endif
|
||||
#if Y_MAX_PIN > -1
|
||||
SET_INPUT(Y_MAX_PIN);
|
||||
WRITE(Y_MAX_PIN,HIGH);
|
||||
#endif
|
||||
#if Z_MIN_PIN > -1
|
||||
#endif
|
||||
#if Z_MIN_PIN > -1
|
||||
SET_INPUT(Z_MIN_PIN);
|
||||
WRITE(Z_MIN_PIN,HIGH);
|
||||
#endif
|
||||
#if Z_MAX_PIN > -1
|
||||
#endif
|
||||
#if Z_MAX_PIN > -1
|
||||
SET_INPUT(Z_MAX_PIN);
|
||||
WRITE(Z_MAX_PIN,HIGH);
|
||||
#endif
|
||||
#else //ENDSTOPPULLUPS
|
||||
#if X_MIN_PIN > -1
|
||||
#endif
|
||||
#else //ENDSTOPPULLUPS
|
||||
#if X_MIN_PIN > -1
|
||||
SET_INPUT(X_MIN_PIN);
|
||||
#endif
|
||||
#if X_MAX_PIN > -1
|
||||
#endif
|
||||
#if X_MAX_PIN > -1
|
||||
SET_INPUT(X_MAX_PIN);
|
||||
#endif
|
||||
#if Y_MIN_PIN > -1
|
||||
#endif
|
||||
#if Y_MIN_PIN > -1
|
||||
SET_INPUT(Y_MIN_PIN);
|
||||
#endif
|
||||
#if Y_MAX_PIN > -1
|
||||
#endif
|
||||
#if Y_MAX_PIN > -1
|
||||
SET_INPUT(Y_MAX_PIN);
|
||||
#endif
|
||||
#if Z_MIN_PIN > -1
|
||||
#endif
|
||||
#if Z_MIN_PIN > -1
|
||||
SET_INPUT(Z_MIN_PIN);
|
||||
#endif
|
||||
#if Z_MAX_PIN > -1
|
||||
#endif
|
||||
#if Z_MAX_PIN > -1
|
||||
SET_INPUT(Z_MAX_PIN);
|
||||
#endif
|
||||
#endif //ENDSTOPPULLUPS
|
||||
#endif
|
||||
#endif //ENDSTOPPULLUPS
|
||||
|
||||
|
||||
//Initialize Step Pins
|
||||
#if (X_STEP_PIN > -1)
|
||||
#if (X_STEP_PIN > -1)
|
||||
SET_OUTPUT(X_STEP_PIN);
|
||||
#endif
|
||||
#if (Y_STEP_PIN > -1)
|
||||
#endif
|
||||
#if (Y_STEP_PIN > -1)
|
||||
SET_OUTPUT(Y_STEP_PIN);
|
||||
#endif
|
||||
#if (Z_STEP_PIN > -1)
|
||||
#endif
|
||||
#if (Z_STEP_PIN > -1)
|
||||
SET_OUTPUT(Z_STEP_PIN);
|
||||
#endif
|
||||
#if (E_STEP_PIN > -1)
|
||||
#endif
|
||||
#if (E_STEP_PIN > -1)
|
||||
SET_OUTPUT(E_STEP_PIN);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// waveform generation = 0100 = CTC
|
||||
TCCR1B &= ~(1<<WGM13);
|
||||
@ -574,10 +576,10 @@ void st_init()
|
||||
OCR1A = 0x4000;
|
||||
DISABLE_STEPPER_DRIVER_INTERRUPT();
|
||||
|
||||
#ifdef ADVANCE
|
||||
#ifdef ADVANCE
|
||||
e_steps = 0;
|
||||
TIMSK0 |= (1<<OCIE0A);
|
||||
#endif //ADVANCE
|
||||
#endif //ADVANCE
|
||||
sei();
|
||||
}
|
||||
|
||||
|
||||
@ -36,8 +36,8 @@ void st_wake_up();
|
||||
// if DEBUG_STEPS is enabled, M114 can be used to compare two methods of determining the X,Y,Z position of the printer.
|
||||
// for debugging purposes only, should be disabled by default
|
||||
#ifdef DEBUG_STEPS
|
||||
extern volatile long count_position[NUM_AXIS];
|
||||
extern volatile int count_direction[NUM_AXIS];
|
||||
extern volatile long count_position[NUM_AXIS];
|
||||
extern volatile int count_direction[NUM_AXIS];
|
||||
#endif
|
||||
|
||||
extern block_t *current_block; // A pointer to the block currently being traced
|
||||
|
||||
@ -74,24 +74,24 @@ unsigned long previous_millis_heater, previous_millis_bed_heater;
|
||||
#endif //WATCHPERIOD
|
||||
|
||||
#ifdef HEATER_0_MINTEMP
|
||||
int minttemp_0 = temp2analog(HEATER_0_MINTEMP);
|
||||
int minttemp_0 = temp2analog(HEATER_0_MINTEMP);
|
||||
#endif //MINTEMP
|
||||
#ifdef HEATER_0_MAXTEMP
|
||||
int maxttemp_0 = temp2analog(HEATER_0_MAXTEMP);
|
||||
int maxttemp_0 = temp2analog(HEATER_0_MAXTEMP);
|
||||
#endif //MAXTEMP
|
||||
|
||||
#ifdef HEATER_1_MINTEMP
|
||||
int minttemp_1 = temp2analog(HEATER_1_MINTEMP);
|
||||
int minttemp_1 = temp2analog(HEATER_1_MINTEMP);
|
||||
#endif //MINTEMP
|
||||
#ifdef HEATER_1_MAXTEMP
|
||||
int maxttemp_1 = temp2analog(HEATER_1_MAXTEMP);
|
||||
int maxttemp_1 = temp2analog(HEATER_1_MAXTEMP);
|
||||
#endif //MAXTEMP
|
||||
|
||||
#ifdef BED_MINTEMP
|
||||
int bed_minttemp = temp2analog(BED_MINTEMP);
|
||||
int bed_minttemp = temp2analog(BED_MINTEMP);
|
||||
#endif //BED_MINTEMP
|
||||
#ifdef BED_MAXTEMP
|
||||
int bed_maxttemp = temp2analog(BED_MAXTEMP);
|
||||
int bed_maxttemp = temp2analog(BED_MAXTEMP);
|
||||
#endif //BED_MAXTEMP
|
||||
|
||||
void manage_heater()
|
||||
@ -105,14 +105,14 @@ void manage_heater()
|
||||
if(temp_meas_ready != true) //better readability
|
||||
return;
|
||||
|
||||
CRITICAL_SECTION_START;
|
||||
CRITICAL_SECTION_START;
|
||||
temp_meas_ready = false;
|
||||
CRITICAL_SECTION_END;
|
||||
CRITICAL_SECTION_END;
|
||||
|
||||
#ifdef PIDTEMP
|
||||
#ifdef PIDTEMP
|
||||
pid_input = analog2temp(current_raw[TEMPSENSOR_HOTEND_0]);
|
||||
|
||||
#ifndef PID_OPENLOOP
|
||||
#ifndef PID_OPENLOOP
|
||||
pid_error = pid_setpoint - pid_input;
|
||||
if(pid_error > 10){
|
||||
pid_output = PID_MAX;
|
||||
@ -140,15 +140,14 @@ CRITICAL_SECTION_END;
|
||||
#endif
|
||||
pid_output = constrain(pTerm + iTerm - dTerm, 0, PID_MAX);
|
||||
}
|
||||
#endif //PID_OPENLOOP
|
||||
#ifdef PID_DEBUG
|
||||
#endif //PID_OPENLOOP
|
||||
#ifdef PID_DEBUG
|
||||
SERIAL_ECHOLN(" PIDDEBUG Input "<<pid_input<<" Output "<<pid_output" pTerm "<<pTerm<<" iTerm "<<iTerm<<" dTerm "<<dTerm);
|
||||
|
||||
#endif //PID_DEBUG
|
||||
#endif //PID_DEBUG
|
||||
analogWrite(HEATER_0_PIN, pid_output);
|
||||
#endif //PIDTEMP
|
||||
#endif //PIDTEMP
|
||||
|
||||
#ifndef PIDTEMP
|
||||
#ifndef PIDTEMP
|
||||
if(current_raw[0] >= target_raw[0])
|
||||
{
|
||||
WRITE(HEATER_0_PIN,LOW);
|
||||
@ -157,7 +156,7 @@ CRITICAL_SECTION_END;
|
||||
{
|
||||
WRITE(HEATER_0_PIN,HIGH);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if(millis() - previous_millis_bed_heater < BED_CHECK_INTERVAL)
|
||||
return;
|
||||
@ -173,7 +172,7 @@ CRITICAL_SECTION_END;
|
||||
WRITE(HEATER_1_PIN,HIGH);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
// Takes hot end temperature value as input and returns corresponding raw value.
|
||||
// For a thermistor, it uses the RepRap thermistor temp table.
|
||||
@ -300,26 +299,26 @@ float analog2tempBed(int raw) {
|
||||
|
||||
void tp_init()
|
||||
{
|
||||
#if (HEATER_0_PIN > -1)
|
||||
#if (HEATER_0_PIN > -1)
|
||||
SET_OUTPUT(HEATER_0_PIN);
|
||||
#endif
|
||||
#if (HEATER_1_PIN > -1)
|
||||
#endif
|
||||
#if (HEATER_1_PIN > -1)
|
||||
SET_OUTPUT(HEATER_1_PIN);
|
||||
#endif
|
||||
#if (HEATER_2_PIN > -1)
|
||||
#endif
|
||||
#if (HEATER_2_PIN > -1)
|
||||
SET_OUTPUT(HEATER_2_PIN);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef PIDTEMP
|
||||
#ifdef PIDTEMP
|
||||
temp_iState_min = 0.0;
|
||||
temp_iState_max = PID_INTEGRAL_DRIVE_MAX / Ki;
|
||||
#endif //PIDTEMP
|
||||
#endif //PIDTEMP
|
||||
|
||||
// Set analog inputs
|
||||
// Set analog inputs
|
||||
ADCSRA = 1<<ADEN | 1<<ADSC | 1<<ADIF | 0x07;
|
||||
|
||||
// Use timer0 for temperature measurement
|
||||
// Interleave temperature interrupt with millies interrupt
|
||||
// Use timer0 for temperature measurement
|
||||
// Interleave temperature interrupt with millies interrupt
|
||||
OCR0B = 128;
|
||||
TIMSK0 |= (1<<OCIE0B);
|
||||
}
|
||||
@ -350,12 +349,14 @@ void disable_heater()
|
||||
WRITE(HEATER_0_PIN,LOW);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if TEMP_1_PIN > -1
|
||||
target_raw[1]=0;
|
||||
#if HEATER_1_PIN > -1
|
||||
WRITE(HEATER_1_PIN,LOW);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if TEMP_2_PIN > -1
|
||||
target_raw[2]=0;
|
||||
#if HEATER_2_PIN > -1
|
||||
@ -472,7 +473,7 @@ ISR(TIMER0_COMPB_vect)
|
||||
raw_temp_0_value = 0;
|
||||
raw_temp_1_value = 0;
|
||||
raw_temp_2_value = 0;
|
||||
#ifdef HEATER_0_MAXTEMP
|
||||
#ifdef HEATER_0_MAXTEMP
|
||||
#if (HEATER_0_PIN > -1)
|
||||
if(current_raw[TEMPSENSOR_HOTEND_0] >= maxttemp_0) {
|
||||
target_raw[TEMPSENSOR_HOTEND_0] = 0;
|
||||
@ -481,8 +482,8 @@ ISR(TIMER0_COMPB_vect)
|
||||
kill();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#ifdef HEATER_1_MAXTEMP
|
||||
#endif
|
||||
#ifdef HEATER_1_MAXTEMP
|
||||
#if (HEATER_1_PIN > -1)
|
||||
if(current_raw[TEMPSENSOR_HOTEND_1] >= maxttemp_1) {
|
||||
target_raw[TEMPSENSOR_HOTEND_1] = 0;
|
||||
@ -492,8 +493,9 @@ ISR(TIMER0_COMPB_vect)
|
||||
kill()
|
||||
}
|
||||
#endif
|
||||
#endif //MAXTEMP
|
||||
#ifdef HEATER_0_MINTEMP
|
||||
#endif //MAXTEMP
|
||||
|
||||
#ifdef HEATER_0_MINTEMP
|
||||
#if (HEATER_0_PIN > -1)
|
||||
if(current_raw[TEMPSENSOR_HOTEND_0] <= minttemp_0) {
|
||||
target_raw[TEMPSENSOR_HOTEND_0] = 0;
|
||||
@ -502,8 +504,9 @@ ISR(TIMER0_COMPB_vect)
|
||||
kill();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#ifdef HEATER_1_MINTEMP
|
||||
#endif
|
||||
|
||||
#ifdef HEATER_1_MINTEMP
|
||||
#if (HEATER_2_PIN > -1)
|
||||
if(current_raw[TEMPSENSOR_HOTEND_1] <= minttemp_1) {
|
||||
target_raw[TEMPSENSOR_HOTEND_1] = 0;
|
||||
@ -512,8 +515,9 @@ ISR(TIMER0_COMPB_vect)
|
||||
kill();
|
||||
}
|
||||
#endif
|
||||
#endif //MAXTEMP
|
||||
#ifdef BED_MINTEMP
|
||||
#endif //MAXTEMP
|
||||
|
||||
#ifdef BED_MINTEMP
|
||||
#if (HEATER_1_PIN > -1)
|
||||
if(current_raw[1] <= bed_minttemp) {
|
||||
target_raw[1] = 0;
|
||||
@ -522,8 +526,9 @@ ISR(TIMER0_COMPB_vect)
|
||||
kill();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#ifdef BED_MAXTEMP
|
||||
#endif
|
||||
|
||||
#ifdef BED_MAXTEMP
|
||||
#if (HEATER_1_PIN > -1)
|
||||
if(current_raw[1] >= bed_maxttemp) {
|
||||
target_raw[1] = 0;
|
||||
@ -532,7 +537,7 @@ ISR(TIMER0_COMPB_vect)
|
||||
kill();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -27,9 +27,11 @@
|
||||
#include "stepper.h"
|
||||
#endif
|
||||
|
||||
// public functions
|
||||
void tp_init(); //initialise the heating
|
||||
void manage_heater(); //it is critical that this is called periodically.
|
||||
|
||||
|
||||
enum TempSensor {TEMPSENSOR_HOTEND_0=0,TEMPSENSOR_BED=1, TEMPSENSOR_HOTEND_1=2};
|
||||
|
||||
//low leven conversion routines
|
||||
@ -41,9 +43,11 @@ float analog2tempBed(int raw);
|
||||
extern int target_raw[3];
|
||||
extern int current_raw[3];
|
||||
extern float Kp,Ki,Kd,Kc;
|
||||
|
||||
#ifdef PIDTEMP
|
||||
extern float pid_setpoint ;
|
||||
#endif
|
||||
|
||||
#ifdef WATCHPERIOD
|
||||
extern int watch_raw[3] ;
|
||||
extern unsigned long watchmillis;
|
||||
@ -63,15 +67,15 @@ inline float degTargetHotend0() { return analog2temp(target_raw[TEMPSENSOR_HOTE
|
||||
inline float degTargetHotend1() { return analog2temp(target_raw[TEMPSENSOR_HOTEND_1]);};
|
||||
inline float degTargetBed() { return analog2tempBed(target_raw[TEMPSENSOR_BED]);};
|
||||
|
||||
inline void setTargetHotend0(float celsius)
|
||||
inline void setTargetHotend0(const float &celsius)
|
||||
{
|
||||
target_raw[TEMPSENSOR_HOTEND_0]=temp2analog(celsius);
|
||||
#ifdef PIDTEMP
|
||||
pid_setpoint = celsius;
|
||||
#endif //PIDTEMP
|
||||
};
|
||||
inline void setTargetHotend1(float celsius) { target_raw[TEMPSENSOR_HOTEND_1]=temp2analog(celsius);};
|
||||
inline void setTargetBed(float celsius) { target_raw[TEMPSENSOR_BED ]=temp2analogBed(celsius);};
|
||||
inline void setTargetHotend1(const float &celsius) { target_raw[TEMPSENSOR_HOTEND_1]=temp2analog(celsius);};
|
||||
inline void setTargetBed(const float &celsius) { target_raw[TEMPSENSOR_BED ]=temp2analogBed(celsius);};
|
||||
|
||||
inline bool isHeatingHotend0() {return target_raw[TEMPSENSOR_HOTEND_0] > current_raw[TEMPSENSOR_HOTEND_0];};
|
||||
inline bool isHeatingHotend1() {return target_raw[TEMPSENSOR_HOTEND_1] > current_raw[TEMPSENSOR_HOTEND_1];};
|
||||
@ -84,16 +88,5 @@ inline bool isCoolingBed() {return target_raw[TEMPSENSOR_BED] < current_raw[TEMP
|
||||
void disable_heater();
|
||||
void setWatch();
|
||||
|
||||
#ifdef HEATER_0_USES_THERMISTOR
|
||||
#define HEATERSOURCE 1
|
||||
#endif
|
||||
#ifdef BED_USES_THERMISTOR
|
||||
#define BEDSOURCE 1
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@ -9,89 +9,28 @@
|
||||
void lcd_status(const char* message);
|
||||
void beep();
|
||||
void buttons_check();
|
||||
#define LCDSTATUSRIGHT
|
||||
|
||||
|
||||
#define LCD_UPDATE_INTERVAL 100
|
||||
#define STATUSTIMEOUT 15000
|
||||
|
||||
#include "Configuration.h"
|
||||
|
||||
#include <LiquidCrystal.h>
|
||||
extern LiquidCrystal lcd;
|
||||
|
||||
//lcd display size
|
||||
|
||||
#ifdef NEWPANEL
|
||||
//arduino pin witch triggers an piezzo beeper
|
||||
#define BEEPER 18
|
||||
#ifdef NEWPANEL
|
||||
|
||||
#define LCD_PINS_RS 20
|
||||
#define LCD_PINS_ENABLE 17
|
||||
#define LCD_PINS_D4 16
|
||||
#define LCD_PINS_D5 21
|
||||
#define LCD_PINS_D6 5
|
||||
#define LCD_PINS_D7 6
|
||||
|
||||
//buttons are directly attached
|
||||
#define BTN_EN1 40
|
||||
#define BTN_EN2 42
|
||||
#define BTN_ENC 19 //the click
|
||||
|
||||
#define BLEN_C 2
|
||||
#define BLEN_B 1
|
||||
#define BLEN_A 0
|
||||
|
||||
#define SDCARDDETECT 38
|
||||
|
||||
#define EN_C (1<<BLEN_C)
|
||||
#define EN_B (1<<BLEN_B)
|
||||
#define EN_A (1<<BLEN_A)
|
||||
|
||||
//encoder rotation values
|
||||
#define encrot0 0
|
||||
#define encrot1 2
|
||||
#define encrot2 3
|
||||
#define encrot3 1
|
||||
|
||||
|
||||
#define CLICKED (buttons&EN_C)
|
||||
#define BLOCK {blocking=millis()+blocktime;}
|
||||
#define CARDINSERTED (READ(SDCARDDETECT)==0)
|
||||
|
||||
#else
|
||||
//arduino pin witch triggers an piezzo beeper
|
||||
#define BEEPER 18
|
||||
|
||||
//buttons are attached to a shift register
|
||||
#define SHIFT_CLK 38
|
||||
#define SHIFT_LD 42
|
||||
#define SHIFT_OUT 40
|
||||
#define SHIFT_EN 17
|
||||
|
||||
#define LCD_PINS_RS 16
|
||||
#define LCD_PINS_ENABLE 5
|
||||
#define LCD_PINS_D4 6
|
||||
#define LCD_PINS_D5 21
|
||||
#define LCD_PINS_D6 20
|
||||
#define LCD_PINS_D7 19
|
||||
|
||||
//bits in the shift register that carry the buttons for:
|
||||
// left up center down right red
|
||||
#define BL_LE 7
|
||||
#define BL_UP 6
|
||||
#define BL_MI 5
|
||||
#define BL_DW 4
|
||||
#define BL_RI 3
|
||||
#define BL_ST 2
|
||||
|
||||
#define BLEN_B 1
|
||||
#define BLEN_A 0
|
||||
|
||||
//encoder rotation values
|
||||
#define encrot0 0
|
||||
#define encrot1 2
|
||||
#define encrot2 3
|
||||
#define encrot3 1
|
||||
#else
|
||||
|
||||
//atomatic, do not change
|
||||
#define B_LE (1<<BL_LE)
|
||||
@ -106,10 +45,12 @@
|
||||
#define CLICKED ((buttons&B_MI)||(buttons&B_ST))
|
||||
#define BLOCK {blocking[BL_MI]=millis()+blocktime;blocking[BL_ST]=millis()+blocktime;}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// blocking time for recognizing a new keypress of one key, ms
|
||||
#define blocktime 500
|
||||
#define lcdslow 5
|
||||
#define blocktime 500
|
||||
#define lcdslow 5
|
||||
|
||||
enum MainStatus{Main_Status, Main_Menu, Main_Prepare, Main_Control, Main_SD};
|
||||
|
||||
class MainMenu{
|
||||
@ -134,6 +75,7 @@
|
||||
bool linechanging;
|
||||
};
|
||||
|
||||
//conversion routines, could need some overworking
|
||||
char *fillto(int8_t n,char *c);
|
||||
char *ftostr51(const float &x);
|
||||
char *ftostr31(const float &x);
|
||||
@ -146,11 +88,15 @@
|
||||
#else //no lcd
|
||||
#define LCD_STATUS
|
||||
#define LCD_MESSAGE(x)
|
||||
inline void lcd_status() {};
|
||||
#endif
|
||||
|
||||
#ifndef ULTIPANEL
|
||||
#define CLICKED false
|
||||
#define BLOCK ;
|
||||
#define BLOCK ;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif //ULTRALCD
|
||||
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#include "ultralcd.h"
|
||||
|
||||
|
||||
#ifdef ULTRA_LCD
|
||||
|
||||
|
||||
extern volatile int feedmultiply;
|
||||
extern long position[4];
|
||||
|
||||
@ -122,9 +122,11 @@ void lcd_status()
|
||||
menu.update();
|
||||
}
|
||||
#ifdef ULTIPANEL
|
||||
|
||||
|
||||
void buttons_init()
|
||||
{
|
||||
#ifdef NEWPANEL
|
||||
#ifdef NEWPANEL
|
||||
pinMode(BTN_EN1,INPUT);
|
||||
pinMode(BTN_EN2,INPUT);
|
||||
pinMode(BTN_ENC,INPUT);
|
||||
@ -133,7 +135,7 @@ void buttons_init()
|
||||
WRITE(BTN_EN2,HIGH);
|
||||
WRITE(BTN_ENC,HIGH);
|
||||
WRITE(SDCARDDETECT,HIGH);
|
||||
#else
|
||||
#else
|
||||
pinMode(SHIFT_CLK,OUTPUT);
|
||||
pinMode(SHIFT_LD,OUTPUT);
|
||||
pinMode(SHIFT_EN,OUTPUT);
|
||||
@ -141,25 +143,21 @@ void buttons_init()
|
||||
WRITE(SHIFT_OUT,HIGH);
|
||||
WRITE(SHIFT_LD,HIGH);
|
||||
WRITE(SHIFT_EN,LOW);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void buttons_check()
|
||||
{
|
||||
// volatile static bool busy=false;
|
||||
// if(busy)
|
||||
// return;
|
||||
// busy=true;
|
||||
|
||||
#ifdef NEWPANEL
|
||||
#ifdef NEWPANEL
|
||||
uint8_t newbutton=0;
|
||||
if(READ(BTN_EN1)==0) newbutton|=EN_A;
|
||||
if(READ(BTN_EN2)==0) newbutton|=EN_B;
|
||||
if((blocking<millis()) &&(READ(BTN_ENC)==0))
|
||||
newbutton|=EN_C;
|
||||
buttons=newbutton;
|
||||
#else //read it from the shift register
|
||||
#else //read it from the shift register
|
||||
uint8_t newbutton=0;
|
||||
WRITE(SHIFT_LD,LOW);
|
||||
WRITE(SHIFT_LD,HIGH);
|
||||
@ -173,7 +171,8 @@ void buttons_check()
|
||||
WRITE(SHIFT_CLK,LOW);
|
||||
}
|
||||
buttons=~newbutton; //invert it, because a pressed switch produces a logical 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
char enc=0;
|
||||
if(buttons&EN_A)
|
||||
enc|=(1<<0);
|
||||
@ -212,7 +211,6 @@ void buttons_check()
|
||||
}
|
||||
}
|
||||
lastenc=enc;
|
||||
// busy=false;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -223,9 +221,9 @@ MainMenu::MainMenu()
|
||||
displayStartingRow=0;
|
||||
activeline=0;
|
||||
force_lcd_update=true;
|
||||
#ifdef ULTIPANEL
|
||||
#ifdef ULTIPANEL
|
||||
buttons_init();
|
||||
#endif
|
||||
#endif
|
||||
lcd_init();
|
||||
linechanging=false;
|
||||
}
|
||||
@ -1154,12 +1152,13 @@ uint8_t getnrfilenames()
|
||||
cnt++;
|
||||
}
|
||||
return cnt;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
void MainMenu::showSD()
|
||||
{
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
uint8_t line=0;
|
||||
|
||||
@ -1205,11 +1204,11 @@ void MainMenu::showSD()
|
||||
if(force_lcd_update)
|
||||
{
|
||||
lcd.setCursor(0,line);
|
||||
#ifdef CARDINSERTED
|
||||
#ifdef CARDINSERTED
|
||||
if(CARDINSERTED)
|
||||
#else
|
||||
#else
|
||||
if(true)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
lcd.print(" \004Refresh");
|
||||
}
|
||||
@ -1306,9 +1305,9 @@ void MainMenu::showMainMenu()
|
||||
{
|
||||
//if(int(encoderpos/lcdslow)!=int(lastencoderpos/lcdslow))
|
||||
// force_lcd_update=true;
|
||||
#ifndef ULTIPANEL
|
||||
#ifndef ULTIPANEL
|
||||
force_lcd_update=false;
|
||||
#endif
|
||||
#endif
|
||||
//Serial.println((int)activeline);
|
||||
if(force_lcd_update)
|
||||
clear();
|
||||
@ -1347,17 +1346,17 @@ void MainMenu::showMainMenu()
|
||||
beepshort();
|
||||
}
|
||||
}break;
|
||||
#ifdef SDSUPPORT
|
||||
#ifdef SDSUPPORT
|
||||
case ItemM_file:
|
||||
{
|
||||
if(force_lcd_update)
|
||||
{
|
||||
lcd.setCursor(0,line);
|
||||
#ifdef CARDINSERTED
|
||||
#ifdef CARDINSERTED
|
||||
if(CARDINSERTED)
|
||||
#else
|
||||
#else
|
||||
if(true)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
if(sdmode)
|
||||
lcd.print(" Stop Print \x7E");
|
||||
@ -1380,28 +1379,30 @@ void MainMenu::showMainMenu()
|
||||
beepshort();
|
||||
}
|
||||
}break;
|
||||
#endif
|
||||
#endif
|
||||
default:
|
||||
SERIAL_ERRORLN("Something is wrong in the MenuStructure.");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(activeline<0) activeline=0;
|
||||
if(activeline>=LCD_HEIGHT) activeline=LCD_HEIGHT-1;
|
||||
if(activeline<0)
|
||||
activeline=0;
|
||||
if(activeline>=LCD_HEIGHT)
|
||||
activeline=LCD_HEIGHT-1;
|
||||
if((encoderpos!=lastencoderpos)||force_lcd_update)
|
||||
{
|
||||
lcd.setCursor(0,activeline);lcd.print(activeline?' ':' ');
|
||||
if(encoderpos<0) encoderpos=0;
|
||||
if(encoderpos>3*lcdslow) encoderpos=3*lcdslow;
|
||||
if(encoderpos>3*lcdslow)
|
||||
encoderpos=3*lcdslow;
|
||||
activeline=abs(encoderpos/lcdslow)%LCD_HEIGHT;
|
||||
if(activeline<0) activeline=0;
|
||||
if(activeline>=LCD_HEIGHT) activeline=LCD_HEIGHT-1;
|
||||
if(activeline<0)
|
||||
activeline=0;
|
||||
if(activeline>=LCD_HEIGHT)
|
||||
activeline=LCD_HEIGHT-1;
|
||||
lastencoderpos=encoderpos;
|
||||
lcd.setCursor(0,activeline);lcd.print(activeline?'>':'\003');
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
void MainMenu::update()
|
||||
@ -1409,7 +1410,7 @@ void MainMenu::update()
|
||||
static MainStatus oldstatus=Main_Menu; //init automatically causes foce_lcd_update=true
|
||||
static long timeoutToStatus=0;
|
||||
static bool oldcardstatus=false;
|
||||
#ifdef CARDINSERTED
|
||||
#ifdef CARDINSERTED
|
||||
if((CARDINSERTED != oldcardstatus))
|
||||
{
|
||||
force_lcd_update=true;
|
||||
@ -1424,10 +1425,9 @@ void MainMenu::update()
|
||||
{
|
||||
sdactive=false;
|
||||
lcd_status("Card removed");
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if(status!=oldstatus)
|
||||
{
|
||||
@ -1484,9 +1484,9 @@ void MainMenu::update()
|
||||
|
||||
|
||||
//return for string conversion routines
|
||||
char conv[8];
|
||||
static char conv[8];
|
||||
|
||||
/// convert float to string with +123.4 format
|
||||
// convert float to string with +123.4 format
|
||||
char *ftostr3(const float &x)
|
||||
{
|
||||
//sprintf(conv,"%5.1f",x);
|
||||
@ -1497,6 +1497,7 @@ char *ftostr3(const float &x)
|
||||
conv[3]=0;
|
||||
return conv;
|
||||
}
|
||||
|
||||
char *itostr2(const uint8_t &x)
|
||||
{
|
||||
//sprintf(conv,"%5.1f",x);
|
||||
@ -1506,10 +1507,10 @@ char *itostr2(const uint8_t &x)
|
||||
conv[2]=0;
|
||||
return conv;
|
||||
}
|
||||
/// convert float to string with +123.4 format
|
||||
|
||||
// convert float to string with +123.4 format
|
||||
char *ftostr31(const float &x)
|
||||
{
|
||||
//sprintf(conv,"%5.1f",x);
|
||||
int xx=x*10;
|
||||
conv[0]=(xx>=0)?'+':'-';
|
||||
xx=abs(xx);
|
||||
@ -1524,7 +1525,6 @@ char *ftostr31(const float &x)
|
||||
|
||||
char *itostr31(const int &xx)
|
||||
{
|
||||
//sprintf(conv,"%5.1f",x);
|
||||
conv[0]=(xx>=0)?'+':'-';
|
||||
conv[1]=(xx/1000)%10+'0';
|
||||
conv[2]=(xx/100)%10+'0';
|
||||
@ -1534,6 +1534,7 @@ char *itostr31(const int &xx)
|
||||
conv[6]=0;
|
||||
return conv;
|
||||
}
|
||||
|
||||
char *itostr3(const int &xx)
|
||||
{
|
||||
conv[0]=(xx/100)%10+'0';
|
||||
@ -1553,7 +1554,7 @@ char *itostr4(const int &xx)
|
||||
return conv;
|
||||
}
|
||||
|
||||
/// convert float to string with +1234.5 format
|
||||
// convert float to string with +1234.5 format
|
||||
char *ftostr51(const float &x)
|
||||
{
|
||||
int xx=x*10;
|
||||
@ -1587,11 +1588,9 @@ char *fillto(int8_t n,char *c)
|
||||
}
|
||||
ret[n]=0;
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
#else
|
||||
inline void lcd_status() {};
|
||||
#endif
|
||||
|
||||
#endif //ULTRA_LCD
|
||||
|
||||
|
||||
|
||||
@ -1,13 +1,16 @@
|
||||
#ifndef __WATCHDOGH
|
||||
#define __WATCHDOGH
|
||||
#include "Configuration.h"
|
||||
//#ifdef USE_WATCHDOG
|
||||
#ifdef USE_WATCHDOG
|
||||
|
||||
/// intialise watch dog with a 1 sec interrupt time
|
||||
void wd_init();
|
||||
/// pad the dog/reset watchdog. MUST be called at least every second after the first wd_init or avr will go into emergency procedures..
|
||||
void wd_reset();
|
||||
// intialise watch dog with a 1 sec interrupt time
|
||||
void wd_init();
|
||||
// pad the dog/reset watchdog. MUST be called at least every second after the first wd_init or avr will go into emergency procedures..
|
||||
void wd_reset();
|
||||
|
||||
//#endif
|
||||
#else
|
||||
inline void wd_init() {};
|
||||
inline void wd_reset() {};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
#include <avr/wdt.h>
|
||||
#include <avr/interrupt.h>
|
||||
|
||||
volatile uint8_t timeout_seconds=0;
|
||||
static volatile uint8_t timeout_seconds=0;
|
||||
|
||||
void(* ctrlaltdelete) (void) = 0; //does not work on my atmega2560
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user