My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

Marlin_main.cpp 226KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199
  1. /**
  2. * Marlin Firmware
  3. *
  4. * Based on Sprinter and grbl.
  5. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  6. *
  7. * This program is free software: you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation, either version 3 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * This program is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  19. *
  20. * About Marlin
  21. *
  22. * This firmware is a mashup between Sprinter and grbl.
  23. * - https://github.com/kliment/Sprinter
  24. * - https://github.com/simen/grbl/tree
  25. *
  26. * It has preliminary support for Matthew Roberts advance algorithm
  27. * - http://reprap.org/pipermail/reprap-dev/2011-May/003323.html
  28. */
  29. #include "Marlin.h"
  30. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  31. #include "vector_3.h"
  32. #if ENABLED(AUTO_BED_LEVELING_GRID)
  33. #include "qr_solve.h"
  34. #endif
  35. #endif // AUTO_BED_LEVELING_FEATURE
  36. #if ENABLED(MESH_BED_LEVELING)
  37. #include "mesh_bed_leveling.h"
  38. #endif
  39. #include "ultralcd.h"
  40. #include "planner.h"
  41. #include "stepper.h"
  42. #include "temperature.h"
  43. #include "cardreader.h"
  44. #include "watchdog.h"
  45. #include "configuration_store.h"
  46. #include "language.h"
  47. #include "pins_arduino.h"
  48. #include "math.h"
  49. #include "buzzer.h"
  50. #if ENABLED(BLINKM)
  51. #include "blinkm.h"
  52. #include "Wire.h"
  53. #endif
  54. #if HAS_SERVOS
  55. #include "servo.h"
  56. #endif
  57. #if HAS_DIGIPOTSS
  58. #include <SPI.h>
  59. #endif
  60. /**
  61. * Look here for descriptions of G-codes:
  62. * - http://linuxcnc.org/handbook/gcode/g-code.html
  63. * - http://objects.reprap.org/wiki/Mendel_User_Manual:_RepRapGCodes
  64. *
  65. * Help us document these G-codes online:
  66. * - http://www.marlinfirmware.org/index.php/G-Code
  67. * - http://reprap.org/wiki/G-code
  68. *
  69. * -----------------
  70. * Implemented Codes
  71. * -----------------
  72. *
  73. * "G" Codes
  74. *
  75. * G0 -> G1
  76. * G1 - Coordinated Movement X Y Z E
  77. * G2 - CW ARC
  78. * G3 - CCW ARC
  79. * G4 - Dwell S<seconds> or P<milliseconds>
  80. * G10 - retract filament according to settings of M207
  81. * G11 - retract recover filament according to settings of M208
  82. * G28 - Home one or more axes
  83. * G29 - Detailed Z probe, probes the bed at 3 or more points. Will fail if you haven't homed yet.
  84. * G30 - Single Z probe, probes bed at current XY location.
  85. * G31 - Dock sled (Z_PROBE_SLED only)
  86. * G32 - Undock sled (Z_PROBE_SLED only)
  87. * G90 - Use Absolute Coordinates
  88. * G91 - Use Relative Coordinates
  89. * G92 - Set current position to coordinates given
  90. *
  91. * "M" Codes
  92. *
  93. * M0 - Unconditional stop - Wait for user to press a button on the LCD (Only if ULTRA_LCD is enabled)
  94. * M1 - Same as M0
  95. * M17 - Enable/Power all stepper motors
  96. * M18 - Disable all stepper motors; same as M84
  97. * M20 - List SD card
  98. * M21 - Init SD card
  99. * M22 - Release SD card
  100. * M23 - Select SD file (M23 filename.g)
  101. * M24 - Start/resume SD print
  102. * M25 - Pause SD print
  103. * M26 - Set SD position in bytes (M26 S12345)
  104. * M27 - Report SD print status
  105. * M28 - Start SD write (M28 filename.g)
  106. * M29 - Stop SD write
  107. * M30 - Delete file from SD (M30 filename.g)
  108. * M31 - Output time since last M109 or SD card start to serial
  109. * M32 - Select file and start SD print (Can be used _while_ printing from SD card files):
  110. * syntax "M32 /path/filename#", or "M32 S<startpos bytes> !filename#"
  111. * Call gcode file : "M32 P !filename#" and return to caller file after finishing (similar to #include).
  112. * The '#' is necessary when calling from within sd files, as it stops buffer prereading
  113. * M33 - Get the longname version of a path
  114. * M42 - Change pin status via gcode Use M42 Px Sy to set pin x to value y, when omitting Px the onboard led will be used.
  115. * M48 - Measure Z_Probe repeatability. M48 [P # of points] [X position] [Y position] [V_erboseness #] [E_ngage Probe] [L # of legs of travel]
  116. * M80 - Turn on Power Supply
  117. * M81 - Turn off Power Supply
  118. * M82 - Set E codes absolute (default)
  119. * M83 - Set E codes relative while in Absolute Coordinates (G90) mode
  120. * M84 - Disable steppers until next move,
  121. * or use S<seconds> to specify an inactivity timeout, after which the steppers will be disabled. S0 to disable the timeout.
  122. * M85 - Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
  123. * M92 - Set axis_steps_per_unit - same syntax as G92
  124. * M104 - Set extruder target temp
  125. * M105 - Read current temp
  126. * M106 - Fan on
  127. * M107 - Fan off
  128. * M109 - Sxxx Wait for extruder current temp to reach target temp. Waits only when heating
  129. * Rxxx Wait for extruder current temp to reach target temp. Waits when heating and cooling
  130. * IF AUTOTEMP is enabled, S<mintemp> B<maxtemp> F<factor>. Exit autotemp by any M109 without F
  131. * M110 - Set the current line number
  132. * M111 - Set debug flags with S<mask>. See flag bits defined in Marlin.h.
  133. * M112 - Emergency stop
  134. * M114 - Output current position to serial port
  135. * M115 - Capabilities string
  136. * M117 - Display a message on the controller screen
  137. * M119 - Output Endstop status to serial port
  138. * M120 - Enable endstop detection
  139. * M121 - Disable endstop detection
  140. * M126 - Solenoid Air Valve Open (BariCUDA support by jmil)
  141. * M127 - Solenoid Air Valve Closed (BariCUDA vent to atmospheric pressure by jmil)
  142. * M128 - EtoP Open (BariCUDA EtoP = electricity to air pressure transducer by jmil)
  143. * M129 - EtoP Closed (BariCUDA EtoP = electricity to air pressure transducer by jmil)
  144. * M140 - Set bed target temp
  145. * M145 - Set the heatup state H<hotend> B<bed> F<fan speed> for S<material> (0=PLA, 1=ABS)
  146. * M150 - Set BlinkM Color Output R: Red<0-255> U(!): Green<0-255> B: Blue<0-255> over i2c, G for green does not work.
  147. * M190 - Sxxx Wait for bed current temp to reach target temp. Waits only when heating
  148. * Rxxx Wait for bed current temp to reach target temp. Waits when heating and cooling
  149. * M200 - set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).:D<millimeters>-
  150. * M201 - Set max acceleration in units/s^2 for print moves (M201 X1000 Y1000)
  151. * M202 - Set max acceleration in units/s^2 for travel moves (M202 X1000 Y1000) Unused in Marlin!!
  152. * M203 - Set maximum feedrate that your machine can sustain (M203 X200 Y200 Z300 E10000) in mm/sec
  153. * M204 - Set default acceleration: P for Printing moves, R for Retract only (no X, Y, Z) moves and T for Travel (non printing) moves (ex. M204 P800 T3000 R9000) in mm/sec^2
  154. * M205 - advanced settings: minimum travel speed S=while printing T=travel only, B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk, E=maximum E jerk
  155. * M206 - Set additional homing offset
  156. * M207 - Set retract length S[positive mm] F[feedrate mm/min] Z[additional zlift/hop], stays in mm regardless of M200 setting
  157. * M208 - Set recover=unretract length S[positive mm surplus to the M207 S*] F[feedrate mm/min]
  158. * M209 - S<1=true/0=false> enable automatic retract detect if the slicer did not support G10/11: every normal extrude-only move will be classified as retract depending on the direction.
  159. * M218 - Set hotend offset (in mm): T<extruder_number> X<offset_on_X> Y<offset_on_Y>
  160. * M220 - Set speed factor override percentage: S<factor in percent>
  161. * M221 - Set extrude factor override percentage: S<factor in percent>
  162. * M226 - Wait until the specified pin reaches the state required: P<pin number> S<pin state>
  163. * M240 - Trigger a camera to take a photograph
  164. * M250 - Set LCD contrast C<contrast value> (value 0..63)
  165. * M280 - Set servo position absolute. P: servo index, S: angle or microseconds
  166. * M300 - Play beep sound S<frequency Hz> P<duration ms>
  167. * M301 - Set PID parameters P I and D
  168. * M302 - Allow cold extrudes, or set the minimum extrude S<temperature>.
  169. * M303 - PID relay autotune S<temperature> sets the target temperature. (default target temperature = 150C)
  170. * M304 - Set bed PID parameters P I and D
  171. * M380 - Activate solenoid on active extruder
  172. * M381 - Disable all solenoids
  173. * M400 - Finish all moves
  174. * M401 - Lower Z probe if present
  175. * M402 - Raise Z probe if present
  176. * M404 - N<dia in mm> Enter the nominal filament width (3mm, 1.75mm ) or will display nominal filament width without parameters
  177. * M405 - Turn on Filament Sensor extrusion control. Optional D<delay in cm> to set delay in centimeters between sensor and extruder
  178. * M406 - Turn off Filament Sensor extrusion control
  179. * M407 - Display measured filament diameter
  180. * M410 - Quickstop. Abort all the planned moves
  181. * M420 - Enable/Disable Mesh Leveling (with current values) S1=enable S0=disable
  182. * M421 - Set a single Z coordinate in the Mesh Leveling grid. X<mm> Y<mm> Z<mm>
  183. * M428 - Set the home_offset logically based on the current_position
  184. * M500 - Store parameters in EEPROM
  185. * M501 - Read parameters from EEPROM (if you need reset them after you changed them temporarily).
  186. * M502 - Revert to the default "factory settings". You still need to store them in EEPROM afterwards if you want to.
  187. * M503 - Print the current settings (from memory not from EEPROM). Use S0 to leave off headings.
  188. * M540 - Use S[0|1] to enable or disable the stop SD card print on endstop hit (requires ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
  189. * M600 - Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
  190. * M665 - Set delta configurations: L<diagonal rod> R<delta radius> S<segments/s>
  191. * M666 - Set delta endstop adjustment
  192. * M605 - Set dual x-carriage movement mode: S<mode> [ X<duplication x-offset> R<duplication temp offset> ]
  193. * M907 - Set digital trimpot motor current using axis codes.
  194. * M908 - Control digital trimpot directly.
  195. * M350 - Set microstepping mode.
  196. * M351 - Toggle MS1 MS2 pins directly.
  197. *
  198. * ************ SCARA Specific - This can change to suit future G-code regulations
  199. * M360 - SCARA calibration: Move to cal-position ThetaA (0 deg calibration)
  200. * M361 - SCARA calibration: Move to cal-position ThetaB (90 deg calibration - steps per degree)
  201. * M362 - SCARA calibration: Move to cal-position PsiA (0 deg calibration)
  202. * M363 - SCARA calibration: Move to cal-position PsiB (90 deg calibration - steps per degree)
  203. * M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
  204. * M365 - SCARA calibration: Scaling factor, X, Y, Z axis
  205. * ************* SCARA End ***************
  206. *
  207. * ************ Custom codes - This can change to suit future G-code regulations
  208. * M100 - Watch Free Memory (For Debugging Only)
  209. * M851 - Set Z probe's Z offset (mm above extruder -- The value will always be negative)
  210. * M928 - Start SD logging (M928 filename.g) - ended by M29
  211. * M999 - Restart after being stopped by error
  212. *
  213. * "T" Codes
  214. *
  215. * T0-T3 - Select a tool by index (usually an extruder) [ F<mm/min> ]
  216. *
  217. */
  218. #if ENABLED(M100_FREE_MEMORY_WATCHER)
  219. void gcode_M100();
  220. #endif
  221. #if ENABLED(SDSUPPORT)
  222. CardReader card;
  223. #endif
  224. bool Running = true;
  225. uint8_t marlin_debug_flags = DEBUG_INFO|DEBUG_ERRORS;
  226. static float feedrate = 1500.0, saved_feedrate;
  227. float current_position[NUM_AXIS] = { 0.0 };
  228. static float destination[NUM_AXIS] = { 0.0 };
  229. bool axis_known_position[3] = { false };
  230. static long gcode_N, gcode_LastN, Stopped_gcode_LastN = 0;
  231. static char *current_command, *current_command_args;
  232. static int cmd_queue_index_r = 0;
  233. static int cmd_queue_index_w = 0;
  234. static int commands_in_queue = 0;
  235. static char command_queue[BUFSIZE][MAX_CMD_SIZE];
  236. const float homing_feedrate[] = HOMING_FEEDRATE;
  237. bool axis_relative_modes[] = AXIS_RELATIVE_MODES;
  238. int feedrate_multiplier = 100; //100->1 200->2
  239. int saved_feedrate_multiplier;
  240. int extruder_multiplier[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(100);
  241. bool volumetric_enabled = false;
  242. float filament_size[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_NOMINAL_FILAMENT_DIA);
  243. float volumetric_multiplier[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(1.0);
  244. float home_offset[3] = { 0 };
  245. float min_pos[3] = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS };
  246. float max_pos[3] = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS };
  247. uint8_t active_extruder = 0;
  248. int fanSpeed = 0;
  249. bool cancel_heatup = false;
  250. const char errormagic[] PROGMEM = "Error:";
  251. const char echomagic[] PROGMEM = "echo:";
  252. const char axis_codes[NUM_AXIS] = {'X', 'Y', 'Z', 'E'};
  253. static bool relative_mode = false; //Determines Absolute or Relative Coordinates
  254. static char serial_char;
  255. static int serial_count = 0;
  256. static boolean comment_mode = false;
  257. static char *seen_pointer; ///< A pointer to find chars in the command string (X, Y, Z, E, etc.)
  258. const char* queued_commands_P= NULL; /* pointer to the current line in the active sequence of commands, or NULL when none */
  259. const int sensitive_pins[] = SENSITIVE_PINS; ///< Sensitive pin list for M42
  260. // Inactivity shutdown
  261. millis_t previous_cmd_ms = 0;
  262. static millis_t max_inactive_time = 0;
  263. static millis_t stepper_inactive_time = DEFAULT_STEPPER_DEACTIVE_TIME * 1000L;
  264. millis_t print_job_start_ms = 0; ///< Print job start time
  265. millis_t print_job_stop_ms = 0; ///< Print job stop time
  266. static uint8_t target_extruder;
  267. bool no_wait_for_cooling = true;
  268. bool target_direction;
  269. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  270. int xy_travel_speed = XY_TRAVEL_SPEED;
  271. float zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
  272. #endif
  273. #if ENABLED(Z_DUAL_ENDSTOPS) && DISABLED(DELTA)
  274. float z_endstop_adj = 0;
  275. #endif
  276. // Extruder offsets
  277. #if EXTRUDERS > 1
  278. #ifndef EXTRUDER_OFFSET_X
  279. #define EXTRUDER_OFFSET_X { 0 }
  280. #endif
  281. #ifndef EXTRUDER_OFFSET_Y
  282. #define EXTRUDER_OFFSET_Y { 0 }
  283. #endif
  284. float extruder_offset[][EXTRUDERS] = {
  285. EXTRUDER_OFFSET_X,
  286. EXTRUDER_OFFSET_Y
  287. #if ENABLED(DUAL_X_CARRIAGE)
  288. , { 0 } // supports offsets in XYZ plane
  289. #endif
  290. };
  291. #endif
  292. #if HAS_SERVO_ENDSTOPS
  293. const int servo_endstop_id[] = SERVO_ENDSTOP_IDS;
  294. const int servo_endstop_angle[][2] = SERVO_ENDSTOP_ANGLES;
  295. #endif
  296. #if ENABLED(BARICUDA)
  297. int ValvePressure = 0;
  298. int EtoPPressure = 0;
  299. #endif
  300. #if ENABLED(FWRETRACT)
  301. bool autoretract_enabled = false;
  302. bool retracted[EXTRUDERS] = { false };
  303. bool retracted_swap[EXTRUDERS] = { false };
  304. float retract_length = RETRACT_LENGTH;
  305. float retract_length_swap = RETRACT_LENGTH_SWAP;
  306. float retract_feedrate = RETRACT_FEEDRATE;
  307. float retract_zlift = RETRACT_ZLIFT;
  308. float retract_recover_length = RETRACT_RECOVER_LENGTH;
  309. float retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
  310. float retract_recover_feedrate = RETRACT_RECOVER_FEEDRATE;
  311. #endif // FWRETRACT
  312. #if ENABLED(ULTIPANEL) && HAS_POWER_SWITCH
  313. bool powersupply =
  314. #if ENABLED(PS_DEFAULT_OFF)
  315. false
  316. #else
  317. true
  318. #endif
  319. ;
  320. #endif
  321. #if ENABLED(DELTA)
  322. #define TOWER_1 X_AXIS
  323. #define TOWER_2 Y_AXIS
  324. #define TOWER_3 Z_AXIS
  325. float delta[3] = { 0 };
  326. #define SIN_60 0.8660254037844386
  327. #define COS_60 0.5
  328. float endstop_adj[3] = { 0 };
  329. // these are the default values, can be overriden with M665
  330. float delta_radius = DELTA_RADIUS;
  331. float delta_tower1_x = -SIN_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1); // front left tower
  332. float delta_tower1_y = -COS_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1);
  333. float delta_tower2_x = SIN_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2); // front right tower
  334. float delta_tower2_y = -COS_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2);
  335. float delta_tower3_x = 0; // back middle tower
  336. float delta_tower3_y = (delta_radius + DELTA_RADIUS_TRIM_TOWER_3);
  337. float delta_diagonal_rod = DELTA_DIAGONAL_ROD;
  338. float delta_diagonal_rod_trim_tower_1 = DELTA_DIAGONAL_ROD_TRIM_TOWER_1;
  339. float delta_diagonal_rod_trim_tower_2 = DELTA_DIAGONAL_ROD_TRIM_TOWER_2;
  340. float delta_diagonal_rod_trim_tower_3 = DELTA_DIAGONAL_ROD_TRIM_TOWER_3;
  341. float delta_diagonal_rod_2_tower_1 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_1);
  342. float delta_diagonal_rod_2_tower_2 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_2);
  343. float delta_diagonal_rod_2_tower_3 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_3);
  344. //float delta_diagonal_rod_2 = sq(delta_diagonal_rod);
  345. float delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND;
  346. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  347. int delta_grid_spacing[2] = { 0, 0 };
  348. float bed_level[AUTO_BED_LEVELING_GRID_POINTS][AUTO_BED_LEVELING_GRID_POINTS];
  349. #endif
  350. #else
  351. static bool home_all_axis = true;
  352. #endif
  353. #if ENABLED(SCARA)
  354. float delta_segments_per_second = SCARA_SEGMENTS_PER_SECOND;
  355. static float delta[3] = { 0 };
  356. float axis_scaling[3] = { 1, 1, 1 }; // Build size scaling, default to 1
  357. #endif
  358. #if ENABLED(FILAMENT_SENSOR)
  359. //Variables for Filament Sensor input
  360. float filament_width_nominal = DEFAULT_NOMINAL_FILAMENT_DIA; //Set nominal filament width, can be changed with M404
  361. bool filament_sensor = false; //M405 turns on filament_sensor control, M406 turns it off
  362. float filament_width_meas = DEFAULT_MEASURED_FILAMENT_DIA; //Stores the measured filament diameter
  363. signed char measurement_delay[MAX_MEASUREMENT_DELAY+1]; //ring buffer to delay measurement store extruder factor after subtracting 100
  364. int delay_index1 = 0; //index into ring buffer
  365. int delay_index2 = -1; //index into ring buffer - set to -1 on startup to indicate ring buffer needs to be initialized
  366. float delay_dist = 0; //delay distance counter
  367. int meas_delay_cm = MEASUREMENT_DELAY_CM; //distance delay setting
  368. #endif
  369. #if ENABLED(FILAMENT_RUNOUT_SENSOR)
  370. static bool filrunoutEnqueued = false;
  371. #endif
  372. #if ENABLED(SDSUPPORT)
  373. static bool fromsd[BUFSIZE];
  374. #endif
  375. #if HAS_SERVOS
  376. Servo servo[NUM_SERVOS];
  377. #endif
  378. #ifdef CHDK
  379. unsigned long chdkHigh = 0;
  380. boolean chdkActive = false;
  381. #endif
  382. //===========================================================================
  383. //================================ Functions ================================
  384. //===========================================================================
  385. void process_next_command();
  386. void plan_arc(float target[NUM_AXIS], float *offset, uint8_t clockwise);
  387. bool setTargetedHotend(int code);
  388. void serial_echopair_P(const char *s_P, int v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
  389. void serial_echopair_P(const char *s_P, long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
  390. void serial_echopair_P(const char *s_P, float v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
  391. void serial_echopair_P(const char *s_P, double v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
  392. void serial_echopair_P(const char *s_P, unsigned long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
  393. #if ENABLED(PREVENT_DANGEROUS_EXTRUDE)
  394. float extrude_min_temp = EXTRUDE_MINTEMP;
  395. #endif
  396. #if ENABLED(SDSUPPORT)
  397. #include "SdFatUtil.h"
  398. int freeMemory() { return SdFatUtil::FreeRam(); }
  399. #else
  400. extern "C" {
  401. extern unsigned int __bss_end;
  402. extern unsigned int __heap_start;
  403. extern void *__brkval;
  404. int freeMemory() {
  405. int free_memory;
  406. if ((int)__brkval == 0)
  407. free_memory = ((int)&free_memory) - ((int)&__bss_end);
  408. else
  409. free_memory = ((int)&free_memory) - ((int)__brkval);
  410. return free_memory;
  411. }
  412. }
  413. #endif //!SDSUPPORT
  414. /**
  415. * Inject the next command from the command queue, when possible
  416. * Return false only if no command was pending
  417. */
  418. static bool drain_queued_commands_P() {
  419. if (!queued_commands_P) return false;
  420. // Get the next 30 chars from the sequence of gcodes to run
  421. char cmd[30];
  422. strncpy_P(cmd, queued_commands_P, sizeof(cmd) - 1);
  423. cmd[sizeof(cmd) - 1] = '\0';
  424. // Look for the end of line, or the end of sequence
  425. size_t i = 0;
  426. char c;
  427. while((c = cmd[i]) && c != '\n') i++; // find the end of this gcode command
  428. cmd[i] = '\0';
  429. if (enqueuecommand(cmd)) { // buffer was not full (else we will retry later)
  430. if (c)
  431. queued_commands_P += i + 1; // move to next command
  432. else
  433. queued_commands_P = NULL; // will have no more commands in the sequence
  434. }
  435. return true;
  436. }
  437. /**
  438. * Record one or many commands to run from program memory.
  439. * Aborts the current queue, if any.
  440. * Note: drain_queued_commands_P() must be called repeatedly to drain the commands afterwards
  441. */
  442. void enqueuecommands_P(const char* pgcode) {
  443. queued_commands_P = pgcode;
  444. drain_queued_commands_P(); // first command executed asap (when possible)
  445. }
  446. /**
  447. * Copy a command directly into the main command buffer, from RAM.
  448. *
  449. * This is done in a non-safe way and needs a rework someday.
  450. * Returns false if it doesn't add any command
  451. */
  452. bool enqueuecommand(const char *cmd) {
  453. if (*cmd == ';' || commands_in_queue >= BUFSIZE) return false;
  454. // This is dangerous if a mixing of serial and this happens
  455. char *command = command_queue[cmd_queue_index_w];
  456. strcpy(command, cmd);
  457. SERIAL_ECHO_START;
  458. SERIAL_ECHOPGM(MSG_Enqueueing);
  459. SERIAL_ECHO(command);
  460. SERIAL_ECHOLNPGM("\"");
  461. cmd_queue_index_w = (cmd_queue_index_w + 1) % BUFSIZE;
  462. commands_in_queue++;
  463. return true;
  464. }
  465. void setup_killpin() {
  466. #if HAS_KILL
  467. SET_INPUT(KILL_PIN);
  468. WRITE(KILL_PIN, HIGH);
  469. #endif
  470. }
  471. void setup_filrunoutpin() {
  472. #if HAS_FILRUNOUT
  473. pinMode(FILRUNOUT_PIN, INPUT);
  474. #if ENABLED(ENDSTOPPULLUP_FIL_RUNOUT)
  475. WRITE(FILRUNOUT_PIN, HIGH);
  476. #endif
  477. #endif
  478. }
  479. // Set home pin
  480. void setup_homepin(void) {
  481. #if HAS_HOME
  482. SET_INPUT(HOME_PIN);
  483. WRITE(HOME_PIN, HIGH);
  484. #endif
  485. }
  486. void setup_photpin() {
  487. #if HAS_PHOTOGRAPH
  488. OUT_WRITE(PHOTOGRAPH_PIN, LOW);
  489. #endif
  490. }
  491. void setup_powerhold() {
  492. #if HAS_SUICIDE
  493. OUT_WRITE(SUICIDE_PIN, HIGH);
  494. #endif
  495. #if HAS_POWER_SWITCH
  496. #if ENABLED(PS_DEFAULT_OFF)
  497. OUT_WRITE(PS_ON_PIN, PS_ON_ASLEEP);
  498. #else
  499. OUT_WRITE(PS_ON_PIN, PS_ON_AWAKE);
  500. #endif
  501. #endif
  502. }
  503. void suicide() {
  504. #if HAS_SUICIDE
  505. OUT_WRITE(SUICIDE_PIN, LOW);
  506. #endif
  507. }
  508. void servo_init() {
  509. #if NUM_SERVOS >= 1 && HAS_SERVO_0
  510. servo[0].attach(SERVO0_PIN);
  511. servo[0].detach(); // Just set up the pin. We don't have a position yet. Don't move to a random position.
  512. #endif
  513. #if NUM_SERVOS >= 2 && HAS_SERVO_1
  514. servo[1].attach(SERVO1_PIN);
  515. servo[1].detach();
  516. #endif
  517. #if NUM_SERVOS >= 3 && HAS_SERVO_2
  518. servo[2].attach(SERVO2_PIN);
  519. servo[2].detach();
  520. #endif
  521. #if NUM_SERVOS >= 4 && HAS_SERVO_3
  522. servo[3].attach(SERVO3_PIN);
  523. servo[3].detach();
  524. #endif
  525. // Set position of Servo Endstops that are defined
  526. #if HAS_SERVO_ENDSTOPS
  527. for (int i = 0; i < 3; i++)
  528. if (servo_endstop_id[i] >= 0)
  529. servo[servo_endstop_id[i]].move(servo_endstop_angle[i][1]);
  530. #endif
  531. }
  532. /**
  533. * Stepper Reset (RigidBoard, et.al.)
  534. */
  535. #if HAS_STEPPER_RESET
  536. void disableStepperDrivers() {
  537. pinMode(STEPPER_RESET_PIN, OUTPUT);
  538. digitalWrite(STEPPER_RESET_PIN, LOW); // drive it down to hold in reset motor driver chips
  539. }
  540. void enableStepperDrivers() { pinMode(STEPPER_RESET_PIN, INPUT); } // set to input, which allows it to be pulled high by pullups
  541. #endif
  542. /**
  543. * Marlin entry-point: Set up before the program loop
  544. * - Set up the kill pin, filament runout, power hold
  545. * - Start the serial port
  546. * - Print startup messages and diagnostics
  547. * - Get EEPROM or default settings
  548. * - Initialize managers for:
  549. * • temperature
  550. * • planner
  551. * • watchdog
  552. * • stepper
  553. * • photo pin
  554. * • servos
  555. * • LCD controller
  556. * • Digipot I2C
  557. * • Z probe sled
  558. * • status LEDs
  559. */
  560. void setup() {
  561. setup_killpin();
  562. setup_filrunoutpin();
  563. setup_powerhold();
  564. #if HAS_STEPPER_RESET
  565. disableStepperDrivers();
  566. #endif
  567. MYSERIAL.begin(BAUDRATE);
  568. SERIAL_PROTOCOLLNPGM("start");
  569. SERIAL_ECHO_START;
  570. // Check startup - does nothing if bootloader sets MCUSR to 0
  571. byte mcu = MCUSR;
  572. if (mcu & 1) SERIAL_ECHOLNPGM(MSG_POWERUP);
  573. if (mcu & 2) SERIAL_ECHOLNPGM(MSG_EXTERNAL_RESET);
  574. if (mcu & 4) SERIAL_ECHOLNPGM(MSG_BROWNOUT_RESET);
  575. if (mcu & 8) SERIAL_ECHOLNPGM(MSG_WATCHDOG_RESET);
  576. if (mcu & 32) SERIAL_ECHOLNPGM(MSG_SOFTWARE_RESET);
  577. MCUSR = 0;
  578. SERIAL_ECHOPGM(MSG_MARLIN);
  579. SERIAL_ECHOLNPGM(" " SHORT_BUILD_VERSION);
  580. #ifdef STRING_DISTRIBUTION_DATE
  581. #ifdef STRING_CONFIG_H_AUTHOR
  582. SERIAL_ECHO_START;
  583. SERIAL_ECHOPGM(MSG_CONFIGURATION_VER);
  584. SERIAL_ECHOPGM(STRING_DISTRIBUTION_DATE);
  585. SERIAL_ECHOPGM(MSG_AUTHOR);
  586. SERIAL_ECHOLNPGM(STRING_CONFIG_H_AUTHOR);
  587. SERIAL_ECHOPGM("Compiled: ");
  588. SERIAL_ECHOLNPGM(__DATE__);
  589. #endif // STRING_CONFIG_H_AUTHOR
  590. #endif // STRING_DISTRIBUTION_DATE
  591. SERIAL_ECHO_START;
  592. SERIAL_ECHOPGM(MSG_FREE_MEMORY);
  593. SERIAL_ECHO(freeMemory());
  594. SERIAL_ECHOPGM(MSG_PLANNER_BUFFER_BYTES);
  595. SERIAL_ECHOLN((int)sizeof(block_t)*BLOCK_BUFFER_SIZE);
  596. #if ENABLED(SDSUPPORT)
  597. for (int8_t i = 0; i < BUFSIZE; i++) fromsd[i] = false;
  598. #endif
  599. // loads data from EEPROM if available else uses defaults (and resets step acceleration rate)
  600. Config_RetrieveSettings();
  601. lcd_init();
  602. tp_init(); // Initialize temperature loop
  603. plan_init(); // Initialize planner;
  604. watchdog_init();
  605. st_init(); // Initialize stepper, this enables interrupts!
  606. setup_photpin();
  607. servo_init();
  608. #if HAS_CONTROLLERFAN
  609. SET_OUTPUT(CONTROLLERFAN_PIN); //Set pin used for driver cooling fan
  610. #endif
  611. #if HAS_STEPPER_RESET
  612. enableStepperDrivers();
  613. #endif
  614. #if ENABLED(DIGIPOT_I2C)
  615. digipot_i2c_init();
  616. #endif
  617. #if ENABLED(Z_PROBE_SLED)
  618. pinMode(SLED_PIN, OUTPUT);
  619. digitalWrite(SLED_PIN, LOW); // turn it off
  620. #endif // Z_PROBE_SLED
  621. setup_homepin();
  622. #ifdef STAT_LED_RED
  623. pinMode(STAT_LED_RED, OUTPUT);
  624. digitalWrite(STAT_LED_RED, LOW); // turn it off
  625. #endif
  626. #ifdef STAT_LED_BLUE
  627. pinMode(STAT_LED_BLUE, OUTPUT);
  628. digitalWrite(STAT_LED_BLUE, LOW); // turn it off
  629. #endif
  630. }
  631. /**
  632. * The main Marlin program loop
  633. *
  634. * - Save or log commands to SD
  635. * - Process available commands (if not saving)
  636. * - Call heater manager
  637. * - Call inactivity manager
  638. * - Call endstop manager
  639. * - Call LCD update
  640. */
  641. void loop() {
  642. if (commands_in_queue < BUFSIZE - 1) get_command();
  643. #if ENABLED(SDSUPPORT)
  644. card.checkautostart(false);
  645. #endif
  646. if (commands_in_queue) {
  647. #if ENABLED(SDSUPPORT)
  648. if (card.saving) {
  649. char *command = command_queue[cmd_queue_index_r];
  650. if (strstr_P(command, PSTR("M29"))) {
  651. // M29 closes the file
  652. card.closefile();
  653. SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
  654. }
  655. else {
  656. // Write the string from the read buffer to SD
  657. card.write_command(command);
  658. if (card.logging)
  659. process_next_command(); // The card is saving because it's logging
  660. else
  661. SERIAL_PROTOCOLLNPGM(MSG_OK);
  662. }
  663. }
  664. else
  665. process_next_command();
  666. #else
  667. process_next_command();
  668. #endif // SDSUPPORT
  669. commands_in_queue--;
  670. cmd_queue_index_r = (cmd_queue_index_r + 1) % BUFSIZE;
  671. }
  672. checkHitEndstops();
  673. idle();
  674. }
  675. void gcode_line_error(const char *err, bool doFlush=true) {
  676. SERIAL_ERROR_START;
  677. serialprintPGM(err);
  678. SERIAL_ERRORLN(gcode_LastN);
  679. //Serial.println(gcode_N);
  680. if (doFlush) FlushSerialRequestResend();
  681. serial_count = 0;
  682. }
  683. /**
  684. * Add to the circular command queue the next command from:
  685. * - The command-injection queue (queued_commands_P)
  686. * - The active serial input (usually USB)
  687. * - The SD card file being actively printed
  688. */
  689. void get_command() {
  690. if (drain_queued_commands_P()) return; // priority is given to non-serial commands
  691. #if ENABLED(NO_TIMEOUTS)
  692. static millis_t last_command_time = 0;
  693. millis_t ms = millis();
  694. if (!MYSERIAL.available() && commands_in_queue == 0 && ms - last_command_time > NO_TIMEOUTS) {
  695. SERIAL_ECHOLNPGM(MSG_WAIT);
  696. last_command_time = ms;
  697. }
  698. #endif
  699. //
  700. // Loop while serial characters are incoming and the queue is not full
  701. //
  702. while (commands_in_queue < BUFSIZE && MYSERIAL.available() > 0) {
  703. #if ENABLED(NO_TIMEOUTS)
  704. last_command_time = ms;
  705. #endif
  706. serial_char = MYSERIAL.read();
  707. //
  708. // If the character ends the line, or the line is full...
  709. //
  710. if (serial_char == '\n' || serial_char == '\r' || serial_count >= MAX_CMD_SIZE-1) {
  711. // end of line == end of comment
  712. comment_mode = false;
  713. if (!serial_count) return; // empty lines just exit
  714. char *command = command_queue[cmd_queue_index_w];
  715. command[serial_count] = 0; // terminate string
  716. // this item in the queue is not from sd
  717. #if ENABLED(SDSUPPORT)
  718. fromsd[cmd_queue_index_w] = false;
  719. #endif
  720. char *npos = strchr(command, 'N');
  721. char *apos = strchr(command, '*');
  722. if (npos) {
  723. boolean M110 = strstr_P(command, PSTR("M110")) != NULL;
  724. if (M110) {
  725. char *n2pos = strchr(command + 4, 'N');
  726. if (n2pos) npos = n2pos;
  727. }
  728. gcode_N = strtol(npos + 1, NULL, 10);
  729. if (gcode_N != gcode_LastN + 1 && !M110) {
  730. gcode_line_error(PSTR(MSG_ERR_LINE_NO));
  731. return;
  732. }
  733. if (apos) {
  734. byte checksum = 0, count = 0;
  735. while (command[count] != '*') checksum ^= command[count++];
  736. if (strtol(apos + 1, NULL, 10) != checksum) {
  737. gcode_line_error(PSTR(MSG_ERR_CHECKSUM_MISMATCH));
  738. return;
  739. }
  740. // if no errors, continue parsing
  741. }
  742. else if (npos == command) {
  743. gcode_line_error(PSTR(MSG_ERR_NO_CHECKSUM));
  744. return;
  745. }
  746. gcode_LastN = gcode_N;
  747. // if no errors, continue parsing
  748. }
  749. else if (apos) { // No '*' without 'N'
  750. gcode_line_error(PSTR(MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM), false);
  751. return;
  752. }
  753. // Movement commands alert when stopped
  754. if (IsStopped()) {
  755. char *gpos = strchr(command, 'G');
  756. if (gpos) {
  757. int codenum = strtol(gpos + 1, NULL, 10);
  758. switch (codenum) {
  759. case 0:
  760. case 1:
  761. case 2:
  762. case 3:
  763. SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
  764. LCD_MESSAGEPGM(MSG_STOPPED);
  765. break;
  766. }
  767. }
  768. }
  769. // If command was e-stop process now
  770. if (strcmp(command, "M112") == 0) kill(PSTR(MSG_KILLED));
  771. cmd_queue_index_w = (cmd_queue_index_w + 1) % BUFSIZE;
  772. commands_in_queue += 1;
  773. serial_count = 0; //clear buffer
  774. }
  775. else if (serial_char == '\\') { // Handle escapes
  776. if (MYSERIAL.available() > 0 && commands_in_queue < BUFSIZE) {
  777. // if we have one more character, copy it over
  778. serial_char = MYSERIAL.read();
  779. command_queue[cmd_queue_index_w][serial_count++] = serial_char;
  780. }
  781. // otherwise do nothing
  782. }
  783. else { // its not a newline, carriage return or escape char
  784. if (serial_char == ';') comment_mode = true;
  785. if (!comment_mode) command_queue[cmd_queue_index_w][serial_count++] = serial_char;
  786. }
  787. }
  788. #if ENABLED(SDSUPPORT)
  789. if (!card.sdprinting || serial_count) return;
  790. // '#' stops reading from SD to the buffer prematurely, so procedural macro calls are possible
  791. // if it occurs, stop_buffering is triggered and the buffer is ran dry.
  792. // this character _can_ occur in serial com, due to checksums. however, no checksums are used in SD printing
  793. static bool stop_buffering = false;
  794. if (commands_in_queue == 0) stop_buffering = false;
  795. while (!card.eof() && commands_in_queue < BUFSIZE && !stop_buffering) {
  796. int16_t n = card.get();
  797. serial_char = (char)n;
  798. if (serial_char == '\n' || serial_char == '\r' ||
  799. ((serial_char == '#' || serial_char == ':') && !comment_mode) ||
  800. serial_count >= (MAX_CMD_SIZE - 1) || n == -1
  801. ) {
  802. if (card.eof()) {
  803. SERIAL_PROTOCOLLNPGM(MSG_FILE_PRINTED);
  804. print_job_stop_ms = millis();
  805. char time[30];
  806. millis_t t = (print_job_stop_ms - print_job_start_ms) / 1000;
  807. int hours = t / 60 / 60, minutes = (t / 60) % 60;
  808. sprintf_P(time, PSTR("%i " MSG_END_HOUR " %i " MSG_END_MINUTE), hours, minutes);
  809. SERIAL_ECHO_START;
  810. SERIAL_ECHOLN(time);
  811. lcd_setstatus(time, true);
  812. card.printingHasFinished();
  813. card.checkautostart(true);
  814. }
  815. if (serial_char == '#') stop_buffering = true;
  816. if (!serial_count) {
  817. comment_mode = false; //for new command
  818. return; //if empty line
  819. }
  820. command_queue[cmd_queue_index_w][serial_count] = 0; //terminate string
  821. // if (!comment_mode) {
  822. fromsd[cmd_queue_index_w] = true;
  823. commands_in_queue += 1;
  824. cmd_queue_index_w = (cmd_queue_index_w + 1) % BUFSIZE;
  825. // }
  826. comment_mode = false; //for new command
  827. serial_count = 0; //clear buffer
  828. }
  829. else {
  830. if (serial_char == ';') comment_mode = true;
  831. if (!comment_mode) command_queue[cmd_queue_index_w][serial_count++] = serial_char;
  832. }
  833. }
  834. #endif // SDSUPPORT
  835. }
  836. bool code_has_value() {
  837. int i = 1;
  838. char c = seen_pointer[i];
  839. if (c == '-' || c == '+') c = seen_pointer[++i];
  840. if (c == '.') c = seen_pointer[++i];
  841. return (c >= '0' && c <= '9');
  842. }
  843. float code_value() {
  844. float ret;
  845. char *e = strchr(seen_pointer, 'E');
  846. if (e) {
  847. *e = 0;
  848. ret = strtod(seen_pointer+1, NULL);
  849. *e = 'E';
  850. }
  851. else
  852. ret = strtod(seen_pointer+1, NULL);
  853. return ret;
  854. }
  855. long code_value_long() { return strtol(seen_pointer + 1, NULL, 10); }
  856. int16_t code_value_short() { return (int16_t)strtol(seen_pointer + 1, NULL, 10); }
  857. bool code_seen(char code) {
  858. seen_pointer = strchr(current_command_args, code);
  859. return (seen_pointer != NULL); // Return TRUE if the code-letter was found
  860. }
  861. #define DEFINE_PGM_READ_ANY(type, reader) \
  862. static inline type pgm_read_any(const type *p) \
  863. { return pgm_read_##reader##_near(p); }
  864. DEFINE_PGM_READ_ANY(float, float);
  865. DEFINE_PGM_READ_ANY(signed char, byte);
  866. #define XYZ_CONSTS_FROM_CONFIG(type, array, CONFIG) \
  867. static const PROGMEM type array##_P[3] = \
  868. { X_##CONFIG, Y_##CONFIG, Z_##CONFIG }; \
  869. static inline type array(int axis) \
  870. { return pgm_read_any(&array##_P[axis]); }
  871. XYZ_CONSTS_FROM_CONFIG(float, base_min_pos, MIN_POS);
  872. XYZ_CONSTS_FROM_CONFIG(float, base_max_pos, MAX_POS);
  873. XYZ_CONSTS_FROM_CONFIG(float, base_home_pos, HOME_POS);
  874. XYZ_CONSTS_FROM_CONFIG(float, max_length, MAX_LENGTH);
  875. XYZ_CONSTS_FROM_CONFIG(float, home_bump_mm, HOME_BUMP_MM);
  876. XYZ_CONSTS_FROM_CONFIG(signed char, home_dir, HOME_DIR);
  877. #if ENABLED(DUAL_X_CARRIAGE)
  878. #define DXC_FULL_CONTROL_MODE 0
  879. #define DXC_AUTO_PARK_MODE 1
  880. #define DXC_DUPLICATION_MODE 2
  881. static int dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE;
  882. static float x_home_pos(int extruder) {
  883. if (extruder == 0)
  884. return base_home_pos(X_AXIS) + home_offset[X_AXIS];
  885. else
  886. // In dual carriage mode the extruder offset provides an override of the
  887. // second X-carriage offset when homed - otherwise X2_HOME_POS is used.
  888. // This allow soft recalibration of the second extruder offset position without firmware reflash
  889. // (through the M218 command).
  890. return (extruder_offset[X_AXIS][1] > 0) ? extruder_offset[X_AXIS][1] : X2_HOME_POS;
  891. }
  892. static int x_home_dir(int extruder) {
  893. return (extruder == 0) ? X_HOME_DIR : X2_HOME_DIR;
  894. }
  895. static float inactive_extruder_x_pos = X2_MAX_POS; // used in mode 0 & 1
  896. static bool active_extruder_parked = false; // used in mode 1 & 2
  897. static float raised_parked_position[NUM_AXIS]; // used in mode 1
  898. static millis_t delayed_move_time = 0; // used in mode 1
  899. static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2
  900. static float duplicate_extruder_temp_offset = 0; // used in mode 2
  901. bool extruder_duplication_enabled = false; // used in mode 2
  902. #endif //DUAL_X_CARRIAGE
  903. #if ENABLED(DEBUG_LEVELING_FEATURE)
  904. void print_xyz(const char *prefix, const float x, const float y, const float z) {
  905. SERIAL_ECHO(prefix);
  906. SERIAL_ECHOPAIR(": (", x);
  907. SERIAL_ECHOPAIR(", ", y);
  908. SERIAL_ECHOPAIR(", ", z);
  909. SERIAL_ECHOLNPGM(")");
  910. }
  911. void print_xyz(const char *prefix, const float xyz[]) {
  912. print_xyz(prefix, xyz[X_AXIS], xyz[Y_AXIS], xyz[Z_AXIS]);
  913. }
  914. #endif
  915. static void set_axis_is_at_home(AxisEnum axis) {
  916. #if ENABLED(DUAL_X_CARRIAGE)
  917. if (axis == X_AXIS) {
  918. if (active_extruder != 0) {
  919. current_position[X_AXIS] = x_home_pos(active_extruder);
  920. min_pos[X_AXIS] = X2_MIN_POS;
  921. max_pos[X_AXIS] = max(extruder_offset[X_AXIS][1], X2_MAX_POS);
  922. return;
  923. }
  924. else if (dual_x_carriage_mode == DXC_DUPLICATION_MODE) {
  925. float xoff = home_offset[X_AXIS];
  926. current_position[X_AXIS] = base_home_pos(X_AXIS) + xoff;
  927. min_pos[X_AXIS] = base_min_pos(X_AXIS) + xoff;
  928. max_pos[X_AXIS] = min(base_max_pos(X_AXIS) + xoff, max(extruder_offset[X_AXIS][1], X2_MAX_POS) - duplicate_extruder_x_offset);
  929. return;
  930. }
  931. }
  932. #endif
  933. #if ENABLED(SCARA)
  934. if (axis == X_AXIS || axis == Y_AXIS) {
  935. float homeposition[3];
  936. for (int i = 0; i < 3; i++) homeposition[i] = base_home_pos(i);
  937. // SERIAL_ECHOPGM("homeposition[x]= "); SERIAL_ECHO(homeposition[0]);
  938. // SERIAL_ECHOPGM("homeposition[y]= "); SERIAL_ECHOLN(homeposition[1]);
  939. // Works out real Homeposition angles using inverse kinematics,
  940. // and calculates homing offset using forward kinematics
  941. calculate_delta(homeposition);
  942. // SERIAL_ECHOPGM("base Theta= "); SERIAL_ECHO(delta[X_AXIS]);
  943. // SERIAL_ECHOPGM(" base Psi+Theta="); SERIAL_ECHOLN(delta[Y_AXIS]);
  944. for (int i = 0; i < 2; i++) delta[i] -= home_offset[i];
  945. // SERIAL_ECHOPGM("addhome X="); SERIAL_ECHO(home_offset[X_AXIS]);
  946. // SERIAL_ECHOPGM(" addhome Y="); SERIAL_ECHO(home_offset[Y_AXIS]);
  947. // SERIAL_ECHOPGM(" addhome Theta="); SERIAL_ECHO(delta[X_AXIS]);
  948. // SERIAL_ECHOPGM(" addhome Psi+Theta="); SERIAL_ECHOLN(delta[Y_AXIS]);
  949. calculate_SCARA_forward_Transform(delta);
  950. // SERIAL_ECHOPGM("Delta X="); SERIAL_ECHO(delta[X_AXIS]);
  951. // SERIAL_ECHOPGM(" Delta Y="); SERIAL_ECHOLN(delta[Y_AXIS]);
  952. current_position[axis] = delta[axis];
  953. // SCARA home positions are based on configuration since the actual limits are determined by the
  954. // inverse kinematic transform.
  955. min_pos[axis] = base_min_pos(axis); // + (delta[axis] - base_home_pos(axis));
  956. max_pos[axis] = base_max_pos(axis); // + (delta[axis] - base_home_pos(axis));
  957. }
  958. else
  959. #endif
  960. {
  961. current_position[axis] = base_home_pos(axis) + home_offset[axis];
  962. min_pos[axis] = base_min_pos(axis) + home_offset[axis];
  963. max_pos[axis] = base_max_pos(axis) + home_offset[axis];
  964. #if ENABLED(AUTO_BED_LEVELING_FEATURE) && Z_HOME_DIR < 0
  965. if (axis == Z_AXIS) current_position[Z_AXIS] -= zprobe_zoffset;
  966. #endif
  967. #if ENABLED(DEBUG_LEVELING_FEATURE)
  968. if (marlin_debug_flags & DEBUG_LEVELING) {
  969. SERIAL_ECHOPAIR("set_axis_is_at_home ", (unsigned long)axis);
  970. SERIAL_ECHOPAIR(" > (home_offset[axis]==", home_offset[axis]);
  971. print_xyz(") > current_position", current_position);
  972. }
  973. #endif
  974. }
  975. }
  976. /**
  977. * Some planner shorthand inline functions
  978. */
  979. inline void set_homing_bump_feedrate(AxisEnum axis) {
  980. const int homing_bump_divisor[] = HOMING_BUMP_DIVISOR;
  981. int hbd = homing_bump_divisor[axis];
  982. if (hbd < 1) {
  983. hbd = 10;
  984. SERIAL_ECHO_START;
  985. SERIAL_ECHOLNPGM("Warning: Homing Bump Divisor < 1");
  986. }
  987. feedrate = homing_feedrate[axis] / hbd;
  988. }
  989. inline void line_to_current_position() {
  990. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate/60, active_extruder);
  991. }
  992. inline void line_to_z(float zPosition) {
  993. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
  994. }
  995. inline void line_to_destination(float mm_m) {
  996. plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], mm_m/60, active_extruder);
  997. }
  998. inline void line_to_destination() {
  999. line_to_destination(feedrate);
  1000. }
  1001. inline void sync_plan_position() {
  1002. plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
  1003. }
  1004. #if ENABLED(DELTA) || ENABLED(SCARA)
  1005. inline void sync_plan_position_delta() {
  1006. calculate_delta(current_position);
  1007. plan_set_position(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS]);
  1008. }
  1009. #endif
  1010. inline void set_current_to_destination() { memcpy(current_position, destination, sizeof(current_position)); }
  1011. inline void set_destination_to_current() { memcpy(destination, current_position, sizeof(destination)); }
  1012. static void setup_for_endstop_move() {
  1013. saved_feedrate = feedrate;
  1014. saved_feedrate_multiplier = feedrate_multiplier;
  1015. feedrate_multiplier = 100;
  1016. refresh_cmd_timeout();
  1017. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1018. if (marlin_debug_flags & DEBUG_LEVELING) {
  1019. SERIAL_ECHOLNPGM("setup_for_endstop_move > enable_endstops(true)");
  1020. }
  1021. #endif
  1022. enable_endstops(true);
  1023. }
  1024. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  1025. #if ENABLED(DELTA)
  1026. /**
  1027. * Calculate delta, start a line, and set current_position to destination
  1028. */
  1029. void prepare_move_raw() {
  1030. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1031. if (marlin_debug_flags & DEBUG_LEVELING) {
  1032. print_xyz("prepare_move_raw > destination", destination);
  1033. }
  1034. #endif
  1035. refresh_cmd_timeout();
  1036. calculate_delta(destination);
  1037. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], (feedrate/60)*(feedrate_multiplier/100.0), active_extruder);
  1038. set_current_to_destination();
  1039. }
  1040. #endif
  1041. #if ENABLED(AUTO_BED_LEVELING_GRID)
  1042. #if DISABLED(DELTA)
  1043. static void set_bed_level_equation_lsq(double *plane_equation_coefficients) {
  1044. vector_3 planeNormal = vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1);
  1045. planeNormal.debug("planeNormal");
  1046. plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
  1047. //bedLevel.debug("bedLevel");
  1048. //plan_bed_level_matrix.debug("bed level before");
  1049. //vector_3 uncorrected_position = plan_get_position_mm();
  1050. //uncorrected_position.debug("position before");
  1051. vector_3 corrected_position = plan_get_position();
  1052. //corrected_position.debug("position after");
  1053. current_position[X_AXIS] = corrected_position.x;
  1054. current_position[Y_AXIS] = corrected_position.y;
  1055. current_position[Z_AXIS] = corrected_position.z;
  1056. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1057. if (marlin_debug_flags & DEBUG_LEVELING) {
  1058. print_xyz("set_bed_level_equation_lsq > current_position", current_position);
  1059. }
  1060. #endif
  1061. sync_plan_position();
  1062. }
  1063. #endif // !DELTA
  1064. #else // !AUTO_BED_LEVELING_GRID
  1065. static void set_bed_level_equation_3pts(float z_at_pt_1, float z_at_pt_2, float z_at_pt_3) {
  1066. plan_bed_level_matrix.set_to_identity();
  1067. vector_3 pt1 = vector_3(ABL_PROBE_PT_1_X, ABL_PROBE_PT_1_Y, z_at_pt_1);
  1068. vector_3 pt2 = vector_3(ABL_PROBE_PT_2_X, ABL_PROBE_PT_2_Y, z_at_pt_2);
  1069. vector_3 pt3 = vector_3(ABL_PROBE_PT_3_X, ABL_PROBE_PT_3_Y, z_at_pt_3);
  1070. vector_3 planeNormal = vector_3::cross(pt1 - pt2, pt3 - pt2).get_normal();
  1071. if (planeNormal.z < 0) {
  1072. planeNormal.x = -planeNormal.x;
  1073. planeNormal.y = -planeNormal.y;
  1074. planeNormal.z = -planeNormal.z;
  1075. }
  1076. plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
  1077. vector_3 corrected_position = plan_get_position();
  1078. current_position[X_AXIS] = corrected_position.x;
  1079. current_position[Y_AXIS] = corrected_position.y;
  1080. current_position[Z_AXIS] = corrected_position.z;
  1081. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1082. if (marlin_debug_flags & DEBUG_LEVELING) {
  1083. print_xyz("set_bed_level_equation_3pts > current_position", current_position);
  1084. }
  1085. #endif
  1086. sync_plan_position();
  1087. }
  1088. #endif // !AUTO_BED_LEVELING_GRID
  1089. static void run_z_probe() {
  1090. #if ENABLED(DELTA)
  1091. float start_z = current_position[Z_AXIS];
  1092. long start_steps = st_get_position(Z_AXIS);
  1093. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1094. if (marlin_debug_flags & DEBUG_LEVELING) {
  1095. SERIAL_ECHOLNPGM("run_z_probe (DELTA) 1");
  1096. }
  1097. #endif
  1098. // move down slowly until you find the bed
  1099. feedrate = homing_feedrate[Z_AXIS] / 4;
  1100. destination[Z_AXIS] = -10;
  1101. prepare_move_raw(); // this will also set_current_to_destination
  1102. st_synchronize();
  1103. endstops_hit_on_purpose(); // clear endstop hit flags
  1104. // we have to let the planner know where we are right now as it is not where we said to go.
  1105. long stop_steps = st_get_position(Z_AXIS);
  1106. float mm = start_z - float(start_steps - stop_steps) / axis_steps_per_unit[Z_AXIS];
  1107. current_position[Z_AXIS] = mm;
  1108. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1109. if (marlin_debug_flags & DEBUG_LEVELING) {
  1110. print_xyz("run_z_probe (DELTA) 2 > current_position", current_position);
  1111. }
  1112. #endif
  1113. sync_plan_position_delta();
  1114. #else // !DELTA
  1115. plan_bed_level_matrix.set_to_identity();
  1116. feedrate = homing_feedrate[Z_AXIS];
  1117. // Move down until the Z probe (or endstop?) is triggered
  1118. float zPosition = -(Z_MAX_LENGTH + 10);
  1119. line_to_z(zPosition);
  1120. st_synchronize();
  1121. // Tell the planner where we ended up - Get this from the stepper handler
  1122. zPosition = st_get_position_mm(Z_AXIS);
  1123. plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS]);
  1124. // move up the retract distance
  1125. zPosition += home_bump_mm(Z_AXIS);
  1126. line_to_z(zPosition);
  1127. st_synchronize();
  1128. endstops_hit_on_purpose(); // clear endstop hit flags
  1129. // move back down slowly to find bed
  1130. set_homing_bump_feedrate(Z_AXIS);
  1131. zPosition -= home_bump_mm(Z_AXIS) * 2;
  1132. line_to_z(zPosition);
  1133. st_synchronize();
  1134. endstops_hit_on_purpose(); // clear endstop hit flags
  1135. // Get the current stepper position after bumping an endstop
  1136. current_position[Z_AXIS] = st_get_position_mm(Z_AXIS);
  1137. sync_plan_position();
  1138. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1139. if (marlin_debug_flags & DEBUG_LEVELING) {
  1140. print_xyz("run_z_probe > current_position", current_position);
  1141. }
  1142. #endif
  1143. #endif // !DELTA
  1144. }
  1145. /**
  1146. * Plan a move to (X, Y, Z) and set the current_position
  1147. * The final current_position may not be the one that was requested
  1148. */
  1149. static void do_blocking_move_to(float x, float y, float z) {
  1150. float oldFeedRate = feedrate;
  1151. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1152. if (marlin_debug_flags & DEBUG_LEVELING) {
  1153. print_xyz("do_blocking_move_to", x, y, z);
  1154. }
  1155. #endif
  1156. #if ENABLED(DELTA)
  1157. feedrate = XY_TRAVEL_SPEED;
  1158. destination[X_AXIS] = x;
  1159. destination[Y_AXIS] = y;
  1160. destination[Z_AXIS] = z;
  1161. prepare_move_raw(); // this will also set_current_to_destination
  1162. st_synchronize();
  1163. #else
  1164. feedrate = homing_feedrate[Z_AXIS];
  1165. current_position[Z_AXIS] = z;
  1166. line_to_current_position();
  1167. st_synchronize();
  1168. feedrate = xy_travel_speed;
  1169. current_position[X_AXIS] = x;
  1170. current_position[Y_AXIS] = y;
  1171. line_to_current_position();
  1172. st_synchronize();
  1173. #endif
  1174. feedrate = oldFeedRate;
  1175. }
  1176. inline void do_blocking_move_to_xy(float x, float y) { do_blocking_move_to(x, y, current_position[Z_AXIS]); }
  1177. inline void do_blocking_move_to_x(float x) { do_blocking_move_to(x, current_position[Y_AXIS], current_position[Z_AXIS]); }
  1178. inline void do_blocking_move_to_z(float z) { do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z); }
  1179. static void clean_up_after_endstop_move() {
  1180. #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING)
  1181. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1182. if (marlin_debug_flags & DEBUG_LEVELING) {
  1183. SERIAL_ECHOLNPGM("clean_up_after_endstop_move > ENDSTOPS_ONLY_FOR_HOMING > enable_endstops(false)");
  1184. }
  1185. #endif
  1186. enable_endstops(false);
  1187. #endif
  1188. feedrate = saved_feedrate;
  1189. feedrate_multiplier = saved_feedrate_multiplier;
  1190. refresh_cmd_timeout();
  1191. }
  1192. static void deploy_z_probe() {
  1193. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1194. if (marlin_debug_flags & DEBUG_LEVELING) {
  1195. print_xyz("deploy_z_probe > current_position", current_position);
  1196. }
  1197. #endif
  1198. #if HAS_SERVO_ENDSTOPS
  1199. // Engage Z Servo endstop if enabled
  1200. if (servo_endstop_id[Z_AXIS] >= 0) servo[servo_endstop_id[Z_AXIS]].move(servo_endstop_angle[Z_AXIS][0]);
  1201. #elif ENABLED(Z_PROBE_ALLEN_KEY)
  1202. feedrate = Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE;
  1203. // If endstop is already false, the Z probe is deployed
  1204. #if ENABLED(Z_MIN_PROBE_ENDSTOP)
  1205. bool z_probe_endstop = (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING);
  1206. if (z_probe_endstop)
  1207. #else
  1208. bool z_min_endstop = (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING);
  1209. if (z_min_endstop)
  1210. #endif
  1211. {
  1212. // Move to the start position to initiate deployment
  1213. destination[X_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_1_X;
  1214. destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_1_Y;
  1215. destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_1_Z;
  1216. prepare_move_raw(); // this will also set_current_to_destination
  1217. // Move to engage deployment
  1218. if (Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE != Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE) {
  1219. feedrate = Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE;
  1220. }
  1221. if (Z_PROBE_ALLEN_KEY_DEPLOY_2_X != Z_PROBE_ALLEN_KEY_DEPLOY_1_X) {
  1222. destination[X_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_2_X;
  1223. }
  1224. if (Z_PROBE_ALLEN_KEY_DEPLOY_2_Y != Z_PROBE_ALLEN_KEY_DEPLOY_1_Y) {
  1225. destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_2_Y;
  1226. }
  1227. if (Z_PROBE_ALLEN_KEY_DEPLOY_2_Z != Z_PROBE_ALLEN_KEY_DEPLOY_1_Z) {
  1228. destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_2_Z;
  1229. }
  1230. prepare_move_raw();
  1231. #ifdef Z_PROBE_ALLEN_KEY_DEPLOY_3_X
  1232. if (Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE != Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE) {
  1233. feedrate = Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE;
  1234. }
  1235. // Move to trigger deployment
  1236. if (Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE != Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE) {
  1237. feedrate = Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE;
  1238. }
  1239. if (Z_PROBE_ALLEN_KEY_DEPLOY_3_X != Z_PROBE_ALLEN_KEY_DEPLOY_2_X) {
  1240. destination[X_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_3_X;
  1241. }
  1242. if (Z_PROBE_ALLEN_KEY_DEPLOY_3_Y != Z_PROBE_ALLEN_KEY_DEPLOY_2_Y) {
  1243. destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_3_Y;
  1244. }
  1245. if (Z_PROBE_ALLEN_KEY_DEPLOY_3_Z != Z_PROBE_ALLEN_KEY_DEPLOY_2_Z) {
  1246. destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_3_Z;
  1247. }
  1248. prepare_move_raw();
  1249. #endif
  1250. }
  1251. // Partially Home X,Y for safety
  1252. destination[X_AXIS] = destination[X_AXIS]*0.75;
  1253. destination[Y_AXIS] = destination[Y_AXIS]*0.75;
  1254. prepare_move_raw(); // this will also set_current_to_destination
  1255. st_synchronize();
  1256. #if ENABLED(Z_MIN_PROBE_ENDSTOP)
  1257. z_probe_endstop = (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING);
  1258. if (z_probe_endstop)
  1259. #else
  1260. z_min_endstop = (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING);
  1261. if (z_min_endstop)
  1262. #endif
  1263. {
  1264. if (IsRunning()) {
  1265. SERIAL_ERROR_START;
  1266. SERIAL_ERRORLNPGM("Z-Probe failed to engage!");
  1267. LCD_ALERTMESSAGEPGM("Err: ZPROBE");
  1268. }
  1269. Stop();
  1270. }
  1271. #endif // Z_PROBE_ALLEN_KEY
  1272. }
  1273. static void stow_z_probe(bool doRaise=true) {
  1274. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1275. if (marlin_debug_flags & DEBUG_LEVELING) {
  1276. print_xyz("stow_z_probe > current_position", current_position);
  1277. }
  1278. #endif
  1279. #if HAS_SERVO_ENDSTOPS
  1280. // Retract Z Servo endstop if enabled
  1281. if (servo_endstop_id[Z_AXIS] >= 0) {
  1282. #if Z_RAISE_AFTER_PROBING > 0
  1283. if (doRaise) {
  1284. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1285. if (marlin_debug_flags & DEBUG_LEVELING) {
  1286. SERIAL_ECHOPAIR("Raise Z (after) by ", (float)Z_RAISE_AFTER_PROBING);
  1287. SERIAL_EOL;
  1288. SERIAL_ECHOPAIR("> SERVO_ENDSTOPS > do_blocking_move_to_z ", current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING);
  1289. SERIAL_EOL;
  1290. }
  1291. #endif
  1292. do_blocking_move_to_z(current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING); // this also updates current_position
  1293. st_synchronize();
  1294. }
  1295. #endif
  1296. // Change the Z servo angle
  1297. servo[servo_endstop_id[Z_AXIS]].move(servo_endstop_angle[Z_AXIS][1]);
  1298. }
  1299. #elif ENABLED(Z_PROBE_ALLEN_KEY)
  1300. // Move up for safety
  1301. feedrate = Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE;
  1302. #if Z_RAISE_AFTER_PROBING > 0
  1303. destination[Z_AXIS] = current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING;
  1304. prepare_move_raw(); // this will also set_current_to_destination
  1305. #endif
  1306. // Move to the start position to initiate retraction
  1307. destination[X_AXIS] = Z_PROBE_ALLEN_KEY_STOW_1_X;
  1308. destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_STOW_1_Y;
  1309. destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_STOW_1_Z;
  1310. prepare_move_raw();
  1311. // Move the nozzle down to push the Z probe into retracted position
  1312. if (Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE != Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE) {
  1313. feedrate = Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE;
  1314. }
  1315. if (Z_PROBE_ALLEN_KEY_STOW_2_X != Z_PROBE_ALLEN_KEY_STOW_1_X) {
  1316. destination[X_AXIS] = Z_PROBE_ALLEN_KEY_STOW_2_X;
  1317. }
  1318. if (Z_PROBE_ALLEN_KEY_STOW_2_Y != Z_PROBE_ALLEN_KEY_STOW_1_Y) {
  1319. destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_STOW_2_Y;
  1320. }
  1321. destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_STOW_2_Z;
  1322. prepare_move_raw();
  1323. // Move up for safety
  1324. if (Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE != Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE) {
  1325. feedrate = Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE;
  1326. }
  1327. if (Z_PROBE_ALLEN_KEY_STOW_3_X != Z_PROBE_ALLEN_KEY_STOW_2_X) {
  1328. destination[X_AXIS] = Z_PROBE_ALLEN_KEY_STOW_3_X;
  1329. }
  1330. if (Z_PROBE_ALLEN_KEY_STOW_3_Y != Z_PROBE_ALLEN_KEY_STOW_2_Y) {
  1331. destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_STOW_3_Y;
  1332. }
  1333. destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_STOW_3_Z;
  1334. prepare_move_raw();
  1335. // Home XY for safety
  1336. feedrate = homing_feedrate[X_AXIS]/2;
  1337. destination[X_AXIS] = 0;
  1338. destination[Y_AXIS] = 0;
  1339. prepare_move_raw(); // this will also set_current_to_destination
  1340. st_synchronize();
  1341. #if ENABLED(Z_MIN_PROBE_ENDSTOP)
  1342. bool z_probe_endstop = (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING);
  1343. if (!z_probe_endstop)
  1344. #else
  1345. bool z_min_endstop = (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING);
  1346. if (!z_min_endstop)
  1347. #endif
  1348. {
  1349. if (IsRunning()) {
  1350. SERIAL_ERROR_START;
  1351. SERIAL_ERRORLNPGM("Z-Probe failed to retract!");
  1352. LCD_ALERTMESSAGEPGM("Err: ZPROBE");
  1353. }
  1354. Stop();
  1355. }
  1356. #endif // Z_PROBE_ALLEN_KEY
  1357. }
  1358. enum ProbeAction {
  1359. ProbeStay = 0,
  1360. ProbeDeploy = BIT(0),
  1361. ProbeStow = BIT(1),
  1362. ProbeDeployAndStow = (ProbeDeploy | ProbeStow)
  1363. };
  1364. // Probe bed height at position (x,y), returns the measured z value
  1365. static float probe_pt(float x, float y, float z_before, ProbeAction probe_action=ProbeDeployAndStow, int verbose_level=1) {
  1366. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1367. if (marlin_debug_flags & DEBUG_LEVELING) {
  1368. SERIAL_ECHOLNPGM("probe_pt >>>");
  1369. SERIAL_ECHOPAIR("> ProbeAction:", (unsigned long)probe_action);
  1370. SERIAL_EOL;
  1371. print_xyz("> current_position", current_position);
  1372. }
  1373. #endif
  1374. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1375. if (marlin_debug_flags & DEBUG_LEVELING) {
  1376. SERIAL_ECHOPAIR("Z Raise to z_before ", z_before);
  1377. SERIAL_EOL;
  1378. SERIAL_ECHOPAIR("> do_blocking_move_to_z ", z_before);
  1379. SERIAL_EOL;
  1380. }
  1381. #endif
  1382. // Move Z up to the z_before height, then move the Z probe to the given XY
  1383. do_blocking_move_to_z(z_before); // this also updates current_position
  1384. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1385. if (marlin_debug_flags & DEBUG_LEVELING) {
  1386. SERIAL_ECHOPAIR("> do_blocking_move_to_xy ", x - X_PROBE_OFFSET_FROM_EXTRUDER);
  1387. SERIAL_ECHOPAIR(", ", y - Y_PROBE_OFFSET_FROM_EXTRUDER);
  1388. SERIAL_EOL;
  1389. }
  1390. #endif
  1391. do_blocking_move_to_xy(x - X_PROBE_OFFSET_FROM_EXTRUDER, y - Y_PROBE_OFFSET_FROM_EXTRUDER); // this also updates current_position
  1392. #if DISABLED(Z_PROBE_SLED) && DISABLED(Z_PROBE_ALLEN_KEY)
  1393. if (probe_action & ProbeDeploy) {
  1394. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1395. if (marlin_debug_flags & DEBUG_LEVELING) {
  1396. SERIAL_ECHOLNPGM("> ProbeDeploy");
  1397. }
  1398. #endif
  1399. deploy_z_probe();
  1400. }
  1401. #endif
  1402. run_z_probe();
  1403. float measured_z = current_position[Z_AXIS];
  1404. #if DISABLED(Z_PROBE_SLED) && DISABLED(Z_PROBE_ALLEN_KEY)
  1405. if (probe_action & ProbeStow) {
  1406. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1407. if (marlin_debug_flags & DEBUG_LEVELING) {
  1408. SERIAL_ECHOLNPGM("> ProbeStow (stow_z_probe will do Z Raise)");
  1409. }
  1410. #endif
  1411. stow_z_probe();
  1412. }
  1413. #endif
  1414. if (verbose_level > 2) {
  1415. SERIAL_PROTOCOLPGM("Bed X: ");
  1416. SERIAL_PROTOCOL_F(x, 3);
  1417. SERIAL_PROTOCOLPGM(" Y: ");
  1418. SERIAL_PROTOCOL_F(y, 3);
  1419. SERIAL_PROTOCOLPGM(" Z: ");
  1420. SERIAL_PROTOCOL_F(measured_z, 3);
  1421. SERIAL_EOL;
  1422. }
  1423. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1424. if (marlin_debug_flags & DEBUG_LEVELING) {
  1425. SERIAL_ECHOLNPGM("<<< probe_pt");
  1426. }
  1427. #endif
  1428. return measured_z;
  1429. }
  1430. #if ENABLED(DELTA)
  1431. /**
  1432. * All DELTA leveling in the Marlin uses NONLINEAR_BED_LEVELING
  1433. */
  1434. static void extrapolate_one_point(int x, int y, int xdir, int ydir) {
  1435. if (bed_level[x][y] != 0.0) {
  1436. return; // Don't overwrite good values.
  1437. }
  1438. float a = 2*bed_level[x+xdir][y] - bed_level[x+xdir*2][y]; // Left to right.
  1439. float b = 2*bed_level[x][y+ydir] - bed_level[x][y+ydir*2]; // Front to back.
  1440. float c = 2*bed_level[x+xdir][y+ydir] - bed_level[x+xdir*2][y+ydir*2]; // Diagonal.
  1441. float median = c; // Median is robust (ignores outliers).
  1442. if (a < b) {
  1443. if (b < c) median = b;
  1444. if (c < a) median = a;
  1445. } else { // b <= a
  1446. if (c < b) median = b;
  1447. if (a < c) median = a;
  1448. }
  1449. bed_level[x][y] = median;
  1450. }
  1451. // Fill in the unprobed points (corners of circular print surface)
  1452. // using linear extrapolation, away from the center.
  1453. static void extrapolate_unprobed_bed_level() {
  1454. int half = (AUTO_BED_LEVELING_GRID_POINTS-1)/2;
  1455. for (int y = 0; y <= half; y++) {
  1456. for (int x = 0; x <= half; x++) {
  1457. if (x + y < 3) continue;
  1458. extrapolate_one_point(half-x, half-y, x>1?+1:0, y>1?+1:0);
  1459. extrapolate_one_point(half+x, half-y, x>1?-1:0, y>1?+1:0);
  1460. extrapolate_one_point(half-x, half+y, x>1?+1:0, y>1?-1:0);
  1461. extrapolate_one_point(half+x, half+y, x>1?-1:0, y>1?-1:0);
  1462. }
  1463. }
  1464. }
  1465. // Print calibration results for plotting or manual frame adjustment.
  1466. static void print_bed_level() {
  1467. for (int y = 0; y < AUTO_BED_LEVELING_GRID_POINTS; y++) {
  1468. for (int x = 0; x < AUTO_BED_LEVELING_GRID_POINTS; x++) {
  1469. SERIAL_PROTOCOL_F(bed_level[x][y], 2);
  1470. SERIAL_PROTOCOLCHAR(' ');
  1471. }
  1472. SERIAL_EOL;
  1473. }
  1474. }
  1475. // Reset calibration results to zero.
  1476. void reset_bed_level() {
  1477. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1478. if (marlin_debug_flags & DEBUG_LEVELING) {
  1479. SERIAL_ECHOLNPGM("reset_bed_level");
  1480. }
  1481. #endif
  1482. for (int y = 0; y < AUTO_BED_LEVELING_GRID_POINTS; y++) {
  1483. for (int x = 0; x < AUTO_BED_LEVELING_GRID_POINTS; x++) {
  1484. bed_level[x][y] = 0.0;
  1485. }
  1486. }
  1487. }
  1488. #endif // DELTA
  1489. #if HAS_SERVO_ENDSTOPS && DISABLED(Z_PROBE_SLED)
  1490. void raise_z_for_servo() {
  1491. float zpos = current_position[Z_AXIS], z_dest = Z_RAISE_BEFORE_PROBING;
  1492. z_dest += axis_known_position[Z_AXIS] ? zprobe_zoffset : zpos;
  1493. if (zpos < z_dest) do_blocking_move_to_z(z_dest); // also updates current_position
  1494. }
  1495. #endif
  1496. #endif // AUTO_BED_LEVELING_FEATURE
  1497. #if ENABLED(Z_PROBE_SLED)
  1498. #ifndef SLED_DOCKING_OFFSET
  1499. #define SLED_DOCKING_OFFSET 0
  1500. #endif
  1501. /**
  1502. * Method to dock/undock a sled designed by Charles Bell.
  1503. *
  1504. * dock[in] If true, move to MAX_X and engage the electromagnet
  1505. * offset[in] The additional distance to move to adjust docking location
  1506. */
  1507. static void dock_sled(bool dock, int offset=0) {
  1508. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1509. if (marlin_debug_flags & DEBUG_LEVELING) {
  1510. SERIAL_ECHOPAIR("dock_sled", dock);
  1511. SERIAL_EOL;
  1512. }
  1513. #endif
  1514. if (!axis_known_position[X_AXIS] || !axis_known_position[Y_AXIS]) {
  1515. LCD_MESSAGEPGM(MSG_POSITION_UNKNOWN);
  1516. SERIAL_ECHO_START;
  1517. SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN);
  1518. return;
  1519. }
  1520. float oldXpos = current_position[X_AXIS]; // save x position
  1521. if (dock) {
  1522. #if Z_RAISE_AFTER_PROBING > 0
  1523. do_blocking_move_to_z(current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING); // raise Z
  1524. #endif
  1525. do_blocking_move_to_x(X_MAX_POS + SLED_DOCKING_OFFSET + offset - 1); // Dock sled a bit closer to ensure proper capturing
  1526. digitalWrite(SLED_PIN, LOW); // turn off magnet
  1527. } else {
  1528. float z_loc = current_position[Z_AXIS];
  1529. if (z_loc < Z_RAISE_BEFORE_PROBING + 5) z_loc = Z_RAISE_BEFORE_PROBING;
  1530. do_blocking_move_to(X_MAX_POS + SLED_DOCKING_OFFSET + offset, current_position[Y_AXIS], z_loc); // this also updates current_position
  1531. digitalWrite(SLED_PIN, HIGH); // turn on magnet
  1532. }
  1533. do_blocking_move_to_x(oldXpos); // return to position before docking
  1534. }
  1535. #endif // Z_PROBE_SLED
  1536. /**
  1537. * Home an individual axis
  1538. */
  1539. #define HOMEAXIS(LETTER) homeaxis(LETTER##_AXIS)
  1540. static void homeaxis(AxisEnum axis) {
  1541. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1542. if (marlin_debug_flags & DEBUG_LEVELING) {
  1543. SERIAL_ECHOPAIR(">>> homeaxis(", (unsigned long)axis);
  1544. SERIAL_CHAR(')');
  1545. SERIAL_EOL;
  1546. }
  1547. #endif
  1548. #define HOMEAXIS_DO(LETTER) \
  1549. ((LETTER##_MIN_PIN > -1 && LETTER##_HOME_DIR==-1) || (LETTER##_MAX_PIN > -1 && LETTER##_HOME_DIR==1))
  1550. if (axis == X_AXIS ? HOMEAXIS_DO(X) : axis == Y_AXIS ? HOMEAXIS_DO(Y) : axis == Z_AXIS ? HOMEAXIS_DO(Z) : 0) {
  1551. int axis_home_dir =
  1552. #if ENABLED(DUAL_X_CARRIAGE)
  1553. (axis == X_AXIS) ? x_home_dir(active_extruder) :
  1554. #endif
  1555. home_dir(axis);
  1556. // Set the axis position as setup for the move
  1557. current_position[axis] = 0;
  1558. sync_plan_position();
  1559. #if ENABLED(Z_PROBE_SLED)
  1560. // Get Probe
  1561. if (axis == Z_AXIS) {
  1562. if (axis_home_dir < 0) dock_sled(false);
  1563. }
  1564. #endif
  1565. #if SERVO_LEVELING && DISABLED(Z_PROBE_SLED)
  1566. // Deploy a Z probe if there is one, and homing towards the bed
  1567. if (axis == Z_AXIS) {
  1568. if (axis_home_dir < 0) deploy_z_probe();
  1569. }
  1570. #endif
  1571. #if HAS_SERVO_ENDSTOPS
  1572. // Engage Servo endstop if enabled
  1573. if (axis != Z_AXIS && servo_endstop_id[axis] >= 0)
  1574. servo[servo_endstop_id[axis]].move(servo_endstop_angle[axis][0]);
  1575. #endif
  1576. // Set a flag for Z motor locking
  1577. #if ENABLED(Z_DUAL_ENDSTOPS)
  1578. if (axis == Z_AXIS) In_Homing_Process(true);
  1579. #endif
  1580. // Move towards the endstop until an endstop is triggered
  1581. destination[axis] = 1.5 * max_length(axis) * axis_home_dir;
  1582. feedrate = homing_feedrate[axis];
  1583. line_to_destination();
  1584. st_synchronize();
  1585. // Set the axis position as setup for the move
  1586. current_position[axis] = 0;
  1587. sync_plan_position();
  1588. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1589. if (marlin_debug_flags & DEBUG_LEVELING) {
  1590. SERIAL_ECHOLNPGM("> enable_endstops(false)");
  1591. }
  1592. #endif
  1593. enable_endstops(false); // Disable endstops while moving away
  1594. // Move away from the endstop by the axis HOME_BUMP_MM
  1595. destination[axis] = -home_bump_mm(axis) * axis_home_dir;
  1596. line_to_destination();
  1597. st_synchronize();
  1598. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1599. if (marlin_debug_flags & DEBUG_LEVELING) {
  1600. SERIAL_ECHOLNPGM("> enable_endstops(true)");
  1601. }
  1602. #endif
  1603. enable_endstops(true); // Enable endstops for next homing move
  1604. // Slow down the feedrate for the next move
  1605. set_homing_bump_feedrate(axis);
  1606. // Move slowly towards the endstop until triggered
  1607. destination[axis] = 2 * home_bump_mm(axis) * axis_home_dir;
  1608. line_to_destination();
  1609. st_synchronize();
  1610. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1611. if (marlin_debug_flags & DEBUG_LEVELING) {
  1612. print_xyz("> TRIGGER ENDSTOP > current_position", current_position);
  1613. }
  1614. #endif
  1615. #if ENABLED(Z_DUAL_ENDSTOPS)
  1616. if (axis == Z_AXIS) {
  1617. float adj = fabs(z_endstop_adj);
  1618. bool lockZ1;
  1619. if (axis_home_dir > 0) {
  1620. adj = -adj;
  1621. lockZ1 = (z_endstop_adj > 0);
  1622. }
  1623. else
  1624. lockZ1 = (z_endstop_adj < 0);
  1625. if (lockZ1) Lock_z_motor(true); else Lock_z2_motor(true);
  1626. sync_plan_position();
  1627. // Move to the adjusted endstop height
  1628. feedrate = homing_feedrate[axis];
  1629. destination[Z_AXIS] = adj;
  1630. line_to_destination();
  1631. st_synchronize();
  1632. if (lockZ1) Lock_z_motor(false); else Lock_z2_motor(false);
  1633. In_Homing_Process(false);
  1634. } // Z_AXIS
  1635. #endif
  1636. #if ENABLED(DELTA)
  1637. // retrace by the amount specified in endstop_adj
  1638. if (endstop_adj[axis] * axis_home_dir < 0) {
  1639. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1640. if (marlin_debug_flags & DEBUG_LEVELING) {
  1641. SERIAL_ECHOLNPGM("> enable_endstops(false)");
  1642. }
  1643. #endif
  1644. enable_endstops(false); // Disable endstops while moving away
  1645. sync_plan_position();
  1646. destination[axis] = endstop_adj[axis];
  1647. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1648. if (marlin_debug_flags & DEBUG_LEVELING) {
  1649. SERIAL_ECHOPAIR("> endstop_adj = ", endstop_adj[axis]);
  1650. print_xyz(" > destination", destination);
  1651. }
  1652. #endif
  1653. line_to_destination();
  1654. st_synchronize();
  1655. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1656. if (marlin_debug_flags & DEBUG_LEVELING) {
  1657. SERIAL_ECHOLNPGM("> enable_endstops(true)");
  1658. }
  1659. #endif
  1660. enable_endstops(true); // Enable endstops for next homing move
  1661. }
  1662. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1663. else {
  1664. if (marlin_debug_flags & DEBUG_LEVELING) {
  1665. SERIAL_ECHOPAIR("> endstop_adj * axis_home_dir = ", endstop_adj[axis] * axis_home_dir);
  1666. SERIAL_EOL;
  1667. }
  1668. }
  1669. #endif
  1670. #endif
  1671. // Set the axis position to its home position (plus home offsets)
  1672. set_axis_is_at_home(axis);
  1673. sync_plan_position();
  1674. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1675. if (marlin_debug_flags & DEBUG_LEVELING) {
  1676. print_xyz("> AFTER set_axis_is_at_home > current_position", current_position);
  1677. }
  1678. #endif
  1679. destination[axis] = current_position[axis];
  1680. feedrate = 0.0;
  1681. endstops_hit_on_purpose(); // clear endstop hit flags
  1682. axis_known_position[axis] = true;
  1683. #if ENABLED(Z_PROBE_SLED)
  1684. // bring Z probe back
  1685. if (axis == Z_AXIS) {
  1686. if (axis_home_dir < 0) dock_sled(true);
  1687. }
  1688. #endif
  1689. #if SERVO_LEVELING && DISABLED(Z_PROBE_SLED)
  1690. // Deploy a Z probe if there is one, and homing towards the bed
  1691. if (axis == Z_AXIS) {
  1692. if (axis_home_dir < 0) {
  1693. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1694. if (marlin_debug_flags & DEBUG_LEVELING) {
  1695. SERIAL_ECHOLNPGM("> SERVO_LEVELING > stow_z_probe");
  1696. }
  1697. #endif
  1698. stow_z_probe();
  1699. }
  1700. }
  1701. else
  1702. #endif
  1703. {
  1704. #if HAS_SERVO_ENDSTOPS
  1705. // Retract Servo endstop if enabled
  1706. if (servo_endstop_id[axis] >= 0) {
  1707. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1708. if (marlin_debug_flags & DEBUG_LEVELING) {
  1709. SERIAL_ECHOLNPGM("> SERVO_ENDSTOPS > Stow with servo.move()");
  1710. }
  1711. #endif
  1712. servo[servo_endstop_id[axis]].move(servo_endstop_angle[axis][1]);
  1713. }
  1714. #endif
  1715. }
  1716. }
  1717. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1718. if (marlin_debug_flags & DEBUG_LEVELING) {
  1719. SERIAL_ECHOPAIR("<<< homeaxis(", (unsigned long)axis);
  1720. SERIAL_CHAR(')');
  1721. SERIAL_EOL;
  1722. }
  1723. #endif
  1724. }
  1725. #if ENABLED(FWRETRACT)
  1726. void retract(bool retracting, bool swapping=false) {
  1727. if (retracting == retracted[active_extruder]) return;
  1728. float oldFeedrate = feedrate;
  1729. set_destination_to_current();
  1730. if (retracting) {
  1731. feedrate = retract_feedrate * 60;
  1732. current_position[E_AXIS] += (swapping ? retract_length_swap : retract_length) / volumetric_multiplier[active_extruder];
  1733. plan_set_e_position(current_position[E_AXIS]);
  1734. prepare_move();
  1735. if (retract_zlift > 0.01) {
  1736. current_position[Z_AXIS] -= retract_zlift;
  1737. #if ENABLED(DELTA)
  1738. sync_plan_position_delta();
  1739. #else
  1740. sync_plan_position();
  1741. #endif
  1742. prepare_move();
  1743. }
  1744. }
  1745. else {
  1746. if (retract_zlift > 0.01) {
  1747. current_position[Z_AXIS] += retract_zlift;
  1748. #if ENABLED(DELTA)
  1749. sync_plan_position_delta();
  1750. #else
  1751. sync_plan_position();
  1752. #endif
  1753. //prepare_move();
  1754. }
  1755. feedrate = retract_recover_feedrate * 60;
  1756. float move_e = swapping ? retract_length_swap + retract_recover_length_swap : retract_length + retract_recover_length;
  1757. current_position[E_AXIS] -= move_e / volumetric_multiplier[active_extruder];
  1758. plan_set_e_position(current_position[E_AXIS]);
  1759. prepare_move();
  1760. }
  1761. feedrate = oldFeedrate;
  1762. retracted[active_extruder] = retracting;
  1763. } // retract()
  1764. #endif // FWRETRACT
  1765. /**
  1766. *
  1767. * G-Code Handler functions
  1768. *
  1769. */
  1770. /**
  1771. * Set XYZE destination and feedrate from the current GCode command
  1772. *
  1773. * - Set destination from included axis codes
  1774. * - Set to current for missing axis codes
  1775. * - Set the feedrate, if included
  1776. */
  1777. void gcode_get_destination() {
  1778. for (int i = 0; i < NUM_AXIS; i++) {
  1779. if (code_seen(axis_codes[i]))
  1780. destination[i] = code_value() + (axis_relative_modes[i] || relative_mode ? current_position[i] : 0);
  1781. else
  1782. destination[i] = current_position[i];
  1783. }
  1784. if (code_seen('F')) {
  1785. float next_feedrate = code_value();
  1786. if (next_feedrate > 0.0) feedrate = next_feedrate;
  1787. }
  1788. }
  1789. void unknown_command_error() {
  1790. SERIAL_ECHO_START;
  1791. SERIAL_ECHOPGM(MSG_UNKNOWN_COMMAND);
  1792. SERIAL_ECHO(current_command);
  1793. SERIAL_ECHOPGM("\"\n");
  1794. }
  1795. /**
  1796. * G0, G1: Coordinated movement of X Y Z E axes
  1797. */
  1798. inline void gcode_G0_G1() {
  1799. if (IsRunning()) {
  1800. gcode_get_destination(); // For X Y Z E F
  1801. #if ENABLED(FWRETRACT)
  1802. if (autoretract_enabled && !(code_seen('X') || code_seen('Y') || code_seen('Z')) && code_seen('E')) {
  1803. float echange = destination[E_AXIS] - current_position[E_AXIS];
  1804. // Is this move an attempt to retract or recover?
  1805. if ((echange < -MIN_RETRACT && !retracted[active_extruder]) || (echange > MIN_RETRACT && retracted[active_extruder])) {
  1806. current_position[E_AXIS] = destination[E_AXIS]; // hide the slicer-generated retract/recover from calculations
  1807. plan_set_e_position(current_position[E_AXIS]); // AND from the planner
  1808. retract(!retracted[active_extruder]);
  1809. return;
  1810. }
  1811. }
  1812. #endif //FWRETRACT
  1813. prepare_move();
  1814. }
  1815. }
  1816. /**
  1817. * G2: Clockwise Arc
  1818. * G3: Counterclockwise Arc
  1819. */
  1820. inline void gcode_G2_G3(bool clockwise) {
  1821. if (IsRunning()) {
  1822. #if ENABLED(SF_ARC_FIX)
  1823. bool relative_mode_backup = relative_mode;
  1824. relative_mode = true;
  1825. #endif
  1826. gcode_get_destination();
  1827. #if ENABLED(SF_ARC_FIX)
  1828. relative_mode = relative_mode_backup;
  1829. #endif
  1830. // Center of arc as offset from current_position
  1831. float arc_offset[2] = {
  1832. code_seen('I') ? code_value() : 0,
  1833. code_seen('J') ? code_value() : 0
  1834. };
  1835. // Send an arc to the planner
  1836. plan_arc(destination, arc_offset, clockwise);
  1837. refresh_cmd_timeout();
  1838. }
  1839. }
  1840. /**
  1841. * G4: Dwell S<seconds> or P<milliseconds>
  1842. */
  1843. inline void gcode_G4() {
  1844. millis_t codenum = 0;
  1845. if (code_seen('P')) codenum = code_value_long(); // milliseconds to wait
  1846. if (code_seen('S')) codenum = code_value() * 1000; // seconds to wait
  1847. st_synchronize();
  1848. refresh_cmd_timeout();
  1849. codenum += previous_cmd_ms; // keep track of when we started waiting
  1850. if (!lcd_hasstatus()) LCD_MESSAGEPGM(MSG_DWELL);
  1851. while (millis() < codenum) idle();
  1852. }
  1853. #if ENABLED(FWRETRACT)
  1854. /**
  1855. * G10 - Retract filament according to settings of M207
  1856. * G11 - Recover filament according to settings of M208
  1857. */
  1858. inline void gcode_G10_G11(bool doRetract=false) {
  1859. #if EXTRUDERS > 1
  1860. if (doRetract) {
  1861. retracted_swap[active_extruder] = (code_seen('S') && code_value_short() == 1); // checks for swap retract argument
  1862. }
  1863. #endif
  1864. retract(doRetract
  1865. #if EXTRUDERS > 1
  1866. , retracted_swap[active_extruder]
  1867. #endif
  1868. );
  1869. }
  1870. #endif //FWRETRACT
  1871. /**
  1872. * G28: Home all axes according to settings
  1873. *
  1874. * Parameters
  1875. *
  1876. * None Home to all axes with no parameters.
  1877. * With QUICK_HOME enabled XY will home together, then Z.
  1878. *
  1879. * Cartesian parameters
  1880. *
  1881. * X Home to the X endstop
  1882. * Y Home to the Y endstop
  1883. * Z Home to the Z endstop
  1884. *
  1885. */
  1886. inline void gcode_G28() {
  1887. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1888. if (marlin_debug_flags & DEBUG_LEVELING) {
  1889. SERIAL_ECHOLNPGM("gcode_G28 >>>");
  1890. }
  1891. #endif
  1892. // Wait for planner moves to finish!
  1893. st_synchronize();
  1894. // For auto bed leveling, clear the level matrix
  1895. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  1896. plan_bed_level_matrix.set_to_identity();
  1897. #if ENABLED(DELTA)
  1898. reset_bed_level();
  1899. #endif
  1900. #endif
  1901. // For manual bed leveling deactivate the matrix temporarily
  1902. #if ENABLED(MESH_BED_LEVELING)
  1903. uint8_t mbl_was_active = mbl.active;
  1904. mbl.active = 0;
  1905. #endif
  1906. setup_for_endstop_move();
  1907. set_destination_to_current();
  1908. feedrate = 0.0;
  1909. #if ENABLED(DELTA)
  1910. // A delta can only safely home all axis at the same time
  1911. // all axis have to home at the same time
  1912. // Pretend the current position is 0,0,0
  1913. for (int i = X_AXIS; i <= Z_AXIS; i++) current_position[i] = 0;
  1914. sync_plan_position();
  1915. // Move all carriages up together until the first endstop is hit.
  1916. for (int i = X_AXIS; i <= Z_AXIS; i++) destination[i] = 3 * Z_MAX_LENGTH;
  1917. feedrate = 1.732 * homing_feedrate[X_AXIS];
  1918. line_to_destination();
  1919. st_synchronize();
  1920. endstops_hit_on_purpose(); // clear endstop hit flags
  1921. // Destination reached
  1922. for (int i = X_AXIS; i <= Z_AXIS; i++) current_position[i] = destination[i];
  1923. // take care of back off and rehome now we are all at the top
  1924. HOMEAXIS(X);
  1925. HOMEAXIS(Y);
  1926. HOMEAXIS(Z);
  1927. sync_plan_position_delta();
  1928. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1929. if (marlin_debug_flags & DEBUG_LEVELING) {
  1930. print_xyz("(DELTA) > current_position", current_position);
  1931. }
  1932. #endif
  1933. #else // NOT DELTA
  1934. bool homeX = code_seen(axis_codes[X_AXIS]),
  1935. homeY = code_seen(axis_codes[Y_AXIS]),
  1936. homeZ = code_seen(axis_codes[Z_AXIS]);
  1937. home_all_axis = (!homeX && !homeY && !homeZ) || (homeX && homeY && homeZ);
  1938. if (home_all_axis || homeZ) {
  1939. #if Z_HOME_DIR > 0 // If homing away from BED do Z first
  1940. HOMEAXIS(Z);
  1941. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1942. if (marlin_debug_flags & DEBUG_LEVELING) {
  1943. print_xyz("> HOMEAXIS(Z) > current_position", current_position);
  1944. }
  1945. #endif
  1946. #elif DISABLED(Z_SAFE_HOMING) && defined(Z_RAISE_BEFORE_HOMING) && Z_RAISE_BEFORE_HOMING > 0
  1947. // Raise Z before homing any other axes
  1948. // (Does this need to be "negative home direction?" Why not just use Z_RAISE_BEFORE_HOMING?)
  1949. destination[Z_AXIS] = -Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS);
  1950. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1951. if (marlin_debug_flags & DEBUG_LEVELING) {
  1952. SERIAL_ECHOPAIR("Raise Z (before homing) by ", (float)Z_RAISE_BEFORE_HOMING);
  1953. SERIAL_EOL;
  1954. print_xyz("> (home_all_axis || homeZ) > destination", destination);
  1955. }
  1956. #endif
  1957. feedrate = max_feedrate[Z_AXIS] * 60;
  1958. line_to_destination();
  1959. st_synchronize();
  1960. #endif
  1961. } // home_all_axis || homeZ
  1962. #if ENABLED(QUICK_HOME)
  1963. if (home_all_axis || (homeX && homeY)) { // First diagonal move
  1964. current_position[X_AXIS] = current_position[Y_AXIS] = 0;
  1965. #if ENABLED(DUAL_X_CARRIAGE)
  1966. int x_axis_home_dir = x_home_dir(active_extruder);
  1967. extruder_duplication_enabled = false;
  1968. #else
  1969. int x_axis_home_dir = home_dir(X_AXIS);
  1970. #endif
  1971. sync_plan_position();
  1972. float mlx = max_length(X_AXIS), mly = max_length(Y_AXIS),
  1973. mlratio = mlx>mly ? mly/mlx : mlx/mly;
  1974. destination[X_AXIS] = 1.5 * mlx * x_axis_home_dir;
  1975. destination[Y_AXIS] = 1.5 * mly * home_dir(Y_AXIS);
  1976. feedrate = min(homing_feedrate[X_AXIS], homing_feedrate[Y_AXIS]) * sqrt(mlratio * mlratio + 1);
  1977. line_to_destination();
  1978. st_synchronize();
  1979. set_axis_is_at_home(X_AXIS);
  1980. set_axis_is_at_home(Y_AXIS);
  1981. sync_plan_position();
  1982. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1983. if (marlin_debug_flags & DEBUG_LEVELING) {
  1984. print_xyz("> QUICK_HOME > current_position 1", current_position);
  1985. }
  1986. #endif
  1987. destination[X_AXIS] = current_position[X_AXIS];
  1988. destination[Y_AXIS] = current_position[Y_AXIS];
  1989. line_to_destination();
  1990. feedrate = 0.0;
  1991. st_synchronize();
  1992. endstops_hit_on_purpose(); // clear endstop hit flags
  1993. current_position[X_AXIS] = destination[X_AXIS];
  1994. current_position[Y_AXIS] = destination[Y_AXIS];
  1995. #if DISABLED(SCARA)
  1996. current_position[Z_AXIS] = destination[Z_AXIS];
  1997. #endif
  1998. #if ENABLED(DEBUG_LEVELING_FEATURE)
  1999. if (marlin_debug_flags & DEBUG_LEVELING) {
  2000. print_xyz("> QUICK_HOME > current_position 2", current_position);
  2001. }
  2002. #endif
  2003. }
  2004. #endif // QUICK_HOME
  2005. #if ENABLED(HOME_Y_BEFORE_X)
  2006. // Home Y
  2007. if (home_all_axis || homeY) HOMEAXIS(Y);
  2008. #endif
  2009. // Home X
  2010. if (home_all_axis || homeX) {
  2011. #if ENABLED(DUAL_X_CARRIAGE)
  2012. int tmp_extruder = active_extruder;
  2013. extruder_duplication_enabled = false;
  2014. active_extruder = !active_extruder;
  2015. HOMEAXIS(X);
  2016. inactive_extruder_x_pos = current_position[X_AXIS];
  2017. active_extruder = tmp_extruder;
  2018. HOMEAXIS(X);
  2019. // reset state used by the different modes
  2020. memcpy(raised_parked_position, current_position, sizeof(raised_parked_position));
  2021. delayed_move_time = 0;
  2022. active_extruder_parked = true;
  2023. #else
  2024. HOMEAXIS(X);
  2025. #endif
  2026. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2027. if (marlin_debug_flags & DEBUG_LEVELING) {
  2028. print_xyz("> homeX", current_position);
  2029. }
  2030. #endif
  2031. }
  2032. #if DISABLED(HOME_Y_BEFORE_X)
  2033. // Home Y
  2034. if (home_all_axis || homeY) {
  2035. HOMEAXIS(Y);
  2036. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2037. if (marlin_debug_flags & DEBUG_LEVELING) {
  2038. print_xyz("> homeY", current_position);
  2039. }
  2040. #endif
  2041. }
  2042. #endif
  2043. // Home Z last if homing towards the bed
  2044. #if Z_HOME_DIR < 0
  2045. if (home_all_axis || homeZ) {
  2046. #if ENABLED(Z_SAFE_HOMING)
  2047. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2048. if (marlin_debug_flags & DEBUG_LEVELING) {
  2049. SERIAL_ECHOLNPGM("> Z_SAFE_HOMING >>>");
  2050. }
  2051. #endif
  2052. if (home_all_axis) {
  2053. current_position[Z_AXIS] = 0;
  2054. sync_plan_position();
  2055. //
  2056. // Set the Z probe (or just the nozzle) destination to the safe homing point
  2057. //
  2058. // NOTE: If current_position[X_AXIS] or current_position[Y_AXIS] were set above
  2059. // then this may not work as expected.
  2060. destination[X_AXIS] = round(Z_SAFE_HOMING_X_POINT - X_PROBE_OFFSET_FROM_EXTRUDER);
  2061. destination[Y_AXIS] = round(Z_SAFE_HOMING_Y_POINT - Y_PROBE_OFFSET_FROM_EXTRUDER);
  2062. destination[Z_AXIS] = -Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS); // Set destination away from bed
  2063. feedrate = XY_TRAVEL_SPEED;
  2064. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2065. if (marlin_debug_flags & DEBUG_LEVELING) {
  2066. SERIAL_ECHOPAIR("Raise Z (before homing) by ", (float)Z_RAISE_BEFORE_HOMING);
  2067. SERIAL_EOL;
  2068. print_xyz("> home_all_axis > current_position", current_position);
  2069. print_xyz("> home_all_axis > destination", destination);
  2070. }
  2071. #endif
  2072. // This could potentially move X, Y, Z all together
  2073. line_to_destination();
  2074. st_synchronize();
  2075. // Set current X, Y is the Z_SAFE_HOMING_POINT minus PROBE_OFFSET_FROM_EXTRUDER
  2076. current_position[X_AXIS] = destination[X_AXIS];
  2077. current_position[Y_AXIS] = destination[Y_AXIS];
  2078. // Home the Z axis
  2079. HOMEAXIS(Z);
  2080. }
  2081. else if (homeZ) { // Don't need to Home Z twice
  2082. // Let's see if X and Y are homed
  2083. if (axis_known_position[X_AXIS] && axis_known_position[Y_AXIS]) {
  2084. // Make sure the Z probe is within the physical limits
  2085. // NOTE: This doesn't necessarily ensure the Z probe is also within the bed!
  2086. float cpx = current_position[X_AXIS], cpy = current_position[Y_AXIS];
  2087. if ( cpx >= X_MIN_POS - X_PROBE_OFFSET_FROM_EXTRUDER
  2088. && cpx <= X_MAX_POS - X_PROBE_OFFSET_FROM_EXTRUDER
  2089. && cpy >= Y_MIN_POS - Y_PROBE_OFFSET_FROM_EXTRUDER
  2090. && cpy <= Y_MAX_POS - Y_PROBE_OFFSET_FROM_EXTRUDER) {
  2091. // Set the plan current position to X, Y, 0
  2092. current_position[Z_AXIS] = 0;
  2093. plan_set_position(cpx, cpy, 0, current_position[E_AXIS]); // = sync_plan_position
  2094. // Set Z destination away from bed and raise the axis
  2095. // NOTE: This should always just be Z_RAISE_BEFORE_HOMING unless...???
  2096. destination[Z_AXIS] = -Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS);
  2097. feedrate = max_feedrate[Z_AXIS] * 60; // feedrate (mm/m) = max_feedrate (mm/s)
  2098. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2099. if (marlin_debug_flags & DEBUG_LEVELING) {
  2100. SERIAL_ECHOPAIR("Raise Z (before homing) by ", (float)Z_RAISE_BEFORE_HOMING);
  2101. SERIAL_EOL;
  2102. print_xyz("> homeZ > current_position", current_position);
  2103. print_xyz("> homeZ > destination", destination);
  2104. }
  2105. #endif
  2106. line_to_destination();
  2107. st_synchronize();
  2108. // Home the Z axis
  2109. HOMEAXIS(Z);
  2110. }
  2111. else {
  2112. LCD_MESSAGEPGM(MSG_ZPROBE_OUT);
  2113. SERIAL_ECHO_START;
  2114. SERIAL_ECHOLNPGM(MSG_ZPROBE_OUT);
  2115. }
  2116. }
  2117. else {
  2118. LCD_MESSAGEPGM(MSG_POSITION_UNKNOWN);
  2119. SERIAL_ECHO_START;
  2120. SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN);
  2121. }
  2122. } // !home_all_axes && homeZ
  2123. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2124. if (marlin_debug_flags & DEBUG_LEVELING) {
  2125. SERIAL_ECHOLNPGM("<<< Z_SAFE_HOMING");
  2126. }
  2127. #endif
  2128. #else // !Z_SAFE_HOMING
  2129. HOMEAXIS(Z);
  2130. #endif // !Z_SAFE_HOMING
  2131. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2132. if (marlin_debug_flags & DEBUG_LEVELING) {
  2133. print_xyz("> (home_all_axis || homeZ) > final", current_position);
  2134. }
  2135. #endif
  2136. } // home_all_axis || homeZ
  2137. #endif // Z_HOME_DIR < 0
  2138. sync_plan_position();
  2139. #endif // else DELTA
  2140. #if ENABLED(SCARA)
  2141. sync_plan_position_delta();
  2142. #endif
  2143. #if ENABLED(ENDSTOPS_ONLY_FOR_HOMING)
  2144. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2145. if (marlin_debug_flags & DEBUG_LEVELING) {
  2146. SERIAL_ECHOLNPGM("ENDSTOPS_ONLY_FOR_HOMING enable_endstops(false)");
  2147. }
  2148. #endif
  2149. enable_endstops(false);
  2150. #endif
  2151. // For manual leveling move back to 0,0
  2152. #if ENABLED(MESH_BED_LEVELING)
  2153. if (mbl_was_active) {
  2154. current_position[X_AXIS] = mbl.get_x(0);
  2155. current_position[Y_AXIS] = mbl.get_y(0);
  2156. set_destination_to_current();
  2157. feedrate = homing_feedrate[X_AXIS];
  2158. line_to_destination();
  2159. st_synchronize();
  2160. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  2161. sync_plan_position();
  2162. mbl.active = 1;
  2163. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2164. if (marlin_debug_flags & DEBUG_LEVELING) {
  2165. print_xyz("mbl_was_active > current_position", current_position);
  2166. }
  2167. #endif
  2168. }
  2169. #endif
  2170. feedrate = saved_feedrate;
  2171. feedrate_multiplier = saved_feedrate_multiplier;
  2172. refresh_cmd_timeout();
  2173. endstops_hit_on_purpose(); // clear endstop hit flags
  2174. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2175. if (marlin_debug_flags & DEBUG_LEVELING) {
  2176. SERIAL_ECHOLNPGM("<<< gcode_G28");
  2177. }
  2178. #endif
  2179. }
  2180. #if ENABLED(MESH_BED_LEVELING)
  2181. enum MeshLevelingState { MeshReport, MeshStart, MeshNext, MeshSet };
  2182. /**
  2183. * G29: Mesh-based Z probe, probes a grid and produces a
  2184. * mesh to compensate for variable bed height
  2185. *
  2186. * Parameters With MESH_BED_LEVELING:
  2187. *
  2188. * S0 Produce a mesh report
  2189. * S1 Start probing mesh points
  2190. * S2 Probe the next mesh point
  2191. * S3 Xn Yn Zn.nn Manually modify a single point
  2192. *
  2193. * The S0 report the points as below
  2194. *
  2195. * +----> X-axis
  2196. * |
  2197. * |
  2198. * v Y-axis
  2199. *
  2200. */
  2201. inline void gcode_G29() {
  2202. static int probe_point = -1;
  2203. MeshLevelingState state = code_seen('S') ? (MeshLevelingState)code_value_short() : MeshReport;
  2204. if (state < 0 || state > 3) {
  2205. SERIAL_PROTOCOLLNPGM("S out of range (0-3).");
  2206. return;
  2207. }
  2208. int ix, iy;
  2209. float z;
  2210. switch(state) {
  2211. case MeshReport:
  2212. if (mbl.active) {
  2213. SERIAL_PROTOCOLPGM("Num X,Y: ");
  2214. SERIAL_PROTOCOL(MESH_NUM_X_POINTS);
  2215. SERIAL_PROTOCOLCHAR(',');
  2216. SERIAL_PROTOCOL(MESH_NUM_Y_POINTS);
  2217. SERIAL_PROTOCOLPGM("\nZ search height: ");
  2218. SERIAL_PROTOCOL(MESH_HOME_SEARCH_Z);
  2219. SERIAL_PROTOCOLLNPGM("\nMeasured points:");
  2220. for (int y = 0; y < MESH_NUM_Y_POINTS; y++) {
  2221. for (int x = 0; x < MESH_NUM_X_POINTS; x++) {
  2222. SERIAL_PROTOCOLPGM(" ");
  2223. SERIAL_PROTOCOL_F(mbl.z_values[y][x], 5);
  2224. }
  2225. SERIAL_EOL;
  2226. }
  2227. }
  2228. else
  2229. SERIAL_PROTOCOLLNPGM("Mesh bed leveling not active.");
  2230. break;
  2231. case MeshStart:
  2232. mbl.reset();
  2233. probe_point = 0;
  2234. enqueuecommands_P(PSTR("G28\nG29 S2"));
  2235. break;
  2236. case MeshNext:
  2237. if (probe_point < 0) {
  2238. SERIAL_PROTOCOLLNPGM("Start mesh probing with \"G29 S1\" first.");
  2239. return;
  2240. }
  2241. if (probe_point == 0) {
  2242. // Set Z to a positive value before recording the first Z.
  2243. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  2244. sync_plan_position();
  2245. }
  2246. else {
  2247. // For others, save the Z of the previous point, then raise Z again.
  2248. ix = (probe_point - 1) % MESH_NUM_X_POINTS;
  2249. iy = (probe_point - 1) / MESH_NUM_X_POINTS;
  2250. if (iy & 1) ix = (MESH_NUM_X_POINTS - 1) - ix; // zig-zag
  2251. mbl.set_z(ix, iy, current_position[Z_AXIS]);
  2252. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  2253. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[X_AXIS]/60, active_extruder);
  2254. st_synchronize();
  2255. }
  2256. // Is there another point to sample? Move there.
  2257. if (probe_point < MESH_NUM_X_POINTS * MESH_NUM_Y_POINTS) {
  2258. ix = probe_point % MESH_NUM_X_POINTS;
  2259. iy = probe_point / MESH_NUM_X_POINTS;
  2260. if (iy & 1) ix = (MESH_NUM_X_POINTS - 1) - ix; // zig-zag
  2261. current_position[X_AXIS] = mbl.get_x(ix);
  2262. current_position[Y_AXIS] = mbl.get_y(iy);
  2263. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[X_AXIS]/60, active_extruder);
  2264. st_synchronize();
  2265. probe_point++;
  2266. }
  2267. else {
  2268. // After recording the last point, activate the mbl and home
  2269. SERIAL_PROTOCOLLNPGM("Mesh probing done.");
  2270. probe_point = -1;
  2271. mbl.active = 1;
  2272. enqueuecommands_P(PSTR("G28"));
  2273. }
  2274. break;
  2275. case MeshSet:
  2276. if (code_seen('X')) {
  2277. ix = code_value_long()-1;
  2278. if (ix < 0 || ix >= MESH_NUM_X_POINTS) {
  2279. SERIAL_PROTOCOLPGM("X out of range (1-" STRINGIFY(MESH_NUM_X_POINTS) ").\n");
  2280. return;
  2281. }
  2282. } else {
  2283. SERIAL_PROTOCOLPGM("X not entered.\n");
  2284. return;
  2285. }
  2286. if (code_seen('Y')) {
  2287. iy = code_value_long()-1;
  2288. if (iy < 0 || iy >= MESH_NUM_Y_POINTS) {
  2289. SERIAL_PROTOCOLPGM("Y out of range (1-" STRINGIFY(MESH_NUM_Y_POINTS) ").\n");
  2290. return;
  2291. }
  2292. } else {
  2293. SERIAL_PROTOCOLPGM("Y not entered.\n");
  2294. return;
  2295. }
  2296. if (code_seen('Z')) {
  2297. z = code_value();
  2298. } else {
  2299. SERIAL_PROTOCOLPGM("Z not entered.\n");
  2300. return;
  2301. }
  2302. mbl.z_values[iy][ix] = z;
  2303. } // switch(state)
  2304. }
  2305. #elif ENABLED(AUTO_BED_LEVELING_FEATURE)
  2306. void out_of_range_error(const char *p_edge) {
  2307. SERIAL_PROTOCOLPGM("?Probe ");
  2308. serialprintPGM(p_edge);
  2309. SERIAL_PROTOCOLLNPGM(" position out of range.");
  2310. }
  2311. /**
  2312. * G29: Detailed Z probe, probes the bed at 3 or more points.
  2313. * Will fail if the printer has not been homed with G28.
  2314. *
  2315. * Enhanced G29 Auto Bed Leveling Probe Routine
  2316. *
  2317. * Parameters With AUTO_BED_LEVELING_GRID:
  2318. *
  2319. * P Set the size of the grid that will be probed (P x P points).
  2320. * Not supported by non-linear delta printer bed leveling.
  2321. * Example: "G29 P4"
  2322. *
  2323. * S Set the XY travel speed between probe points (in mm/min)
  2324. *
  2325. * D Dry-Run mode. Just evaluate the bed Topology - Don't apply
  2326. * or clean the rotation Matrix. Useful to check the topology
  2327. * after a first run of G29.
  2328. *
  2329. * V Set the verbose level (0-4). Example: "G29 V3"
  2330. *
  2331. * T Generate a Bed Topology Report. Example: "G29 P5 T" for a detailed report.
  2332. * This is useful for manual bed leveling and finding flaws in the bed (to
  2333. * assist with part placement).
  2334. * Not supported by non-linear delta printer bed leveling.
  2335. *
  2336. * F Set the Front limit of the probing grid
  2337. * B Set the Back limit of the probing grid
  2338. * L Set the Left limit of the probing grid
  2339. * R Set the Right limit of the probing grid
  2340. *
  2341. * Global Parameters:
  2342. *
  2343. * E/e By default G29 will engage the Z probe, test the bed, then disengage.
  2344. * Include "E" to engage/disengage the Z probe for each sample.
  2345. * There's no extra effect if you have a fixed Z probe.
  2346. * Usage: "G29 E" or "G29 e"
  2347. *
  2348. */
  2349. inline void gcode_G29() {
  2350. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2351. if (marlin_debug_flags & DEBUG_LEVELING) {
  2352. SERIAL_ECHOLNPGM("gcode_G29 >>>");
  2353. }
  2354. #endif
  2355. // Don't allow auto-leveling without homing first
  2356. if (!axis_known_position[X_AXIS] || !axis_known_position[Y_AXIS]) {
  2357. LCD_MESSAGEPGM(MSG_POSITION_UNKNOWN);
  2358. SERIAL_ECHO_START;
  2359. SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN);
  2360. return;
  2361. }
  2362. int verbose_level = code_seen('V') ? code_value_short() : 1;
  2363. if (verbose_level < 0 || verbose_level > 4) {
  2364. SERIAL_ECHOLNPGM("?(V)erbose Level is implausible (0-4).");
  2365. return;
  2366. }
  2367. bool dryrun = code_seen('D'),
  2368. deploy_probe_for_each_reading = code_seen('E');
  2369. #if ENABLED(AUTO_BED_LEVELING_GRID)
  2370. #if DISABLED(DELTA)
  2371. bool do_topography_map = verbose_level > 2 || code_seen('T');
  2372. #endif
  2373. if (verbose_level > 0) {
  2374. SERIAL_PROTOCOLPGM("G29 Auto Bed Leveling\n");
  2375. if (dryrun) SERIAL_ECHOLNPGM("Running in DRY-RUN mode");
  2376. }
  2377. int auto_bed_leveling_grid_points = AUTO_BED_LEVELING_GRID_POINTS;
  2378. #if DISABLED(DELTA)
  2379. if (code_seen('P')) auto_bed_leveling_grid_points = code_value_short();
  2380. if (auto_bed_leveling_grid_points < 2) {
  2381. SERIAL_PROTOCOLPGM("?Number of probed (P)oints is implausible (2 minimum).\n");
  2382. return;
  2383. }
  2384. #endif
  2385. xy_travel_speed = code_seen('S') ? code_value_short() : XY_TRAVEL_SPEED;
  2386. int left_probe_bed_position = code_seen('L') ? code_value_short() : LEFT_PROBE_BED_POSITION,
  2387. right_probe_bed_position = code_seen('R') ? code_value_short() : RIGHT_PROBE_BED_POSITION,
  2388. front_probe_bed_position = code_seen('F') ? code_value_short() : FRONT_PROBE_BED_POSITION,
  2389. back_probe_bed_position = code_seen('B') ? code_value_short() : BACK_PROBE_BED_POSITION;
  2390. bool left_out_l = left_probe_bed_position < MIN_PROBE_X,
  2391. left_out = left_out_l || left_probe_bed_position > right_probe_bed_position - MIN_PROBE_EDGE,
  2392. right_out_r = right_probe_bed_position > MAX_PROBE_X,
  2393. right_out = right_out_r || right_probe_bed_position < left_probe_bed_position + MIN_PROBE_EDGE,
  2394. front_out_f = front_probe_bed_position < MIN_PROBE_Y,
  2395. front_out = front_out_f || front_probe_bed_position > back_probe_bed_position - MIN_PROBE_EDGE,
  2396. back_out_b = back_probe_bed_position > MAX_PROBE_Y,
  2397. back_out = back_out_b || back_probe_bed_position < front_probe_bed_position + MIN_PROBE_EDGE;
  2398. if (left_out || right_out || front_out || back_out) {
  2399. if (left_out) {
  2400. out_of_range_error(PSTR("(L)eft"));
  2401. left_probe_bed_position = left_out_l ? MIN_PROBE_X : right_probe_bed_position - MIN_PROBE_EDGE;
  2402. }
  2403. if (right_out) {
  2404. out_of_range_error(PSTR("(R)ight"));
  2405. right_probe_bed_position = right_out_r ? MAX_PROBE_X : left_probe_bed_position + MIN_PROBE_EDGE;
  2406. }
  2407. if (front_out) {
  2408. out_of_range_error(PSTR("(F)ront"));
  2409. front_probe_bed_position = front_out_f ? MIN_PROBE_Y : back_probe_bed_position - MIN_PROBE_EDGE;
  2410. }
  2411. if (back_out) {
  2412. out_of_range_error(PSTR("(B)ack"));
  2413. back_probe_bed_position = back_out_b ? MAX_PROBE_Y : front_probe_bed_position + MIN_PROBE_EDGE;
  2414. }
  2415. return;
  2416. }
  2417. #endif // AUTO_BED_LEVELING_GRID
  2418. #if ENABLED(Z_PROBE_SLED)
  2419. dock_sled(false); // engage (un-dock) the Z probe
  2420. #elif ENABLED(Z_PROBE_ALLEN_KEY) //|| SERVO_LEVELING
  2421. deploy_z_probe();
  2422. #endif
  2423. st_synchronize();
  2424. if (!dryrun) {
  2425. // make sure the bed_level_rotation_matrix is identity or the planner will get it wrong
  2426. plan_bed_level_matrix.set_to_identity();
  2427. #if ENABLED(DELTA)
  2428. reset_bed_level();
  2429. #else //!DELTA
  2430. //vector_3 corrected_position = plan_get_position_mm();
  2431. //corrected_position.debug("position before G29");
  2432. vector_3 uncorrected_position = plan_get_position();
  2433. //uncorrected_position.debug("position during G29");
  2434. current_position[X_AXIS] = uncorrected_position.x;
  2435. current_position[Y_AXIS] = uncorrected_position.y;
  2436. current_position[Z_AXIS] = uncorrected_position.z;
  2437. sync_plan_position();
  2438. #endif // !DELTA
  2439. }
  2440. setup_for_endstop_move();
  2441. feedrate = homing_feedrate[Z_AXIS];
  2442. #if ENABLED(AUTO_BED_LEVELING_GRID)
  2443. // probe at the points of a lattice grid
  2444. const int xGridSpacing = (right_probe_bed_position - left_probe_bed_position) / (auto_bed_leveling_grid_points - 1),
  2445. yGridSpacing = (back_probe_bed_position - front_probe_bed_position) / (auto_bed_leveling_grid_points - 1);
  2446. #if ENABLED(DELTA)
  2447. delta_grid_spacing[0] = xGridSpacing;
  2448. delta_grid_spacing[1] = yGridSpacing;
  2449. float z_offset = zprobe_zoffset;
  2450. if (code_seen(axis_codes[Z_AXIS])) z_offset += code_value();
  2451. #else // !DELTA
  2452. // solve the plane equation ax + by + d = z
  2453. // A is the matrix with rows [x y 1] for all the probed points
  2454. // B is the vector of the Z positions
  2455. // the normal vector to the plane is formed by the coefficients of the plane equation in the standard form, which is Vx*x+Vy*y+Vz*z+d = 0
  2456. // so Vx = -a Vy = -b Vz = 1 (we want the vector facing towards positive Z
  2457. int abl2 = auto_bed_leveling_grid_points * auto_bed_leveling_grid_points;
  2458. double eqnAMatrix[abl2 * 3], // "A" matrix of the linear system of equations
  2459. eqnBVector[abl2], // "B" vector of Z points
  2460. mean = 0.0;
  2461. int8_t indexIntoAB[auto_bed_leveling_grid_points][auto_bed_leveling_grid_points];
  2462. #endif // !DELTA
  2463. int probePointCounter = 0;
  2464. bool zig = (auto_bed_leveling_grid_points & 1) ? true : false; //always end at [RIGHT_PROBE_BED_POSITION, BACK_PROBE_BED_POSITION]
  2465. for (int yCount = 0; yCount < auto_bed_leveling_grid_points; yCount++) {
  2466. double yProbe = front_probe_bed_position + yGridSpacing * yCount;
  2467. int xStart, xStop, xInc;
  2468. if (zig) {
  2469. xStart = 0;
  2470. xStop = auto_bed_leveling_grid_points;
  2471. xInc = 1;
  2472. }
  2473. else {
  2474. xStart = auto_bed_leveling_grid_points - 1;
  2475. xStop = -1;
  2476. xInc = -1;
  2477. }
  2478. zig = !zig;
  2479. for (int xCount = xStart; xCount != xStop; xCount += xInc) {
  2480. double xProbe = left_probe_bed_position + xGridSpacing * xCount;
  2481. // raise extruder
  2482. float measured_z,
  2483. z_before = probePointCounter ? Z_RAISE_BETWEEN_PROBINGS + current_position[Z_AXIS] : Z_RAISE_BEFORE_PROBING;
  2484. if (probePointCounter) {
  2485. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2486. if (marlin_debug_flags & DEBUG_LEVELING) {
  2487. SERIAL_ECHOPAIR("z_before = (between) ", (float)(Z_RAISE_BETWEEN_PROBINGS + current_position[Z_AXIS]));
  2488. SERIAL_EOL;
  2489. }
  2490. #endif
  2491. }
  2492. else {
  2493. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2494. if (marlin_debug_flags & DEBUG_LEVELING) {
  2495. SERIAL_ECHOPAIR("z_before = (before) ", (float)Z_RAISE_BEFORE_PROBING);
  2496. SERIAL_EOL;
  2497. }
  2498. #endif
  2499. }
  2500. #if ENABLED(DELTA)
  2501. // Avoid probing the corners (outside the round or hexagon print surface) on a delta printer.
  2502. float distance_from_center = sqrt(xProbe*xProbe + yProbe*yProbe);
  2503. if (distance_from_center > DELTA_PROBABLE_RADIUS) continue;
  2504. #endif //DELTA
  2505. ProbeAction act;
  2506. if (deploy_probe_for_each_reading) // G29 E - Stow between probes
  2507. act = ProbeDeployAndStow;
  2508. else if (yCount == 0 && xCount == xStart)
  2509. act = ProbeDeploy;
  2510. else if (yCount == auto_bed_leveling_grid_points - 1 && xCount == xStop - xInc)
  2511. act = ProbeStow;
  2512. else
  2513. act = ProbeStay;
  2514. measured_z = probe_pt(xProbe, yProbe, z_before, act, verbose_level);
  2515. #if DISABLED(DELTA)
  2516. mean += measured_z;
  2517. eqnBVector[probePointCounter] = measured_z;
  2518. eqnAMatrix[probePointCounter + 0 * abl2] = xProbe;
  2519. eqnAMatrix[probePointCounter + 1 * abl2] = yProbe;
  2520. eqnAMatrix[probePointCounter + 2 * abl2] = 1;
  2521. indexIntoAB[xCount][yCount] = probePointCounter;
  2522. #else
  2523. bed_level[xCount][yCount] = measured_z + z_offset;
  2524. #endif
  2525. probePointCounter++;
  2526. idle();
  2527. } //xProbe
  2528. } //yProbe
  2529. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2530. if (marlin_debug_flags & DEBUG_LEVELING) {
  2531. print_xyz("> probing complete > current_position", current_position);
  2532. }
  2533. #endif
  2534. clean_up_after_endstop_move();
  2535. #if ENABLED(DELTA)
  2536. if (!dryrun) extrapolate_unprobed_bed_level();
  2537. print_bed_level();
  2538. #else // !DELTA
  2539. // solve lsq problem
  2540. double plane_equation_coefficients[3];
  2541. qr_solve(plane_equation_coefficients, abl2, 3, eqnAMatrix, eqnBVector);
  2542. mean /= abl2;
  2543. if (verbose_level) {
  2544. SERIAL_PROTOCOLPGM("Eqn coefficients: a: ");
  2545. SERIAL_PROTOCOL_F(plane_equation_coefficients[0], 8);
  2546. SERIAL_PROTOCOLPGM(" b: ");
  2547. SERIAL_PROTOCOL_F(plane_equation_coefficients[1], 8);
  2548. SERIAL_PROTOCOLPGM(" d: ");
  2549. SERIAL_PROTOCOL_F(plane_equation_coefficients[2], 8);
  2550. SERIAL_EOL;
  2551. if (verbose_level > 2) {
  2552. SERIAL_PROTOCOLPGM("Mean of sampled points: ");
  2553. SERIAL_PROTOCOL_F(mean, 8);
  2554. SERIAL_EOL;
  2555. }
  2556. }
  2557. if (!dryrun) set_bed_level_equation_lsq(plane_equation_coefficients);
  2558. // Show the Topography map if enabled
  2559. if (do_topography_map) {
  2560. SERIAL_PROTOCOLPGM(" \nBed Height Topography: \n");
  2561. SERIAL_PROTOCOLPGM("+-----------+\n");
  2562. SERIAL_PROTOCOLPGM("|...Back....|\n");
  2563. SERIAL_PROTOCOLPGM("|Left..Right|\n");
  2564. SERIAL_PROTOCOLPGM("|...Front...|\n");
  2565. SERIAL_PROTOCOLPGM("+-----------+\n");
  2566. float min_diff = 999;
  2567. for (int yy = auto_bed_leveling_grid_points - 1; yy >= 0; yy--) {
  2568. for (int xx = 0; xx < auto_bed_leveling_grid_points; xx++) {
  2569. int ind = indexIntoAB[xx][yy];
  2570. float diff = eqnBVector[ind] - mean;
  2571. float x_tmp = eqnAMatrix[ind + 0 * abl2],
  2572. y_tmp = eqnAMatrix[ind + 1 * abl2],
  2573. z_tmp = 0;
  2574. apply_rotation_xyz(plan_bed_level_matrix,x_tmp,y_tmp,z_tmp);
  2575. if (eqnBVector[ind] - z_tmp < min_diff)
  2576. min_diff = eqnBVector[ind] - z_tmp;
  2577. if (diff >= 0.0)
  2578. SERIAL_PROTOCOLPGM(" +"); // Include + for column alignment
  2579. else
  2580. SERIAL_PROTOCOLCHAR(' ');
  2581. SERIAL_PROTOCOL_F(diff, 5);
  2582. } // xx
  2583. SERIAL_EOL;
  2584. } // yy
  2585. SERIAL_EOL;
  2586. if (verbose_level > 3) {
  2587. SERIAL_PROTOCOLPGM(" \nCorrected Bed Height vs. Bed Topology: \n");
  2588. for (int yy = auto_bed_leveling_grid_points - 1; yy >= 0; yy--) {
  2589. for (int xx = 0; xx < auto_bed_leveling_grid_points; xx++) {
  2590. int ind = indexIntoAB[xx][yy];
  2591. float x_tmp = eqnAMatrix[ind + 0 * abl2],
  2592. y_tmp = eqnAMatrix[ind + 1 * abl2],
  2593. z_tmp = 0;
  2594. apply_rotation_xyz(plan_bed_level_matrix,x_tmp,y_tmp,z_tmp);
  2595. float diff = eqnBVector[ind] - z_tmp - min_diff;
  2596. if (diff >= 0.0)
  2597. SERIAL_PROTOCOLPGM(" +");
  2598. // Include + for column alignment
  2599. else
  2600. SERIAL_PROTOCOLCHAR(' ');
  2601. SERIAL_PROTOCOL_F(diff, 5);
  2602. } // xx
  2603. SERIAL_EOL;
  2604. } // yy
  2605. SERIAL_EOL;
  2606. }
  2607. } //do_topography_map
  2608. #endif //!DELTA
  2609. #else // !AUTO_BED_LEVELING_GRID
  2610. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2611. if (marlin_debug_flags & DEBUG_LEVELING) {
  2612. SERIAL_ECHOLNPGM("> 3-point Leveling");
  2613. }
  2614. #endif
  2615. // Actions for each probe
  2616. ProbeAction p1, p2, p3;
  2617. if (deploy_probe_for_each_reading)
  2618. p1 = p2 = p3 = ProbeDeployAndStow;
  2619. else
  2620. p1 = ProbeDeploy, p2 = ProbeStay, p3 = ProbeStow;
  2621. // Probe at 3 arbitrary points
  2622. float z_at_pt_1 = probe_pt(ABL_PROBE_PT_1_X, ABL_PROBE_PT_1_Y, Z_RAISE_BEFORE_PROBING, p1, verbose_level),
  2623. z_at_pt_2 = probe_pt(ABL_PROBE_PT_2_X, ABL_PROBE_PT_2_Y, current_position[Z_AXIS] + Z_RAISE_BETWEEN_PROBINGS, p2, verbose_level),
  2624. z_at_pt_3 = probe_pt(ABL_PROBE_PT_3_X, ABL_PROBE_PT_3_Y, current_position[Z_AXIS] + Z_RAISE_BETWEEN_PROBINGS, p3, verbose_level);
  2625. clean_up_after_endstop_move();
  2626. if (!dryrun) set_bed_level_equation_3pts(z_at_pt_1, z_at_pt_2, z_at_pt_3);
  2627. #endif // !AUTO_BED_LEVELING_GRID
  2628. #if DISABLED(DELTA)
  2629. if (verbose_level > 0)
  2630. plan_bed_level_matrix.debug(" \n\nBed Level Correction Matrix:");
  2631. if (!dryrun) {
  2632. // Correct the Z height difference from Z probe position and nozzle tip position.
  2633. // The Z height on homing is measured by Z probe, but the Z probe is quite far from the nozzle.
  2634. // When the bed is uneven, this height must be corrected.
  2635. float x_tmp = current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER,
  2636. y_tmp = current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER,
  2637. z_tmp = current_position[Z_AXIS],
  2638. real_z = st_get_position_mm(Z_AXIS); //get the real Z (since plan_get_position is now correcting the plane)
  2639. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2640. if (marlin_debug_flags & DEBUG_LEVELING) {
  2641. SERIAL_ECHOPAIR("> BEFORE apply_rotation_xyz > z_tmp = ", z_tmp);
  2642. SERIAL_EOL;
  2643. SERIAL_ECHOPAIR("> BEFORE apply_rotation_xyz > real_z = ", real_z);
  2644. SERIAL_EOL;
  2645. }
  2646. #endif
  2647. apply_rotation_xyz(plan_bed_level_matrix, x_tmp, y_tmp, z_tmp); // Apply the correction sending the Z probe offset
  2648. // Get the current Z position and send it to the planner.
  2649. //
  2650. // >> (z_tmp - real_z) : The rotated current Z minus the uncorrected Z (most recent plan_set_position/sync_plan_position)
  2651. //
  2652. // >> zprobe_zoffset : Z distance from nozzle to Z probe (set by default, M851, EEPROM, or Menu)
  2653. //
  2654. // >> Z_RAISE_AFTER_PROBING : The distance the Z probe will have lifted after the last probe
  2655. //
  2656. // >> Should home_offset[Z_AXIS] be included?
  2657. //
  2658. // Discussion: home_offset[Z_AXIS] was applied in G28 to set the starting Z.
  2659. // If Z is not tweaked in G29 -and- the Z probe in G29 is not actually "homing" Z...
  2660. // then perhaps it should not be included here. The purpose of home_offset[] is to
  2661. // adjust for inaccurate endstops, not for reasonably accurate probes. If it were
  2662. // added here, it could be seen as a compensating factor for the Z probe.
  2663. //
  2664. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2665. if (marlin_debug_flags & DEBUG_LEVELING) {
  2666. SERIAL_ECHOPAIR("> AFTER apply_rotation_xyz > z_tmp = ", z_tmp);
  2667. SERIAL_EOL;
  2668. }
  2669. #endif
  2670. current_position[Z_AXIS] = -zprobe_zoffset + (z_tmp - real_z)
  2671. #if HAS_SERVO_ENDSTOPS || ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED)
  2672. + Z_RAISE_AFTER_PROBING
  2673. #endif
  2674. ;
  2675. // current_position[Z_AXIS] += home_offset[Z_AXIS]; // The Z probe determines Z=0, not "Z home"
  2676. sync_plan_position();
  2677. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2678. if (marlin_debug_flags & DEBUG_LEVELING) {
  2679. print_xyz("> corrected Z in G29", current_position);
  2680. }
  2681. #endif
  2682. }
  2683. #endif // !DELTA
  2684. #if ENABLED(Z_PROBE_SLED)
  2685. dock_sled(true); // dock the Z probe
  2686. #elif ENABLED(Z_PROBE_ALLEN_KEY) //|| SERVO_LEVELING
  2687. stow_z_probe();
  2688. #endif
  2689. #ifdef Z_PROBE_END_SCRIPT
  2690. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2691. if (marlin_debug_flags & DEBUG_LEVELING) {
  2692. SERIAL_ECHO("Z Probe End Script: ");
  2693. SERIAL_ECHOLNPGM(Z_PROBE_END_SCRIPT);
  2694. }
  2695. #endif
  2696. enqueuecommands_P(PSTR(Z_PROBE_END_SCRIPT));
  2697. st_synchronize();
  2698. #endif
  2699. #if ENABLED(DEBUG_LEVELING_FEATURE)
  2700. if (marlin_debug_flags & DEBUG_LEVELING) {
  2701. SERIAL_ECHOLNPGM("<<< gcode_G29");
  2702. }
  2703. #endif
  2704. }
  2705. #if DISABLED(Z_PROBE_SLED)
  2706. /**
  2707. * G30: Do a single Z probe at the current XY
  2708. */
  2709. inline void gcode_G30() {
  2710. #if HAS_SERVO_ENDSTOPS
  2711. raise_z_for_servo();
  2712. #endif
  2713. deploy_z_probe(); // Engage Z Servo endstop if available
  2714. st_synchronize();
  2715. // TODO: clear the leveling matrix or the planner will be set incorrectly
  2716. setup_for_endstop_move();
  2717. feedrate = homing_feedrate[Z_AXIS];
  2718. run_z_probe();
  2719. SERIAL_PROTOCOLPGM("Bed X: ");
  2720. SERIAL_PROTOCOL(current_position[X_AXIS] + 0.0001);
  2721. SERIAL_PROTOCOLPGM(" Y: ");
  2722. SERIAL_PROTOCOL(current_position[Y_AXIS] + 0.0001);
  2723. SERIAL_PROTOCOLPGM(" Z: ");
  2724. SERIAL_PROTOCOL(current_position[Z_AXIS] + 0.0001);
  2725. SERIAL_EOL;
  2726. clean_up_after_endstop_move();
  2727. #if HAS_SERVO_ENDSTOPS
  2728. raise_z_for_servo();
  2729. #endif
  2730. stow_z_probe(false); // Retract Z Servo endstop if available
  2731. }
  2732. #endif //!Z_PROBE_SLED
  2733. #endif //AUTO_BED_LEVELING_FEATURE
  2734. /**
  2735. * G92: Set current position to given X Y Z E
  2736. */
  2737. inline void gcode_G92() {
  2738. if (!code_seen(axis_codes[E_AXIS]))
  2739. st_synchronize();
  2740. bool didXYZ = false;
  2741. for (int i = 0; i < NUM_AXIS; i++) {
  2742. if (code_seen(axis_codes[i])) {
  2743. float v = current_position[i] = code_value();
  2744. if (i == E_AXIS)
  2745. plan_set_e_position(v);
  2746. else
  2747. didXYZ = true;
  2748. }
  2749. }
  2750. if (didXYZ) {
  2751. #if ENABLED(DELTA) || ENABLED(SCARA)
  2752. sync_plan_position_delta();
  2753. #else
  2754. sync_plan_position();
  2755. #endif
  2756. }
  2757. }
  2758. #if ENABLED(ULTIPANEL)
  2759. /**
  2760. * M0: // M0 - Unconditional stop - Wait for user button press on LCD
  2761. * M1: // M1 - Conditional stop - Wait for user button press on LCD
  2762. */
  2763. inline void gcode_M0_M1() {
  2764. char *args = current_command_args;
  2765. millis_t codenum = 0;
  2766. bool hasP = false, hasS = false;
  2767. if (code_seen('P')) {
  2768. codenum = code_value_short(); // milliseconds to wait
  2769. hasP = codenum > 0;
  2770. }
  2771. if (code_seen('S')) {
  2772. codenum = code_value() * 1000; // seconds to wait
  2773. hasS = codenum > 0;
  2774. }
  2775. if (!hasP && !hasS && *args != '\0')
  2776. lcd_setstatus(args, true);
  2777. else {
  2778. LCD_MESSAGEPGM(MSG_USERWAIT);
  2779. #if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
  2780. dontExpireStatus();
  2781. #endif
  2782. }
  2783. lcd_ignore_click();
  2784. st_synchronize();
  2785. refresh_cmd_timeout();
  2786. if (codenum > 0) {
  2787. codenum += previous_cmd_ms; // wait until this time for a click
  2788. while (millis() < codenum && !lcd_clicked()) idle();
  2789. lcd_ignore_click(false);
  2790. }
  2791. else {
  2792. if (!lcd_detected()) return;
  2793. while (!lcd_clicked()) idle();
  2794. }
  2795. if (IS_SD_PRINTING)
  2796. LCD_MESSAGEPGM(MSG_RESUMING);
  2797. else
  2798. LCD_MESSAGEPGM(WELCOME_MSG);
  2799. }
  2800. #endif // ULTIPANEL
  2801. /**
  2802. * M17: Enable power on all stepper motors
  2803. */
  2804. inline void gcode_M17() {
  2805. LCD_MESSAGEPGM(MSG_NO_MOVE);
  2806. enable_all_steppers();
  2807. }
  2808. #if ENABLED(SDSUPPORT)
  2809. /**
  2810. * M20: List SD card to serial output
  2811. */
  2812. inline void gcode_M20() {
  2813. SERIAL_PROTOCOLLNPGM(MSG_BEGIN_FILE_LIST);
  2814. card.ls();
  2815. SERIAL_PROTOCOLLNPGM(MSG_END_FILE_LIST);
  2816. }
  2817. /**
  2818. * M21: Init SD Card
  2819. */
  2820. inline void gcode_M21() {
  2821. card.initsd();
  2822. }
  2823. /**
  2824. * M22: Release SD Card
  2825. */
  2826. inline void gcode_M22() {
  2827. card.release();
  2828. }
  2829. /**
  2830. * M23: Select a file
  2831. */
  2832. inline void gcode_M23() {
  2833. card.openFile(current_command_args, true);
  2834. }
  2835. /**
  2836. * M24: Start SD Print
  2837. */
  2838. inline void gcode_M24() {
  2839. card.startFileprint();
  2840. print_job_start_ms = millis();
  2841. }
  2842. /**
  2843. * M25: Pause SD Print
  2844. */
  2845. inline void gcode_M25() {
  2846. card.pauseSDPrint();
  2847. }
  2848. /**
  2849. * M26: Set SD Card file index
  2850. */
  2851. inline void gcode_M26() {
  2852. if (card.cardOK && code_seen('S'))
  2853. card.setIndex(code_value_short());
  2854. }
  2855. /**
  2856. * M27: Get SD Card status
  2857. */
  2858. inline void gcode_M27() {
  2859. card.getStatus();
  2860. }
  2861. /**
  2862. * M28: Start SD Write
  2863. */
  2864. inline void gcode_M28() {
  2865. card.openFile(current_command_args, false);
  2866. }
  2867. /**
  2868. * M29: Stop SD Write
  2869. * Processed in write to file routine above
  2870. */
  2871. inline void gcode_M29() {
  2872. // card.saving = false;
  2873. }
  2874. /**
  2875. * M30 <filename>: Delete SD Card file
  2876. */
  2877. inline void gcode_M30() {
  2878. if (card.cardOK) {
  2879. card.closefile();
  2880. card.removeFile(current_command_args);
  2881. }
  2882. }
  2883. #endif
  2884. /**
  2885. * M31: Get the time since the start of SD Print (or last M109)
  2886. */
  2887. inline void gcode_M31() {
  2888. print_job_stop_ms = millis();
  2889. millis_t t = (print_job_stop_ms - print_job_start_ms) / 1000;
  2890. int min = t / 60, sec = t % 60;
  2891. char time[30];
  2892. sprintf_P(time, PSTR("%i min, %i sec"), min, sec);
  2893. SERIAL_ECHO_START;
  2894. SERIAL_ECHOLN(time);
  2895. lcd_setstatus(time);
  2896. autotempShutdown();
  2897. }
  2898. #if ENABLED(SDSUPPORT)
  2899. /**
  2900. * M32: Select file and start SD Print
  2901. */
  2902. inline void gcode_M32() {
  2903. if (card.sdprinting)
  2904. st_synchronize();
  2905. char* namestartpos = strchr(current_command_args, '!'); // Find ! to indicate filename string start.
  2906. if (!namestartpos)
  2907. namestartpos = current_command_args; // Default name position, 4 letters after the M
  2908. else
  2909. namestartpos++; //to skip the '!'
  2910. bool call_procedure = code_seen('P') && (seen_pointer < namestartpos);
  2911. if (card.cardOK) {
  2912. card.openFile(namestartpos, true, !call_procedure);
  2913. if (code_seen('S') && seen_pointer < namestartpos) // "S" (must occur _before_ the filename!)
  2914. card.setIndex(code_value_short());
  2915. card.startFileprint();
  2916. if (!call_procedure)
  2917. print_job_start_ms = millis(); //procedure calls count as normal print time.
  2918. }
  2919. }
  2920. #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
  2921. /**
  2922. * M33: Get the long full path of a file or folder
  2923. *
  2924. * Parameters:
  2925. * <dospath> Case-insensitive DOS-style path to a file or folder
  2926. *
  2927. * Example:
  2928. * M33 miscel~1/armchair/armcha~1.gco
  2929. *
  2930. * Output:
  2931. * /Miscellaneous/Armchair/Armchair.gcode
  2932. */
  2933. inline void gcode_M33() {
  2934. card.printLongPath(current_command_args);
  2935. }
  2936. #endif
  2937. /**
  2938. * M928: Start SD Write
  2939. */
  2940. inline void gcode_M928() {
  2941. card.openLogFile(current_command_args);
  2942. }
  2943. #endif // SDSUPPORT
  2944. /**
  2945. * M42: Change pin status via GCode
  2946. */
  2947. inline void gcode_M42() {
  2948. if (code_seen('S')) {
  2949. int pin_status = code_value_short(),
  2950. pin_number = LED_PIN;
  2951. if (code_seen('P') && pin_status >= 0 && pin_status <= 255)
  2952. pin_number = code_value_short();
  2953. for (uint8_t i = 0; i < COUNT(sensitive_pins); i++) {
  2954. if (sensitive_pins[i] == pin_number) {
  2955. pin_number = -1;
  2956. break;
  2957. }
  2958. }
  2959. #if HAS_FAN
  2960. if (pin_number == FAN_PIN) fanSpeed = pin_status;
  2961. #endif
  2962. if (pin_number > -1) {
  2963. pinMode(pin_number, OUTPUT);
  2964. digitalWrite(pin_number, pin_status);
  2965. analogWrite(pin_number, pin_status);
  2966. }
  2967. } // code_seen('S')
  2968. }
  2969. #if ENABLED(AUTO_BED_LEVELING_FEATURE) && ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
  2970. // This is redundant since the SanityCheck.h already checks for a valid Z_MIN_PROBE_PIN, but here for clarity.
  2971. #if ENABLED(Z_MIN_PROBE_ENDSTOP)
  2972. #if !HAS_Z_PROBE
  2973. #error You must define Z_MIN_PROBE_PIN to enable Z probe repeatability calculation.
  2974. #endif
  2975. #elif !HAS_Z_MIN
  2976. #error You must define Z_MIN_PIN to enable Z probe repeatability calculation.
  2977. #endif
  2978. /**
  2979. * M48: Z probe repeatability measurement function.
  2980. *
  2981. * Usage:
  2982. * M48 <P#> <X#> <Y#> <V#> <E> <L#>
  2983. * P = Number of sampled points (4-50, default 10)
  2984. * X = Sample X position
  2985. * Y = Sample Y position
  2986. * V = Verbose level (0-4, default=1)
  2987. * E = Engage Z probe for each reading
  2988. * L = Number of legs of movement before probe
  2989. *
  2990. * This function assumes the bed has been homed. Specifically, that a G28 command
  2991. * as been issued prior to invoking the M48 Z probe repeatability measurement function.
  2992. * Any information generated by a prior G29 Bed leveling command will be lost and need to be
  2993. * regenerated.
  2994. */
  2995. inline void gcode_M48() {
  2996. double sum = 0.0, mean = 0.0, sigma = 0.0, sample_set[50];
  2997. uint8_t verbose_level = 1, n_samples = 10, n_legs = 0;
  2998. if (code_seen('V')) {
  2999. verbose_level = code_value_short();
  3000. if (verbose_level < 0 || verbose_level > 4 ) {
  3001. SERIAL_PROTOCOLPGM("?Verbose Level not plausible (0-4).\n");
  3002. return;
  3003. }
  3004. }
  3005. if (verbose_level > 0)
  3006. SERIAL_PROTOCOLPGM("M48 Z-Probe Repeatability test\n");
  3007. if (code_seen('P')) {
  3008. n_samples = code_value_short();
  3009. if (n_samples < 4 || n_samples > 50) {
  3010. SERIAL_PROTOCOLPGM("?Sample size not plausible (4-50).\n");
  3011. return;
  3012. }
  3013. }
  3014. double X_current = st_get_position_mm(X_AXIS),
  3015. Y_current = st_get_position_mm(Y_AXIS),
  3016. Z_current = st_get_position_mm(Z_AXIS),
  3017. E_current = st_get_position_mm(E_AXIS),
  3018. X_probe_location = X_current, Y_probe_location = Y_current,
  3019. Z_start_location = Z_current + Z_RAISE_BEFORE_PROBING;
  3020. bool deploy_probe_for_each_reading = code_seen('E');
  3021. if (code_seen('X')) {
  3022. X_probe_location = code_value() - X_PROBE_OFFSET_FROM_EXTRUDER;
  3023. if (X_probe_location < X_MIN_POS || X_probe_location > X_MAX_POS) {
  3024. out_of_range_error(PSTR("X"));
  3025. return;
  3026. }
  3027. }
  3028. if (code_seen('Y')) {
  3029. Y_probe_location = code_value() - Y_PROBE_OFFSET_FROM_EXTRUDER;
  3030. if (Y_probe_location < Y_MIN_POS || Y_probe_location > Y_MAX_POS) {
  3031. out_of_range_error(PSTR("Y"));
  3032. return;
  3033. }
  3034. }
  3035. if (code_seen('L')) {
  3036. n_legs = code_value_short();
  3037. if (n_legs == 1) n_legs = 2;
  3038. if (n_legs < 0 || n_legs > 15) {
  3039. SERIAL_PROTOCOLPGM("?Number of legs in movement not plausible (0-15).\n");
  3040. return;
  3041. }
  3042. }
  3043. //
  3044. // Do all the preliminary setup work. First raise the Z probe.
  3045. //
  3046. st_synchronize();
  3047. plan_bed_level_matrix.set_to_identity();
  3048. plan_buffer_line(X_current, Y_current, Z_start_location, E_current, homing_feedrate[Z_AXIS] / 60, active_extruder);
  3049. st_synchronize();
  3050. //
  3051. // Now get everything to the specified probe point So we can safely do a probe to
  3052. // get us close to the bed. If the Z-Axis is far from the bed, we don't want to
  3053. // use that as a starting point for each probe.
  3054. //
  3055. if (verbose_level > 2)
  3056. SERIAL_PROTOCOLPGM("Positioning the probe...\n");
  3057. plan_buffer_line( X_probe_location, Y_probe_location, Z_start_location,
  3058. E_current,
  3059. homing_feedrate[X_AXIS]/60,
  3060. active_extruder);
  3061. st_synchronize();
  3062. current_position[X_AXIS] = X_current = st_get_position_mm(X_AXIS);
  3063. current_position[Y_AXIS] = Y_current = st_get_position_mm(Y_AXIS);
  3064. current_position[Z_AXIS] = Z_current = st_get_position_mm(Z_AXIS);
  3065. current_position[E_AXIS] = E_current = st_get_position_mm(E_AXIS);
  3066. //
  3067. // OK, do the initial probe to get us close to the bed.
  3068. // Then retrace the right amount and use that in subsequent probes
  3069. //
  3070. deploy_z_probe();
  3071. setup_for_endstop_move();
  3072. run_z_probe();
  3073. current_position[Z_AXIS] = Z_current = st_get_position_mm(Z_AXIS);
  3074. Z_start_location = st_get_position_mm(Z_AXIS) + Z_RAISE_BEFORE_PROBING;
  3075. plan_buffer_line( X_probe_location, Y_probe_location, Z_start_location,
  3076. E_current,
  3077. homing_feedrate[X_AXIS]/60,
  3078. active_extruder);
  3079. st_synchronize();
  3080. current_position[Z_AXIS] = Z_current = st_get_position_mm(Z_AXIS);
  3081. if (deploy_probe_for_each_reading) stow_z_probe();
  3082. for (uint8_t n=0; n < n_samples; n++) {
  3083. // Make sure we are at the probe location
  3084. do_blocking_move_to(X_probe_location, Y_probe_location, Z_start_location); // this also updates current_position
  3085. if (n_legs) {
  3086. millis_t ms = millis();
  3087. double radius = ms % (X_MAX_LENGTH / 4), // limit how far out to go
  3088. theta = RADIANS(ms % 360L);
  3089. float dir = (ms & 0x0001) ? 1 : -1; // clockwise or counter clockwise
  3090. //SERIAL_ECHOPAIR("starting radius: ",radius);
  3091. //SERIAL_ECHOPAIR(" theta: ",theta);
  3092. //SERIAL_ECHOPAIR(" direction: ",dir);
  3093. //SERIAL_EOL;
  3094. for (uint8_t l = 0; l < n_legs - 1; l++) {
  3095. ms = millis();
  3096. theta += RADIANS(dir * (ms % 20L));
  3097. radius += (ms % 10L) - 5L;
  3098. if (radius < 0.0) radius = -radius;
  3099. X_current = X_probe_location + cos(theta) * radius;
  3100. X_current = constrain(X_current, X_MIN_POS, X_MAX_POS);
  3101. Y_current = Y_probe_location + sin(theta) * radius;
  3102. Y_current = constrain(Y_current, Y_MIN_POS, Y_MAX_POS);
  3103. if (verbose_level > 3) {
  3104. SERIAL_ECHOPAIR("x: ", X_current);
  3105. SERIAL_ECHOPAIR("y: ", Y_current);
  3106. SERIAL_EOL;
  3107. }
  3108. do_blocking_move_to(X_current, Y_current, Z_current); // this also updates current_position
  3109. } // n_legs loop
  3110. // Go back to the probe location
  3111. do_blocking_move_to(X_probe_location, Y_probe_location, Z_start_location); // this also updates current_position
  3112. } // n_legs
  3113. if (deploy_probe_for_each_reading) {
  3114. deploy_z_probe();
  3115. delay(1000);
  3116. }
  3117. setup_for_endstop_move();
  3118. run_z_probe();
  3119. sample_set[n] = current_position[Z_AXIS];
  3120. //
  3121. // Get the current mean for the data points we have so far
  3122. //
  3123. sum = 0.0;
  3124. for (uint8_t j = 0; j <= n; j++) sum += sample_set[j];
  3125. mean = sum / (n + 1);
  3126. //
  3127. // Now, use that mean to calculate the standard deviation for the
  3128. // data points we have so far
  3129. //
  3130. sum = 0.0;
  3131. for (uint8_t j = 0; j <= n; j++) {
  3132. float ss = sample_set[j] - mean;
  3133. sum += ss * ss;
  3134. }
  3135. sigma = sqrt(sum / (n + 1));
  3136. if (verbose_level > 1) {
  3137. SERIAL_PROTOCOL(n+1);
  3138. SERIAL_PROTOCOLPGM(" of ");
  3139. SERIAL_PROTOCOL((int)n_samples);
  3140. SERIAL_PROTOCOLPGM(" z: ");
  3141. SERIAL_PROTOCOL_F(current_position[Z_AXIS], 6);
  3142. if (verbose_level > 2) {
  3143. SERIAL_PROTOCOLPGM(" mean: ");
  3144. SERIAL_PROTOCOL_F(mean,6);
  3145. SERIAL_PROTOCOLPGM(" sigma: ");
  3146. SERIAL_PROTOCOL_F(sigma,6);
  3147. }
  3148. }
  3149. if (verbose_level > 0) SERIAL_EOL;
  3150. plan_buffer_line(X_probe_location, Y_probe_location, Z_start_location, current_position[E_AXIS], homing_feedrate[Z_AXIS]/60, active_extruder);
  3151. st_synchronize();
  3152. // Stow between
  3153. if (deploy_probe_for_each_reading) {
  3154. stow_z_probe();
  3155. delay(1000);
  3156. }
  3157. }
  3158. // Stow after
  3159. if (!deploy_probe_for_each_reading) {
  3160. stow_z_probe();
  3161. delay(1000);
  3162. }
  3163. clean_up_after_endstop_move();
  3164. if (verbose_level > 0) {
  3165. SERIAL_PROTOCOLPGM("Mean: ");
  3166. SERIAL_PROTOCOL_F(mean, 6);
  3167. SERIAL_EOL;
  3168. }
  3169. SERIAL_PROTOCOLPGM("Standard Deviation: ");
  3170. SERIAL_PROTOCOL_F(sigma, 6);
  3171. SERIAL_EOL; SERIAL_EOL;
  3172. }
  3173. #endif // AUTO_BED_LEVELING_FEATURE && Z_MIN_PROBE_REPEATABILITY_TEST
  3174. /**
  3175. * M104: Set hot end temperature
  3176. */
  3177. inline void gcode_M104() {
  3178. if (setTargetedHotend(104)) return;
  3179. if (marlin_debug_flags & DEBUG_DRYRUN) return;
  3180. if (code_seen('S')) {
  3181. float temp = code_value();
  3182. setTargetHotend(temp, target_extruder);
  3183. #if ENABLED(DUAL_X_CARRIAGE)
  3184. if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
  3185. setTargetHotend1(temp == 0.0 ? 0.0 : temp + duplicate_extruder_temp_offset);
  3186. #endif
  3187. }
  3188. }
  3189. /**
  3190. * M105: Read hot end and bed temperature
  3191. */
  3192. inline void gcode_M105() {
  3193. if (setTargetedHotend(105)) return;
  3194. #if HAS_TEMP_0 || HAS_TEMP_BED || ENABLED(HEATER_0_USES_MAX6675)
  3195. SERIAL_PROTOCOLPGM(MSG_OK);
  3196. #if HAS_TEMP_0 || ENABLED(HEATER_0_USES_MAX6675)
  3197. SERIAL_PROTOCOLPGM(" T:");
  3198. SERIAL_PROTOCOL_F(degHotend(target_extruder), 1);
  3199. SERIAL_PROTOCOLPGM(" /");
  3200. SERIAL_PROTOCOL_F(degTargetHotend(target_extruder), 1);
  3201. #endif
  3202. #if HAS_TEMP_BED
  3203. SERIAL_PROTOCOLPGM(" B:");
  3204. SERIAL_PROTOCOL_F(degBed(), 1);
  3205. SERIAL_PROTOCOLPGM(" /");
  3206. SERIAL_PROTOCOL_F(degTargetBed(), 1);
  3207. #endif
  3208. for (int8_t e = 0; e < EXTRUDERS; ++e) {
  3209. SERIAL_PROTOCOLPGM(" T");
  3210. SERIAL_PROTOCOL(e);
  3211. SERIAL_PROTOCOLCHAR(':');
  3212. SERIAL_PROTOCOL_F(degHotend(e), 1);
  3213. SERIAL_PROTOCOLPGM(" /");
  3214. SERIAL_PROTOCOL_F(degTargetHotend(e), 1);
  3215. }
  3216. #else // !HAS_TEMP_0 && !HAS_TEMP_BED
  3217. SERIAL_ERROR_START;
  3218. SERIAL_ERRORLNPGM(MSG_ERR_NO_THERMISTORS);
  3219. #endif
  3220. SERIAL_PROTOCOLPGM(" @:");
  3221. #ifdef EXTRUDER_WATTS
  3222. SERIAL_PROTOCOL((EXTRUDER_WATTS * getHeaterPower(target_extruder))/127);
  3223. SERIAL_PROTOCOLCHAR('W');
  3224. #else
  3225. SERIAL_PROTOCOL(getHeaterPower(target_extruder));
  3226. #endif
  3227. SERIAL_PROTOCOLPGM(" B@:");
  3228. #ifdef BED_WATTS
  3229. SERIAL_PROTOCOL((BED_WATTS * getHeaterPower(-1))/127);
  3230. SERIAL_PROTOCOLCHAR('W');
  3231. #else
  3232. SERIAL_PROTOCOL(getHeaterPower(-1));
  3233. #endif
  3234. #if ENABLED(SHOW_TEMP_ADC_VALUES)
  3235. #if HAS_TEMP_BED
  3236. SERIAL_PROTOCOLPGM(" ADC B:");
  3237. SERIAL_PROTOCOL_F(degBed(),1);
  3238. SERIAL_PROTOCOLPGM("C->");
  3239. SERIAL_PROTOCOL_F(rawBedTemp()/OVERSAMPLENR,0);
  3240. #endif
  3241. for (int8_t cur_extruder = 0; cur_extruder < EXTRUDERS; ++cur_extruder) {
  3242. SERIAL_PROTOCOLPGM(" T");
  3243. SERIAL_PROTOCOL(cur_extruder);
  3244. SERIAL_PROTOCOLCHAR(':');
  3245. SERIAL_PROTOCOL_F(degHotend(cur_extruder),1);
  3246. SERIAL_PROTOCOLPGM("C->");
  3247. SERIAL_PROTOCOL_F(rawHotendTemp(cur_extruder)/OVERSAMPLENR,0);
  3248. }
  3249. #endif
  3250. SERIAL_EOL;
  3251. }
  3252. #if HAS_FAN
  3253. /**
  3254. * M106: Set Fan Speed
  3255. */
  3256. inline void gcode_M106() { fanSpeed = code_seen('S') ? constrain(code_value_short(), 0, 255) : 255; }
  3257. /**
  3258. * M107: Fan Off
  3259. */
  3260. inline void gcode_M107() { fanSpeed = 0; }
  3261. #endif // HAS_FAN
  3262. /**
  3263. * M109: Wait for extruder(s) to reach temperature
  3264. */
  3265. inline void gcode_M109() {
  3266. if (setTargetedHotend(109)) return;
  3267. if (marlin_debug_flags & DEBUG_DRYRUN) return;
  3268. LCD_MESSAGEPGM(MSG_HEATING);
  3269. no_wait_for_cooling = code_seen('S');
  3270. if (no_wait_for_cooling || code_seen('R')) {
  3271. float temp = code_value();
  3272. setTargetHotend(temp, target_extruder);
  3273. #if ENABLED(DUAL_X_CARRIAGE)
  3274. if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
  3275. setTargetHotend1(temp == 0.0 ? 0.0 : temp + duplicate_extruder_temp_offset);
  3276. #endif
  3277. }
  3278. #if ENABLED(AUTOTEMP)
  3279. autotemp_enabled = code_seen('F');
  3280. if (autotemp_enabled) autotemp_factor = code_value();
  3281. if (code_seen('S')) autotemp_min = code_value();
  3282. if (code_seen('B')) autotemp_max = code_value();
  3283. #endif
  3284. millis_t temp_ms = millis();
  3285. /* See if we are heating up or cooling down */
  3286. target_direction = isHeatingHotend(target_extruder); // true if heating, false if cooling
  3287. cancel_heatup = false;
  3288. #ifdef TEMP_RESIDENCY_TIME
  3289. long residency_start_ms = -1;
  3290. /* continue to loop until we have reached the target temp
  3291. _and_ until TEMP_RESIDENCY_TIME hasn't passed since we reached it */
  3292. while((!cancel_heatup)&&((residency_start_ms == -1) ||
  3293. (residency_start_ms >= 0 && (((unsigned int) (millis() - residency_start_ms)) < (TEMP_RESIDENCY_TIME * 1000UL)))) )
  3294. #else
  3295. while ( target_direction ? (isHeatingHotend(target_extruder)) : (isCoolingHotend(target_extruder)&&(no_wait_for_cooling==false)) )
  3296. #endif //TEMP_RESIDENCY_TIME
  3297. { // while loop
  3298. if (millis() > temp_ms + 1000UL) { //Print temp & remaining time every 1s while waiting
  3299. SERIAL_PROTOCOLPGM("T:");
  3300. SERIAL_PROTOCOL_F(degHotend(target_extruder),1);
  3301. SERIAL_PROTOCOLPGM(" E:");
  3302. SERIAL_PROTOCOL((int)target_extruder);
  3303. #ifdef TEMP_RESIDENCY_TIME
  3304. SERIAL_PROTOCOLPGM(" W:");
  3305. if (residency_start_ms > -1) {
  3306. temp_ms = ((TEMP_RESIDENCY_TIME * 1000UL) - (millis() - residency_start_ms)) / 1000UL;
  3307. SERIAL_PROTOCOLLN(temp_ms);
  3308. }
  3309. else {
  3310. SERIAL_PROTOCOLLNPGM("?");
  3311. }
  3312. #else
  3313. SERIAL_EOL;
  3314. #endif
  3315. temp_ms = millis();
  3316. }
  3317. idle();
  3318. #ifdef TEMP_RESIDENCY_TIME
  3319. // start/restart the TEMP_RESIDENCY_TIME timer whenever we reach target temp for the first time
  3320. // or when current temp falls outside the hysteresis after target temp was reached
  3321. if ((residency_start_ms == -1 && target_direction && (degHotend(target_extruder) >= (degTargetHotend(target_extruder)-TEMP_WINDOW))) ||
  3322. (residency_start_ms == -1 && !target_direction && (degHotend(target_extruder) <= (degTargetHotend(target_extruder)+TEMP_WINDOW))) ||
  3323. (residency_start_ms > -1 && labs(degHotend(target_extruder) - degTargetHotend(target_extruder)) > TEMP_HYSTERESIS) )
  3324. {
  3325. residency_start_ms = millis();
  3326. }
  3327. #endif //TEMP_RESIDENCY_TIME
  3328. }
  3329. LCD_MESSAGEPGM(MSG_HEATING_COMPLETE);
  3330. refresh_cmd_timeout();
  3331. print_job_start_ms = previous_cmd_ms;
  3332. }
  3333. #if HAS_TEMP_BED
  3334. /**
  3335. * M190: Sxxx Wait for bed current temp to reach target temp. Waits only when heating
  3336. * Rxxx Wait for bed current temp to reach target temp. Waits when heating and cooling
  3337. */
  3338. inline void gcode_M190() {
  3339. if (marlin_debug_flags & DEBUG_DRYRUN) return;
  3340. LCD_MESSAGEPGM(MSG_BED_HEATING);
  3341. no_wait_for_cooling = code_seen('S');
  3342. if (no_wait_for_cooling || code_seen('R'))
  3343. setTargetBed(code_value());
  3344. millis_t temp_ms = millis();
  3345. cancel_heatup = false;
  3346. target_direction = isHeatingBed(); // true if heating, false if cooling
  3347. while ((target_direction && !cancel_heatup) ? isHeatingBed() : isCoolingBed() && !no_wait_for_cooling) {
  3348. millis_t ms = millis();
  3349. if (ms > temp_ms + 1000UL) { //Print Temp Reading every 1 second while heating up.
  3350. temp_ms = ms;
  3351. float tt = degHotend(active_extruder);
  3352. SERIAL_PROTOCOLPGM("T:");
  3353. SERIAL_PROTOCOL(tt);
  3354. SERIAL_PROTOCOLPGM(" E:");
  3355. SERIAL_PROTOCOL((int)active_extruder);
  3356. SERIAL_PROTOCOLPGM(" B:");
  3357. SERIAL_PROTOCOL_F(degBed(), 1);
  3358. SERIAL_EOL;
  3359. }
  3360. idle();
  3361. }
  3362. LCD_MESSAGEPGM(MSG_BED_DONE);
  3363. refresh_cmd_timeout();
  3364. }
  3365. #endif // HAS_TEMP_BED
  3366. /**
  3367. * M111: Set the debug level
  3368. */
  3369. inline void gcode_M111() {
  3370. marlin_debug_flags = code_seen('S') ? code_value_short() : DEBUG_INFO|DEBUG_COMMUNICATION;
  3371. if (marlin_debug_flags & DEBUG_ECHO) {
  3372. SERIAL_ECHO_START;
  3373. SERIAL_ECHOLNPGM(MSG_DEBUG_ECHO);
  3374. }
  3375. // FOR MOMENT NOT ACTIVE
  3376. //if (marlin_debug_flags & DEBUG_INFO) SERIAL_ECHOLNPGM(MSG_DEBUG_INFO);
  3377. //if (marlin_debug_flags & DEBUG_ERRORS) SERIAL_ECHOLNPGM(MSG_DEBUG_ERRORS);
  3378. if (marlin_debug_flags & DEBUG_DRYRUN) {
  3379. SERIAL_ECHO_START;
  3380. SERIAL_ECHOLNPGM(MSG_DEBUG_DRYRUN);
  3381. disable_all_heaters();
  3382. }
  3383. #if ENABLED(DEBUG_LEVELING_FEATURE)
  3384. if (marlin_debug_flags & DEBUG_LEVELING) {
  3385. SERIAL_ECHO_START;
  3386. SERIAL_ECHOLNPGM(MSG_DEBUG_LEVELING);
  3387. }
  3388. #endif
  3389. }
  3390. /**
  3391. * M112: Emergency Stop
  3392. */
  3393. inline void gcode_M112() { kill(PSTR(MSG_KILLED)); }
  3394. #if ENABLED(BARICUDA)
  3395. #if HAS_HEATER_1
  3396. /**
  3397. * M126: Heater 1 valve open
  3398. */
  3399. inline void gcode_M126() { ValvePressure = code_seen('S') ? constrain(code_value(), 0, 255) : 255; }
  3400. /**
  3401. * M127: Heater 1 valve close
  3402. */
  3403. inline void gcode_M127() { ValvePressure = 0; }
  3404. #endif
  3405. #if HAS_HEATER_2
  3406. /**
  3407. * M128: Heater 2 valve open
  3408. */
  3409. inline void gcode_M128() { EtoPPressure = code_seen('S') ? constrain(code_value(), 0, 255) : 255; }
  3410. /**
  3411. * M129: Heater 2 valve close
  3412. */
  3413. inline void gcode_M129() { EtoPPressure = 0; }
  3414. #endif
  3415. #endif //BARICUDA
  3416. /**
  3417. * M140: Set bed temperature
  3418. */
  3419. inline void gcode_M140() {
  3420. if (marlin_debug_flags & DEBUG_DRYRUN) return;
  3421. if (code_seen('S')) setTargetBed(code_value());
  3422. }
  3423. #if ENABLED(ULTIPANEL)
  3424. /**
  3425. * M145: Set the heatup state for a material in the LCD menu
  3426. * S<material> (0=PLA, 1=ABS)
  3427. * H<hotend temp>
  3428. * B<bed temp>
  3429. * F<fan speed>
  3430. */
  3431. inline void gcode_M145() {
  3432. uint8_t material = code_seen('S') ? code_value_short() : 0;
  3433. if (material < 0 || material > 1) {
  3434. SERIAL_ERROR_START;
  3435. SERIAL_ERRORLNPGM(MSG_ERR_MATERIAL_INDEX);
  3436. }
  3437. else {
  3438. int v;
  3439. switch (material) {
  3440. case 0:
  3441. if (code_seen('H')) {
  3442. v = code_value_short();
  3443. plaPreheatHotendTemp = constrain(v, EXTRUDE_MINTEMP, HEATER_0_MAXTEMP - 15);
  3444. }
  3445. if (code_seen('F')) {
  3446. v = code_value_short();
  3447. plaPreheatFanSpeed = constrain(v, 0, 255);
  3448. }
  3449. #if TEMP_SENSOR_BED != 0
  3450. if (code_seen('B')) {
  3451. v = code_value_short();
  3452. plaPreheatHPBTemp = constrain(v, BED_MINTEMP, BED_MAXTEMP - 15);
  3453. }
  3454. #endif
  3455. break;
  3456. case 1:
  3457. if (code_seen('H')) {
  3458. v = code_value_short();
  3459. absPreheatHotendTemp = constrain(v, EXTRUDE_MINTEMP, HEATER_0_MAXTEMP - 15);
  3460. }
  3461. if (code_seen('F')) {
  3462. v = code_value_short();
  3463. absPreheatFanSpeed = constrain(v, 0, 255);
  3464. }
  3465. #if TEMP_SENSOR_BED != 0
  3466. if (code_seen('B')) {
  3467. v = code_value_short();
  3468. absPreheatHPBTemp = constrain(v, BED_MINTEMP, BED_MAXTEMP - 15);
  3469. }
  3470. #endif
  3471. break;
  3472. }
  3473. }
  3474. }
  3475. #endif
  3476. #if HAS_POWER_SWITCH
  3477. /**
  3478. * M80: Turn on Power Supply
  3479. */
  3480. inline void gcode_M80() {
  3481. OUT_WRITE(PS_ON_PIN, PS_ON_AWAKE); //GND
  3482. // If you have a switch on suicide pin, this is useful
  3483. // if you want to start another print with suicide feature after
  3484. // a print without suicide...
  3485. #if HAS_SUICIDE
  3486. OUT_WRITE(SUICIDE_PIN, HIGH);
  3487. #endif
  3488. #if ENABLED(ULTIPANEL)
  3489. powersupply = true;
  3490. LCD_MESSAGEPGM(WELCOME_MSG);
  3491. lcd_update();
  3492. #endif
  3493. }
  3494. #endif // HAS_POWER_SWITCH
  3495. /**
  3496. * M81: Turn off Power, including Power Supply, if there is one.
  3497. *
  3498. * This code should ALWAYS be available for EMERGENCY SHUTDOWN!
  3499. */
  3500. inline void gcode_M81() {
  3501. disable_all_heaters();
  3502. finishAndDisableSteppers();
  3503. fanSpeed = 0;
  3504. delay(1000); // Wait 1 second before switching off
  3505. #if HAS_SUICIDE
  3506. st_synchronize();
  3507. suicide();
  3508. #elif HAS_POWER_SWITCH
  3509. OUT_WRITE(PS_ON_PIN, PS_ON_ASLEEP);
  3510. #endif
  3511. #if ENABLED(ULTIPANEL)
  3512. #if HAS_POWER_SWITCH
  3513. powersupply = false;
  3514. #endif
  3515. LCD_MESSAGEPGM(MACHINE_NAME " " MSG_OFF ".");
  3516. lcd_update();
  3517. #endif
  3518. }
  3519. /**
  3520. * M82: Set E codes absolute (default)
  3521. */
  3522. inline void gcode_M82() { axis_relative_modes[E_AXIS] = false; }
  3523. /**
  3524. * M83: Set E codes relative while in Absolute Coordinates (G90) mode
  3525. */
  3526. inline void gcode_M83() { axis_relative_modes[E_AXIS] = true; }
  3527. /**
  3528. * M18, M84: Disable all stepper motors
  3529. */
  3530. inline void gcode_M18_M84() {
  3531. if (code_seen('S')) {
  3532. stepper_inactive_time = code_value() * 1000;
  3533. }
  3534. else {
  3535. bool all_axis = !((code_seen(axis_codes[X_AXIS])) || (code_seen(axis_codes[Y_AXIS])) || (code_seen(axis_codes[Z_AXIS]))|| (code_seen(axis_codes[E_AXIS])));
  3536. if (all_axis) {
  3537. finishAndDisableSteppers();
  3538. }
  3539. else {
  3540. st_synchronize();
  3541. if (code_seen('X')) disable_x();
  3542. if (code_seen('Y')) disable_y();
  3543. if (code_seen('Z')) disable_z();
  3544. #if ((E0_ENABLE_PIN != X_ENABLE_PIN) && (E1_ENABLE_PIN != Y_ENABLE_PIN)) // Only enable on boards that have seperate ENABLE_PINS
  3545. if (code_seen('E')) {
  3546. disable_e0();
  3547. disable_e1();
  3548. disable_e2();
  3549. disable_e3();
  3550. }
  3551. #endif
  3552. }
  3553. }
  3554. }
  3555. /**
  3556. * M85: Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
  3557. */
  3558. inline void gcode_M85() {
  3559. if (code_seen('S')) max_inactive_time = code_value() * 1000;
  3560. }
  3561. /**
  3562. * M92: Set axis steps-per-unit for one or more axes, X, Y, Z, and E.
  3563. * (Follows the same syntax as G92)
  3564. */
  3565. inline void gcode_M92() {
  3566. for(int8_t i=0; i < NUM_AXIS; i++) {
  3567. if (code_seen(axis_codes[i])) {
  3568. if (i == E_AXIS) {
  3569. float value = code_value();
  3570. if (value < 20.0) {
  3571. float factor = axis_steps_per_unit[i] / value; // increase e constants if M92 E14 is given for netfab.
  3572. max_e_jerk *= factor;
  3573. max_feedrate[i] *= factor;
  3574. axis_steps_per_sqr_second[i] *= factor;
  3575. }
  3576. axis_steps_per_unit[i] = value;
  3577. }
  3578. else {
  3579. axis_steps_per_unit[i] = code_value();
  3580. }
  3581. }
  3582. }
  3583. }
  3584. /**
  3585. * M114: Output current position to serial port
  3586. */
  3587. inline void gcode_M114() {
  3588. SERIAL_PROTOCOLPGM("X:");
  3589. SERIAL_PROTOCOL(current_position[X_AXIS]);
  3590. SERIAL_PROTOCOLPGM(" Y:");
  3591. SERIAL_PROTOCOL(current_position[Y_AXIS]);
  3592. SERIAL_PROTOCOLPGM(" Z:");
  3593. SERIAL_PROTOCOL(current_position[Z_AXIS]);
  3594. SERIAL_PROTOCOLPGM(" E:");
  3595. SERIAL_PROTOCOL(current_position[E_AXIS]);
  3596. SERIAL_PROTOCOLPGM(MSG_COUNT_X);
  3597. SERIAL_PROTOCOL(st_get_position_mm(X_AXIS));
  3598. SERIAL_PROTOCOLPGM(" Y:");
  3599. SERIAL_PROTOCOL(st_get_position_mm(Y_AXIS));
  3600. SERIAL_PROTOCOLPGM(" Z:");
  3601. SERIAL_PROTOCOL(st_get_position_mm(Z_AXIS));
  3602. SERIAL_EOL;
  3603. #if ENABLED(SCARA)
  3604. SERIAL_PROTOCOLPGM("SCARA Theta:");
  3605. SERIAL_PROTOCOL(delta[X_AXIS]);
  3606. SERIAL_PROTOCOLPGM(" Psi+Theta:");
  3607. SERIAL_PROTOCOL(delta[Y_AXIS]);
  3608. SERIAL_EOL;
  3609. SERIAL_PROTOCOLPGM("SCARA Cal - Theta:");
  3610. SERIAL_PROTOCOL(delta[X_AXIS]+home_offset[X_AXIS]);
  3611. SERIAL_PROTOCOLPGM(" Psi+Theta (90):");
  3612. SERIAL_PROTOCOL(delta[Y_AXIS]-delta[X_AXIS]-90+home_offset[Y_AXIS]);
  3613. SERIAL_EOL;
  3614. SERIAL_PROTOCOLPGM("SCARA step Cal - Theta:");
  3615. SERIAL_PROTOCOL(delta[X_AXIS]/90*axis_steps_per_unit[X_AXIS]);
  3616. SERIAL_PROTOCOLPGM(" Psi+Theta:");
  3617. SERIAL_PROTOCOL((delta[Y_AXIS]-delta[X_AXIS])/90*axis_steps_per_unit[Y_AXIS]);
  3618. SERIAL_EOL; SERIAL_EOL;
  3619. #endif
  3620. }
  3621. /**
  3622. * M115: Capabilities string
  3623. */
  3624. inline void gcode_M115() {
  3625. SERIAL_PROTOCOLPGM(MSG_M115_REPORT);
  3626. }
  3627. /**
  3628. * M117: Set LCD Status Message
  3629. */
  3630. inline void gcode_M117() {
  3631. lcd_setstatus(current_command_args);
  3632. }
  3633. /**
  3634. * M119: Output endstop states to serial output
  3635. */
  3636. inline void gcode_M119() {
  3637. SERIAL_PROTOCOLLN(MSG_M119_REPORT);
  3638. #if HAS_X_MIN
  3639. SERIAL_PROTOCOLPGM(MSG_X_MIN);
  3640. SERIAL_PROTOCOLLN(((READ(X_MIN_PIN)^X_MIN_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3641. #endif
  3642. #if HAS_X_MAX
  3643. SERIAL_PROTOCOLPGM(MSG_X_MAX);
  3644. SERIAL_PROTOCOLLN(((READ(X_MAX_PIN)^X_MAX_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3645. #endif
  3646. #if HAS_Y_MIN
  3647. SERIAL_PROTOCOLPGM(MSG_Y_MIN);
  3648. SERIAL_PROTOCOLLN(((READ(Y_MIN_PIN)^Y_MIN_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3649. #endif
  3650. #if HAS_Y_MAX
  3651. SERIAL_PROTOCOLPGM(MSG_Y_MAX);
  3652. SERIAL_PROTOCOLLN(((READ(Y_MAX_PIN)^Y_MAX_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3653. #endif
  3654. #if HAS_Z_MIN
  3655. SERIAL_PROTOCOLPGM(MSG_Z_MIN);
  3656. SERIAL_PROTOCOLLN(((READ(Z_MIN_PIN)^Z_MIN_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3657. #endif
  3658. #if HAS_Z_MAX
  3659. SERIAL_PROTOCOLPGM(MSG_Z_MAX);
  3660. SERIAL_PROTOCOLLN(((READ(Z_MAX_PIN)^Z_MAX_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3661. #endif
  3662. #if HAS_Z2_MAX
  3663. SERIAL_PROTOCOLPGM(MSG_Z2_MAX);
  3664. SERIAL_PROTOCOLLN(((READ(Z2_MAX_PIN)^Z2_MAX_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3665. #endif
  3666. #if HAS_Z_PROBE
  3667. SERIAL_PROTOCOLPGM(MSG_Z_PROBE);
  3668. SERIAL_PROTOCOLLN(((READ(Z_MIN_PROBE_PIN)^Z_MIN_PROBE_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
  3669. #endif
  3670. }
  3671. /**
  3672. * M120: Enable endstops
  3673. */
  3674. inline void gcode_M120() { enable_endstops(true); }
  3675. /**
  3676. * M121: Disable endstops
  3677. */
  3678. inline void gcode_M121() { enable_endstops(false); }
  3679. #if ENABLED(BLINKM)
  3680. /**
  3681. * M150: Set Status LED Color - Use R-U-B for R-G-B
  3682. */
  3683. inline void gcode_M150() {
  3684. SendColors(
  3685. code_seen('R') ? (byte)code_value_short() : 0,
  3686. code_seen('U') ? (byte)code_value_short() : 0,
  3687. code_seen('B') ? (byte)code_value_short() : 0
  3688. );
  3689. }
  3690. #endif // BLINKM
  3691. /**
  3692. * M200: Set filament diameter and set E axis units to cubic millimeters
  3693. *
  3694. * T<extruder> - Optional extruder number. Current extruder if omitted.
  3695. * D<mm> - Diameter of the filament. Use "D0" to set units back to millimeters.
  3696. */
  3697. inline void gcode_M200() {
  3698. if (setTargetedHotend(200)) return;
  3699. if (code_seen('D')) {
  3700. float diameter = code_value();
  3701. // setting any extruder filament size disables volumetric on the assumption that
  3702. // slicers either generate in extruder values as cubic mm or as as filament feeds
  3703. // for all extruders
  3704. volumetric_enabled = (diameter != 0.0);
  3705. if (volumetric_enabled) {
  3706. filament_size[target_extruder] = diameter;
  3707. // make sure all extruders have some sane value for the filament size
  3708. for (int i=0; i<EXTRUDERS; i++)
  3709. if (! filament_size[i]) filament_size[i] = DEFAULT_NOMINAL_FILAMENT_DIA;
  3710. }
  3711. }
  3712. else {
  3713. //reserved for setting filament diameter via UFID or filament measuring device
  3714. return;
  3715. }
  3716. calculate_volumetric_multipliers();
  3717. }
  3718. /**
  3719. * M201: Set max acceleration in units/s^2 for print moves (M201 X1000 Y1000)
  3720. */
  3721. inline void gcode_M201() {
  3722. for (int8_t i=0; i < NUM_AXIS; i++) {
  3723. if (code_seen(axis_codes[i])) {
  3724. max_acceleration_units_per_sq_second[i] = code_value();
  3725. }
  3726. }
  3727. // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
  3728. reset_acceleration_rates();
  3729. }
  3730. #if 0 // Not used for Sprinter/grbl gen6
  3731. inline void gcode_M202() {
  3732. for(int8_t i=0; i < NUM_AXIS; i++) {
  3733. if(code_seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = code_value() * axis_steps_per_unit[i];
  3734. }
  3735. }
  3736. #endif
  3737. /**
  3738. * M203: Set maximum feedrate that your machine can sustain (M203 X200 Y200 Z300 E10000) in mm/sec
  3739. */
  3740. inline void gcode_M203() {
  3741. for (int8_t i=0; i < NUM_AXIS; i++) {
  3742. if (code_seen(axis_codes[i])) {
  3743. max_feedrate[i] = code_value();
  3744. }
  3745. }
  3746. }
  3747. /**
  3748. * M204: Set Accelerations in mm/sec^2 (M204 P1200 R3000 T3000)
  3749. *
  3750. * P = Printing moves
  3751. * R = Retract only (no X, Y, Z) moves
  3752. * T = Travel (non printing) moves
  3753. *
  3754. * Also sets minimum segment time in ms (B20000) to prevent buffer under-runs and M20 minimum feedrate
  3755. */
  3756. inline void gcode_M204() {
  3757. if (code_seen('S')) { // Kept for legacy compatibility. Should NOT BE USED for new developments.
  3758. travel_acceleration = acceleration = code_value();
  3759. SERIAL_ECHOPAIR("Setting Print and Travel Acceleration: ", acceleration);
  3760. SERIAL_EOL;
  3761. }
  3762. if (code_seen('P')) {
  3763. acceleration = code_value();
  3764. SERIAL_ECHOPAIR("Setting Print Acceleration: ", acceleration );
  3765. SERIAL_EOL;
  3766. }
  3767. if (code_seen('R')) {
  3768. retract_acceleration = code_value();
  3769. SERIAL_ECHOPAIR("Setting Retract Acceleration: ", retract_acceleration );
  3770. SERIAL_EOL;
  3771. }
  3772. if (code_seen('T')) {
  3773. travel_acceleration = code_value();
  3774. SERIAL_ECHOPAIR("Setting Travel Acceleration: ", travel_acceleration );
  3775. SERIAL_EOL;
  3776. }
  3777. }
  3778. /**
  3779. * M205: Set Advanced Settings
  3780. *
  3781. * S = Min Feed Rate (mm/s)
  3782. * T = Min Travel Feed Rate (mm/s)
  3783. * B = Min Segment Time (µs)
  3784. * X = Max XY Jerk (mm/s/s)
  3785. * Z = Max Z Jerk (mm/s/s)
  3786. * E = Max E Jerk (mm/s/s)
  3787. */
  3788. inline void gcode_M205() {
  3789. if (code_seen('S')) minimumfeedrate = code_value();
  3790. if (code_seen('T')) mintravelfeedrate = code_value();
  3791. if (code_seen('B')) minsegmenttime = code_value();
  3792. if (code_seen('X')) max_xy_jerk = code_value();
  3793. if (code_seen('Z')) max_z_jerk = code_value();
  3794. if (code_seen('E')) max_e_jerk = code_value();
  3795. }
  3796. /**
  3797. * M206: Set Additional Homing Offset (X Y Z). SCARA aliases T=X, P=Y
  3798. */
  3799. inline void gcode_M206() {
  3800. for (int8_t i=X_AXIS; i <= Z_AXIS; i++) {
  3801. if (code_seen(axis_codes[i])) {
  3802. home_offset[i] = code_value();
  3803. }
  3804. }
  3805. #if ENABLED(SCARA)
  3806. if (code_seen('T')) home_offset[X_AXIS] = code_value(); // Theta
  3807. if (code_seen('P')) home_offset[Y_AXIS] = code_value(); // Psi
  3808. #endif
  3809. }
  3810. #if ENABLED(DELTA)
  3811. /**
  3812. * M665: Set delta configurations
  3813. *
  3814. * L = diagonal rod
  3815. * R = delta radius
  3816. * S = segments per second
  3817. * A = Alpha (Tower 1) diagonal rod trim
  3818. * B = Beta (Tower 2) diagonal rod trim
  3819. * C = Gamma (Tower 3) diagonal rod trim
  3820. */
  3821. inline void gcode_M665() {
  3822. if (code_seen('L')) delta_diagonal_rod = code_value();
  3823. if (code_seen('R')) delta_radius = code_value();
  3824. if (code_seen('S')) delta_segments_per_second = code_value();
  3825. if (code_seen('A')) delta_diagonal_rod_trim_tower_1 = code_value();
  3826. if (code_seen('B')) delta_diagonal_rod_trim_tower_2 = code_value();
  3827. if (code_seen('C')) delta_diagonal_rod_trim_tower_3 = code_value();
  3828. recalc_delta_settings(delta_radius, delta_diagonal_rod);
  3829. }
  3830. /**
  3831. * M666: Set delta endstop adjustment
  3832. */
  3833. inline void gcode_M666() {
  3834. #if ENABLED(DEBUG_LEVELING_FEATURE)
  3835. if (marlin_debug_flags & DEBUG_LEVELING) {
  3836. SERIAL_ECHOLNPGM(">>> gcode_M666");
  3837. }
  3838. #endif
  3839. for (int8_t i = X_AXIS; i <= Z_AXIS; i++) {
  3840. if (code_seen(axis_codes[i])) {
  3841. endstop_adj[i] = code_value();
  3842. #if ENABLED(DEBUG_LEVELING_FEATURE)
  3843. if (marlin_debug_flags & DEBUG_LEVELING) {
  3844. SERIAL_ECHOPGM("endstop_adj[");
  3845. SERIAL_ECHO(axis_codes[i]);
  3846. SERIAL_ECHOPAIR("] = ", endstop_adj[i]);
  3847. SERIAL_EOL;
  3848. }
  3849. #endif
  3850. }
  3851. }
  3852. #if ENABLED(DEBUG_LEVELING_FEATURE)
  3853. if (marlin_debug_flags & DEBUG_LEVELING) {
  3854. SERIAL_ECHOLNPGM("<<< gcode_M666");
  3855. }
  3856. #endif
  3857. }
  3858. #elif ENABLED(Z_DUAL_ENDSTOPS) // !DELTA && ENABLED(Z_DUAL_ENDSTOPS)
  3859. /**
  3860. * M666: For Z Dual Endstop setup, set z axis offset to the z2 axis.
  3861. */
  3862. inline void gcode_M666() {
  3863. if (code_seen('Z')) z_endstop_adj = code_value();
  3864. SERIAL_ECHOPAIR("Z Endstop Adjustment set to (mm):", z_endstop_adj);
  3865. SERIAL_EOL;
  3866. }
  3867. #endif // !DELTA && Z_DUAL_ENDSTOPS
  3868. #if ENABLED(FWRETRACT)
  3869. /**
  3870. * M207: Set firmware retraction values
  3871. *
  3872. * S[+mm] retract_length
  3873. * W[+mm] retract_length_swap (multi-extruder)
  3874. * F[mm/min] retract_feedrate
  3875. * Z[mm] retract_zlift
  3876. */
  3877. inline void gcode_M207() {
  3878. if (code_seen('S')) retract_length = code_value();
  3879. if (code_seen('F')) retract_feedrate = code_value() / 60;
  3880. if (code_seen('Z')) retract_zlift = code_value();
  3881. #if EXTRUDERS > 1
  3882. if (code_seen('W')) retract_length_swap = code_value();
  3883. #endif
  3884. }
  3885. /**
  3886. * M208: Set firmware un-retraction values
  3887. *
  3888. * S[+mm] retract_recover_length (in addition to M207 S*)
  3889. * W[+mm] retract_recover_length_swap (multi-extruder)
  3890. * F[mm/min] retract_recover_feedrate
  3891. */
  3892. inline void gcode_M208() {
  3893. if (code_seen('S')) retract_recover_length = code_value();
  3894. if (code_seen('F')) retract_recover_feedrate = code_value() / 60;
  3895. #if EXTRUDERS > 1
  3896. if (code_seen('W')) retract_recover_length_swap = code_value();
  3897. #endif
  3898. }
  3899. /**
  3900. * M209: Enable automatic retract (M209 S1)
  3901. * detect if the slicer did not support G10/11: every normal extrude-only move will be classified as retract depending on the direction.
  3902. */
  3903. inline void gcode_M209() {
  3904. if (code_seen('S')) {
  3905. int t = code_value_short();
  3906. switch(t) {
  3907. case 0:
  3908. autoretract_enabled = false;
  3909. break;
  3910. case 1:
  3911. autoretract_enabled = true;
  3912. break;
  3913. default:
  3914. unknown_command_error();
  3915. return;
  3916. }
  3917. for (int i=0; i<EXTRUDERS; i++) retracted[i] = false;
  3918. }
  3919. }
  3920. #endif // FWRETRACT
  3921. #if EXTRUDERS > 1
  3922. /**
  3923. * M218 - set hotend offset (in mm), T<extruder_number> X<offset_on_X> Y<offset_on_Y>
  3924. */
  3925. inline void gcode_M218() {
  3926. if (setTargetedHotend(218)) return;
  3927. if (code_seen('X')) extruder_offset[X_AXIS][target_extruder] = code_value();
  3928. if (code_seen('Y')) extruder_offset[Y_AXIS][target_extruder] = code_value();
  3929. #if ENABLED(DUAL_X_CARRIAGE)
  3930. if (code_seen('Z')) extruder_offset[Z_AXIS][target_extruder] = code_value();
  3931. #endif
  3932. SERIAL_ECHO_START;
  3933. SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
  3934. for (int e = 0; e < EXTRUDERS; e++) {
  3935. SERIAL_CHAR(' ');
  3936. SERIAL_ECHO(extruder_offset[X_AXIS][e]);
  3937. SERIAL_CHAR(',');
  3938. SERIAL_ECHO(extruder_offset[Y_AXIS][e]);
  3939. #if ENABLED(DUAL_X_CARRIAGE)
  3940. SERIAL_CHAR(',');
  3941. SERIAL_ECHO(extruder_offset[Z_AXIS][e]);
  3942. #endif
  3943. }
  3944. SERIAL_EOL;
  3945. }
  3946. #endif // EXTRUDERS > 1
  3947. /**
  3948. * M220: Set speed percentage factor, aka "Feed Rate" (M220 S95)
  3949. */
  3950. inline void gcode_M220() {
  3951. if (code_seen('S')) feedrate_multiplier = code_value();
  3952. }
  3953. /**
  3954. * M221: Set extrusion percentage (M221 T0 S95)
  3955. */
  3956. inline void gcode_M221() {
  3957. if (code_seen('S')) {
  3958. int sval = code_value();
  3959. if (code_seen('T')) {
  3960. if (setTargetedHotend(221)) return;
  3961. extruder_multiplier[target_extruder] = sval;
  3962. }
  3963. else {
  3964. extruder_multiplier[active_extruder] = sval;
  3965. }
  3966. }
  3967. }
  3968. /**
  3969. * M226: Wait until the specified pin reaches the state required (M226 P<pin> S<state>)
  3970. */
  3971. inline void gcode_M226() {
  3972. if (code_seen('P')) {
  3973. int pin_number = code_value();
  3974. int pin_state = code_seen('S') ? code_value() : -1; // required pin state - default is inverted
  3975. if (pin_state >= -1 && pin_state <= 1) {
  3976. for (uint8_t i = 0; i < COUNT(sensitive_pins); i++) {
  3977. if (sensitive_pins[i] == pin_number) {
  3978. pin_number = -1;
  3979. break;
  3980. }
  3981. }
  3982. if (pin_number > -1) {
  3983. int target = LOW;
  3984. st_synchronize();
  3985. pinMode(pin_number, INPUT);
  3986. switch(pin_state){
  3987. case 1:
  3988. target = HIGH;
  3989. break;
  3990. case 0:
  3991. target = LOW;
  3992. break;
  3993. case -1:
  3994. target = !digitalRead(pin_number);
  3995. break;
  3996. }
  3997. while (digitalRead(pin_number) != target) idle();
  3998. } // pin_number > -1
  3999. } // pin_state -1 0 1
  4000. } // code_seen('P')
  4001. }
  4002. #if HAS_SERVOS
  4003. /**
  4004. * M280: Get or set servo position. P<index> S<angle>
  4005. */
  4006. inline void gcode_M280() {
  4007. int servo_index = code_seen('P') ? code_value_short() : -1;
  4008. int servo_position = 0;
  4009. if (code_seen('S')) {
  4010. servo_position = code_value_short();
  4011. if (servo_index >= 0 && servo_index < NUM_SERVOS)
  4012. servo[servo_index].move(servo_position);
  4013. else {
  4014. SERIAL_ECHO_START;
  4015. SERIAL_ECHO("Servo ");
  4016. SERIAL_ECHO(servo_index);
  4017. SERIAL_ECHOLN(" out of range");
  4018. }
  4019. }
  4020. else if (servo_index >= 0) {
  4021. SERIAL_PROTOCOL(MSG_OK);
  4022. SERIAL_PROTOCOL(" Servo ");
  4023. SERIAL_PROTOCOL(servo_index);
  4024. SERIAL_PROTOCOL(": ");
  4025. SERIAL_PROTOCOL(servo[servo_index].read());
  4026. SERIAL_EOL;
  4027. }
  4028. }
  4029. #endif // HAS_SERVOS
  4030. #if HAS_BUZZER
  4031. /**
  4032. * M300: Play beep sound S<frequency Hz> P<duration ms>
  4033. */
  4034. inline void gcode_M300() {
  4035. uint16_t beepS = code_seen('S') ? code_value_short() : 110;
  4036. uint32_t beepP = code_seen('P') ? code_value_long() : 1000;
  4037. if (beepP > 5000) beepP = 5000; // limit to 5 seconds
  4038. buzz(beepP, beepS);
  4039. }
  4040. #endif // HAS_BUZZER
  4041. #if ENABLED(PIDTEMP)
  4042. /**
  4043. * M301: Set PID parameters P I D (and optionally C)
  4044. */
  4045. inline void gcode_M301() {
  4046. // multi-extruder PID patch: M301 updates or prints a single extruder's PID values
  4047. // default behaviour (omitting E parameter) is to update for extruder 0 only
  4048. int e = code_seen('E') ? code_value() : 0; // extruder being updated
  4049. if (e < EXTRUDERS) { // catch bad input value
  4050. if (code_seen('P')) PID_PARAM(Kp, e) = code_value();
  4051. if (code_seen('I')) PID_PARAM(Ki, e) = scalePID_i(code_value());
  4052. if (code_seen('D')) PID_PARAM(Kd, e) = scalePID_d(code_value());
  4053. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  4054. if (code_seen('C')) PID_PARAM(Kc, e) = code_value();
  4055. #endif
  4056. updatePID();
  4057. SERIAL_PROTOCOL(MSG_OK);
  4058. #if ENABLED(PID_PARAMS_PER_EXTRUDER)
  4059. SERIAL_PROTOCOL(" e:"); // specify extruder in serial output
  4060. SERIAL_PROTOCOL(e);
  4061. #endif // PID_PARAMS_PER_EXTRUDER
  4062. SERIAL_PROTOCOL(" p:");
  4063. SERIAL_PROTOCOL(PID_PARAM(Kp, e));
  4064. SERIAL_PROTOCOL(" i:");
  4065. SERIAL_PROTOCOL(unscalePID_i(PID_PARAM(Ki, e)));
  4066. SERIAL_PROTOCOL(" d:");
  4067. SERIAL_PROTOCOL(unscalePID_d(PID_PARAM(Kd, e)));
  4068. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  4069. SERIAL_PROTOCOL(" c:");
  4070. //Kc does not have scaling applied above, or in resetting defaults
  4071. SERIAL_PROTOCOL(PID_PARAM(Kc, e));
  4072. #endif
  4073. SERIAL_EOL;
  4074. }
  4075. else {
  4076. SERIAL_ECHO_START;
  4077. SERIAL_ECHOLN(MSG_INVALID_EXTRUDER);
  4078. }
  4079. }
  4080. #endif // PIDTEMP
  4081. #if ENABLED(PIDTEMPBED)
  4082. inline void gcode_M304() {
  4083. if (code_seen('P')) bedKp = code_value();
  4084. if (code_seen('I')) bedKi = scalePID_i(code_value());
  4085. if (code_seen('D')) bedKd = scalePID_d(code_value());
  4086. updatePID();
  4087. SERIAL_PROTOCOL(MSG_OK);
  4088. SERIAL_PROTOCOL(" p:");
  4089. SERIAL_PROTOCOL(bedKp);
  4090. SERIAL_PROTOCOL(" i:");
  4091. SERIAL_PROTOCOL(unscalePID_i(bedKi));
  4092. SERIAL_PROTOCOL(" d:");
  4093. SERIAL_PROTOCOL(unscalePID_d(bedKd));
  4094. SERIAL_EOL;
  4095. }
  4096. #endif // PIDTEMPBED
  4097. #if defined(CHDK) || HAS_PHOTOGRAPH
  4098. /**
  4099. * M240: Trigger a camera by emulating a Canon RC-1
  4100. * See http://www.doc-diy.net/photo/rc-1_hacked/
  4101. */
  4102. inline void gcode_M240() {
  4103. #ifdef CHDK
  4104. OUT_WRITE(CHDK, HIGH);
  4105. chdkHigh = millis();
  4106. chdkActive = true;
  4107. #elif HAS_PHOTOGRAPH
  4108. const uint8_t NUM_PULSES = 16;
  4109. const float PULSE_LENGTH = 0.01524;
  4110. for (int i = 0; i < NUM_PULSES; i++) {
  4111. WRITE(PHOTOGRAPH_PIN, HIGH);
  4112. _delay_ms(PULSE_LENGTH);
  4113. WRITE(PHOTOGRAPH_PIN, LOW);
  4114. _delay_ms(PULSE_LENGTH);
  4115. }
  4116. delay(7.33);
  4117. for (int i = 0; i < NUM_PULSES; i++) {
  4118. WRITE(PHOTOGRAPH_PIN, HIGH);
  4119. _delay_ms(PULSE_LENGTH);
  4120. WRITE(PHOTOGRAPH_PIN, LOW);
  4121. _delay_ms(PULSE_LENGTH);
  4122. }
  4123. #endif // !CHDK && HAS_PHOTOGRAPH
  4124. }
  4125. #endif // CHDK || PHOTOGRAPH_PIN
  4126. #if ENABLED(HAS_LCD_CONTRAST)
  4127. /**
  4128. * M250: Read and optionally set the LCD contrast
  4129. */
  4130. inline void gcode_M250() {
  4131. if (code_seen('C')) lcd_setcontrast(code_value_short() & 0x3F);
  4132. SERIAL_PROTOCOLPGM("lcd contrast value: ");
  4133. SERIAL_PROTOCOL(lcd_contrast);
  4134. SERIAL_EOL;
  4135. }
  4136. #endif // HAS_LCD_CONTRAST
  4137. #if ENABLED(PREVENT_DANGEROUS_EXTRUDE)
  4138. void set_extrude_min_temp(float temp) { extrude_min_temp = temp; }
  4139. /**
  4140. * M302: Allow cold extrudes, or set the minimum extrude S<temperature>.
  4141. */
  4142. inline void gcode_M302() {
  4143. set_extrude_min_temp(code_seen('S') ? code_value() : 0);
  4144. }
  4145. #endif // PREVENT_DANGEROUS_EXTRUDE
  4146. /**
  4147. * M303: PID relay autotune
  4148. * S<temperature> sets the target temperature. (default target temperature = 150C)
  4149. * E<extruder> (-1 for the bed)
  4150. * C<cycles>
  4151. */
  4152. inline void gcode_M303() {
  4153. int e = code_seen('E') ? code_value_short() : 0;
  4154. int c = code_seen('C') ? code_value_short() : 5;
  4155. float temp = code_seen('S') ? code_value() : (e < 0 ? 70.0 : 150.0);
  4156. PID_autotune(temp, e, c);
  4157. }
  4158. #if ENABLED(SCARA)
  4159. bool SCARA_move_to_cal(uint8_t delta_x, uint8_t delta_y) {
  4160. //SoftEndsEnabled = false; // Ignore soft endstops during calibration
  4161. //SERIAL_ECHOLN(" Soft endstops disabled ");
  4162. if (IsRunning()) {
  4163. //gcode_get_destination(); // For X Y Z E F
  4164. delta[X_AXIS] = delta_x;
  4165. delta[Y_AXIS] = delta_y;
  4166. calculate_SCARA_forward_Transform(delta);
  4167. destination[X_AXIS] = delta[X_AXIS]/axis_scaling[X_AXIS];
  4168. destination[Y_AXIS] = delta[Y_AXIS]/axis_scaling[Y_AXIS];
  4169. prepare_move();
  4170. //ok_to_send();
  4171. return true;
  4172. }
  4173. return false;
  4174. }
  4175. /**
  4176. * M360: SCARA calibration: Move to cal-position ThetaA (0 deg calibration)
  4177. */
  4178. inline bool gcode_M360() {
  4179. SERIAL_ECHOLN(" Cal: Theta 0 ");
  4180. return SCARA_move_to_cal(0, 120);
  4181. }
  4182. /**
  4183. * M361: SCARA calibration: Move to cal-position ThetaB (90 deg calibration - steps per degree)
  4184. */
  4185. inline bool gcode_M361() {
  4186. SERIAL_ECHOLN(" Cal: Theta 90 ");
  4187. return SCARA_move_to_cal(90, 130);
  4188. }
  4189. /**
  4190. * M362: SCARA calibration: Move to cal-position PsiA (0 deg calibration)
  4191. */
  4192. inline bool gcode_M362() {
  4193. SERIAL_ECHOLN(" Cal: Psi 0 ");
  4194. return SCARA_move_to_cal(60, 180);
  4195. }
  4196. /**
  4197. * M363: SCARA calibration: Move to cal-position PsiB (90 deg calibration - steps per degree)
  4198. */
  4199. inline bool gcode_M363() {
  4200. SERIAL_ECHOLN(" Cal: Psi 90 ");
  4201. return SCARA_move_to_cal(50, 90);
  4202. }
  4203. /**
  4204. * M364: SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
  4205. */
  4206. inline bool gcode_M364() {
  4207. SERIAL_ECHOLN(" Cal: Theta-Psi 90 ");
  4208. return SCARA_move_to_cal(45, 135);
  4209. }
  4210. /**
  4211. * M365: SCARA calibration: Scaling factor, X, Y, Z axis
  4212. */
  4213. inline void gcode_M365() {
  4214. for (int8_t i = X_AXIS; i <= Z_AXIS; i++) {
  4215. if (code_seen(axis_codes[i])) {
  4216. axis_scaling[i] = code_value();
  4217. }
  4218. }
  4219. }
  4220. #endif // SCARA
  4221. #if ENABLED(EXT_SOLENOID)
  4222. void enable_solenoid(uint8_t num) {
  4223. switch(num) {
  4224. case 0:
  4225. OUT_WRITE(SOL0_PIN, HIGH);
  4226. break;
  4227. #if HAS_SOLENOID_1
  4228. case 1:
  4229. OUT_WRITE(SOL1_PIN, HIGH);
  4230. break;
  4231. #endif
  4232. #if HAS_SOLENOID_2
  4233. case 2:
  4234. OUT_WRITE(SOL2_PIN, HIGH);
  4235. break;
  4236. #endif
  4237. #if HAS_SOLENOID_3
  4238. case 3:
  4239. OUT_WRITE(SOL3_PIN, HIGH);
  4240. break;
  4241. #endif
  4242. default:
  4243. SERIAL_ECHO_START;
  4244. SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID);
  4245. break;
  4246. }
  4247. }
  4248. void enable_solenoid_on_active_extruder() { enable_solenoid(active_extruder); }
  4249. void disable_all_solenoids() {
  4250. OUT_WRITE(SOL0_PIN, LOW);
  4251. OUT_WRITE(SOL1_PIN, LOW);
  4252. OUT_WRITE(SOL2_PIN, LOW);
  4253. OUT_WRITE(SOL3_PIN, LOW);
  4254. }
  4255. /**
  4256. * M380: Enable solenoid on the active extruder
  4257. */
  4258. inline void gcode_M380() { enable_solenoid_on_active_extruder(); }
  4259. /**
  4260. * M381: Disable all solenoids
  4261. */
  4262. inline void gcode_M381() { disable_all_solenoids(); }
  4263. #endif // EXT_SOLENOID
  4264. /**
  4265. * M400: Finish all moves
  4266. */
  4267. inline void gcode_M400() { st_synchronize(); }
  4268. #if ENABLED(AUTO_BED_LEVELING_FEATURE) && DISABLED(Z_PROBE_SLED) && (HAS_SERVO_ENDSTOPS || ENABLED(Z_PROBE_ALLEN_KEY))
  4269. /**
  4270. * M401: Engage Z Servo endstop if available
  4271. */
  4272. inline void gcode_M401() {
  4273. #if HAS_SERVO_ENDSTOPS
  4274. raise_z_for_servo();
  4275. #endif
  4276. deploy_z_probe();
  4277. }
  4278. /**
  4279. * M402: Retract Z Servo endstop if enabled
  4280. */
  4281. inline void gcode_M402() {
  4282. #if HAS_SERVO_ENDSTOPS
  4283. raise_z_for_servo();
  4284. #endif
  4285. stow_z_probe(false);
  4286. }
  4287. #endif // AUTO_BED_LEVELING_FEATURE && (HAS_SERVO_ENDSTOPS || Z_PROBE_ALLEN_KEY) && !Z_PROBE_SLED
  4288. #if ENABLED(FILAMENT_SENSOR)
  4289. /**
  4290. * M404: Display or set the nominal filament width (3mm, 1.75mm ) W<3.0>
  4291. */
  4292. inline void gcode_M404() {
  4293. #if HAS_FILWIDTH
  4294. if (code_seen('W')) {
  4295. filament_width_nominal = code_value();
  4296. }
  4297. else {
  4298. SERIAL_PROTOCOLPGM("Filament dia (nominal mm):");
  4299. SERIAL_PROTOCOLLN(filament_width_nominal);
  4300. }
  4301. #endif
  4302. }
  4303. /**
  4304. * M405: Turn on filament sensor for control
  4305. */
  4306. inline void gcode_M405() {
  4307. if (code_seen('D')) meas_delay_cm = code_value();
  4308. if (meas_delay_cm > MAX_MEASUREMENT_DELAY) meas_delay_cm = MAX_MEASUREMENT_DELAY;
  4309. if (delay_index2 == -1) { //initialize the ring buffer if it has not been done since startup
  4310. int temp_ratio = widthFil_to_size_ratio();
  4311. for (delay_index1 = 0; delay_index1 < MAX_MEASUREMENT_DELAY + 1; ++delay_index1)
  4312. measurement_delay[delay_index1] = temp_ratio - 100; //subtract 100 to scale within a signed byte
  4313. delay_index1 = delay_index2 = 0;
  4314. }
  4315. filament_sensor = true;
  4316. //SERIAL_PROTOCOLPGM("Filament dia (measured mm):");
  4317. //SERIAL_PROTOCOL(filament_width_meas);
  4318. //SERIAL_PROTOCOLPGM("Extrusion ratio(%):");
  4319. //SERIAL_PROTOCOL(extruder_multiplier[active_extruder]);
  4320. }
  4321. /**
  4322. * M406: Turn off filament sensor for control
  4323. */
  4324. inline void gcode_M406() { filament_sensor = false; }
  4325. /**
  4326. * M407: Get measured filament diameter on serial output
  4327. */
  4328. inline void gcode_M407() {
  4329. SERIAL_PROTOCOLPGM("Filament dia (measured mm):");
  4330. SERIAL_PROTOCOLLN(filament_width_meas);
  4331. }
  4332. #endif // FILAMENT_SENSOR
  4333. /**
  4334. * M410: Quickstop - Abort all planned moves
  4335. *
  4336. * This will stop the carriages mid-move, so most likely they
  4337. * will be out of sync with the stepper position after this.
  4338. */
  4339. inline void gcode_M410() { quickStop(); }
  4340. #if ENABLED(MESH_BED_LEVELING)
  4341. /**
  4342. * M420: Enable/Disable Mesh Bed Leveling
  4343. */
  4344. inline void gcode_M420() { if (code_seen('S') && code_has_value()) mbl.active = !!code_value_short(); }
  4345. /**
  4346. * M421: Set a single Mesh Bed Leveling Z coordinate
  4347. */
  4348. inline void gcode_M421() {
  4349. float x, y, z;
  4350. bool err = false, hasX, hasY, hasZ;
  4351. if ((hasX = code_seen('X'))) x = code_value();
  4352. if ((hasY = code_seen('Y'))) y = code_value();
  4353. if ((hasZ = code_seen('Z'))) z = code_value();
  4354. if (!hasX || !hasY || !hasZ) {
  4355. SERIAL_ERROR_START;
  4356. SERIAL_ERRORLNPGM(MSG_ERR_M421_REQUIRES_XYZ);
  4357. err = true;
  4358. }
  4359. if (x >= MESH_NUM_X_POINTS || y >= MESH_NUM_Y_POINTS) {
  4360. SERIAL_ERROR_START;
  4361. SERIAL_ERRORLNPGM(MSG_ERR_MESH_INDEX_OOB);
  4362. err = true;
  4363. }
  4364. if (!err) mbl.set_z(mbl.select_x_index(x), mbl.select_y_index(y), z);
  4365. }
  4366. #endif
  4367. /**
  4368. * M428: Set home_offset based on the distance between the
  4369. * current_position and the nearest "reference point."
  4370. * If an axis is past center its endstop position
  4371. * is the reference-point. Otherwise it uses 0. This allows
  4372. * the Z offset to be set near the bed when using a max endstop.
  4373. *
  4374. * M428 can't be used more than 2cm away from 0 or an endstop.
  4375. *
  4376. * Use M206 to set these values directly.
  4377. */
  4378. inline void gcode_M428() {
  4379. bool err = false;
  4380. float new_offs[3], new_pos[3];
  4381. memcpy(new_pos, current_position, sizeof(new_pos));
  4382. memcpy(new_offs, home_offset, sizeof(new_offs));
  4383. for (int8_t i = X_AXIS; i <= Z_AXIS; i++) {
  4384. if (axis_known_position[i]) {
  4385. float base = (new_pos[i] > (min_pos[i] + max_pos[i]) / 2) ? base_home_pos(i) : 0,
  4386. diff = new_pos[i] - base;
  4387. if (diff > -20 && diff < 20) {
  4388. new_offs[i] -= diff;
  4389. new_pos[i] = base;
  4390. }
  4391. else {
  4392. SERIAL_ERROR_START;
  4393. SERIAL_ERRORLNPGM(MSG_ERR_M428_TOO_FAR);
  4394. LCD_ALERTMESSAGEPGM("Err: Too far!");
  4395. #if HAS_BUZZER
  4396. enqueuecommands_P(PSTR("M300 S40 P200"));
  4397. #endif
  4398. err = true;
  4399. break;
  4400. }
  4401. }
  4402. }
  4403. if (!err) {
  4404. memcpy(current_position, new_pos, sizeof(new_pos));
  4405. memcpy(home_offset, new_offs, sizeof(new_offs));
  4406. sync_plan_position();
  4407. LCD_ALERTMESSAGEPGM("Offset applied.");
  4408. #if HAS_BUZZER
  4409. enqueuecommands_P(PSTR("M300 S659 P200\nM300 S698 P200"));
  4410. #endif
  4411. }
  4412. }
  4413. /**
  4414. * M500: Store settings in EEPROM
  4415. */
  4416. inline void gcode_M500() {
  4417. Config_StoreSettings();
  4418. }
  4419. /**
  4420. * M501: Read settings from EEPROM
  4421. */
  4422. inline void gcode_M501() {
  4423. Config_RetrieveSettings();
  4424. }
  4425. /**
  4426. * M502: Revert to default settings
  4427. */
  4428. inline void gcode_M502() {
  4429. Config_ResetDefault();
  4430. }
  4431. /**
  4432. * M503: print settings currently in memory
  4433. */
  4434. inline void gcode_M503() {
  4435. Config_PrintSettings(code_seen('S') && code_value() == 0);
  4436. }
  4437. #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
  4438. /**
  4439. * M540: Set whether SD card print should abort on endstop hit (M540 S<0|1>)
  4440. */
  4441. inline void gcode_M540() {
  4442. if (code_seen('S')) abort_on_endstop_hit = (code_value() > 0);
  4443. }
  4444. #endif // ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
  4445. #ifdef CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
  4446. inline void gcode_SET_Z_PROBE_OFFSET() {
  4447. SERIAL_ECHO_START;
  4448. SERIAL_ECHOPGM(MSG_ZPROBE_ZOFFSET);
  4449. SERIAL_CHAR(' ');
  4450. if (code_seen('Z')) {
  4451. float value = code_value();
  4452. if (Z_PROBE_OFFSET_RANGE_MIN <= value && value <= Z_PROBE_OFFSET_RANGE_MAX) {
  4453. zprobe_zoffset = value;
  4454. SERIAL_ECHOPGM(MSG_OK);
  4455. }
  4456. else {
  4457. SERIAL_ECHOPGM(MSG_Z_MIN);
  4458. SERIAL_ECHO(Z_PROBE_OFFSET_RANGE_MIN);
  4459. SERIAL_ECHOPGM(MSG_Z_MAX);
  4460. SERIAL_ECHO(Z_PROBE_OFFSET_RANGE_MAX);
  4461. }
  4462. }
  4463. else {
  4464. SERIAL_ECHOPAIR(": ", zprobe_zoffset);
  4465. }
  4466. SERIAL_EOL;
  4467. }
  4468. #endif // CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
  4469. #if ENABLED(FILAMENTCHANGEENABLE)
  4470. /**
  4471. * M600: Pause for filament change
  4472. *
  4473. * E[distance] - Retract the filament this far (negative value)
  4474. * Z[distance] - Move the Z axis by this distance
  4475. * X[position] - Move to this X position, with Y
  4476. * Y[position] - Move to this Y position, with X
  4477. * L[distance] - Retract distance for removal (manual reload)
  4478. *
  4479. * Default values are used for omitted arguments.
  4480. *
  4481. */
  4482. inline void gcode_M600() {
  4483. if (degHotend(active_extruder) < extrude_min_temp) {
  4484. SERIAL_ERROR_START;
  4485. SERIAL_ERRORLNPGM(MSG_TOO_COLD_FOR_M600);
  4486. return;
  4487. }
  4488. float lastpos[NUM_AXIS], fr60 = feedrate / 60;
  4489. for (int i=0; i<NUM_AXIS; i++)
  4490. lastpos[i] = destination[i] = current_position[i];
  4491. #if ENABLED(DELTA)
  4492. #define RUNPLAN calculate_delta(destination); \
  4493. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], fr60, active_extruder);
  4494. #else
  4495. #define RUNPLAN line_to_destination();
  4496. #endif
  4497. //retract by E
  4498. if (code_seen('E')) destination[E_AXIS] += code_value();
  4499. #ifdef FILAMENTCHANGE_FIRSTRETRACT
  4500. else destination[E_AXIS] += FILAMENTCHANGE_FIRSTRETRACT;
  4501. #endif
  4502. RUNPLAN;
  4503. //lift Z
  4504. if (code_seen('Z')) destination[Z_AXIS] += code_value();
  4505. #ifdef FILAMENTCHANGE_ZADD
  4506. else destination[Z_AXIS] += FILAMENTCHANGE_ZADD;
  4507. #endif
  4508. RUNPLAN;
  4509. //move xy
  4510. if (code_seen('X')) destination[X_AXIS] = code_value();
  4511. #ifdef FILAMENTCHANGE_XPOS
  4512. else destination[X_AXIS] = FILAMENTCHANGE_XPOS;
  4513. #endif
  4514. if (code_seen('Y')) destination[Y_AXIS] = code_value();
  4515. #ifdef FILAMENTCHANGE_YPOS
  4516. else destination[Y_AXIS] = FILAMENTCHANGE_YPOS;
  4517. #endif
  4518. RUNPLAN;
  4519. if (code_seen('L')) destination[E_AXIS] += code_value();
  4520. #ifdef FILAMENTCHANGE_FINALRETRACT
  4521. else destination[E_AXIS] += FILAMENTCHANGE_FINALRETRACT;
  4522. #endif
  4523. RUNPLAN;
  4524. //finish moves
  4525. st_synchronize();
  4526. //disable extruder steppers so filament can be removed
  4527. disable_e0();
  4528. disable_e1();
  4529. disable_e2();
  4530. disable_e3();
  4531. delay(100);
  4532. LCD_ALERTMESSAGEPGM(MSG_FILAMENTCHANGE);
  4533. millis_t next_tick = 0;
  4534. while (!lcd_clicked()) {
  4535. #if DISABLED(AUTO_FILAMENT_CHANGE)
  4536. millis_t ms = millis();
  4537. if (ms >= next_tick) {
  4538. lcd_quick_feedback();
  4539. next_tick = ms + 2500; // feedback every 2.5s while waiting
  4540. }
  4541. manage_heater();
  4542. manage_inactivity(true);
  4543. lcd_update();
  4544. #else
  4545. current_position[E_AXIS] += AUTO_FILAMENT_CHANGE_LENGTH;
  4546. destination[E_AXIS] = current_position[E_AXIS];
  4547. line_to_destination(AUTO_FILAMENT_CHANGE_FEEDRATE);
  4548. st_synchronize();
  4549. #endif
  4550. } // while(!lcd_clicked)
  4551. lcd_quick_feedback(); // click sound feedback
  4552. #if ENABLED(AUTO_FILAMENT_CHANGE)
  4553. current_position[E_AXIS] = 0;
  4554. st_synchronize();
  4555. #endif
  4556. //return to normal
  4557. if (code_seen('L')) destination[E_AXIS] -= code_value();
  4558. #ifdef FILAMENTCHANGE_FINALRETRACT
  4559. else destination[E_AXIS] -= FILAMENTCHANGE_FINALRETRACT;
  4560. #endif
  4561. current_position[E_AXIS] = destination[E_AXIS]; //the long retract of L is compensated by manual filament feeding
  4562. plan_set_e_position(current_position[E_AXIS]);
  4563. RUNPLAN; //should do nothing
  4564. lcd_reset_alert_level();
  4565. #if ENABLED(DELTA)
  4566. // Move XYZ to starting position, then E
  4567. calculate_delta(lastpos);
  4568. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], fr60, active_extruder);
  4569. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], lastpos[E_AXIS], fr60, active_extruder);
  4570. #else
  4571. // Move XY to starting position, then Z, then E
  4572. destination[X_AXIS] = lastpos[X_AXIS];
  4573. destination[Y_AXIS] = lastpos[Y_AXIS];
  4574. line_to_destination();
  4575. destination[Z_AXIS] = lastpos[Z_AXIS];
  4576. line_to_destination();
  4577. destination[E_AXIS] = lastpos[E_AXIS];
  4578. line_to_destination();
  4579. #endif
  4580. #if ENABLED(FILAMENT_RUNOUT_SENSOR)
  4581. filrunoutEnqueued = false;
  4582. #endif
  4583. }
  4584. #endif // FILAMENTCHANGEENABLE
  4585. #if ENABLED(DUAL_X_CARRIAGE)
  4586. /**
  4587. * M605: Set dual x-carriage movement mode
  4588. *
  4589. * M605 S0: Full control mode. The slicer has full control over x-carriage movement
  4590. * M605 S1: Auto-park mode. The inactive head will auto park/unpark without slicer involvement
  4591. * M605 S2 [Xnnn] [Rmmm]: Duplication mode. The second extruder will duplicate the first with nnn
  4592. * millimeters x-offset and an optional differential hotend temperature of
  4593. * mmm degrees. E.g., with "M605 S2 X100 R2" the second extruder will duplicate
  4594. * the first with a spacing of 100mm in the x direction and 2 degrees hotter.
  4595. *
  4596. * Note: the X axis should be homed after changing dual x-carriage mode.
  4597. */
  4598. inline void gcode_M605() {
  4599. st_synchronize();
  4600. if (code_seen('S')) dual_x_carriage_mode = code_value();
  4601. switch(dual_x_carriage_mode) {
  4602. case DXC_DUPLICATION_MODE:
  4603. if (code_seen('X')) duplicate_extruder_x_offset = max(code_value(), X2_MIN_POS - x_home_pos(0));
  4604. if (code_seen('R')) duplicate_extruder_temp_offset = code_value();
  4605. SERIAL_ECHO_START;
  4606. SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
  4607. SERIAL_CHAR(' ');
  4608. SERIAL_ECHO(extruder_offset[X_AXIS][0]);
  4609. SERIAL_CHAR(',');
  4610. SERIAL_ECHO(extruder_offset[Y_AXIS][0]);
  4611. SERIAL_CHAR(' ');
  4612. SERIAL_ECHO(duplicate_extruder_x_offset);
  4613. SERIAL_CHAR(',');
  4614. SERIAL_ECHOLN(extruder_offset[Y_AXIS][1]);
  4615. break;
  4616. case DXC_FULL_CONTROL_MODE:
  4617. case DXC_AUTO_PARK_MODE:
  4618. break;
  4619. default:
  4620. dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE;
  4621. break;
  4622. }
  4623. active_extruder_parked = false;
  4624. extruder_duplication_enabled = false;
  4625. delayed_move_time = 0;
  4626. }
  4627. #endif // DUAL_X_CARRIAGE
  4628. /**
  4629. * M907: Set digital trimpot motor current using axis codes X, Y, Z, E, B, S
  4630. */
  4631. inline void gcode_M907() {
  4632. #if HAS_DIGIPOTSS
  4633. for (int i=0;i<NUM_AXIS;i++)
  4634. if (code_seen(axis_codes[i])) digipot_current(i, code_value());
  4635. if (code_seen('B')) digipot_current(4, code_value());
  4636. if (code_seen('S')) for (int i=0; i<=4; i++) digipot_current(i, code_value());
  4637. #endif
  4638. #ifdef MOTOR_CURRENT_PWM_XY_PIN
  4639. if (code_seen('X')) digipot_current(0, code_value());
  4640. #endif
  4641. #ifdef MOTOR_CURRENT_PWM_Z_PIN
  4642. if (code_seen('Z')) digipot_current(1, code_value());
  4643. #endif
  4644. #ifdef MOTOR_CURRENT_PWM_E_PIN
  4645. if (code_seen('E')) digipot_current(2, code_value());
  4646. #endif
  4647. #if ENABLED(DIGIPOT_I2C)
  4648. // this one uses actual amps in floating point
  4649. for (int i=0;i<NUM_AXIS;i++) if(code_seen(axis_codes[i])) digipot_i2c_set_current(i, code_value());
  4650. // for each additional extruder (named B,C,D,E..., channels 4,5,6,7...)
  4651. for (int i=NUM_AXIS;i<DIGIPOT_I2C_NUM_CHANNELS;i++) if(code_seen('B'+i-NUM_AXIS)) digipot_i2c_set_current(i, code_value());
  4652. #endif
  4653. }
  4654. #if HAS_DIGIPOTSS
  4655. /**
  4656. * M908: Control digital trimpot directly (M908 P<pin> S<current>)
  4657. */
  4658. inline void gcode_M908() {
  4659. digitalPotWrite(
  4660. code_seen('P') ? code_value() : 0,
  4661. code_seen('S') ? code_value() : 0
  4662. );
  4663. }
  4664. #endif // HAS_DIGIPOTSS
  4665. #if HAS_MICROSTEPS
  4666. // M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
  4667. inline void gcode_M350() {
  4668. if(code_seen('S')) for(int i=0;i<=4;i++) microstep_mode(i,code_value());
  4669. for(int i=0;i<NUM_AXIS;i++) if(code_seen(axis_codes[i])) microstep_mode(i,(uint8_t)code_value());
  4670. if(code_seen('B')) microstep_mode(4,code_value());
  4671. microstep_readings();
  4672. }
  4673. /**
  4674. * M351: Toggle MS1 MS2 pins directly with axis codes X Y Z E B
  4675. * S# determines MS1 or MS2, X# sets the pin high/low.
  4676. */
  4677. inline void gcode_M351() {
  4678. if (code_seen('S')) switch(code_value_short()) {
  4679. case 1:
  4680. for(int i=0;i<NUM_AXIS;i++) if (code_seen(axis_codes[i])) microstep_ms(i, code_value(), -1);
  4681. if (code_seen('B')) microstep_ms(4, code_value(), -1);
  4682. break;
  4683. case 2:
  4684. for(int i=0;i<NUM_AXIS;i++) if (code_seen(axis_codes[i])) microstep_ms(i, -1, code_value());
  4685. if (code_seen('B')) microstep_ms(4, -1, code_value());
  4686. break;
  4687. }
  4688. microstep_readings();
  4689. }
  4690. #endif // HAS_MICROSTEPS
  4691. /**
  4692. * M999: Restart after being stopped
  4693. */
  4694. inline void gcode_M999() {
  4695. Running = true;
  4696. lcd_reset_alert_level();
  4697. // gcode_LastN = Stopped_gcode_LastN;
  4698. FlushSerialRequestResend();
  4699. }
  4700. /**
  4701. * T0-T3: Switch tool, usually switching extruders
  4702. *
  4703. * F[mm/min] Set the movement feedrate
  4704. */
  4705. inline void gcode_T(uint8_t tmp_extruder) {
  4706. if (tmp_extruder >= EXTRUDERS) {
  4707. SERIAL_ECHO_START;
  4708. SERIAL_CHAR('T');
  4709. SERIAL_PROTOCOL_F(tmp_extruder,DEC);
  4710. SERIAL_ECHOLN(MSG_INVALID_EXTRUDER);
  4711. }
  4712. else {
  4713. target_extruder = tmp_extruder;
  4714. #if EXTRUDERS > 1
  4715. bool make_move = false;
  4716. #endif
  4717. if (code_seen('F')) {
  4718. #if EXTRUDERS > 1
  4719. make_move = true;
  4720. #endif
  4721. float next_feedrate = code_value();
  4722. if (next_feedrate > 0.0) feedrate = next_feedrate;
  4723. }
  4724. #if EXTRUDERS > 1
  4725. if (tmp_extruder != active_extruder) {
  4726. // Save current position to return to after applying extruder offset
  4727. set_destination_to_current();
  4728. #if ENABLED(DUAL_X_CARRIAGE)
  4729. if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE && IsRunning() &&
  4730. (delayed_move_time != 0 || current_position[X_AXIS] != x_home_pos(active_extruder))) {
  4731. // Park old head: 1) raise 2) move to park position 3) lower
  4732. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT,
  4733. current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder);
  4734. plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT,
  4735. current_position[E_AXIS], max_feedrate[X_AXIS], active_extruder);
  4736. plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS],
  4737. current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder);
  4738. st_synchronize();
  4739. }
  4740. // apply Y & Z extruder offset (x offset is already used in determining home pos)
  4741. current_position[Y_AXIS] = current_position[Y_AXIS] -
  4742. extruder_offset[Y_AXIS][active_extruder] +
  4743. extruder_offset[Y_AXIS][tmp_extruder];
  4744. current_position[Z_AXIS] = current_position[Z_AXIS] -
  4745. extruder_offset[Z_AXIS][active_extruder] +
  4746. extruder_offset[Z_AXIS][tmp_extruder];
  4747. active_extruder = tmp_extruder;
  4748. // This function resets the max/min values - the current position may be overwritten below.
  4749. set_axis_is_at_home(X_AXIS);
  4750. if (dual_x_carriage_mode == DXC_FULL_CONTROL_MODE) {
  4751. current_position[X_AXIS] = inactive_extruder_x_pos;
  4752. inactive_extruder_x_pos = destination[X_AXIS];
  4753. }
  4754. else if (dual_x_carriage_mode == DXC_DUPLICATION_MODE) {
  4755. active_extruder_parked = (active_extruder == 0); // this triggers the second extruder to move into the duplication position
  4756. if (active_extruder == 0 || active_extruder_parked)
  4757. current_position[X_AXIS] = inactive_extruder_x_pos;
  4758. else
  4759. current_position[X_AXIS] = destination[X_AXIS] + duplicate_extruder_x_offset;
  4760. inactive_extruder_x_pos = destination[X_AXIS];
  4761. extruder_duplication_enabled = false;
  4762. }
  4763. else {
  4764. // record raised toolhead position for use by unpark
  4765. memcpy(raised_parked_position, current_position, sizeof(raised_parked_position));
  4766. raised_parked_position[Z_AXIS] += TOOLCHANGE_UNPARK_ZLIFT;
  4767. active_extruder_parked = true;
  4768. delayed_move_time = 0;
  4769. }
  4770. #else // !DUAL_X_CARRIAGE
  4771. // Offset extruder (only by XY)
  4772. for (int i=X_AXIS; i<=Y_AXIS; i++)
  4773. current_position[i] += extruder_offset[i][tmp_extruder] - extruder_offset[i][active_extruder];
  4774. // Set the new active extruder and position
  4775. active_extruder = tmp_extruder;
  4776. #endif // !DUAL_X_CARRIAGE
  4777. #if ENABLED(DELTA)
  4778. sync_plan_position_delta();
  4779. #else
  4780. sync_plan_position();
  4781. #endif
  4782. // Move to the old position if 'F' was in the parameters
  4783. if (make_move && IsRunning()) prepare_move();
  4784. }
  4785. #if ENABLED(EXT_SOLENOID)
  4786. st_synchronize();
  4787. disable_all_solenoids();
  4788. enable_solenoid_on_active_extruder();
  4789. #endif // EXT_SOLENOID
  4790. #endif // EXTRUDERS > 1
  4791. SERIAL_ECHO_START;
  4792. SERIAL_ECHO(MSG_ACTIVE_EXTRUDER);
  4793. SERIAL_PROTOCOLLN((int)active_extruder);
  4794. }
  4795. }
  4796. /**
  4797. * Process a single command and dispatch it to its handler
  4798. * This is called from the main loop()
  4799. */
  4800. void process_next_command() {
  4801. current_command = command_queue[cmd_queue_index_r];
  4802. if ((marlin_debug_flags & DEBUG_ECHO)) {
  4803. SERIAL_ECHO_START;
  4804. SERIAL_ECHOLN(current_command);
  4805. }
  4806. // Sanitize the current command:
  4807. // - Skip leading spaces
  4808. // - Bypass N[0-9][0-9]*[ ]*
  4809. // - Overwrite * with nul to mark the end
  4810. while (*current_command == ' ') ++current_command;
  4811. if (*current_command == 'N' && ((current_command[1] >= '0' && current_command[1] <= '9') || current_command[1] == '-')) {
  4812. current_command += 2; // skip N[-0-9]
  4813. while (*current_command >= '0' && *current_command <= '9') ++current_command; // skip [0-9]*
  4814. while (*current_command == ' ') ++current_command; // skip [ ]*
  4815. }
  4816. char *starpos = strchr(current_command, '*'); // * should always be the last parameter
  4817. if (starpos) while (*starpos == ' ' || *starpos == '*') *starpos-- = '\0'; // nullify '*' and ' '
  4818. // Get the command code, which must be G, M, or T
  4819. char command_code = *current_command;
  4820. // The code must have a numeric value
  4821. bool code_is_good = (current_command[1] >= '0' && current_command[1] <= '9');
  4822. int codenum; // define ahead of goto
  4823. // Bail early if there's no code
  4824. if (!code_is_good) goto ExitUnknownCommand;
  4825. // Args pointer optimizes code_seen, especially those taking XYZEF
  4826. // This wastes a little cpu on commands that expect no arguments.
  4827. current_command_args = current_command;
  4828. while (*current_command_args && *current_command_args != ' ') ++current_command_args;
  4829. while (*current_command_args == ' ') ++current_command_args;
  4830. // Interpret the code int
  4831. seen_pointer = current_command;
  4832. codenum = code_value_short();
  4833. // Handle a known G, M, or T
  4834. switch(command_code) {
  4835. case 'G': switch (codenum) {
  4836. // G0, G1
  4837. case 0:
  4838. case 1:
  4839. gcode_G0_G1();
  4840. break;
  4841. // G2, G3
  4842. #if DISABLED(SCARA)
  4843. case 2: // G2 - CW ARC
  4844. case 3: // G3 - CCW ARC
  4845. gcode_G2_G3(codenum == 2);
  4846. break;
  4847. #endif
  4848. // G4 Dwell
  4849. case 4:
  4850. gcode_G4();
  4851. break;
  4852. #if ENABLED(FWRETRACT)
  4853. case 10: // G10: retract
  4854. case 11: // G11: retract_recover
  4855. gcode_G10_G11(codenum == 10);
  4856. break;
  4857. #endif //FWRETRACT
  4858. case 28: // G28: Home all axes, one at a time
  4859. gcode_G28();
  4860. break;
  4861. #if ENABLED(AUTO_BED_LEVELING_FEATURE) || ENABLED(MESH_BED_LEVELING)
  4862. case 29: // G29 Detailed Z probe, probes the bed at 3 or more points.
  4863. gcode_G29();
  4864. break;
  4865. #endif
  4866. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  4867. #if DISABLED(Z_PROBE_SLED)
  4868. case 30: // G30 Single Z probe
  4869. gcode_G30();
  4870. break;
  4871. #else // Z_PROBE_SLED
  4872. case 31: // G31: dock the sled
  4873. case 32: // G32: undock the sled
  4874. dock_sled(codenum == 31);
  4875. break;
  4876. #endif // Z_PROBE_SLED
  4877. #endif // AUTO_BED_LEVELING_FEATURE
  4878. case 90: // G90
  4879. relative_mode = false;
  4880. break;
  4881. case 91: // G91
  4882. relative_mode = true;
  4883. break;
  4884. case 92: // G92
  4885. gcode_G92();
  4886. break;
  4887. }
  4888. break;
  4889. case 'M': switch (codenum) {
  4890. #if ENABLED(ULTIPANEL)
  4891. case 0: // M0 - Unconditional stop - Wait for user button press on LCD
  4892. case 1: // M1 - Conditional stop - Wait for user button press on LCD
  4893. gcode_M0_M1();
  4894. break;
  4895. #endif // ULTIPANEL
  4896. case 17:
  4897. gcode_M17();
  4898. break;
  4899. #if ENABLED(SDSUPPORT)
  4900. case 20: // M20 - list SD card
  4901. gcode_M20(); break;
  4902. case 21: // M21 - init SD card
  4903. gcode_M21(); break;
  4904. case 22: //M22 - release SD card
  4905. gcode_M22(); break;
  4906. case 23: //M23 - Select file
  4907. gcode_M23(); break;
  4908. case 24: //M24 - Start SD print
  4909. gcode_M24(); break;
  4910. case 25: //M25 - Pause SD print
  4911. gcode_M25(); break;
  4912. case 26: //M26 - Set SD index
  4913. gcode_M26(); break;
  4914. case 27: //M27 - Get SD status
  4915. gcode_M27(); break;
  4916. case 28: //M28 - Start SD write
  4917. gcode_M28(); break;
  4918. case 29: //M29 - Stop SD write
  4919. gcode_M29(); break;
  4920. case 30: //M30 <filename> Delete File
  4921. gcode_M30(); break;
  4922. case 32: //M32 - Select file and start SD print
  4923. gcode_M32(); break;
  4924. #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
  4925. case 33: //M33 - Get the long full path to a file or folder
  4926. gcode_M33(); break;
  4927. #endif // LONG_FILENAME_HOST_SUPPORT
  4928. case 928: //M928 - Start SD write
  4929. gcode_M928(); break;
  4930. #endif //SDSUPPORT
  4931. case 31: //M31 take time since the start of the SD print or an M109 command
  4932. gcode_M31();
  4933. break;
  4934. case 42: //M42 -Change pin status via gcode
  4935. gcode_M42();
  4936. break;
  4937. #if ENABLED(AUTO_BED_LEVELING_FEATURE) && ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
  4938. case 48: // M48 Z probe repeatability
  4939. gcode_M48();
  4940. break;
  4941. #endif // AUTO_BED_LEVELING_FEATURE && Z_MIN_PROBE_REPEATABILITY_TEST
  4942. #if ENABLED(M100_FREE_MEMORY_WATCHER)
  4943. case 100:
  4944. gcode_M100();
  4945. break;
  4946. #endif
  4947. case 104: // M104
  4948. gcode_M104();
  4949. break;
  4950. case 111: // M111: Set debug level
  4951. gcode_M111();
  4952. break;
  4953. case 112: // M112: Emergency Stop
  4954. gcode_M112();
  4955. break;
  4956. case 140: // M140: Set bed temp
  4957. gcode_M140();
  4958. break;
  4959. case 105: // M105: Read current temperature
  4960. gcode_M105();
  4961. return; // "ok" already printed
  4962. case 109: // M109: Wait for temperature
  4963. gcode_M109();
  4964. break;
  4965. #if HAS_TEMP_BED
  4966. case 190: // M190: Wait for bed heater to reach target
  4967. gcode_M190();
  4968. break;
  4969. #endif // HAS_TEMP_BED
  4970. #if HAS_FAN
  4971. case 106: // M106: Fan On
  4972. gcode_M106();
  4973. break;
  4974. case 107: // M107: Fan Off
  4975. gcode_M107();
  4976. break;
  4977. #endif // HAS_FAN
  4978. #if ENABLED(BARICUDA)
  4979. // PWM for HEATER_1_PIN
  4980. #if HAS_HEATER_1
  4981. case 126: // M126: valve open
  4982. gcode_M126();
  4983. break;
  4984. case 127: // M127: valve closed
  4985. gcode_M127();
  4986. break;
  4987. #endif // HAS_HEATER_1
  4988. // PWM for HEATER_2_PIN
  4989. #if HAS_HEATER_2
  4990. case 128: // M128: valve open
  4991. gcode_M128();
  4992. break;
  4993. case 129: // M129: valve closed
  4994. gcode_M129();
  4995. break;
  4996. #endif // HAS_HEATER_2
  4997. #endif // BARICUDA
  4998. #if HAS_POWER_SWITCH
  4999. case 80: // M80: Turn on Power Supply
  5000. gcode_M80();
  5001. break;
  5002. #endif // HAS_POWER_SWITCH
  5003. case 81: // M81: Turn off Power, including Power Supply, if possible
  5004. gcode_M81();
  5005. break;
  5006. case 82:
  5007. gcode_M82();
  5008. break;
  5009. case 83:
  5010. gcode_M83();
  5011. break;
  5012. case 18: // (for compatibility)
  5013. case 84: // M84
  5014. gcode_M18_M84();
  5015. break;
  5016. case 85: // M85
  5017. gcode_M85();
  5018. break;
  5019. case 92: // M92: Set the steps-per-unit for one or more axes
  5020. gcode_M92();
  5021. break;
  5022. case 115: // M115: Report capabilities
  5023. gcode_M115();
  5024. break;
  5025. case 117: // M117: Set LCD message text, if possible
  5026. gcode_M117();
  5027. break;
  5028. case 114: // M114: Report current position
  5029. gcode_M114();
  5030. break;
  5031. case 120: // M120: Enable endstops
  5032. gcode_M120();
  5033. break;
  5034. case 121: // M121: Disable endstops
  5035. gcode_M121();
  5036. break;
  5037. case 119: // M119: Report endstop states
  5038. gcode_M119();
  5039. break;
  5040. #if ENABLED(ULTIPANEL)
  5041. case 145: // M145: Set material heatup parameters
  5042. gcode_M145();
  5043. break;
  5044. #endif
  5045. #if ENABLED(BLINKM)
  5046. case 150: // M150
  5047. gcode_M150();
  5048. break;
  5049. #endif //BLINKM
  5050. case 200: // M200 D<millimeters> set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).
  5051. gcode_M200();
  5052. break;
  5053. case 201: // M201
  5054. gcode_M201();
  5055. break;
  5056. #if 0 // Not used for Sprinter/grbl gen6
  5057. case 202: // M202
  5058. gcode_M202();
  5059. break;
  5060. #endif
  5061. case 203: // M203 max feedrate mm/sec
  5062. gcode_M203();
  5063. break;
  5064. case 204: // M204 acclereration S normal moves T filmanent only moves
  5065. gcode_M204();
  5066. break;
  5067. case 205: //M205 advanced settings: minimum travel speed S=while printing T=travel only, B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk
  5068. gcode_M205();
  5069. break;
  5070. case 206: // M206 additional homing offset
  5071. gcode_M206();
  5072. break;
  5073. #if ENABLED(DELTA)
  5074. case 665: // M665 set delta configurations L<diagonal_rod> R<delta_radius> S<segments_per_sec>
  5075. gcode_M665();
  5076. break;
  5077. #endif
  5078. #if ENABLED(DELTA) || ENABLED(Z_DUAL_ENDSTOPS)
  5079. case 666: // M666 set delta / dual endstop adjustment
  5080. gcode_M666();
  5081. break;
  5082. #endif
  5083. #if ENABLED(FWRETRACT)
  5084. case 207: //M207 - set retract length S[positive mm] F[feedrate mm/min] Z[additional zlift/hop]
  5085. gcode_M207();
  5086. break;
  5087. case 208: // M208 - set retract recover length S[positive mm surplus to the M207 S*] F[feedrate mm/min]
  5088. gcode_M208();
  5089. break;
  5090. case 209: // M209 - S<1=true/0=false> enable automatic retract detect if the slicer did not support G10/11: every normal extrude-only move will be classified as retract depending on the direction.
  5091. gcode_M209();
  5092. break;
  5093. #endif // FWRETRACT
  5094. #if EXTRUDERS > 1
  5095. case 218: // M218 - set hotend offset (in mm), T<extruder_number> X<offset_on_X> Y<offset_on_Y>
  5096. gcode_M218();
  5097. break;
  5098. #endif
  5099. case 220: // M220 S<factor in percent>- set speed factor override percentage
  5100. gcode_M220();
  5101. break;
  5102. case 221: // M221 S<factor in percent>- set extrude factor override percentage
  5103. gcode_M221();
  5104. break;
  5105. case 226: // M226 P<pin number> S<pin state>- Wait until the specified pin reaches the state required
  5106. gcode_M226();
  5107. break;
  5108. #if HAS_SERVOS
  5109. case 280: // M280 - set servo position absolute. P: servo index, S: angle or microseconds
  5110. gcode_M280();
  5111. break;
  5112. #endif // HAS_SERVOS
  5113. #if HAS_BUZZER
  5114. case 300: // M300 - Play beep tone
  5115. gcode_M300();
  5116. break;
  5117. #endif // HAS_BUZZER
  5118. #if ENABLED(PIDTEMP)
  5119. case 301: // M301
  5120. gcode_M301();
  5121. break;
  5122. #endif // PIDTEMP
  5123. #if ENABLED(PIDTEMPBED)
  5124. case 304: // M304
  5125. gcode_M304();
  5126. break;
  5127. #endif // PIDTEMPBED
  5128. #if defined(CHDK) || HAS_PHOTOGRAPH
  5129. case 240: // M240 Triggers a camera by emulating a Canon RC-1 : http://www.doc-diy.net/photo/rc-1_hacked/
  5130. gcode_M240();
  5131. break;
  5132. #endif // CHDK || PHOTOGRAPH_PIN
  5133. #if ENABLED(HAS_LCD_CONTRAST)
  5134. case 250: // M250 Set LCD contrast value: C<value> (value 0..63)
  5135. gcode_M250();
  5136. break;
  5137. #endif // HAS_LCD_CONTRAST
  5138. #if ENABLED(PREVENT_DANGEROUS_EXTRUDE)
  5139. case 302: // allow cold extrudes, or set the minimum extrude temperature
  5140. gcode_M302();
  5141. break;
  5142. #endif // PREVENT_DANGEROUS_EXTRUDE
  5143. case 303: // M303 PID autotune
  5144. gcode_M303();
  5145. break;
  5146. #if ENABLED(SCARA)
  5147. case 360: // M360 SCARA Theta pos1
  5148. if (gcode_M360()) return;
  5149. break;
  5150. case 361: // M361 SCARA Theta pos2
  5151. if (gcode_M361()) return;
  5152. break;
  5153. case 362: // M362 SCARA Psi pos1
  5154. if (gcode_M362()) return;
  5155. break;
  5156. case 363: // M363 SCARA Psi pos2
  5157. if (gcode_M363()) return;
  5158. break;
  5159. case 364: // M364 SCARA Psi pos3 (90 deg to Theta)
  5160. if (gcode_M364()) return;
  5161. break;
  5162. case 365: // M365 Set SCARA scaling for X Y Z
  5163. gcode_M365();
  5164. break;
  5165. #endif // SCARA
  5166. case 400: // M400 finish all moves
  5167. gcode_M400();
  5168. break;
  5169. #if ENABLED(AUTO_BED_LEVELING_FEATURE) && (HAS_SERVO_ENDSTOPS || ENABLED(Z_PROBE_ALLEN_KEY)) && DISABLED(Z_PROBE_SLED)
  5170. case 401:
  5171. gcode_M401();
  5172. break;
  5173. case 402:
  5174. gcode_M402();
  5175. break;
  5176. #endif // AUTO_BED_LEVELING_FEATURE && (HAS_SERVO_ENDSTOPS || Z_PROBE_ALLEN_KEY) && !Z_PROBE_SLED
  5177. #if ENABLED(FILAMENT_SENSOR)
  5178. case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or display nominal filament width
  5179. gcode_M404();
  5180. break;
  5181. case 405: //M405 Turn on filament sensor for control
  5182. gcode_M405();
  5183. break;
  5184. case 406: //M406 Turn off filament sensor for control
  5185. gcode_M406();
  5186. break;
  5187. case 407: //M407 Display measured filament diameter
  5188. gcode_M407();
  5189. break;
  5190. #endif // FILAMENT_SENSOR
  5191. case 410: // M410 quickstop - Abort all the planned moves.
  5192. gcode_M410();
  5193. break;
  5194. #if ENABLED(MESH_BED_LEVELING)
  5195. case 420: // M420 Enable/Disable Mesh Bed Leveling
  5196. gcode_M420();
  5197. break;
  5198. case 421: // M421 Set a Mesh Bed Leveling Z coordinate
  5199. gcode_M421();
  5200. break;
  5201. #endif
  5202. case 428: // M428 Apply current_position to home_offset
  5203. gcode_M428();
  5204. break;
  5205. case 500: // M500 Store settings in EEPROM
  5206. gcode_M500();
  5207. break;
  5208. case 501: // M501 Read settings from EEPROM
  5209. gcode_M501();
  5210. break;
  5211. case 502: // M502 Revert to default settings
  5212. gcode_M502();
  5213. break;
  5214. case 503: // M503 print settings currently in memory
  5215. gcode_M503();
  5216. break;
  5217. #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
  5218. case 540:
  5219. gcode_M540();
  5220. break;
  5221. #endif
  5222. #ifdef CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
  5223. case CUSTOM_M_CODE_SET_Z_PROBE_OFFSET:
  5224. gcode_SET_Z_PROBE_OFFSET();
  5225. break;
  5226. #endif // CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
  5227. #if ENABLED(FILAMENTCHANGEENABLE)
  5228. case 600: //Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
  5229. gcode_M600();
  5230. break;
  5231. #endif // FILAMENTCHANGEENABLE
  5232. #if ENABLED(DUAL_X_CARRIAGE)
  5233. case 605:
  5234. gcode_M605();
  5235. break;
  5236. #endif // DUAL_X_CARRIAGE
  5237. case 907: // M907 Set digital trimpot motor current using axis codes.
  5238. gcode_M907();
  5239. break;
  5240. #if HAS_DIGIPOTSS
  5241. case 908: // M908 Control digital trimpot directly.
  5242. gcode_M908();
  5243. break;
  5244. #endif // HAS_DIGIPOTSS
  5245. #if HAS_MICROSTEPS
  5246. case 350: // M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
  5247. gcode_M350();
  5248. break;
  5249. case 351: // M351 Toggle MS1 MS2 pins directly, S# determines MS1 or MS2, X# sets the pin high/low.
  5250. gcode_M351();
  5251. break;
  5252. #endif // HAS_MICROSTEPS
  5253. case 999: // M999: Restart after being Stopped
  5254. gcode_M999();
  5255. break;
  5256. }
  5257. break;
  5258. case 'T':
  5259. gcode_T(codenum);
  5260. break;
  5261. default: code_is_good = false;
  5262. }
  5263. ExitUnknownCommand:
  5264. // Still unknown command? Throw an error
  5265. if (!code_is_good) unknown_command_error();
  5266. ok_to_send();
  5267. }
  5268. void FlushSerialRequestResend() {
  5269. //char command_queue[cmd_queue_index_r][100]="Resend:";
  5270. MYSERIAL.flush();
  5271. SERIAL_PROTOCOLPGM(MSG_RESEND);
  5272. SERIAL_PROTOCOLLN(gcode_LastN + 1);
  5273. ok_to_send();
  5274. }
  5275. void ok_to_send() {
  5276. refresh_cmd_timeout();
  5277. #if ENABLED(SDSUPPORT)
  5278. if (fromsd[cmd_queue_index_r]) return;
  5279. #endif
  5280. SERIAL_PROTOCOLPGM(MSG_OK);
  5281. #if ENABLED(ADVANCED_OK)
  5282. SERIAL_PROTOCOLPGM(" N"); SERIAL_PROTOCOL(gcode_LastN);
  5283. SERIAL_PROTOCOLPGM(" P"); SERIAL_PROTOCOL(int(BLOCK_BUFFER_SIZE - movesplanned() - 1));
  5284. SERIAL_PROTOCOLPGM(" B"); SERIAL_PROTOCOL(BUFSIZE - commands_in_queue);
  5285. #endif
  5286. SERIAL_EOL;
  5287. }
  5288. void clamp_to_software_endstops(float target[3]) {
  5289. if (min_software_endstops) {
  5290. NOLESS(target[X_AXIS], min_pos[X_AXIS]);
  5291. NOLESS(target[Y_AXIS], min_pos[Y_AXIS]);
  5292. float negative_z_offset = 0;
  5293. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  5294. if (zprobe_zoffset < 0) negative_z_offset += zprobe_zoffset;
  5295. if (home_offset[Z_AXIS] < 0) {
  5296. #if ENABLED(DEBUG_LEVELING_FEATURE)
  5297. if (marlin_debug_flags & DEBUG_LEVELING) {
  5298. SERIAL_ECHOPAIR("> clamp_to_software_endstops > Add home_offset[Z_AXIS]:", home_offset[Z_AXIS]);
  5299. SERIAL_EOL;
  5300. }
  5301. #endif
  5302. negative_z_offset += home_offset[Z_AXIS];
  5303. }
  5304. #endif
  5305. NOLESS(target[Z_AXIS], min_pos[Z_AXIS] + negative_z_offset);
  5306. }
  5307. if (max_software_endstops) {
  5308. NOMORE(target[X_AXIS], max_pos[X_AXIS]);
  5309. NOMORE(target[Y_AXIS], max_pos[Y_AXIS]);
  5310. NOMORE(target[Z_AXIS], max_pos[Z_AXIS]);
  5311. }
  5312. }
  5313. #if ENABLED(DELTA)
  5314. void recalc_delta_settings(float radius, float diagonal_rod) {
  5315. delta_tower1_x = -SIN_60 * (radius + DELTA_RADIUS_TRIM_TOWER_1); // front left tower
  5316. delta_tower1_y = -COS_60 * (radius + DELTA_RADIUS_TRIM_TOWER_1);
  5317. delta_tower2_x = SIN_60 * (radius + DELTA_RADIUS_TRIM_TOWER_2); // front right tower
  5318. delta_tower2_y = -COS_60 * (radius + DELTA_RADIUS_TRIM_TOWER_2);
  5319. delta_tower3_x = 0.0; // back middle tower
  5320. delta_tower3_y = (radius + DELTA_RADIUS_TRIM_TOWER_3);
  5321. delta_diagonal_rod_2_tower_1 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_1);
  5322. delta_diagonal_rod_2_tower_2 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_2);
  5323. delta_diagonal_rod_2_tower_3 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_3);
  5324. }
  5325. void calculate_delta(float cartesian[3]) {
  5326. delta[TOWER_1] = sqrt(delta_diagonal_rod_2_tower_1
  5327. - sq(delta_tower1_x-cartesian[X_AXIS])
  5328. - sq(delta_tower1_y-cartesian[Y_AXIS])
  5329. ) + cartesian[Z_AXIS];
  5330. delta[TOWER_2] = sqrt(delta_diagonal_rod_2_tower_2
  5331. - sq(delta_tower2_x-cartesian[X_AXIS])
  5332. - sq(delta_tower2_y-cartesian[Y_AXIS])
  5333. ) + cartesian[Z_AXIS];
  5334. delta[TOWER_3] = sqrt(delta_diagonal_rod_2_tower_3
  5335. - sq(delta_tower3_x-cartesian[X_AXIS])
  5336. - sq(delta_tower3_y-cartesian[Y_AXIS])
  5337. ) + cartesian[Z_AXIS];
  5338. /*
  5339. SERIAL_ECHOPGM("cartesian x="); SERIAL_ECHO(cartesian[X_AXIS]);
  5340. SERIAL_ECHOPGM(" y="); SERIAL_ECHO(cartesian[Y_AXIS]);
  5341. SERIAL_ECHOPGM(" z="); SERIAL_ECHOLN(cartesian[Z_AXIS]);
  5342. SERIAL_ECHOPGM("delta a="); SERIAL_ECHO(delta[TOWER_1]);
  5343. SERIAL_ECHOPGM(" b="); SERIAL_ECHO(delta[TOWER_2]);
  5344. SERIAL_ECHOPGM(" c="); SERIAL_ECHOLN(delta[TOWER_3]);
  5345. */
  5346. }
  5347. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  5348. // Adjust print surface height by linear interpolation over the bed_level array.
  5349. void adjust_delta(float cartesian[3]) {
  5350. if (delta_grid_spacing[0] == 0 || delta_grid_spacing[1] == 0) return; // G29 not done!
  5351. int half = (AUTO_BED_LEVELING_GRID_POINTS - 1) / 2;
  5352. float h1 = 0.001 - half, h2 = half - 0.001,
  5353. grid_x = max(h1, min(h2, cartesian[X_AXIS] / delta_grid_spacing[0])),
  5354. grid_y = max(h1, min(h2, cartesian[Y_AXIS] / delta_grid_spacing[1]));
  5355. int floor_x = floor(grid_x), floor_y = floor(grid_y);
  5356. float ratio_x = grid_x - floor_x, ratio_y = grid_y - floor_y,
  5357. z1 = bed_level[floor_x + half][floor_y + half],
  5358. z2 = bed_level[floor_x + half][floor_y + half + 1],
  5359. z3 = bed_level[floor_x + half + 1][floor_y + half],
  5360. z4 = bed_level[floor_x + half + 1][floor_y + half + 1],
  5361. left = (1 - ratio_y) * z1 + ratio_y * z2,
  5362. right = (1 - ratio_y) * z3 + ratio_y * z4,
  5363. offset = (1 - ratio_x) * left + ratio_x * right;
  5364. delta[X_AXIS] += offset;
  5365. delta[Y_AXIS] += offset;
  5366. delta[Z_AXIS] += offset;
  5367. /*
  5368. SERIAL_ECHOPGM("grid_x="); SERIAL_ECHO(grid_x);
  5369. SERIAL_ECHOPGM(" grid_y="); SERIAL_ECHO(grid_y);
  5370. SERIAL_ECHOPGM(" floor_x="); SERIAL_ECHO(floor_x);
  5371. SERIAL_ECHOPGM(" floor_y="); SERIAL_ECHO(floor_y);
  5372. SERIAL_ECHOPGM(" ratio_x="); SERIAL_ECHO(ratio_x);
  5373. SERIAL_ECHOPGM(" ratio_y="); SERIAL_ECHO(ratio_y);
  5374. SERIAL_ECHOPGM(" z1="); SERIAL_ECHO(z1);
  5375. SERIAL_ECHOPGM(" z2="); SERIAL_ECHO(z2);
  5376. SERIAL_ECHOPGM(" z3="); SERIAL_ECHO(z3);
  5377. SERIAL_ECHOPGM(" z4="); SERIAL_ECHO(z4);
  5378. SERIAL_ECHOPGM(" left="); SERIAL_ECHO(left);
  5379. SERIAL_ECHOPGM(" right="); SERIAL_ECHO(right);
  5380. SERIAL_ECHOPGM(" offset="); SERIAL_ECHOLN(offset);
  5381. */
  5382. }
  5383. #endif // AUTO_BED_LEVELING_FEATURE
  5384. #endif // DELTA
  5385. #if ENABLED(MESH_BED_LEVELING)
  5386. // This function is used to split lines on mesh borders so each segment is only part of one mesh area
  5387. void mesh_plan_buffer_line(float x, float y, float z, const float e, float feed_rate, const uint8_t &extruder, uint8_t x_splits=0xff, uint8_t y_splits=0xff)
  5388. {
  5389. if (!mbl.active) {
  5390. plan_buffer_line(x, y, z, e, feed_rate, extruder);
  5391. set_current_to_destination();
  5392. return;
  5393. }
  5394. int pix = mbl.select_x_index(current_position[X_AXIS]);
  5395. int piy = mbl.select_y_index(current_position[Y_AXIS]);
  5396. int ix = mbl.select_x_index(x);
  5397. int iy = mbl.select_y_index(y);
  5398. pix = min(pix, MESH_NUM_X_POINTS - 2);
  5399. piy = min(piy, MESH_NUM_Y_POINTS - 2);
  5400. ix = min(ix, MESH_NUM_X_POINTS - 2);
  5401. iy = min(iy, MESH_NUM_Y_POINTS - 2);
  5402. if (pix == ix && piy == iy) {
  5403. // Start and end on same mesh square
  5404. plan_buffer_line(x, y, z, e, feed_rate, extruder);
  5405. set_current_to_destination();
  5406. return;
  5407. }
  5408. float nx, ny, ne, normalized_dist;
  5409. if (ix > pix && (x_splits) & BIT(ix)) {
  5410. nx = mbl.get_x(ix);
  5411. normalized_dist = (nx - current_position[X_AXIS])/(x - current_position[X_AXIS]);
  5412. ny = current_position[Y_AXIS] + (y - current_position[Y_AXIS]) * normalized_dist;
  5413. ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist;
  5414. x_splits ^= BIT(ix);
  5415. } else if (ix < pix && (x_splits) & BIT(pix)) {
  5416. nx = mbl.get_x(pix);
  5417. normalized_dist = (nx - current_position[X_AXIS])/(x - current_position[X_AXIS]);
  5418. ny = current_position[Y_AXIS] + (y - current_position[Y_AXIS]) * normalized_dist;
  5419. ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist;
  5420. x_splits ^= BIT(pix);
  5421. } else if (iy > piy && (y_splits) & BIT(iy)) {
  5422. ny = mbl.get_y(iy);
  5423. normalized_dist = (ny - current_position[Y_AXIS])/(y - current_position[Y_AXIS]);
  5424. nx = current_position[X_AXIS] + (x - current_position[X_AXIS]) * normalized_dist;
  5425. ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist;
  5426. y_splits ^= BIT(iy);
  5427. } else if (iy < piy && (y_splits) & BIT(piy)) {
  5428. ny = mbl.get_y(piy);
  5429. normalized_dist = (ny - current_position[Y_AXIS])/(y - current_position[Y_AXIS]);
  5430. nx = current_position[X_AXIS] + (x - current_position[X_AXIS]) * normalized_dist;
  5431. ne = current_position[E_AXIS] + (e - current_position[E_AXIS]) * normalized_dist;
  5432. y_splits ^= BIT(piy);
  5433. } else {
  5434. // Already split on a border
  5435. plan_buffer_line(x, y, z, e, feed_rate, extruder);
  5436. set_current_to_destination();
  5437. return;
  5438. }
  5439. // Do the split and look for more borders
  5440. destination[X_AXIS] = nx;
  5441. destination[Y_AXIS] = ny;
  5442. destination[E_AXIS] = ne;
  5443. mesh_plan_buffer_line(nx, ny, z, ne, feed_rate, extruder, x_splits, y_splits);
  5444. destination[X_AXIS] = x;
  5445. destination[Y_AXIS] = y;
  5446. destination[E_AXIS] = e;
  5447. mesh_plan_buffer_line(x, y, z, e, feed_rate, extruder, x_splits, y_splits);
  5448. }
  5449. #endif // MESH_BED_LEVELING
  5450. #if ENABLED(PREVENT_DANGEROUS_EXTRUDE)
  5451. inline void prevent_dangerous_extrude(float &curr_e, float &dest_e) {
  5452. if (marlin_debug_flags & DEBUG_DRYRUN) return;
  5453. float de = dest_e - curr_e;
  5454. if (de) {
  5455. if (degHotend(active_extruder) < extrude_min_temp) {
  5456. curr_e = dest_e; // Behave as if the move really took place, but ignore E part
  5457. SERIAL_ECHO_START;
  5458. SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
  5459. }
  5460. #if ENABLED(PREVENT_LENGTHY_EXTRUDE)
  5461. if (labs(de) > EXTRUDE_MAXLENGTH) {
  5462. curr_e = dest_e; // Behave as if the move really took place, but ignore E part
  5463. SERIAL_ECHO_START;
  5464. SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
  5465. }
  5466. #endif
  5467. }
  5468. }
  5469. #endif // PREVENT_DANGEROUS_EXTRUDE
  5470. #if ENABLED(DELTA) || ENABLED(SCARA)
  5471. inline bool prepare_move_delta(float target[NUM_AXIS]) {
  5472. float difference[NUM_AXIS];
  5473. for (int8_t i=0; i < NUM_AXIS; i++) difference[i] = target[i] - current_position[i];
  5474. float cartesian_mm = sqrt(sq(difference[X_AXIS]) + sq(difference[Y_AXIS]) + sq(difference[Z_AXIS]));
  5475. if (cartesian_mm < 0.000001) cartesian_mm = abs(difference[E_AXIS]);
  5476. if (cartesian_mm < 0.000001) return false;
  5477. float seconds = 6000 * cartesian_mm / feedrate / feedrate_multiplier;
  5478. int steps = max(1, int(delta_segments_per_second * seconds));
  5479. // SERIAL_ECHOPGM("mm="); SERIAL_ECHO(cartesian_mm);
  5480. // SERIAL_ECHOPGM(" seconds="); SERIAL_ECHO(seconds);
  5481. // SERIAL_ECHOPGM(" steps="); SERIAL_ECHOLN(steps);
  5482. for (int s = 1; s <= steps; s++) {
  5483. float fraction = float(s) / float(steps);
  5484. for (int8_t i = 0; i < NUM_AXIS; i++)
  5485. target[i] = current_position[i] + difference[i] * fraction;
  5486. calculate_delta(target);
  5487. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  5488. adjust_delta(target);
  5489. #endif
  5490. //SERIAL_ECHOPGM("target[X_AXIS]="); SERIAL_ECHOLN(target[X_AXIS]);
  5491. //SERIAL_ECHOPGM("target[Y_AXIS]="); SERIAL_ECHOLN(target[Y_AXIS]);
  5492. //SERIAL_ECHOPGM("target[Z_AXIS]="); SERIAL_ECHOLN(target[Z_AXIS]);
  5493. //SERIAL_ECHOPGM("delta[X_AXIS]="); SERIAL_ECHOLN(delta[X_AXIS]);
  5494. //SERIAL_ECHOPGM("delta[Y_AXIS]="); SERIAL_ECHOLN(delta[Y_AXIS]);
  5495. //SERIAL_ECHOPGM("delta[Z_AXIS]="); SERIAL_ECHOLN(delta[Z_AXIS]);
  5496. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], target[E_AXIS], feedrate/60*feedrate_multiplier/100.0, active_extruder);
  5497. }
  5498. return true;
  5499. }
  5500. #endif // DELTA || SCARA
  5501. #if ENABLED(SCARA)
  5502. inline bool prepare_move_scara(float target[NUM_AXIS]) { return prepare_move_delta(target); }
  5503. #endif
  5504. #if ENABLED(DUAL_X_CARRIAGE)
  5505. inline bool prepare_move_dual_x_carriage() {
  5506. if (active_extruder_parked) {
  5507. if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && active_extruder == 0) {
  5508. // move duplicate extruder into correct duplication position.
  5509. plan_set_position(inactive_extruder_x_pos, current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
  5510. plan_buffer_line(current_position[X_AXIS] + duplicate_extruder_x_offset,
  5511. current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], max_feedrate[X_AXIS], 1);
  5512. sync_plan_position();
  5513. st_synchronize();
  5514. extruder_duplication_enabled = true;
  5515. active_extruder_parked = false;
  5516. }
  5517. else if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE) { // handle unparking of head
  5518. if (current_position[E_AXIS] == destination[E_AXIS]) {
  5519. // This is a travel move (with no extrusion)
  5520. // Skip it, but keep track of the current position
  5521. // (so it can be used as the start of the next non-travel move)
  5522. if (delayed_move_time != 0xFFFFFFFFUL) {
  5523. set_current_to_destination();
  5524. NOLESS(raised_parked_position[Z_AXIS], destination[Z_AXIS]);
  5525. delayed_move_time = millis();
  5526. return false;
  5527. }
  5528. }
  5529. delayed_move_time = 0;
  5530. // unpark extruder: 1) raise, 2) move into starting XY position, 3) lower
  5531. plan_buffer_line(raised_parked_position[X_AXIS], raised_parked_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder);
  5532. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], min(max_feedrate[X_AXIS], max_feedrate[Y_AXIS]), active_extruder);
  5533. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder);
  5534. active_extruder_parked = false;
  5535. }
  5536. }
  5537. return true;
  5538. }
  5539. #endif // DUAL_X_CARRIAGE
  5540. #if DISABLED(DELTA) && DISABLED(SCARA)
  5541. inline bool prepare_move_cartesian() {
  5542. // Do not use feedrate_multiplier for E or Z only moves
  5543. if (current_position[X_AXIS] == destination[X_AXIS] && current_position[Y_AXIS] == destination[Y_AXIS]) {
  5544. line_to_destination();
  5545. }
  5546. else {
  5547. #if ENABLED(MESH_BED_LEVELING)
  5548. mesh_plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], (feedrate/60)*(feedrate_multiplier/100.0), active_extruder);
  5549. return false;
  5550. #else
  5551. line_to_destination(feedrate * feedrate_multiplier / 100.0);
  5552. #endif
  5553. }
  5554. return true;
  5555. }
  5556. #endif // !DELTA && !SCARA
  5557. /**
  5558. * Prepare a single move and get ready for the next one
  5559. *
  5560. * (This may call plan_buffer_line several times to put
  5561. * smaller moves into the planner for DELTA or SCARA.)
  5562. */
  5563. void prepare_move() {
  5564. clamp_to_software_endstops(destination);
  5565. refresh_cmd_timeout();
  5566. #if ENABLED(PREVENT_DANGEROUS_EXTRUDE)
  5567. prevent_dangerous_extrude(current_position[E_AXIS], destination[E_AXIS]);
  5568. #endif
  5569. #if ENABLED(SCARA)
  5570. if (!prepare_move_scara(destination)) return;
  5571. #elif ENABLED(DELTA)
  5572. if (!prepare_move_delta(destination)) return;
  5573. #endif
  5574. #if ENABLED(DUAL_X_CARRIAGE)
  5575. if (!prepare_move_dual_x_carriage()) return;
  5576. #endif
  5577. #if DISABLED(DELTA) && DISABLED(SCARA)
  5578. if (!prepare_move_cartesian()) return;
  5579. #endif
  5580. set_current_to_destination();
  5581. }
  5582. /**
  5583. * Plan an arc in 2 dimensions
  5584. *
  5585. * The arc is approximated by generating many small linear segments.
  5586. * The length of each segment is configured in MM_PER_ARC_SEGMENT (Default 1mm)
  5587. * Arcs should only be made relatively large (over 5mm), as larger arcs with
  5588. * larger segments will tend to be more efficient. Your slicer should have
  5589. * options for G2/G3 arc generation. In future these options may be GCode tunable.
  5590. */
  5591. void plan_arc(
  5592. float target[NUM_AXIS], // Destination position
  5593. float *offset, // Center of rotation relative to current_position
  5594. uint8_t clockwise // Clockwise?
  5595. ) {
  5596. float radius = hypot(offset[X_AXIS], offset[Y_AXIS]),
  5597. center_axis0 = current_position[X_AXIS] + offset[X_AXIS],
  5598. center_axis1 = current_position[Y_AXIS] + offset[Y_AXIS],
  5599. linear_travel = target[Z_AXIS] - current_position[Z_AXIS],
  5600. extruder_travel = target[E_AXIS] - current_position[E_AXIS],
  5601. r_axis0 = -offset[X_AXIS], // Radius vector from center to current location
  5602. r_axis1 = -offset[Y_AXIS],
  5603. rt_axis0 = target[X_AXIS] - center_axis0,
  5604. rt_axis1 = target[Y_AXIS] - center_axis1;
  5605. // CCW angle of rotation between position and target from the circle center. Only one atan2() trig computation required.
  5606. float angular_travel = atan2(r_axis0*rt_axis1-r_axis1*rt_axis0, r_axis0*rt_axis0+r_axis1*rt_axis1);
  5607. if (angular_travel < 0) { angular_travel += RADIANS(360); }
  5608. if (clockwise) { angular_travel -= RADIANS(360); }
  5609. // Make a circle if the angular rotation is 0
  5610. if (current_position[X_AXIS] == target[X_AXIS] && current_position[Y_AXIS] == target[Y_AXIS] && angular_travel == 0)
  5611. angular_travel += RADIANS(360);
  5612. float mm_of_travel = hypot(angular_travel*radius, fabs(linear_travel));
  5613. if (mm_of_travel < 0.001) { return; }
  5614. uint16_t segments = floor(mm_of_travel / MM_PER_ARC_SEGMENT);
  5615. if (segments == 0) segments = 1;
  5616. float theta_per_segment = angular_travel/segments;
  5617. float linear_per_segment = linear_travel/segments;
  5618. float extruder_per_segment = extruder_travel/segments;
  5619. /* Vector rotation by transformation matrix: r is the original vector, r_T is the rotated vector,
  5620. and phi is the angle of rotation. Based on the solution approach by Jens Geisler.
  5621. r_T = [cos(phi) -sin(phi);
  5622. sin(phi) cos(phi] * r ;
  5623. For arc generation, the center of the circle is the axis of rotation and the radius vector is
  5624. defined from the circle center to the initial position. Each line segment is formed by successive
  5625. vector rotations. This requires only two cos() and sin() computations to form the rotation
  5626. matrix for the duration of the entire arc. Error may accumulate from numerical round-off, since
  5627. all double numbers are single precision on the Arduino. (True double precision will not have
  5628. round off issues for CNC applications.) Single precision error can accumulate to be greater than
  5629. tool precision in some cases. Therefore, arc path correction is implemented.
  5630. Small angle approximation may be used to reduce computation overhead further. This approximation
  5631. holds for everything, but very small circles and large MM_PER_ARC_SEGMENT values. In other words,
  5632. theta_per_segment would need to be greater than 0.1 rad and N_ARC_CORRECTION would need to be large
  5633. to cause an appreciable drift error. N_ARC_CORRECTION~=25 is more than small enough to correct for
  5634. numerical drift error. N_ARC_CORRECTION may be on the order a hundred(s) before error becomes an
  5635. issue for CNC machines with the single precision Arduino calculations.
  5636. This approximation also allows plan_arc to immediately insert a line segment into the planner
  5637. without the initial overhead of computing cos() or sin(). By the time the arc needs to be applied
  5638. a correction, the planner should have caught up to the lag caused by the initial plan_arc overhead.
  5639. This is important when there are successive arc motions.
  5640. */
  5641. // Vector rotation matrix values
  5642. float cos_T = 1-0.5*theta_per_segment*theta_per_segment; // Small angle approximation
  5643. float sin_T = theta_per_segment;
  5644. float arc_target[NUM_AXIS];
  5645. float sin_Ti;
  5646. float cos_Ti;
  5647. float r_axisi;
  5648. uint16_t i;
  5649. int8_t count = 0;
  5650. // Initialize the linear axis
  5651. arc_target[Z_AXIS] = current_position[Z_AXIS];
  5652. // Initialize the extruder axis
  5653. arc_target[E_AXIS] = current_position[E_AXIS];
  5654. float feed_rate = feedrate*feedrate_multiplier/60/100.0;
  5655. for (i = 1; i < segments; i++) { // Increment (segments-1)
  5656. if (count < N_ARC_CORRECTION) {
  5657. // Apply vector rotation matrix to previous r_axis0 / 1
  5658. r_axisi = r_axis0*sin_T + r_axis1*cos_T;
  5659. r_axis0 = r_axis0*cos_T - r_axis1*sin_T;
  5660. r_axis1 = r_axisi;
  5661. count++;
  5662. }
  5663. else {
  5664. // Arc correction to radius vector. Computed only every N_ARC_CORRECTION increments.
  5665. // Compute exact location by applying transformation matrix from initial radius vector(=-offset).
  5666. cos_Ti = cos(i*theta_per_segment);
  5667. sin_Ti = sin(i*theta_per_segment);
  5668. r_axis0 = -offset[X_AXIS]*cos_Ti + offset[Y_AXIS]*sin_Ti;
  5669. r_axis1 = -offset[X_AXIS]*sin_Ti - offset[Y_AXIS]*cos_Ti;
  5670. count = 0;
  5671. }
  5672. // Update arc_target location
  5673. arc_target[X_AXIS] = center_axis0 + r_axis0;
  5674. arc_target[Y_AXIS] = center_axis1 + r_axis1;
  5675. arc_target[Z_AXIS] += linear_per_segment;
  5676. arc_target[E_AXIS] += extruder_per_segment;
  5677. clamp_to_software_endstops(arc_target);
  5678. #if ENABLED(DELTA) || ENABLED(SCARA)
  5679. calculate_delta(arc_target);
  5680. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  5681. adjust_delta(arc_target);
  5682. #endif
  5683. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], arc_target[E_AXIS], feed_rate, active_extruder);
  5684. #else
  5685. plan_buffer_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], arc_target[E_AXIS], feed_rate, active_extruder);
  5686. #endif
  5687. }
  5688. // Ensure last segment arrives at target location.
  5689. #if ENABLED(DELTA) || ENABLED(SCARA)
  5690. calculate_delta(target);
  5691. #if ENABLED(AUTO_BED_LEVELING_FEATURE)
  5692. adjust_delta(target);
  5693. #endif
  5694. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], target[E_AXIS], feed_rate, active_extruder);
  5695. #else
  5696. plan_buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate, active_extruder);
  5697. #endif
  5698. // As far as the parser is concerned, the position is now == target. In reality the
  5699. // motion control system might still be processing the action and the real tool position
  5700. // in any intermediate location.
  5701. set_current_to_destination();
  5702. }
  5703. #if HAS_CONTROLLERFAN
  5704. void controllerFan() {
  5705. static millis_t lastMotor = 0; // Last time a motor was turned on
  5706. static millis_t lastMotorCheck = 0; // Last time the state was checked
  5707. millis_t ms = millis();
  5708. if (ms >= lastMotorCheck + 2500) { // Not a time critical function, so we only check every 2500ms
  5709. lastMotorCheck = ms;
  5710. if (X_ENABLE_READ == X_ENABLE_ON || Y_ENABLE_READ == Y_ENABLE_ON || Z_ENABLE_READ == Z_ENABLE_ON || soft_pwm_bed > 0
  5711. || E0_ENABLE_READ == E_ENABLE_ON // If any of the drivers are enabled...
  5712. #if EXTRUDERS > 1
  5713. || E1_ENABLE_READ == E_ENABLE_ON
  5714. #if HAS_X2_ENABLE
  5715. || X2_ENABLE_READ == X_ENABLE_ON
  5716. #endif
  5717. #if EXTRUDERS > 2
  5718. || E2_ENABLE_READ == E_ENABLE_ON
  5719. #if EXTRUDERS > 3
  5720. || E3_ENABLE_READ == E_ENABLE_ON
  5721. #endif
  5722. #endif
  5723. #endif
  5724. ) {
  5725. lastMotor = ms; //... set time to NOW so the fan will turn on
  5726. }
  5727. uint8_t speed = (lastMotor == 0 || ms >= lastMotor + (CONTROLLERFAN_SECS * 1000UL)) ? 0 : CONTROLLERFAN_SPEED;
  5728. // allows digital or PWM fan output to be used (see M42 handling)
  5729. digitalWrite(CONTROLLERFAN_PIN, speed);
  5730. analogWrite(CONTROLLERFAN_PIN, speed);
  5731. }
  5732. }
  5733. #endif // HAS_CONTROLLERFAN
  5734. #if ENABLED(SCARA)
  5735. void calculate_SCARA_forward_Transform(float f_scara[3]) {
  5736. // Perform forward kinematics, and place results in delta[3]
  5737. // The maths and first version has been done by QHARLEY . Integrated into masterbranch 06/2014 and slightly restructured by Joachim Cerny in June 2014
  5738. float x_sin, x_cos, y_sin, y_cos;
  5739. //SERIAL_ECHOPGM("f_delta x="); SERIAL_ECHO(f_scara[X_AXIS]);
  5740. //SERIAL_ECHOPGM(" y="); SERIAL_ECHO(f_scara[Y_AXIS]);
  5741. x_sin = sin(f_scara[X_AXIS]/SCARA_RAD2DEG) * Linkage_1;
  5742. x_cos = cos(f_scara[X_AXIS]/SCARA_RAD2DEG) * Linkage_1;
  5743. y_sin = sin(f_scara[Y_AXIS]/SCARA_RAD2DEG) * Linkage_2;
  5744. y_cos = cos(f_scara[Y_AXIS]/SCARA_RAD2DEG) * Linkage_2;
  5745. //SERIAL_ECHOPGM(" x_sin="); SERIAL_ECHO(x_sin);
  5746. //SERIAL_ECHOPGM(" x_cos="); SERIAL_ECHO(x_cos);
  5747. //SERIAL_ECHOPGM(" y_sin="); SERIAL_ECHO(y_sin);
  5748. //SERIAL_ECHOPGM(" y_cos="); SERIAL_ECHOLN(y_cos);
  5749. delta[X_AXIS] = x_cos + y_cos + SCARA_offset_x; //theta
  5750. delta[Y_AXIS] = x_sin + y_sin + SCARA_offset_y; //theta+phi
  5751. //SERIAL_ECHOPGM(" delta[X_AXIS]="); SERIAL_ECHO(delta[X_AXIS]);
  5752. //SERIAL_ECHOPGM(" delta[Y_AXIS]="); SERIAL_ECHOLN(delta[Y_AXIS]);
  5753. }
  5754. void calculate_delta(float cartesian[3]){
  5755. //reverse kinematics.
  5756. // Perform reversed kinematics, and place results in delta[3]
  5757. // The maths and first version has been done by QHARLEY . Integrated into masterbranch 06/2014 and slightly restructured by Joachim Cerny in June 2014
  5758. float SCARA_pos[2];
  5759. static float SCARA_C2, SCARA_S2, SCARA_K1, SCARA_K2, SCARA_theta, SCARA_psi;
  5760. SCARA_pos[X_AXIS] = cartesian[X_AXIS] * axis_scaling[X_AXIS] - SCARA_offset_x; //Translate SCARA to standard X Y
  5761. SCARA_pos[Y_AXIS] = cartesian[Y_AXIS] * axis_scaling[Y_AXIS] - SCARA_offset_y; // With scaling factor.
  5762. #if (Linkage_1 == Linkage_2)
  5763. SCARA_C2 = ( ( sq(SCARA_pos[X_AXIS]) + sq(SCARA_pos[Y_AXIS]) ) / (2 * (float)L1_2) ) - 1;
  5764. #else
  5765. SCARA_C2 = ( sq(SCARA_pos[X_AXIS]) + sq(SCARA_pos[Y_AXIS]) - (float)L1_2 - (float)L2_2 ) / 45000;
  5766. #endif
  5767. SCARA_S2 = sqrt( 1 - sq(SCARA_C2) );
  5768. SCARA_K1 = Linkage_1 + Linkage_2 * SCARA_C2;
  5769. SCARA_K2 = Linkage_2 * SCARA_S2;
  5770. SCARA_theta = ( atan2(SCARA_pos[X_AXIS],SCARA_pos[Y_AXIS])-atan2(SCARA_K1, SCARA_K2) ) * -1;
  5771. SCARA_psi = atan2(SCARA_S2,SCARA_C2);
  5772. delta[X_AXIS] = SCARA_theta * SCARA_RAD2DEG; // Multiply by 180/Pi - theta is support arm angle
  5773. delta[Y_AXIS] = (SCARA_theta + SCARA_psi) * SCARA_RAD2DEG; // - equal to sub arm angle (inverted motor)
  5774. delta[Z_AXIS] = cartesian[Z_AXIS];
  5775. /*
  5776. SERIAL_ECHOPGM("cartesian x="); SERIAL_ECHO(cartesian[X_AXIS]);
  5777. SERIAL_ECHOPGM(" y="); SERIAL_ECHO(cartesian[Y_AXIS]);
  5778. SERIAL_ECHOPGM(" z="); SERIAL_ECHOLN(cartesian[Z_AXIS]);
  5779. SERIAL_ECHOPGM("scara x="); SERIAL_ECHO(SCARA_pos[X_AXIS]);
  5780. SERIAL_ECHOPGM(" y="); SERIAL_ECHOLN(SCARA_pos[Y_AXIS]);
  5781. SERIAL_ECHOPGM("delta x="); SERIAL_ECHO(delta[X_AXIS]);
  5782. SERIAL_ECHOPGM(" y="); SERIAL_ECHO(delta[Y_AXIS]);
  5783. SERIAL_ECHOPGM(" z="); SERIAL_ECHOLN(delta[Z_AXIS]);
  5784. SERIAL_ECHOPGM("C2="); SERIAL_ECHO(SCARA_C2);
  5785. SERIAL_ECHOPGM(" S2="); SERIAL_ECHO(SCARA_S2);
  5786. SERIAL_ECHOPGM(" Theta="); SERIAL_ECHO(SCARA_theta);
  5787. SERIAL_ECHOPGM(" Psi="); SERIAL_ECHOLN(SCARA_psi);
  5788. SERIAL_EOL;
  5789. */
  5790. }
  5791. #endif // SCARA
  5792. #if ENABLED(TEMP_STAT_LEDS)
  5793. static bool red_led = false;
  5794. static millis_t next_status_led_update_ms = 0;
  5795. void handle_status_leds(void) {
  5796. float max_temp = 0.0;
  5797. if (millis() > next_status_led_update_ms) {
  5798. next_status_led_update_ms += 500; // Update every 0.5s
  5799. for (int8_t cur_extruder = 0; cur_extruder < EXTRUDERS; ++cur_extruder)
  5800. max_temp = max(max(max_temp, degHotend(cur_extruder)), degTargetHotend(cur_extruder));
  5801. #if HAS_TEMP_BED
  5802. max_temp = max(max(max_temp, degTargetBed()), degBed());
  5803. #endif
  5804. bool new_led = (max_temp > 55.0) ? true : (max_temp < 54.0) ? false : red_led;
  5805. if (new_led != red_led) {
  5806. red_led = new_led;
  5807. digitalWrite(STAT_LED_RED, new_led ? HIGH : LOW);
  5808. digitalWrite(STAT_LED_BLUE, new_led ? LOW : HIGH);
  5809. }
  5810. }
  5811. }
  5812. #endif
  5813. void enable_all_steppers() {
  5814. enable_x();
  5815. enable_y();
  5816. enable_z();
  5817. enable_e0();
  5818. enable_e1();
  5819. enable_e2();
  5820. enable_e3();
  5821. }
  5822. void disable_all_steppers() {
  5823. disable_x();
  5824. disable_y();
  5825. disable_z();
  5826. disable_e0();
  5827. disable_e1();
  5828. disable_e2();
  5829. disable_e3();
  5830. }
  5831. /**
  5832. * Standard idle routine keeps the machine alive
  5833. */
  5834. void idle() {
  5835. manage_heater();
  5836. manage_inactivity();
  5837. lcd_update();
  5838. }
  5839. /**
  5840. * Manage several activities:
  5841. * - Check for Filament Runout
  5842. * - Keep the command buffer full
  5843. * - Check for maximum inactive time between commands
  5844. * - Check for maximum inactive time between stepper commands
  5845. * - Check if pin CHDK needs to go LOW
  5846. * - Check for KILL button held down
  5847. * - Check for HOME button held down
  5848. * - Check if cooling fan needs to be switched on
  5849. * - Check if an idle but hot extruder needs filament extruded (EXTRUDER_RUNOUT_PREVENT)
  5850. */
  5851. void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
  5852. #if HAS_FILRUNOUT
  5853. if (IS_SD_PRINTING && !(READ(FILRUNOUT_PIN) ^ FIL_RUNOUT_INVERTING))
  5854. filrunout();
  5855. #endif
  5856. if (commands_in_queue < BUFSIZE - 1) get_command();
  5857. millis_t ms = millis();
  5858. if (max_inactive_time && ms > previous_cmd_ms + max_inactive_time) kill(PSTR(MSG_KILLED));
  5859. if (stepper_inactive_time && ms > previous_cmd_ms + stepper_inactive_time
  5860. && !ignore_stepper_queue && !blocks_queued()) {
  5861. #if DISABLE_X == true
  5862. disable_x();
  5863. #endif
  5864. #if DISABLE_Y == true
  5865. disable_y();
  5866. #endif
  5867. #if DISABLE_Z == true
  5868. disable_z();
  5869. #endif
  5870. #if DISABLE_E == true
  5871. disable_e0();
  5872. disable_e1();
  5873. disable_e2();
  5874. disable_e3();
  5875. #endif
  5876. }
  5877. #ifdef CHDK // Check if pin should be set to LOW after M240 set it to HIGH
  5878. if (chdkActive && ms > chdkHigh + CHDK_DELAY) {
  5879. chdkActive = false;
  5880. WRITE(CHDK, LOW);
  5881. }
  5882. #endif
  5883. #if HAS_KILL
  5884. // Check if the kill button was pressed and wait just in case it was an accidental
  5885. // key kill key press
  5886. // -------------------------------------------------------------------------------
  5887. static int killCount = 0; // make the inactivity button a bit less responsive
  5888. const int KILL_DELAY = 750;
  5889. if (!READ(KILL_PIN))
  5890. killCount++;
  5891. else if (killCount > 0)
  5892. killCount--;
  5893. // Exceeded threshold and we can confirm that it was not accidental
  5894. // KILL the machine
  5895. // ----------------------------------------------------------------
  5896. if (killCount >= KILL_DELAY) kill(PSTR(MSG_KILLED));
  5897. #endif
  5898. #if HAS_HOME
  5899. // Check to see if we have to home, use poor man's debouncer
  5900. // ---------------------------------------------------------
  5901. static int homeDebounceCount = 0; // poor man's debouncing count
  5902. const int HOME_DEBOUNCE_DELAY = 750;
  5903. if (!READ(HOME_PIN)) {
  5904. if (!homeDebounceCount) {
  5905. enqueuecommands_P(PSTR("G28"));
  5906. LCD_MESSAGEPGM(MSG_AUTO_HOME);
  5907. }
  5908. if (homeDebounceCount < HOME_DEBOUNCE_DELAY)
  5909. homeDebounceCount++;
  5910. else
  5911. homeDebounceCount = 0;
  5912. }
  5913. #endif
  5914. #if HAS_CONTROLLERFAN
  5915. controllerFan(); // Check if fan should be turned on to cool stepper drivers down
  5916. #endif
  5917. #if ENABLED(EXTRUDER_RUNOUT_PREVENT)
  5918. if (ms > previous_cmd_ms + EXTRUDER_RUNOUT_SECONDS * 1000)
  5919. if (degHotend(active_extruder) > EXTRUDER_RUNOUT_MINTEMP) {
  5920. bool oldstatus;
  5921. switch(active_extruder) {
  5922. case 0:
  5923. oldstatus = E0_ENABLE_READ;
  5924. enable_e0();
  5925. break;
  5926. #if EXTRUDERS > 1
  5927. case 1:
  5928. oldstatus = E1_ENABLE_READ;
  5929. enable_e1();
  5930. break;
  5931. #if EXTRUDERS > 2
  5932. case 2:
  5933. oldstatus = E2_ENABLE_READ;
  5934. enable_e2();
  5935. break;
  5936. #if EXTRUDERS > 3
  5937. case 3:
  5938. oldstatus = E3_ENABLE_READ;
  5939. enable_e3();
  5940. break;
  5941. #endif
  5942. #endif
  5943. #endif
  5944. }
  5945. float oldepos = current_position[E_AXIS], oldedes = destination[E_AXIS];
  5946. plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS],
  5947. destination[E_AXIS] + EXTRUDER_RUNOUT_EXTRUDE * EXTRUDER_RUNOUT_ESTEPS / axis_steps_per_unit[E_AXIS],
  5948. EXTRUDER_RUNOUT_SPEED / 60. * EXTRUDER_RUNOUT_ESTEPS / axis_steps_per_unit[E_AXIS], active_extruder);
  5949. current_position[E_AXIS] = oldepos;
  5950. destination[E_AXIS] = oldedes;
  5951. plan_set_e_position(oldepos);
  5952. previous_cmd_ms = ms; // refresh_cmd_timeout()
  5953. st_synchronize();
  5954. switch(active_extruder) {
  5955. case 0:
  5956. E0_ENABLE_WRITE(oldstatus);
  5957. break;
  5958. #if EXTRUDERS > 1
  5959. case 1:
  5960. E1_ENABLE_WRITE(oldstatus);
  5961. break;
  5962. #if EXTRUDERS > 2
  5963. case 2:
  5964. E2_ENABLE_WRITE(oldstatus);
  5965. break;
  5966. #if EXTRUDERS > 3
  5967. case 3:
  5968. E3_ENABLE_WRITE(oldstatus);
  5969. break;
  5970. #endif
  5971. #endif
  5972. #endif
  5973. }
  5974. }
  5975. #endif
  5976. #if ENABLED(DUAL_X_CARRIAGE)
  5977. // handle delayed move timeout
  5978. if (delayed_move_time && ms > delayed_move_time + 1000 && IsRunning()) {
  5979. // travel moves have been received so enact them
  5980. delayed_move_time = 0xFFFFFFFFUL; // force moves to be done
  5981. set_destination_to_current();
  5982. prepare_move();
  5983. }
  5984. #endif
  5985. #if ENABLED(TEMP_STAT_LEDS)
  5986. handle_status_leds();
  5987. #endif
  5988. check_axes_activity();
  5989. }
  5990. void kill(const char *lcd_msg) {
  5991. #if ENABLED(ULTRA_LCD)
  5992. lcd_setalertstatuspgm(lcd_msg);
  5993. #endif
  5994. cli(); // Stop interrupts
  5995. disable_all_heaters();
  5996. disable_all_steppers();
  5997. #if HAS_POWER_SWITCH
  5998. pinMode(PS_ON_PIN, INPUT);
  5999. #endif
  6000. SERIAL_ERROR_START;
  6001. SERIAL_ERRORLNPGM(MSG_ERR_KILLED);
  6002. // FMC small patch to update the LCD before ending
  6003. sei(); // enable interrupts
  6004. for (int i = 5; i--; lcd_update()) delay(200); // Wait a short time
  6005. cli(); // disable interrupts
  6006. suicide();
  6007. while(1) { /* Intentionally left empty */ } // Wait for reset
  6008. }
  6009. #if ENABLED(FILAMENT_RUNOUT_SENSOR)
  6010. void filrunout() {
  6011. if (!filrunoutEnqueued) {
  6012. filrunoutEnqueued = true;
  6013. enqueuecommands_P(PSTR(FILAMENT_RUNOUT_SCRIPT));
  6014. st_synchronize();
  6015. }
  6016. }
  6017. #endif // FILAMENT_RUNOUT_SENSOR
  6018. #if ENABLED(FAST_PWM_FAN)
  6019. void setPwmFrequency(uint8_t pin, int val) {
  6020. val &= 0x07;
  6021. switch (digitalPinToTimer(pin)) {
  6022. #if defined(TCCR0A)
  6023. case TIMER0A:
  6024. case TIMER0B:
  6025. // TCCR0B &= ~(_BV(CS00) | _BV(CS01) | _BV(CS02));
  6026. // TCCR0B |= val;
  6027. break;
  6028. #endif
  6029. #if defined(TCCR1A)
  6030. case TIMER1A:
  6031. case TIMER1B:
  6032. // TCCR1B &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
  6033. // TCCR1B |= val;
  6034. break;
  6035. #endif
  6036. #if defined(TCCR2)
  6037. case TIMER2:
  6038. case TIMER2:
  6039. TCCR2 &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
  6040. TCCR2 |= val;
  6041. break;
  6042. #endif
  6043. #if defined(TCCR2A)
  6044. case TIMER2A:
  6045. case TIMER2B:
  6046. TCCR2B &= ~(_BV(CS20) | _BV(CS21) | _BV(CS22));
  6047. TCCR2B |= val;
  6048. break;
  6049. #endif
  6050. #if defined(TCCR3A)
  6051. case TIMER3A:
  6052. case TIMER3B:
  6053. case TIMER3C:
  6054. TCCR3B &= ~(_BV(CS30) | _BV(CS31) | _BV(CS32));
  6055. TCCR3B |= val;
  6056. break;
  6057. #endif
  6058. #if defined(TCCR4A)
  6059. case TIMER4A:
  6060. case TIMER4B:
  6061. case TIMER4C:
  6062. TCCR4B &= ~(_BV(CS40) | _BV(CS41) | _BV(CS42));
  6063. TCCR4B |= val;
  6064. break;
  6065. #endif
  6066. #if defined(TCCR5A)
  6067. case TIMER5A:
  6068. case TIMER5B:
  6069. case TIMER5C:
  6070. TCCR5B &= ~(_BV(CS50) | _BV(CS51) | _BV(CS52));
  6071. TCCR5B |= val;
  6072. break;
  6073. #endif
  6074. }
  6075. }
  6076. #endif // FAST_PWM_FAN
  6077. void Stop() {
  6078. disable_all_heaters();
  6079. if (IsRunning()) {
  6080. Running = false;
  6081. Stopped_gcode_LastN = gcode_LastN; // Save last g_code for restart
  6082. SERIAL_ERROR_START;
  6083. SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
  6084. LCD_MESSAGEPGM(MSG_STOPPED);
  6085. }
  6086. }
  6087. /**
  6088. * Set target_extruder from the T parameter or the active_extruder
  6089. *
  6090. * Returns TRUE if the target is invalid
  6091. */
  6092. bool setTargetedHotend(int code) {
  6093. target_extruder = active_extruder;
  6094. if (code_seen('T')) {
  6095. target_extruder = code_value_short();
  6096. if (target_extruder >= EXTRUDERS) {
  6097. SERIAL_ECHO_START;
  6098. SERIAL_CHAR('M');
  6099. SERIAL_ECHO(code);
  6100. SERIAL_ECHOPGM(" " MSG_INVALID_EXTRUDER " ");
  6101. SERIAL_ECHOLN(target_extruder);
  6102. return true;
  6103. }
  6104. }
  6105. return false;
  6106. }
  6107. float calculate_volumetric_multiplier(float diameter) {
  6108. if (!volumetric_enabled || diameter == 0) return 1.0;
  6109. float d2 = diameter * 0.5;
  6110. return 1.0 / (M_PI * d2 * d2);
  6111. }
  6112. void calculate_volumetric_multipliers() {
  6113. for (int i=0; i<EXTRUDERS; i++)
  6114. volumetric_multiplier[i] = calculate_volumetric_multiplier(filament_size[i]);
  6115. }