forksand
/
marlin-lulzbot-laser
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'upstream/Development' into Development

Browse Source
master
chrono 10 years ago
parent 558c6313f7 715104e477
commit a375d648c7
14 changed files with 1436 additions and 1908 deletions
Show Stats Download Patch File Download Diff File

9
Marlin/BlinkM.cpp
Unescape View File

@ -5,16 +5,9 @@
#include "Marlin.h" #include "Marlin.h"
#ifdef BLINKM #ifdef BLINKM
#if (ARDUINO >= 100)
# include "Arduino.h"
#else
# include "WProgram.h"
#endif
#include "BlinkM.h" #include "BlinkM.h"
void SendColors(byte red, byte grn, byte blu) void SendColors(byte red, byte grn, byte blu) {
{
Wire.begin(); Wire.begin();
Wire.beginTransmission(0x09); Wire.beginTransmission(0x09);
Wire.write('o'); //to disable ongoing script, only needs to be used once Wire.write('o'); //to disable ongoing script, only needs to be used once

7
Marlin/BlinkM.h
Unescape View File

@ -2,13 +2,12 @@
BlinkM.h BlinkM.h
Library header file for BlinkM library Library header file for BlinkM library
*/ */
#if (ARDUINO >= 100) #if ARDUINO >= 100
# include "Arduino.h" #include "Arduino.h"
#else #else
# include "WProgram.h" #include "WProgram.h"
#endif #endif
#include "Wire.h" #include "Wire.h"
void SendColors(byte red, byte grn, byte blu); void SendColors(byte red, byte grn, byte blu);

6
Marlin/ConfigurationStore.h
Unescape View File

@ -1,5 +1,5 @@
#ifndef CONFIG_STORE_H #ifndef CONFIGURATIONSTORE_H
#define CONFIG_STORE_H #define CONFIGURATIONSTORE_H
#include "Configuration.h" #include "Configuration.h"
@ -19,4 +19,4 @@ void Config_ResetDefault();
FORCE_INLINE void Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); } FORCE_INLINE void Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); }
#endif #endif
#endif // __CONFIG_STORE_H #endif //CONFIGURATIONSTORE_H

2
Marlin/Marlin.h
Unescape View File

@ -181,7 +181,7 @@ void manage_inactivity(bool ignore_stepper_queue=false);
#endif #endif
enum AxisEnum {X_AXIS=0, Y_AXIS=1, Z_AXIS=2, E_AXIS=3, X_HEAD=4, Y_HEAD=5}; enum AxisEnum {X_AXIS=0, Y_AXIS=1, Z_AXIS=2, E_AXIS=3, X_HEAD=4, Y_HEAD=5};
//X_HEAD and Y_HEAD is used for systems that don't have a 1:1 relationship between X_AXIS and X Head movement, like CoreXY bots.
void FlushSerialRequestResend(); void FlushSerialRequestResend();
void ClearToSend(); void ClearToSend();

20
Marlin/Marlin_main.cpp
Unescape View File

@ -1734,16 +1734,6 @@ void process_commands()
SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN); SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN);
break; // abort G29, since we don't know where we are break; // abort G29, since we don't know where we are
} }
int left_probe_bed_position=LEFT_PROBE_BED_POSITION;
int right_probe_bed_position=RIGHT_PROBE_BED_POSITION;
int back_probe_bed_position=BACK_PROBE_BED_POSITION;
int front_probe_bed_position=FRONT_PROBE_BED_POSITION;
int auto_bed_leveling_grid_points=AUTO_BED_LEVELING_GRID_POINTS;
if (code_seen('L')) left_probe_bed_position=(int)code_value();
if (code_seen('R')) right_probe_bed_position=(int)code_value();
if (code_seen('B')) back_probe_bed_position=(int)code_value();
if (code_seen('F')) front_probe_bed_position=(int)code_value();
if (code_seen('P')) auto_bed_leveling_grid_points=(int)code_value();
#ifdef Z_PROBE_SLED #ifdef Z_PROBE_SLED
dock_sled(false); dock_sled(false);
@ -1764,6 +1754,16 @@ void process_commands()
feedrate = homing_feedrate[Z_AXIS]; feedrate = homing_feedrate[Z_AXIS];
#ifdef AUTO_BED_LEVELING_GRID #ifdef AUTO_BED_LEVELING_GRID
// probe at the points of a lattice grid // probe at the points of a lattice grid
int left_probe_bed_position=LEFT_PROBE_BED_POSITION;
int right_probe_bed_position=RIGHT_PROBE_BED_POSITION;
int back_probe_bed_position=BACK_PROBE_BED_POSITION;
int front_probe_bed_position=FRONT_PROBE_BED_POSITION;
int auto_bed_leveling_grid_points=AUTO_BED_LEVELING_GRID_POINTS;
if (code_seen('L')) left_probe_bed_position=(int)code_value();
if (code_seen('R')) right_probe_bed_position=(int)code_value();
if (code_seen('B')) back_probe_bed_position=(int)code_value();
if (code_seen('F')) front_probe_bed_position=(int)code_value();
if (code_seen('P')) auto_bed_leveling_grid_points=(int)code_value();
int xGridSpacing = (right_probe_bed_position - left_probe_bed_position) / (auto_bed_leveling_grid_points-1); int xGridSpacing = (right_probe_bed_position - left_probe_bed_position) / (auto_bed_leveling_grid_points-1);
int yGridSpacing = (back_probe_bed_position - front_probe_bed_position) / (auto_bed_leveling_grid_points-1); int yGridSpacing = (back_probe_bed_position - front_probe_bed_position) / (auto_bed_leveling_grid_points-1);

520
Marlin/cardreader.cpp
Unescape View File

