/// find X MIN endstop void home_x_negative() { #if defined X_MIN_PIN TARGET t = startpoint; t.X = -1000000; if (SEARCH_FAST_X > SEARCH_FEEDRATE_X) // Preprocessor can't check this :-/ t.F = SEARCH_FAST_X; else t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 1); if (SEARCH_FAST_X > SEARCH_FEEDRATE_X) { // back off slowly t.X = +1000000; t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 0); } // set X home queue_wait(); // we have to wait here, see G92 #ifdef X_MIN startpoint.X = next_target.target.X = (int32_t)(X_MIN * 1000.0); #else startpoint.X = next_target.target.X = 0; #endif dda_new_startpoint(); #endif }
int main() { Queue* q = queue_new("example", "localhost", 6379, 0, NULL); queue_connect(q); printf("Current Queue Length: %lld\n", queue_length(q)); /* char *data = calloc(20, sizeof(char)); strncpy(data, "\"ac\"", 7); Task *t = task_new(data, "0"); Job *j = queue_enqueue(q, t); printf("Got job: %s\n", j->urn); task_destroy(t); job_destroy(j); */ Task* t = queue_wait(q, 0); printf("Received: %s URN: %s \n", t->data, t->urn); task_destroy(t); queue_destroy(q); return 0; }
/// find Z MAX endstop void home_z_positive() { #if defined Z_MAX_PIN && ! defined Z_MAX #warning Z_MAX_PIN defined, but not Z_MAX. home_z_positive() disabled. #endif #if defined Z_MAX_PIN && defined Z_MAX TARGET t = startpoint; t.Z = +1000000; if (SEARCH_FAST_Z > SEARCH_FEEDRATE_Z) t.F = SEARCH_FAST_Z; else t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 1); if (SEARCH_FAST_Z > SEARCH_FEEDRATE_Z) { t.Z = -1000000; t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 0); } // set Z home queue_wait(); // set position to MAX startpoint.Z = next_target.target.Z = (int32_t)(Z_MAX * 1000.); dda_new_startpoint(); // go to zero t.Z = 0; t.F = MAXIMUM_FEEDRATE_Z; enqueue(&t); #endif }
/// find Z MIN endstop void home_z_negative() { #if defined Z_MIN_PIN TARGET t = startpoint; t.Z = -1000000; if (SEARCH_FAST_Z > SEARCH_FEEDRATE_Z) t.F = SEARCH_FAST_Z; else t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 1); if (SEARCH_FAST_Z > SEARCH_FEEDRATE_Z) { t.Z = +1000000; t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 0); } // set Z home queue_wait(); #ifdef Z_MIN startpoint.Z = next_target.target.Z = (int32_t)(Z_MIN * 1000.); #else startpoint.Z = next_target.target.Z = 0; #endif dda_new_startpoint(); z_disable(); #endif }
/// find Y MAX endstop void home_y_positive() { #if defined Y_MAX_PIN && ! defined Y_MAX #warning Y_MAX_PIN defined, but not Y_MAX. home_y_positive() disabled. #endif #if defined Y_MAX_PIN && defined Y_MAX TARGET t = startpoint; t.Y = +1000000; if (SEARCH_FAST_Y > SEARCH_FEEDRATE_Y) t.F = SEARCH_FAST_Y; else t.F = SEARCH_FEEDRATE_Y; enqueue_home(&t, 0x2, 1); if (SEARCH_FAST_Y > SEARCH_FEEDRATE_Y) { t.Y = -1000000; t.F = SEARCH_FEEDRATE_Y; enqueue_home(&t, 0x2, 0); } // set Y home queue_wait(); // set position to MAX startpoint.Y = next_target.target.Y = (int32_t)(Y_MAX * 1000.); dda_new_startpoint(); // go to zero t.Y = 0; t.F = MAXIMUM_FEEDRATE_Y; enqueue(&t); #endif }
static void *waitq_thread(void *arg) { Conn *start = NULL; Exec *e = arg; for (;;) { Conn *c = queue_get(e->waitq); if (c->io->stop) { start = NULL; conn_free(c); } else if (sys_iready(c->io, 0)) { start = NULL; queue_put(e->runq, c); } else if (sys_millis() - c->time > KEEP_ALIVE_MS) { start = NULL; conn_free(c); } else { if (start == c) /* we are in the wait-loop */ queue_wait(e->waitq, 10); /* wait for new connections */ if (start == NULL) start = c; queue_put(e->waitq, c); } } return NULL; }
/// find X_MAX endstop void home_x_positive() { #if defined X_MAX_PIN && ! defined X_MAX #warning X_MAX_PIN defined, but not X_MAX. home_x_positive() disabled. #endif #if defined X_MAX_PIN && defined X_MAX TARGET t = startpoint; t.X = +1000000; #ifdef SLOW_HOMING // hit home soft t.F = SEARCH_FEEDRATE_X; #else // hit home hard t.F = MAXIMUM_FEEDRATE_X; #endif enqueue_home(&t, 0x1, 1); #ifndef SLOW_HOMING // back off slowly t.X = -1000000; t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 0); #endif // set X home queue_wait(); // set position to MAX startpoint.X = next_target.target.X = (int32_t)(X_MAX * 1000.); dda_new_startpoint(); // go to zero t.X = 0; t.F = MAXIMUM_FEEDRATE_X; enqueue(&t); #endif }
/// find X MIN endstop void home_x_negative() { TARGET t = startpoint; t.X = -1000000; // hit home hard t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 1); // back off slowly t.X = +1000000; t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 0); // set X home queue_wait(); // we have to wait here, see G92 startpoint.X = next_target.target.X = 0; dda_new_startpoint(); }
/// fund Y MIN endstop void home_y_negative() { #if defined Y_MIN_PIN TARGET t = startpoint; t.Y = -1000000; if (SEARCH_FAST_Y > SEARCH_FEEDRATE_Y) t.F = SEARCH_FAST_Y; else t.F = SEARCH_FEEDRATE_Y; enqueue_home(&t, 0x2, 1); if (SEARCH_FAST_Y > SEARCH_FEEDRATE_Y) { t.Y = +1000000; t.F = SEARCH_FEEDRATE_Y; enqueue_home(&t, 0x2, 0); } // set Y home queue_wait(); #ifdef Y_MIN startpoint.Y = next_target.target.Y = (int32_t)(Y_MIN * 1000.); #else startpoint.Y = next_target.target.Y = 0; #endif dda_new_startpoint(); #endif }
/// find X_MAX endstop void home_x_positive() { #if defined X_MAX_PIN && ! defined X_MAX #warning X_MAX_PIN defined, but not X_MAX. home_x_positive() disabled. #endif #if defined X_MAX_PIN && defined X_MAX TARGET t = startpoint; t.X = +1000000; if (SEARCH_FAST_X > SEARCH_FEEDRATE_X) t.F = SEARCH_FAST_X; else t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 1); if (SEARCH_FAST_X > SEARCH_FEEDRATE_X) { t.X = -1000000; t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 0); } // set X home queue_wait(); // set position to MAX startpoint.X = next_target.target.X = (int32_t)(X_MAX * 1000.); dda_new_startpoint(); // go to zero t.X = 0; t.F = MAXIMUM_FEEDRATE_X; enqueue(&t); #endif }
/// fund Y MIN endstop void home_y_negative() { #if defined Y_MIN_PIN TARGET t = startpoint; t.Y = -1000000; #ifdef SLOW_HOMING // hit home soft t.F = SEARCH_FEEDRATE_Y; #else // hit home hard t.F = MAXIMUM_FEEDRATE_Y; #endif enqueue_home(&t, 0x2, 1); #ifndef SLOW_HOMING // back off slowly t.Y = +1000000; t.F = SEARCH_FEEDRATE_Y; enqueue_home(&t, 0x2, 0); #endif // set Y home queue_wait(); #ifdef Y_MIN startpoint.Y = next_target.target.Y = (int32_t)(Y_MIN * 1000.); #else startpoint.Y = next_target.target.Y = 0; #endif dda_new_startpoint(); #endif }
/// find Z MIN endstop void home_z_negative() { TARGET t = startpoint; t.Z = -1000000; // hit home hard t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 1); // back off slowly t.Z = +1000000; t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 0); // set Z home queue_wait(); startpoint.Z = next_target.target.Z = 0; dda_new_startpoint(); z_disable(); }
int main() { queue_element qel; queue_init(&que); init_hw(); printf_P(PSTR("\n----- EventQueue/Button Tester ver %s -----\n"), VERSION); while(1) { queue_wait(&que, &qel); //printf_P(PSTR("Event received src %d\n"), qel.source); switch (qel.source) { case EVENT_CMD: sev_cmd_exec(1); break; case EVENT_TIMER0: printf("Timer 0 event\n"); break; case EVENT_TIMER1: printf("Timer 1 event\n"); break; case EVENT_BUT_DOWN: printf("Button pressed event\n"); ARD_LED_TOGGLE(); blink = 0; break; case EVENT_BUT_UP: printf("Button released event\n"); break; case EVENT_BUT_LONG: printf("Button hold down event\n"); blink = 1; // start blinking sev_timer_start_single(&eTimer3, 400); // start single timeout break; case EVENT_1S: printf_P(PSTR("Software timer 1s\n")); break; case EVENT_2S: printf_P(PSTR("Software timer 2s\n")); break; case EVENT_4S: printf_P(PSTR("Software timer 4s\n")); blink = 0; break; } } }
/// find Z MIN endstop void home_z_negative() { #if defined Z_MIN_PIN TARGET t = startpoint; t.Z = -1000000; #ifdef SLOW_HOMING // hit home soft t.F = SEARCH_FEEDRATE_Z; #else // hit home hard t.F = MAXIMUM_FEEDRATE_Z; #endif enqueue_home(&t, 0x4, 1); #ifndef SLOW_HOMING // back off slowly t.Z = +1000000; t.F = SEARCH_FEEDRATE_Z; enqueue_home(&t, 0x4, 0); #endif // set Z home queue_wait(); #ifdef Z_MIN startpoint.Z = next_target.target.Z = (int32_t)(Z_MIN * 1000.); #else startpoint.Z = next_target.target.Z = 0; #endif dda_new_startpoint(); z_disable(); #endif }
static void mpr121_thread(void) { struct queue_event ev; while(1) { queue_wait(&mpr121_queue, &ev); /* handle usb connect and ignore all messages except rmi interrupts */ if(ev.id == SYS_USB_CONNECTED) { usb_acknowledge(SYS_USB_CONNECTED_ACK); continue; } else if(ev.id != MPR121_INTERRUPT) continue; /* clear interrupt and get status */ unsigned status; touchpad_btns = 0; if(!mpr121_get_touch_status(&status)) { /* ELE3: up * ELE4: back * ELE5: menu * ELE6: down * ELE7: play */ if(status & 0x8) touchpad_btns |= BUTTON_UP; if(status & 0x10) touchpad_btns |= BUTTON_BACK; if(status & 0x20) touchpad_btns |= BUTTON_MENU; if(status & 0x40) touchpad_btns |= BUTTON_DOWN; if(status & 0x80) touchpad_btns |= BUTTON_PLAY; } /* enable interrupt */ imx233_pinctrl_setup_irq(0, 18, true, true, false, &mpr121_irq_cb, 0); } }
/// find X MIN endstop void home_x_negative() { #if defined X_MIN_PIN TARGET t = startpoint; t.X = -1000000; #ifdef SLOW_HOMING // hit home soft t.F = SEARCH_FEEDRATE_X; #else // hit home hard t.F = MAXIMUM_FEEDRATE_X; #endif enqueue_home(&t, 0x1, 1); #ifndef SLOW_HOMING // back off slowly t.X = +1000000; t.F = SEARCH_FEEDRATE_X; enqueue_home(&t, 0x1, 0); #endif // set X home queue_wait(); // we have to wait here, see G92 #ifdef X_MIN startpoint.X = next_target.target.X = (int32_t)(X_MIN * 1000.0); #else startpoint.X = next_target.target.X = 0; #endif dda_new_startpoint(); #endif }
void sim_thread(void) { struct queue_event ev; long last_broadcast_tick = current_tick; int num_acks_to_expect; while (1) { queue_wait(&sim_queue, &ev); switch(ev.id) { case SIM_SCREENDUMP: screen_dump(); #ifdef HAVE_REMOTE_LCD remote_screen_dump(); #endif break; case SIM_USB_INSERTED: /* from firmware/usb.c: */ /* Tell all threads that they have to back off the storage. We subtract one for our own thread. Expect an ACK for every listener for each broadcast they received. If it has been too long, the user might have entered a screen that didn't ACK when inserting the cable, such as a debugging screen. In that case, reset the count or else USB would be locked out until rebooting because it most likely won't ever come. Simply resetting to the most recent broadcast count is racy. */ if(TIME_AFTER(current_tick, last_broadcast_tick + HZ*5)) { num_acks_to_expect = 0; last_broadcast_tick = current_tick; } num_acks_to_expect += queue_broadcast(SYS_USB_CONNECTED, 0) - 1; DEBUGF("USB inserted. Waiting for %d acks...\n", num_acks_to_expect); break; case SYS_USB_CONNECTED_ACK: if(num_acks_to_expect > 0 && --num_acks_to_expect == 0) { DEBUGF("All threads have acknowledged the connect.\n"); } else { DEBUGF("usb: got ack, %d to go...\n", num_acks_to_expect); } break; case SIM_USB_EXTRACTED: /* in usb.c, this is only done for exclusive storage * do it here anyway but don't depend on the acks */ queue_broadcast(SYS_USB_DISCONNECTED, 0); break; default: DEBUGF("sim_tasks: unhandled event: %ld\n", ev.id); break; } } }
void ff_circular_queue_wait_write(struct ff_circular_queue *cq) { queue_lock(cq); while (cq->size >= cq->capacity && !cq->abort) queue_wait(cq); queue_unlock(cq); }
static void* event_thread(void *data) { QUEUE* event_q = (QUEUE*) data; parrot_event* event; QUEUE_ENTRY *entry; int running = 1; LOCK(event_q->queue_mutex); /* * we might already have an event in the queue */ if (peek_entry(event_q)) running = process_events(event_q); while (running) { entry = peek_entry(event_q); if (!entry) { /* wait infinite until entry arrives */ queue_wait(event_q); } else if (entry->type == QUEUE_ENTRY_TYPE_TIMED_EVENT) { /* do a_timedwait for entry */ struct timespec abs_time; FLOATVAL when; event = (parrot_event* )entry->data; when = event->u.timer_event.abs_time; abs_time.tv_sec = (time_t) when; abs_time.tv_nsec = (when - abs_time.tv_sec) * (1000L*1000L*1000L); queue_timedwait(event_q, &abs_time); } else { /* we shouldn't get here probably */ internal_exception(1, "Spurious event"); } /* * one or more entries arrived - we hold the mutex again * so we have to use the nonsync_pop_entry to pop off event entries */ running = process_events(event_q); } /* event loop */ /* * the main interpreter is dying * TODO empty the queue */ UNLOCK(event_q->queue_mutex); queue_destroy(event_q); stop_io_thread(); edebug((stderr, "event thread stopped\n")); return NULL; }
void usb_wait_for_disconnect(struct event_queue *q) { struct queue_event ev; /* Don't return until we get SYS_USB_DISCONNECTED */ while(1) { queue_wait(q, &ev); if(ev.id == SYS_USB_DISCONNECTED) return; } }
void usb_wait_for_disconnect(struct event_queue *q) { #ifdef USB_FULL_INIT struct queue_event ev; /* Don't return until we get SYS_USB_DISCONNECTED */ while(1) { queue_wait(q, &ev); if(ev.id == SYS_USB_DISCONNECTED) return; } #endif /* USB_FULL_INIT */ (void)q; }
static enum codec_command_action codec_get_command_callback(intptr_t *param) { yield(); if (LIKELY(queue_empty(&codec_queue))) return CODEC_ACTION_NULL; /* As you were */ /* Process the message - return requested action and data (if any should be expected) */ while (1) { enum codec_command_action action = CODEC_ACTION_NULL; struct queue_event ev; queue_wait(&codec_queue, &ev); switch (ev.id) { case Q_CODEC_RUN: /* Already running */ LOGFQUEUE("codec < Q_CODEC_RUN"); break; case Q_CODEC_PAUSE: /* Stay here and wait */ LOGFQUEUE("codec < Q_CODEC_PAUSE"); codec_queue_ack(Q_CODEC_PAUSE); continue; case Q_CODEC_SEEK: /* Audio wants codec to seek */ LOGFQUEUE("codec < Q_CODEC_SEEK %ld", ev.data); *param = ev.data; action = CODEC_ACTION_SEEK_TIME; break; case Q_CODEC_STOP: /* Must only return 0 in main loop */ LOGFQUEUE("codec < Q_CODEC_STOP"); action = CODEC_ACTION_HALT; break; default: /* This is in error in this context. */ ev.id = Q_NULL; logf("codec bad req %ld (%s)", ev.id, __func__); } codec_queue_ack(ev.id); return action; } }
/* Codec thread function */ static void NORETURN_ATTR codec_thread(void) { struct queue_event ev; while (1) { cancel_cpu_boost(); queue_wait(&codec_queue, &ev); switch (ev.id) { case Q_CODEC_LOAD: LOGFQUEUE("codec < Q_CODEC_LOAD"); load_codec((const struct codec_load_info *)ev.data); break; case Q_CODEC_RUN: LOGFQUEUE("codec < Q_CODEC_RUN"); run_codec(); break; case Q_CODEC_PAUSE: LOGFQUEUE("codec < Q_CODEC_PAUSE"); break; case Q_CODEC_SEEK: LOGFQUEUE("codec < Q_CODEC_SEEK: %lu", (unsigned long)ev.data); seek_codec(ev.data); break; case Q_CODEC_UNLOAD: LOGFQUEUE("codec < Q_CODEC_UNLOAD"); unload_codec(); break; case Q_CODEC_DO_CALLBACK: LOGFQUEUE("codec < Q_CODEC_DO_CALLBACK"); do_callback((void (*)(void))ev.data); break; default: LOGFQUEUE("codec < default : %ld", ev.id); } } }
/// find Z MAX endstop void home_z_positive() { queue_wait(); #if defined Z_MAX_PIN uint8_t denoise_count = 0; // home Z z_enable(); // hit home hard z_direction(1); while (denoise_count < 8) { // denoise if (z_max()) denoise_count++; else denoise_count = 0; // step z_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_MM_Z / ((float) MAXIMUM_FEEDRATE_Z))); } denoise_count = 0; // back off slowly z_direction(0); while (z_max() != 0) { // step z_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_MM_Z / ((float) SEARCH_FEEDRATE_Z))); } // set Z home TARGET t = {0, 0, 0, 0, 0}; // set position to MAX startpoint.Z = current_position.Z = (int32_t) (Z_MAX * STEPS_PER_MM_Z); // go to zero t.F = MAXIMUM_FEEDRATE_Z; enqueue(&t); #endif }
static void NORETURN_ATTR audio_thread(void) { struct queue_event ev; ev.id = Q_NULL; /* something not in switch below */ pcm_postinit(); while (1) { switch (ev.id) { /* Starts the playback engine branch */ case Q_AUDIO_PLAY: LOGFQUEUE("audio < Q_AUDIO_PLAY"); audio_playback_handler(&ev); continue; /* Playback has to handle these, even if not playing */ case Q_AUDIO_REMAKE_AUDIO_BUFFER: #ifdef HAVE_DISK_STORAGE case Q_AUDIO_UPDATE_WATERMARK: #endif audio_playback_handler(&ev); break; #ifdef AUDIO_HAVE_RECORDING /* Starts the recording engine branch */ case Q_AUDIO_INIT_RECORDING: LOGFQUEUE("audio < Q_AUDIO_INIT_RECORDING"); audio_recording_handler(&ev); continue; #endif /* All return upon USB */ case SYS_USB_CONNECTED: LOGFQUEUE("audio < SYS_USB_CONNECTED"); voice_stop(); usb_acknowledge(SYS_USB_CONNECTED_ACK); usb_wait_for_disconnect(&audio_queue); break; } queue_wait(&audio_queue, &ev); } }
/// find Y MAX endstop void home_y_positive() { queue_wait(); #if defined Y_MAX_PIN uint8_t denoise_count = 0; // home Y y_enable(); // hit home hard y_direction(1); while (denoise_count < 8) { // denoise if (y_max()) denoise_count++; else denoise_count = 0; // step y_step(); delay(5); unstep(); // wait until neyt step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_MM_Y / ((float) MAXIMUM_FEEDRATE_Y))); } denoise_count = 0; // back off slowly y_direction(0); while (y_max() != 0) { // step y_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_MM_Y / ((float) SEARCH_FEEDRATE_Y))); } // set Y home TARGET t = {0, 0, 0, 0, 0}; // set position to MAX startpoint.Y = current_position.Y = (int32_t) (Y_MAX * STEPS_PER_MM_Y); // go to zero t.F = MAXIMUM_FEEDRATE_Y; enqueue(&t); #endif }
/// find X_MAX endstop void home_x_positive() { queue_wait(); #if defined X_MAX_PIN uint8_t denoise_count = 0; // home X x_enable(); // hit home hard x_direction(1); while (denoise_count < 8) { // denoise if (x_max()) denoise_count++; else denoise_count = 0; // step x_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_M_X * 1000.0 / ((float) MAXIMUM_FEEDRATE_X))); } denoise_count = 0; // back off slowly x_direction(0); while (x_max() != 0) { // step x_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_M_X * 1000.0 / ((float) SEARCH_FEEDRATE_X))); } // set X home TARGET t = {0, 0, 0, 0, 0}; // set position to MAX startpoint.X = current_position.X = (int32_t)(X_MAX * 1000.0); // go to zero t.F = MAXIMUM_FEEDRATE_X; enqueue(&t); #endif }
void sim_thread(void) { struct queue_event ev; while (1) { queue_wait(&sim_queue, &ev); switch(ev.id) { case SIM_SCREENDUMP: screen_dump(); #ifdef HAVE_REMOTE_LCD remote_screen_dump(); #endif break; } } }
static void codec_seek_complete_callback(void) { logf("seek_complete"); /* Clear DSP */ dsp_configure(ci.dsp, DSP_FLUSH, 0); /* Post notification to audio thread */ LOGFQUEUE("audio > Q_AUDIO_CODEC_SEEK_COMPLETE"); audio_queue_post(Q_AUDIO_CODEC_SEEK_COMPLETE, 0); /* Wait for urgent or go message */ do { queue_wait(&codec_queue, NULL); } while (codec_check_queue__have_msg() == 0); }
/// find Z MIN endstop void home_z_negative() { queue_wait(); #if defined Z_MIN_PIN uint8_t denoise_count = 0; // home Z z_enable(); // hit home hard z_direction(0); while (denoise_count < 8) { // denoise if (z_min()) denoise_count++; else denoise_count = 0; // step z_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_MM_Z / ((float) MAXIMUM_FEEDRATE_Z))); } denoise_count = 0; // back off slowly z_direction(1); while (z_min() != 0) { // step z_step(); delay(5); unstep(); // wait until next step time delay((uint32_t) (60.0 * 1000000.0 / STEPS_PER_MM_Z / ((float) SEARCH_FEEDRATE_Z))); } // set Z home startpoint.Z = current_position.Z = 0; z_disable(); #endif }