@ -7,256 +7,194 @@
#ifdef SDSUPPORT #ifdef SDSUPPORT
CardReader::CardReader() {
CardReader::CardReader()
{
filesize = 0; filesize = 0;
sdpos = 0; sdpos = 0;
sdprinting = false; sdprinting = false;
cardOK = false; cardOK = false;
saving = false; saving = false;
logging = false; logging = false;
autostart_atmillis=0;
workDirDepth = 0; workDirDepth = 0;
file_subcall_ctr=0; file_subcall_ctr = 0;
memset(workDirParents, 0, sizeof(workDirParents)); memset(workDirParents, 0, sizeof(workDirParents));
autostart_stilltocheck=true; //the SD start is delayed, because otherwise the serial cannot answer fast enough to make contact with the host software. autostart_stilltocheck = true; //the SD start is delayed, because otherwise the serial cannot answer fast enough to make contact with the host software.
autostart_index=0; autostart_index = 0;
//power to SD reader //power to SD reader
#if SDPOWER > -1 #if SDPOWER > -1
SET_OUTPUT(SDPOWER); SET_OUTPUT(SDPOWER);
WRITE(SDPOWER,HIGH); WRITE(SDPOWER, HIGH);
#endif //SDPOWER #endif //SDPOWER
autostart_atmillis=millis()+5000; autostart_atmillis = millis() + 5000;
} }
char *createFilename(char *buffer,const dir_t &p) //buffer>12characters char *createFilename(char *buffer, const dir_t &p) { //buffer > 12characters
{ char *pos = buffer;
char *pos=buffer; for (uint8_t i = 0; i < 11; i++) {
for (uint8_t i = 0; i < 11; i++) if (p.name[i] == ' ') continue;
{ if (i == 8) *pos++ = '.';
if (p.name[i] == ' ')continue; *pos++ = p.name[i];
if (i == 8)
{
*pos++='.';
} }
*pos++=p.name[i]; *pos++ = 0;
}
*pos++=0;
return buffer; return buffer;
} }
void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/) {
void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/)
{
dir_t p; dir_t p;
uint8_t cnt=0; uint8_t cnt = 0;
while (parent.readDir(p, longFilename) > 0)
{
if( DIR_IS_SUBDIR(&p) && lsAction!=LS_Count && lsAction!=LS_GetFilename) // hence LS_SerialPrint
{
while (parent.readDir(p, longFilename) > 0) {
if (DIR_IS_SUBDIR(&p) && lsAction != LS_Count && lsAction != LS_GetFilename) { // hence LS_SerialPrint
char path[FILENAME_LENGTH*2]; char path[FILENAME_LENGTH*2];
char lfilename[FILENAME_LENGTH]; char lfilename[FILENAME_LENGTH];
createFilename(lfilename,p); createFilename(lfilename, p);
path[0]=0; path[0] = 0;
if(prepend[0]==0) //avoid leading / if already in prepend if (prepend[0] == 0) strcat(path, "/"); //avoid leading / if already in prepend
{ strcat(path, prepend);
strcat(path,"/"); strcat(path, lfilename);
} strcat(path, "/");
strcat(path,prepend);
strcat(path,lfilename);
strcat(path,"/");
//Serial.print(path); //Serial.print(path);
SdFile dir; SdFile dir;
if(!dir.open(parent,lfilename, O_READ)) if (!dir.open(parent, lfilename, O_READ)) {
{ if (lsAction == LS_SerialPrint) {
if(lsAction==LS_SerialPrint)
{
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLN(MSG_SD_CANT_OPEN_SUBDIR); SERIAL_ECHOLN(MSG_SD_CANT_OPEN_SUBDIR);
SERIAL_ECHOLN(lfilename); SERIAL_ECHOLN(lfilename);
} }
} }
lsDive(path,dir); lsDive(path, dir);
//close done automatically by destructor of SdFile //close done automatically by destructor of SdFile
} }
else else {
{
char pn0 = p.name[0]; char pn0 = p.name[0];
if (pn0 == DIR_NAME_FREE) break; if (pn0 == DIR_NAME_FREE) break;
if (pn0 == DIR_NAME_DELETED || pn0 == '.' || pn0 == '_') continue; if (pn0 == DIR_NAME_DELETED || pn0 == '.') continue;
char lf0 = longFilename[0]; char lf0 = longFilename[0];
if (lf0 == '.' || lf0 == '_') continue; if (lf0 == '.') continue;
if (!DIR_IS_FILE_OR_SUBDIR(&p)) continue; if (!DIR_IS_FILE_OR_SUBDIR(&p)) continue;
filenameIsDir=DIR_IS_SUBDIR(&p);
filenameIsDir = DIR_IS_SUBDIR(&p);
if(!filenameIsDir) if (!filenameIsDir && (p.name[8] != 'G' || p.name[9] == '~')) continue;
{
if(p.name[8]!='G') continue; //if (cnt++ != nr) continue;
if(p.name[9]=='~') continue; createFilename(filename, p);
} if (lsAction == LS_SerialPrint) {
//if(cnt++!=nr) continue;
createFilename(filename,p);
if(lsAction==LS_SerialPrint)
{
SERIAL_PROTOCOL(prepend); SERIAL_PROTOCOL(prepend);
SERIAL_PROTOCOLLN(filename); SERIAL_PROTOCOLLN(filename);
} }
else if(lsAction==LS_Count) else if (lsAction == LS_Count) {
{
nrFiles++; nrFiles++;
} }
else if(lsAction==LS_GetFilename) else if (lsAction == LS_GetFilename) {
{
if (match != NULL) { if (match != NULL) {
if (strcasecmp(match, filename) == 0) return; if (strcasecmp(match, filename) == 0) return;
} }
else if (cnt == nrFiles) return; else if (cnt == nrFiles) return;
cnt++; cnt++;
} }
} }
} }
} }
void CardReader::ls() void CardReader::ls() {
{ lsAction = LS_SerialPrint;
lsAction=LS_SerialPrint;
if(lsAction==LS_Count)
nrFiles=0;
root.rewind(); root.rewind();
lsDive("",root); lsDive("", root);
} }
void CardReader::initsd() {
void CardReader::initsd()
{
cardOK = false; cardOK = false;
if(root.isOpen()) if (root.isOpen()) root.close();
root.close();
#ifdef SDSLOW #ifdef SDSLOW
if (!card.init(SPI_HALF_SPEED,SDSS) #define SPI_SPEED SPI_HALF_SPEED
#if defined(LCD_SDSS) && (LCD_SDSS != SDSS) #else
&& !card.init(SPI_HALF_SPEED,LCD_SDSS) #define SPI_SPEED SPI_FULL_SPEED
#endif #endif
)
#else if (!card.init(SPI_SPEED,SDSS)
if (!card.init(SPI_FULL_SPEED,SDSS)
#if defined(LCD_SDSS) && (LCD_SDSS != SDSS) #if defined(LCD_SDSS) && (LCD_SDSS != SDSS)
&& !card.init(SPI_FULL_SPEED,LCD_SDSS) && !card.init(SPI_SPEED, LCD_SDSS)
#endif #endif
) ) {
#endif
{
//if (!card.init(SPI_HALF_SPEED,SDSS)) //if (!card.init(SPI_HALF_SPEED,SDSS))
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM(MSG_SD_INIT_FAIL); SERIAL_ECHOLNPGM(MSG_SD_INIT_FAIL);
} }
else if (!volume.init(&card)) else if (!volume.init(&card)) {
{
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM(MSG_SD_VOL_INIT_FAIL); SERIAL_ERRORLNPGM(MSG_SD_VOL_INIT_FAIL);
} }
else if (!root.openRoot(&volume)) else if (!root.openRoot(&volume)) {
{
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM(MSG_SD_OPENROOT_FAIL); SERIAL_ERRORLNPGM(MSG_SD_OPENROOT_FAIL);
} }
else else {
{
cardOK = true; cardOK = true;
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLNPGM(MSG_SD_CARD_OK); SERIAL_ECHOLNPGM(MSG_SD_CARD_OK);
} }
workDir=root; workDir = root;
curDir=&root; curDir = &root;
/* /*
if(!workDir.openRoot(&volume)) if (!workDir.openRoot(&volume)) {
{
SERIAL_ECHOLNPGM(MSG_SD_WORKDIR_FAIL); SERIAL_ECHOLNPGM(MSG_SD_WORKDIR_FAIL);
} }
*/ */
} }
void CardReader::setroot() void CardReader::setroot() {
{ /*if (!workDir.openRoot(&volume)) {
/*if(!workDir.openRoot(&volume))
{
SERIAL_ECHOLNPGM(MSG_SD_WORKDIR_FAIL); SERIAL_ECHOLNPGM(MSG_SD_WORKDIR_FAIL);
}*/ }*/
workDir=root; workDir = root;
curDir = &workDir;
curDir=&workDir;
} }
void CardReader::release()
{ void CardReader::release() {
sdprinting = false; sdprinting = false;
cardOK = false; cardOK = false;
} }
void CardReader::startFileprint() void CardReader::startFileprint() {
{ if (cardOK) {
if(cardOK)
{
sdprinting = true; sdprinting = true;
} }
} }
void CardReader::pauseSDPrint() void CardReader::pauseSDPrint() {
{ if (sdprinting) sdprinting = false;
if(sdprinting)
{
sdprinting = false;
}
} }
void CardReader::openLogFile(char* name) {
void CardReader::openLogFile(char* name)
{
logging = true; logging = true;
openFile(name, false); openFile(name, false);
} }
void CardReader::getAbsFilename(char *t) void CardReader::getAbsFilename(char *t) {
{ uint8_t cnt = 0;
uint8_t cnt=0; *t = '/'; t++; cnt++;
*t='/';t++;cnt++; for (uint8_t i = 0; i < workDirDepth; i++) {
for(uint8_t i=0;i<workDirDepth;i++)
{
workDirParents[i].getFilename(t); //SDBaseFile.getfilename! workDirParents[i].getFilename(t); //SDBaseFile.getfilename!
while(*t!=0 && cnt< MAXPATHNAMELENGTH) while(*t && cnt < MAXPATHNAMELENGTH) { t++; cnt++; } //crawl counter forward.
{t++;cnt++;} //crawl counter forward.
} }
if(cnt<MAXPATHNAMELENGTH-FILENAME_LENGTH) if (cnt < MAXPATHNAMELENGTH - FILENAME_LENGTH)
file.getFilename(t); file.getFilename(t);
else else
t[0]=0; t[0] = 0;
} }
void CardReader::openFile(char* name,bool read, bool replace_current/*=true*/) void CardReader::openFile(char* name, bool read, bool replace_current/*=true*/) {
{ if (!cardOK) return;
if(!cardOK) if (file.isOpen()) { //replacing current file by new file, or subfile call
return; if (!replace_current) {
if(file.isOpen()) //replacing current file by new file, or subfile call if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) {
{
if(!replace_current)
{
if((int)file_subcall_ctr>(int)SD_PROCEDURE_DEPTH-1)
{
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORPGM("trying to call sub-gcode files with too many levels. MAX level is:"); SERIAL_ERRORPGM("trying to call sub-gcode files with too many levels. MAX level is:");
SERIAL_ERRORLN(SD_PROCEDURE_DEPTH); SERIAL_ERRORLN(SD_PROCEDURE_DEPTH);
@ -275,79 +213,67 @@ void CardReader::openFile(char* name,bool read, bool replace_current/*=true*/)
SERIAL_ECHO(filenames[file_subcall_ctr]); SERIAL_ECHO(filenames[file_subcall_ctr]);
SERIAL_ECHOPGM("\" pos"); SERIAL_ECHOPGM("\" pos");
SERIAL_ECHOLN(sdpos); SERIAL_ECHOLN(sdpos);
filespos[file_subcall_ctr]=sdpos; filespos[file_subcall_ctr] = sdpos;
file_subcall_ctr++; file_subcall_ctr++;
} }
else else {
{
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPGM("Now doing file: "); SERIAL_ECHOPGM("Now doing file: ");
SERIAL_ECHOLN(name); SERIAL_ECHOLN(name);
} }
file.close(); file.close();
} }
else //opening fresh file else { //opening fresh file
{ file_subcall_ctr = 0; //resetting procedure depth in case user cancels print while in procedure
file_subcall_ctr=0; //resetting procedure depth in case user cancels print while in procedure
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPGM("Now fresh file: "); SERIAL_ECHOPGM("Now fresh file: ");
SERIAL_ECHOLN(name); SERIAL_ECHOLN(name);
} }
sdprinting = false; sdprinting = false;
SdFile myDir; SdFile myDir;
curDir=&root; curDir = &root;
char *fname=name; char *fname = name;
char *dirname_start,*dirname_end; char *dirname_start, *dirname_end;
if(name[0]=='/') if (name[0] == '/') {
{ dirname_start = &name[1];
dirname_start=strchr(name,'/')+1; while(dirname_start > 0) {
while(dirname_start>0) dirname_end = strchr(dirname_start, '/');
{ //SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start - name));
dirname_end=strchr(dirname_start,'/'); //SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end - name));
//SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start-name)); if (dirname_end > 0 && dirname_end > dirname_start) {
//SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end-name));
if(dirname_end>0 && dirname_end>dirname_start)
{
char subdirname[FILENAME_LENGTH]; char subdirname[FILENAME_LENGTH];
strncpy(subdirname, dirname_start, dirname_end-dirname_start); strncpy(subdirname, dirname_start, dirname_end - dirname_start);
subdirname[dirname_end-dirname_start]=0; subdirname[dirname_end - dirname_start] = 0;
SERIAL_ECHOLN(subdirname); SERIAL_ECHOLN(subdirname);
if(!myDir.open(curDir,subdirname,O_READ)) if (!myDir.open(curDir, subdirname, O_READ)) {
{
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL); SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(subdirname); SERIAL_PROTOCOL(subdirname);
SERIAL_PROTOCOLLNPGM("."); SERIAL_PROTOCOLLNPGM(".");
return; return;
} }
else else {
{
//SERIAL_ECHOLN("dive ok"); //SERIAL_ECHOLN("dive ok");
} }
curDir=&myDir; curDir = &myDir;
dirname_start=dirname_end+1; dirname_start = dirname_end + 1;
} }
else // the reminder after all /fsa/fdsa/ is the filename else { // the remainder after all /fsa/fdsa/ is the filename
{ fname = dirname_start;
fname=dirname_start; //SERIAL_ECHOLN("remainder");
//SERIAL_ECHOLN("remaider");
//SERIAL_ECHOLN(fname); //SERIAL_ECHOLN(fname);
break; break;
} }
} }
} }
else //relative path else { //relative path
{ curDir = &workDir;
curDir=&workDir;
} }
if(read)
{ if (read) {
if (file.open(curDir, fname, O_READ)) if (file.open(curDir, fname, O_READ)) {
{
filesize = file.fileSize(); filesize = file.fileSize();
SERIAL_PROTOCOLPGM(MSG_SD_FILE_OPENED); SERIAL_PROTOCOLPGM(MSG_SD_FILE_OPENED);
SERIAL_PROTOCOL(fname); SERIAL_PROTOCOL(fname);
@ -359,124 +285,105 @@ void CardReader::openFile(char* name,bool read, bool replace_current/*=true*/)
getfilename(0, fname); getfilename(0, fname);
lcd_setstatus(longFilename[0] ? longFilename : fname); lcd_setstatus(longFilename[0] ? longFilename : fname);
} }
else else {
{
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL); SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(fname); SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLLNPGM("."); SERIAL_PROTOCOLLNPGM(".");
} }
} }
else else { //write
{ //write if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) {
if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC))
{
SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL); SERIAL_PROTOCOLPGM(MSG_SD_OPEN_FILE_FAIL);
SERIAL_PROTOCOL(fname); SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLLNPGM("."); SERIAL_PROTOCOLLNPGM(".");
} }
else else {
{
saving = true; saving = true;
SERIAL_PROTOCOLPGM(MSG_SD_WRITE_TO_FILE); SERIAL_PROTOCOLPGM(MSG_SD_WRITE_TO_FILE);
SERIAL_PROTOCOLLN(name); SERIAL_PROTOCOLLN(name);
lcd_setstatus(fname); lcd_setstatus(fname);
} }
} }
} }
void CardReader::removeFile(char* name) void CardReader::removeFile(char* name) {
{ if (!cardOK) return;
if(!cardOK)
return;
file.close(); file.close();
sdprinting = false; sdprinting = false;
SdFile myDir; SdFile myDir;
curDir=&root; curDir = &root;
char *fname=name; char *fname = name;
char *dirname_start,*dirname_end; char *dirname_start, *dirname_end;
if(name[0]=='/') if (name[0] == '/') {
{ dirname_start = strchr(name, '/') + 1;
dirname_start=strchr(name,'/')+1; while (dirname_start > 0) {
while(dirname_start>0) dirname_end = strchr(dirname_start, '/');
{ //SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start - name));
dirname_end=strchr(dirname_start,'/'); //SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end - name));
//SERIAL_ECHO("start:");SERIAL_ECHOLN((int)(dirname_start-name)); if (dirname_end > 0 && dirname_end > dirname_start) {
//SERIAL_ECHO("end :");SERIAL_ECHOLN((int)(dirname_end-name));
if(dirname_end>0 && dirname_end>dirname_start)
{
char subdirname[FILENAME_LENGTH]; char subdirname[FILENAME_LENGTH];
strncpy(subdirname, dirname_start, dirname_end-dirname_start); strncpy(subdirname, dirname_start, dirname_end - dirname_start);
subdirname[dirname_end-dirname_start]=0; subdirname[dirname_end - dirname_start] = 0;
SERIAL_ECHOLN(subdirname); SERIAL_ECHOLN(subdirname);
if(!myDir.open(curDir,subdirname,O_READ)) if (!myDir.open(curDir, subdirname, O_READ)) {
{
SERIAL_PROTOCOLPGM("open failed, File: "); SERIAL_PROTOCOLPGM("open failed, File: ");
SERIAL_PROTOCOL(subdirname); SERIAL_PROTOCOL(subdirname);
SERIAL_PROTOCOLLNPGM("."); SERIAL_PROTOCOLLNPGM(".");
return; return;
} }
else else {
{
//SERIAL_ECHOLN("dive ok"); //SERIAL_ECHOLN("dive ok");
} }
curDir=&myDir; curDir = &myDir;
dirname_start=dirname_end+1; dirname_start = dirname_end + 1;
} }
else // the reminder after all /fsa/fdsa/ is the filename else { // the remainder after all /fsa/fdsa/ is the filename
{ fname = dirname_start;
fname=dirname_start; //SERIAL_ECHOLN("remainder");
//SERIAL_ECHOLN("remaider");
//SERIAL_ECHOLN(fname); //SERIAL_ECHOLN(fname);
break; break;
} }
} }
} }
else //relative path else { // relative path
{ curDir = &workDir;
curDir=&workDir;
} }
if (file.remove(curDir, fname))
{ if (file.remove(curDir, fname)) {
SERIAL_PROTOCOLPGM("File deleted:"); SERIAL_PROTOCOLPGM("File deleted:");
SERIAL_PROTOCOLLN(fname); SERIAL_PROTOCOLLN(fname);
sdpos = 0; sdpos = 0;
} }
else else {
{
SERIAL_PROTOCOLPGM("Deletion failed, File: "); SERIAL_PROTOCOLPGM("Deletion failed, File: ");
SERIAL_PROTOCOL(fname); SERIAL_PROTOCOL(fname);
SERIAL_PROTOCOLLNPGM("."); SERIAL_PROTOCOLLNPGM(".");
} }
} }
void CardReader::getStatus() void CardReader::getStatus() {
{ if (cardOK) {
if(cardOK){
SERIAL_PROTOCOLPGM(MSG_SD_PRINTING_BYTE); SERIAL_PROTOCOLPGM(MSG_SD_PRINTING_BYTE);
SERIAL_PROTOCOL(sdpos); SERIAL_PROTOCOL(sdpos);
SERIAL_PROTOCOLPGM("/"); SERIAL_PROTOCOLPGM("/");
SERIAL_PROTOCOLLN(filesize); SERIAL_PROTOCOLLN(filesize);
} }
else{ else {
SERIAL_PROTOCOLLNPGM(MSG_SD_NOT_PRINTING); SERIAL_PROTOCOLLNPGM(MSG_SD_NOT_PRINTING);
} }
} }
void CardReader::write_command(char *buf)
{ void CardReader::write_command(char *buf) {
char* begin = buf; char* begin = buf;
char* npos = 0; char* npos = 0;
char* end = buf + strlen(buf) - 1; char* end = buf + strlen(buf) - 1;
file.writeError = false; file.writeError = false;
if((npos = strchr(buf, 'N')) != NULL) if ((npos = strchr(buf, 'N')) != NULL) {
{
begin = strchr(npos, ' ') + 1; begin = strchr(npos, ' ') + 1;
end = strchr(npos, '*') - 1; end = strchr(npos, '*') - 1;
} }
@ -484,162 +391,129 @@ void CardReader::write_command(char *buf)
end[2] = '\n'; end[2] = '\n';
end[3] = '\0'; end[3] = '\0';
file.write(begin); file.write(begin);
if (file.writeError) if (file.writeError) {
{
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORLNPGM(MSG_SD_ERR_WRITE_TO_FILE); SERIAL_ERRORLNPGM(MSG_SD_ERR_WRITE_TO_FILE);
} }
} }
void CardReader::checkautostart(bool force) {
void CardReader::checkautostart(bool force) if (!force && (!autostart_stilltocheck || autostart_atmillis < millis()))
{
if(!force)
{
if(!autostart_stilltocheck)
return;
if(autostart_atmillis<millis())
return; return;
}
autostart_stilltocheck=false; autostart_stilltocheck = false;
if(!cardOK)
{ if (!cardOK) {
initsd(); initsd();
if(!cardOK) //fail if (!cardOK) return; // fail
return;
} }
char autoname[30]; char autoname[30];
sprintf_P(autoname, PSTR("auto%i.g"), autostart_index); sprintf_P(autoname, PSTR("auto%i.g"), autostart_index);
for(int8_t i=0;i<(int8_t)strlen(autoname);i++) for (int8_t i = 0; i < (int8_t)strlen(autoname); i++) autoname[i] = tolower(autoname[i]);
autoname[i]=tolower(autoname[i]);
dir_t p; dir_t p;
root.rewind(); root.rewind();
bool found=false; bool found = false;
while (root.readDir(p, NULL) > 0) while (root.readDir(p, NULL) > 0) {
{ for (int8_t i = 0; i < (int8_t)strlen((char*)p.name); i++) p.name[i] = tolower(p.name[i]);
for(int8_t i=0;i<(int8_t)strlen((char*)p.name);i++) if (p.name[9] != '~' && strncmp((char*)p.name, autoname, 5) == 0) {
p.name[i]=tolower(p.name[i]);
//Serial.print((char*)p.name);
//Serial.print(" ");
//Serial.println(autoname);
if(p.name[9]!='~') //skip safety copies
if(strncmp((char*)p.name,autoname,5)==0)
{
char cmd[30]; char cmd[30];
sprintf_P(cmd, PSTR("M23 %s"), autoname); sprintf_P(cmd, PSTR("M23 %s"), autoname);
enquecommand(cmd); enquecommand(cmd);
enquecommands_P(PSTR("M24")); enquecommands_P(PSTR("M24"));
found=true; found = true;
} }
} }
if(!found) if (!found)
autostart_index=-1; autostart_index = -1;
else else
autostart_index++; autostart_index++;
} }
void CardReader::closefile(bool store_location) void CardReader::closefile(bool store_location) {
{
file.sync(); file.sync();
file.close(); file.close();
saving = false; saving = logging = false;
logging = false;
if(store_location) if (store_location) {
{
//future: store printer state, filename and position for continuing a stopped print //future: store printer state, filename and position for continuing a stopped print
// so one can unplug the printer and continue printing the next day. // so one can unplug the printer and continue printing the next day.
} }
} }
void CardReader::getfilename(uint16_t nr, const char * const match/*=NULL*/) /**
{ * Get the name of a file in the current directory by index
curDir=&workDir; */
lsAction=LS_GetFilename; void CardReader::getfilename(uint16_t nr, const char * const match/*=NULL*/) {
nrFiles=nr; curDir = &workDir;
lsAction = LS_GetFilename;
nrFiles = nr;
curDir->rewind(); curDir->rewind();
lsDive("",*curDir,match); lsDive("", *curDir, match);
} }
uint16_t CardReader::getnrfilenames() uint16_t CardReader::getnrfilenames() {
{ curDir = &workDir;
curDir=&workDir; lsAction = LS_Count;
lsAction=LS_Count; nrFiles = 0;
nrFiles=0;
curDir->rewind(); curDir->rewind();
lsDive("",*curDir); lsDive("", *curDir);
//SERIAL_ECHOLN(nrFiles); //SERIAL_ECHOLN(nrFiles);
return nrFiles; return nrFiles;
} }
void CardReader::chdir(const char * relpath) void CardReader::chdir(const char * relpath) {
{
SdFile newfile; SdFile newfile;
SdFile *parent=&root; SdFile *parent = &root;
if(workDir.isOpen()) if (workDir.isOpen()) parent = &workDir;
parent=&workDir;
if(!newfile.open(*parent,relpath, O_READ)) if (!newfile.open(*parent, relpath, O_READ)) {
{
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPGM(MSG_SD_CANT_ENTER_SUBDIR); SERIAL_ECHOPGM(MSG_SD_CANT_ENTER_SUBDIR);
SERIAL_ECHOLN(relpath); SERIAL_ECHOLN(relpath);
} }
else else {
{
if (workDirDepth < MAX_DIR_DEPTH) { if (workDirDepth < MAX_DIR_DEPTH) {
for (int d = ++workDirDepth; d--;) ++workDirDepth;
workDirParents[d+1] = workDirParents[d]; for (int d = workDirDepth; d--;) workDirParents[d + 1] = workDirParents[d];
workDirParents[0]=*parent; workDirParents[0] = *parent;
} }
workDir=newfile; workDir = newfile;
} }
} }
void CardReader::updir() void CardReader::updir() {
{ if (workDirDepth > 0) {
if(workDirDepth > 0)
{
--workDirDepth; --workDirDepth;
workDir = workDirParents[0]; workDir = workDirParents[0];
int d;
for (int d = 0; d < workDirDepth; d++) for (int d = 0; d < workDirDepth; d++)
workDirParents[d] = workDirParents[d+1]; workDirParents[d] = workDirParents[d+1];
} }
} }
void CardReader::printingHasFinished() {
void CardReader::printingHasFinished()
{
st_synchronize(); st_synchronize();
if(file_subcall_ctr>0) //heading up to a parent file that called current as a procedure. if (file_subcall_ctr > 0) { // Heading up to a parent file that called current as a procedure.
{
file.close(); file.close();
file_subcall_ctr--; file_subcall_ctr--;
openFile(filenames[file_subcall_ctr],true,true); openFile(filenames[file_subcall_ctr], true, true);
setIndex(filespos[file_subcall_ctr]); setIndex(filespos[file_subcall_ctr]);
startFileprint(); startFileprint();
} }
else else {
{
quickStop(); quickStop();
file.close(); file.close();
sdprinting = false; sdprinting = false;
if(SD_FINISHED_STEPPERRELEASE) if (SD_FINISHED_STEPPERRELEASE) {
{
//finishAndDisableSteppers(); //finishAndDisableSteppers();
enquecommands_P(PSTR(SD_FINISHED_RELEASECOMMAND)); enquecommands_P(PSTR(SD_FINISHED_RELEASECOMMAND));
} }
autotempShutdown(); autotempShutdown();
} }
} }
#endif //SDSUPPORT #endif //SDSUPPORT

56
Marlin/cardreader.h
Unescape View File

@ -3,12 +3,12 @@
#ifdef SDSUPPORT #ifdef SDSUPPORT
#define MAX_DIR_DEPTH 10 #define MAX_DIR_DEPTH 10 // Maximum folder depth
#include "SdFile.h" #include "SdFile.h"
enum LsAction {LS_SerialPrint,LS_Count,LS_GetFilename}; enum LsAction { LS_SerialPrint, LS_Count, LS_GetFilename };
class CardReader
{ class CardReader {
public: public:
CardReader(); CardReader();
@ -33,7 +33,6 @@ public:
void getAbsFilename(char *t); void getAbsFilename(char *t);
void ls(); void ls();
void chdir(const char * relpath); void chdir(const char * relpath);
void updir(); void updir();
@ -41,56 +40,52 @@ public:
FORCE_INLINE bool isFileOpen() { return file.isOpen(); } FORCE_INLINE bool isFileOpen() { return file.isOpen(); }
FORCE_INLINE bool eof() { return sdpos>=filesize ;}; FORCE_INLINE bool eof() { return sdpos >= filesize; }
FORCE_INLINE int16_t get() { sdpos = file.curPosition();return (int16_t)file.read();}; FORCE_INLINE int16_t get() { sdpos = file.curPosition(); return (int16_t)file.read(); }
FORCE_INLINE void setIndex(long index) {sdpos = index;file.seekSet(index);}; FORCE_INLINE void setIndex(long index) { sdpos = index; file.seekSet(index); }
FORCE_INLINE uint8_t percentDone(){if(!isFileOpen()) return 0; if(filesize) return sdpos/((filesize+99)/100); else return 0;}; FORCE_INLINE uint8_t percentDone() { return (isFileOpen() && filesize) ? sdpos / ((filesize + 99) / 100) : 0; }
FORCE_INLINE char* getWorkDirName(){workDir.getFilename(filename);return filename;}; FORCE_INLINE char* getWorkDirName() { workDir.getFilename(filename); return filename; }
public: public:
bool saving; bool saving, logging, sdprinting, cardOK, filenameIsDir;
bool logging; char filename[FILENAME_LENGTH], longFilename[LONG_FILENAME_LENGTH];
bool sdprinting;
bool cardOK;
char filename[FILENAME_LENGTH];
char longFilename[LONG_FILENAME_LENGTH];
bool filenameIsDir;
int autostart_index; int autostart_index;
private: private:
SdFile root,*curDir,workDir,workDirParents[MAX_DIR_DEPTH]; SdFile root, *curDir, workDir, workDirParents[MAX_DIR_DEPTH];
uint16_t workDirDepth; uint16_t workDirDepth;
Sd2Card card; Sd2Card card;
SdVolume volume; SdVolume volume;
SdFile file; SdFile file;
#define SD_PROCEDURE_DEPTH 1 #define SD_PROCEDURE_DEPTH 1
#define MAXPATHNAMELENGTH (FILENAME_LENGTH*MAX_DIR_DEPTH+MAX_DIR_DEPTH+1) #define MAXPATHNAMELENGTH (FILENAME_LENGTH*MAX_DIR_DEPTH + MAX_DIR_DEPTH + 1)
uint8_t file_subcall_ctr; uint8_t file_subcall_ctr;
uint32_t filespos[SD_PROCEDURE_DEPTH]; uint32_t filespos[SD_PROCEDURE_DEPTH];
char filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH]; char filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH];
uint32_t filesize; uint32_t filesize;
//int16_t n;
unsigned long autostart_atmillis; unsigned long autostart_atmillis;
uint32_t sdpos ; uint32_t sdpos;
bool autostart_stilltocheck; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware. bool autostart_stilltocheck; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware.
LsAction lsAction; //stored for recursion. LsAction lsAction; //stored for recursion.
int16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory. uint16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory.
char* diveDirName; char* diveDirName;
void lsDive(const char *prepend, SdFile parent, const char * const match=NULL); void lsDive(const char *prepend, SdFile parent, const char * const match=NULL);
}; };
extern CardReader card; extern CardReader card;
#define IS_SD_PRINTING (card.sdprinting) #define IS_SD_PRINTING (card.sdprinting)
#if (SDCARDDETECT > -1) #if (SDCARDDETECT > -1)
# ifdef SDCARDDETECTINVERTED #ifdef SDCARDDETECTINVERTED
# define IS_SD_INSERTED (READ(SDCARDDETECT)!=0) #define IS_SD_INSERTED (READ(SDCARDDETECT) != 0)
# else #else
# define IS_SD_INSERTED (READ(SDCARDDETECT)==0) #define IS_SD_INSERTED (READ(SDCARDDETECT) == 0)
# endif //SDCARDTETECTINVERTED #endif
#else #else
//If we don't have a card detect line, aways asume the card is inserted //No card detect line? Assume the card is inserted.
# define IS_SD_INSERTED true #define IS_SD_INSERTED true
#endif #endif
#else #else
@ -98,4 +93,5 @@ extern CardReader card;
#define IS_SD_PRINTING (false) #define IS_SD_PRINTING (false)
#endif //SDSUPPORT #endif //SDSUPPORT
#endif
#endif //__CARDREADER_H

39
Marlin/digipot_mcp4451.cpp
Unescape View File

@ -1,25 +1,25 @@
#include "Configuration.h" #include "Configuration.h"
#ifdef DIGIPOT_I2C #ifdef DIGIPOT_I2C
#include "Stream.h" #include "Stream.h"
#include "utility/twi.h" #include "utility/twi.h"
#include "Wire.h" #include "Wire.h"
// Settings for the I2C based DIGIPOT (MCP4451) on Azteeg X3 Pro // Settings for the I2C based DIGIPOT (MCP4451) on Azteeg X3 Pro
#if MB(5DPRINT) #if MB(5DPRINT)
#define DIGIPOT_I2C_FACTOR 117.96 #define DIGIPOT_I2C_FACTOR 117.96
#define DIGIPOT_I2C_MAX_CURRENT 1.736 #define DIGIPOT_I2C_MAX_CURRENT 1.736
#else #else
#define DIGIPOT_I2C_FACTOR 106.7 #define DIGIPOT_I2C_FACTOR 106.7
#define DIGIPOT_I2C_MAX_CURRENT 2.5 #define DIGIPOT_I2C_MAX_CURRENT 2.5
#endif #endif
static byte current_to_wiper( float current ){ static byte current_to_wiper(float current) {
return byte(ceil(float((DIGIPOT_I2C_FACTOR*current)))); return byte(ceil(float((DIGIPOT_I2C_FACTOR*current))));
} }
static void i2c_send(byte addr, byte a, byte b) static void i2c_send(byte addr, byte a, byte b) {
{
Wire.beginTransmission(addr); Wire.beginTransmission(addr);
Wire.write(a); Wire.write(a);
Wire.write(b); Wire.write(b);
@ -27,33 +27,32 @@ static void i2c_send(byte addr, byte a, byte b)
} }
// This is for the MCP4451 I2C based digipot // This is for the MCP4451 I2C based digipot
void digipot_i2c_set_current( int channel, float current ) void digipot_i2c_set_current(int channel, float current) {
{
current = min( (float) max( current, 0.0f ), DIGIPOT_I2C_MAX_CURRENT); current = min( (float) max( current, 0.0f ), DIGIPOT_I2C_MAX_CURRENT);
// these addresses are specific to Azteeg X3 Pro, can be set to others, // these addresses are specific to Azteeg X3 Pro, can be set to others,
// In this case first digipot is at address A0=0, A1= 0, second one is at A0=0, A1= 1 // In this case first digipot is at address A0=0, A1= 0, second one is at A0=0, A1= 1
byte addr= 0x2C; // channel 0-3 byte addr = 0x2C; // channel 0-3
if(channel >= 4) { if (channel >= 4) {
addr= 0x2E; // channel 4-7 addr = 0x2E; // channel 4-7
channel-= 4; channel -= 4;
} }
// Initial setup // Initial setup
i2c_send( addr, 0x40, 0xff ); i2c_send(addr, 0x40, 0xff);
i2c_send( addr, 0xA0, 0xff ); i2c_send(addr, 0xA0, 0xff);
// Set actual wiper value // Set actual wiper value
byte addresses[4] = { 0x00, 0x10, 0x60, 0x70 }; byte addresses[4] = { 0x00, 0x10, 0x60, 0x70 };
i2c_send( addr, addresses[channel], current_to_wiper(current) ); i2c_send(addr, addresses[channel], current_to_wiper(current));
} }
void digipot_i2c_init() void digipot_i2c_init() {
{
const float digipot_motor_current[] = DIGIPOT_I2C_MOTOR_CURRENTS; const float digipot_motor_current[] = DIGIPOT_I2C_MOTOR_CURRENTS;
Wire.begin(); Wire.begin();
// setup initial currents as defined in Configuration_adv.h // setup initial currents as defined in Configuration_adv.h
for(int i=0;i<=sizeof(digipot_motor_current)/sizeof(float);i++) { for(int i = 0; i <= sizeof(digipot_motor_current) / sizeof(float); i++) {
digipot_i2c_set_current(i, digipot_motor_current[i]); digipot_i2c_set_current(i, digipot_motor_current[i]);
} }
} }
#endif
#endif //DIGIPOT_I2C

37
Marlin/language.h
Unescape View File

@ -159,6 +159,43 @@
#define MSG_ERR_EEPROM_WRITE "Error writing to EEPROM!" #define MSG_ERR_EEPROM_WRITE "Error writing to EEPROM!"
// temperature.cpp strings
#define MSG_PID_AUTOTUNE "PID Autotune"
#define MSG_PID_AUTOTUNE_START MSG_PID_AUTOTUNE " start"
#define MSG_PID_AUTOTUNE_FAILED MSG_PID_AUTOTUNE " failed!"
#define MSG_PID_BAD_EXTRUDER_NUM MSG_PID_AUTOTUNE_FAILED " Bad extruder number"
#define MSG_PID_TEMP_TOO_HIGH MSG_PID_AUTOTUNE_FAILED " Temperature too high"
#define MSG_PID_TIMEOUT MSG_PID_AUTOTUNE_FAILED " timeout"
#define MSG_BIAS " bias: "
#define MSG_D " d: "
#define MSG_MIN " min: "
#define MSG_MAX " max: "
#define MSG_KU " Ku: "
#define MSG_TU " Tu: "
#define MSG_CLASSIC_PID " Classic PID "
#define MSG_KP " Kp: "
#define MSG_KI " Ki: "
#define MSG_KD " Kd: "
#define MSG_OK_B "ok B:"
#define MSG_OK_T "ok T:"
#define MSG_AT " @:"
#define MSG_PID_AUTOTUNE_FINISHED MSG_PID_AUTOTUNE " finished! Put the last Kp, Ki and Kd constants from above into Configuration.h"
#define MSG_PID_DEBUG " PID_DEBUG "
#define MSG_PID_DEBUG_INPUT ": Input "
#define MSG_PID_DEBUG_OUTPUT " Output "
#define MSG_PID_DEBUG_PTERM " pTerm "
#define MSG_PID_DEBUG_ITERM " iTerm "
#define MSG_PID_DEBUG_DTERM " dTerm "
#define MSG_HEATING_FAILED "Heating failed"
#define MSG_EXTRUDER_SWITCHED_OFF "Extruder switched off. Temperature difference between temp sensors is too high !"
#define MSG_INVALID_EXTRUDER_NUM " - Invalid extruder number !"
#define MSG_THERMAL_RUNAWAY_STOP "Thermal Runaway, system stopped! Heater_ID: "
#define MSG_SWITCHED_OFF_MAX " switched off. MAXTEMP triggered !!"
#define MSG_MINTEMP_EXTRUDER_OFF ": Extruder switched off. MINTEMP triggered !"
#define MSG_MAXTEMP_EXTRUDER_OFF ": Extruder" MSG_SWITCHED_OFF_MAX
#define MSG_MAXTEMP_BED_OFF "Heated bed" MSG_SWITCHED_OFF_MAX
// LCD Menu Messages // LCD Menu Messages
// Add your own character. Reference: https://github.com/MarlinFirmware/Marlin/pull/1434 photos // Add your own character. Reference: https://github.com/MarlinFirmware/Marlin/pull/1434 photos

18
Marlin/language_en.h
Unescape View File

@ -383,6 +383,24 @@
#ifndef MSG_ENDSTOP_ABORT #ifndef MSG_ENDSTOP_ABORT
#define MSG_ENDSTOP_ABORT "Endstop abort" #define MSG_ENDSTOP_ABORT "Endstop abort"
#endif #endif
#ifndef MSG_HEATING_FAILED_LCD
#define MSG_HEATING_FAILED_LCD "Heating failed"
#endif
#ifndef MSG_ERR_REDUNDANT_TEMP
#define MSG_ERR_REDUNDANT_TEMP "Err: REDUNDANT TEMP ERROR"
#endif
#ifndef MSG_THERMAL_RUNAWAY
#define MSG_THERMAL_RUNAWAY "THERMAL RUNAWAY"
#endif
#ifndef MSG_ERR_MAXTEMP
#define MSG_ERR_MAXTEMP "Err: MAXTEMP"
#endif
#ifndef MSG_ERR_MINTEMP
#define MSG_ERR_MINTEMP "Err: MINTEMP"
#endif
#ifndef MSG_ERR_MAXTEMP_BED
#define MSG_ERR_MAXTEMP_BED "Err: MAXTEMP BED"
#endif
#ifdef DELTA_CALIBRATION_MENU #ifdef DELTA_CALIBRATION_MENU
#ifndef MSG_DELTA_CALIBRATE #ifndef MSG_DELTA_CALIBRATE

4
Marlin/pins_RUMBA.h
Unescape View File

@ -6,6 +6,10 @@
#error Oops! Make sure you have 'Arduino Mega' selected from the 'Tools -> Boards' menu. #error Oops! Make sure you have 'Arduino Mega' selected from the 'Tools -> Boards' menu.
#endif #endif
#if EXTRUDERS > 3
#error RUMBA supports up to 3 extruders. Comment this line to keep going.
#endif
#define X_STEP_PIN 17 #define X_STEP_PIN 17
#define X_DIR_PIN 16 #define X_DIR_PIN 16
#define X_ENABLE_PIN 48 #define X_ENABLE_PIN 48

41
Marlin/stepper.cpp
Unescape View File

@ -399,24 +399,24 @@ ISR(TIMER1_COMPA_vect)
count_direction[Y_AXIS]=1; count_direction[Y_AXIS]=1;
} }
// Set direction en check limit switches if(check_endstops) // check X and Y Endstops
{
#ifndef COREXY #ifndef COREXY
if ((out_bits & (1<<X_AXIS)) != 0) // stepping along -X axis if ((out_bits & (1<<X_AXIS)) != 0) // stepping along -X axis (regular cartesians bot)
#else #else
if (!((current_block->steps_x == current_block->steps_y) && ((out_bits & (1<<X_AXIS))>>X_AXIS != (out_bits & (1<<Y_AXIS))>>Y_AXIS))) // AlexBorro: If DeltaX == -DeltaY, the movement is only in Y axis
if ((out_bits & (1<<X_HEAD)) != 0) //AlexBorro: Head direction in -X axis for CoreXY bots. if ((out_bits & (1<<X_HEAD)) != 0) //AlexBorro: Head direction in -X axis for CoreXY bots.
#endif #endif
{ { // -direction
CHECK_ENDSTOPS
{
#ifdef DUAL_X_CARRIAGE #ifdef DUAL_X_CARRIAGE
// with 2 x-carriages, endstops are only checked in the homing direction for the active extruder // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder
if ((current_block->active_extruder == 0 && X_HOME_DIR == -1) if ((current_block->active_extruder == 0 && X_HOME_DIR == -1) || (current_block->active_extruder != 0 && X2_HOME_DIR == -1))
|| (current_block->active_extruder != 0 && X2_HOME_DIR == -1))
#endif #endif
{ {
#if defined(X_MIN_PIN) && X_MIN_PIN > -1 #if defined(X_MIN_PIN) && X_MIN_PIN > -1
bool x_min_endstop=(READ(X_MIN_PIN) != X_MIN_ENDSTOP_INVERTING); bool x_min_endstop=(READ(X_MIN_PIN) != X_MIN_ENDSTOP_INVERTING);
if(x_min_endstop && old_x_min_endstop && (current_block->steps_x > 0)) { if(x_min_endstop && old_x_min_endstop && (current_block->steps_x > 0))
{
endstops_trigsteps[X_AXIS] = count_position[X_AXIS]; endstops_trigsteps[X_AXIS] = count_position[X_AXIS];
endstop_x_hit=true; endstop_x_hit=true;
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
@ -425,20 +425,17 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
} }
} }
}
else else
{ // +direction { // +direction
CHECK_ENDSTOPS
{
#ifdef DUAL_X_CARRIAGE #ifdef DUAL_X_CARRIAGE
// with 2 x-carriages, endstops are only checked in the homing direction for the active extruder // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder
if ((current_block->active_extruder == 0 && X_HOME_DIR == 1) if ((current_block->active_extruder == 0 && X_HOME_DIR == 1) || (current_block->active_extruder != 0 && X2_HOME_DIR == 1))
|| (current_block->active_extruder != 0 && X2_HOME_DIR == 1))
#endif #endif
{ {
#if defined(X_MAX_PIN) && X_MAX_PIN > -1 #if defined(X_MAX_PIN) && X_MAX_PIN > -1
bool x_max_endstop=(READ(X_MAX_PIN) != X_MAX_ENDSTOP_INVERTING); bool x_max_endstop=(READ(X_MAX_PIN) != X_MAX_ENDSTOP_INVERTING);
if(x_max_endstop && old_x_max_endstop && (current_block->steps_x > 0)){ if(x_max_endstop && old_x_max_endstop && (current_block->steps_x > 0))
{
endstops_trigsteps[X_AXIS] = count_position[X_AXIS]; endstops_trigsteps[X_AXIS] = count_position[X_AXIS];
endstop_x_hit=true; endstop_x_hit=true;
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
@ -447,19 +444,18 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
} }
} }
}
#ifndef COREXY #ifndef COREXY
if ((out_bits & (1<<Y_AXIS)) != 0) // -direction if ((out_bits & (1<<Y_AXIS)) != 0) // -direction
#else #else
if (!((current_block->steps_x == current_block->steps_y) && ((out_bits & (1<<X_AXIS))>>X_AXIS == (out_bits & (1<<Y_AXIS))>>Y_AXIS))) // AlexBorro: If DeltaX == DeltaY, the movement is only in X axis
if ((out_bits & (1<<Y_HEAD)) != 0) //AlexBorro: Head direction in -Y axis for CoreXY bots. if ((out_bits & (1<<Y_HEAD)) != 0) //AlexBorro: Head direction in -Y axis for CoreXY bots.
#endif #endif
{ { // -direction
CHECK_ENDSTOPS
{
#if defined(Y_MIN_PIN) && Y_MIN_PIN > -1 #if defined(Y_MIN_PIN) && Y_MIN_PIN > -1
bool y_min_endstop=(READ(Y_MIN_PIN) != Y_MIN_ENDSTOP_INVERTING); bool y_min_endstop=(READ(Y_MIN_PIN) != Y_MIN_ENDSTOP_INVERTING);
if(y_min_endstop && old_y_min_endstop && (current_block->steps_y > 0)) { if(y_min_endstop && old_y_min_endstop && (current_block->steps_y > 0))
{
endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS]; endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS];
endstop_y_hit=true; endstop_y_hit=true;
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
@ -467,20 +463,19 @@ ISR(TIMER1_COMPA_vect)
old_y_min_endstop = y_min_endstop; old_y_min_endstop = y_min_endstop;
#endif #endif
} }
}
else else
{ // +direction { // +direction
CHECK_ENDSTOPS
{
#if defined(Y_MAX_PIN) && Y_MAX_PIN > -1 #if defined(Y_MAX_PIN) && Y_MAX_PIN > -1
bool y_max_endstop=(READ(Y_MAX_PIN) != Y_MAX_ENDSTOP_INVERTING); bool y_max_endstop=(READ(Y_MAX_PIN) != Y_MAX_ENDSTOP_INVERTING);
if(y_max_endstop && old_y_max_endstop && (current_block->steps_y > 0)){ if(y_max_endstop && old_y_max_endstop && (current_block->steps_y > 0))
{
endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS]; endstops_trigsteps[Y_AXIS] = count_position[Y_AXIS];
endstop_y_hit=true; endstop_y_hit=true;
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
old_y_max_endstop = y_max_endstop; old_y_max_endstop = y_max_endstop;
#endif #endif
} }
} }

1764
Marlin/temperature.cpp
View File

File diff suppressed because it is too large Load Diff

109
Marlin/temperature.h
Unescape View File

@ -85,55 +85,25 @@ extern float current_temperature_bed;
//inline so that there is no performance decrease. //inline so that there is no performance decrease.
//deg=degreeCelsius //deg=degreeCelsius
FORCE_INLINE float degHotend(uint8_t extruder) { FORCE_INLINE float degHotend(uint8_t extruder) { return current_temperature[extruder]; }
return current_temperature[extruder]; FORCE_INLINE float degBed() { return current_temperature_bed; }
};
#ifdef SHOW_TEMP_ADC_VALUES #ifdef SHOW_TEMP_ADC_VALUES
FORCE_INLINE float rawHotendTemp(uint8_t extruder) { FORCE_INLINE float rawHotendTemp(uint8_t extruder) { return current_temperature_raw[extruder]; }
return current_temperature_raw[extruder]; FORCE_INLINE float rawBedTemp() { return current_temperature_bed_raw; }
};
FORCE_INLINE float rawBedTemp() {
return current_temperature_bed_raw;
};
#endif #endif
FORCE_INLINE float degBed() { FORCE_INLINE float degTargetHotend(uint8_t extruder) { return target_temperature[extruder]; }
return current_temperature_bed; FORCE_INLINE float degTargetBed() { return target_temperature_bed; }
};
FORCE_INLINE float degTargetHotend(uint8_t extruder) {
return target_temperature[extruder];
};
FORCE_INLINE float degTargetBed() {
return target_temperature_bed;
};
FORCE_INLINE void setTargetHotend(const float &celsius, uint8_t extruder) {
target_temperature[extruder] = celsius;
};
FORCE_INLINE void setTargetBed(const float &celsius) {
target_temperature_bed = celsius;
};
FORCE_INLINE bool isHeatingHotend(uint8_t extruder){ FORCE_INLINE void setTargetHotend(const float &celsius, uint8_t extruder) { target_temperature[extruder] = celsius; }
return target_temperature[extruder] > current_temperature[extruder]; FORCE_INLINE void setTargetBed(const float &celsius) { target_temperature_bed = celsius; }
};
FORCE_INLINE bool isHeatingBed() { FORCE_INLINE bool isHeatingHotend(uint8_t extruder) { return target_temperature[extruder] > current_temperature[extruder]; }
return target_temperature_bed > current_temperature_bed; FORCE_INLINE bool isHeatingBed() { return target_temperature_bed > current_temperature_bed; }
};
FORCE_INLINE bool isCoolingHotend(uint8_t extruder) { FORCE_INLINE bool isCoolingHotend(uint8_t extruder) { return target_temperature[extruder] < current_temperature[extruder]; }
return target_temperature[extruder] < current_temperature[extruder]; FORCE_INLINE bool isCoolingBed() { return target_temperature_bed < current_temperature_bed; }
};
FORCE_INLINE bool isCoolingBed() {
return target_temperature_bed < current_temperature_bed;
};
#define degHotend0() degHotend(0) #define degHotend0() degHotend(0)
#define degTargetHotend0() degTargetHotend(0) #define degTargetHotend0() degTargetHotend(0)
@ -141,38 +111,36 @@ FORCE_INLINE bool isCoolingBed() {
#define isHeatingHotend0() isHeatingHotend(0) #define isHeatingHotend0() isHeatingHotend(0)
#define isCoolingHotend0() isCoolingHotend(0) #define isCoolingHotend0() isCoolingHotend(0)
#if EXTRUDERS > 1 #if EXTRUDERS > 1
#define degHotend1() degHotend(1) #define degHotend1() degHotend(1)
#define degTargetHotend1() degTargetHotend(1) #define degTargetHotend1() degTargetHotend(1)
#define setTargetHotend1(_celsius) setTargetHotend((_celsius), 1) #define setTargetHotend1(_celsius) setTargetHotend((_celsius), 1)
#define isHeatingHotend1() isHeatingHotend(1) #define isHeatingHotend1() isHeatingHotend(1)
#define isCoolingHotend1() isCoolingHotend(1) #define isCoolingHotend1() isCoolingHotend(1)
#else #else
#define setTargetHotend1(_celsius) do{}while(0) #define setTargetHotend1(_celsius) do{}while(0)
#endif #endif
#if EXTRUDERS > 2 #if EXTRUDERS > 2
#define degHotend2() degHotend(2) #define degHotend2() degHotend(2)
#define degTargetHotend2() degTargetHotend(2) #define degTargetHotend2() degTargetHotend(2)
#define setTargetHotend2(_celsius) setTargetHotend((_celsius), 2) #define setTargetHotend2(_celsius) setTargetHotend((_celsius), 2)
#define isHeatingHotend2() isHeatingHotend(2) #define isHeatingHotend2() isHeatingHotend(2)
#define isCoolingHotend2() isCoolingHotend(2) #define isCoolingHotend2() isCoolingHotend(2)
#else #else
#define setTargetHotend2(_celsius) do{}while(0) #define setTargetHotend2(_celsius) do{}while(0)
#endif #endif
#if EXTRUDERS > 3 #if EXTRUDERS > 3
#define degHotend3() degHotend(3) #define degHotend3() degHotend(3)
#define degTargetHotend3() degTargetHotend(3) #define degTargetHotend3() degTargetHotend(3)
#define setTargetHotend3(_celsius) setTargetHotend((_celsius), 3) #define setTargetHotend3(_celsius) setTargetHotend((_celsius), 3)
#define isHeatingHotend3() isHeatingHotend(3) #define isHeatingHotend3() isHeatingHotend(3)
#define isCoolingHotend3() isCoolingHotend(3) #define isCoolingHotend3() isCoolingHotend(3)
#else #else
#define setTargetHotend3(_celsius) do{}while(0) #define setTargetHotend3(_celsius) do{}while(0)
#endif #endif
#if EXTRUDERS > 4 #if EXTRUDERS > 4
#error Invalid number of extruders #error Invalid number of extruders
#endif #endif
int getHeaterPower(int heater); int getHeaterPower(int heater);
void disable_heater(); void disable_heater();
void setWatch(); void setWatch();
@ -189,15 +157,14 @@ static bool thermal_runaway = false;
#endif #endif
#endif #endif
FORCE_INLINE void autotempShutdown(){ FORCE_INLINE void autotempShutdown() {
#ifdef AUTOTEMP #ifdef AUTOTEMP
if(autotemp_enabled) if (autotemp_enabled) {
{ autotemp_enabled = false;
autotemp_enabled=false; if (degTargetHotend(active_extruder) > autotemp_min)
if(degTargetHotend(active_extruder)>autotemp_min) setTargetHotend(0, active_extruder);
setTargetHotend(0,active_extruder);
} }
#endif #endif
} }
void PID_autotune(float temp, int extruder, int ncycles); void PID_autotune(float temp, int extruder, int ncycles);

Write Preview
Loading…
Cancel
Save