marlin_client.c File Reference

#include "marlin_client.h"
#include <stdarg.h>
#include <string.h>
#include "dbg.h"
#include "app.h"
#include "bsod.h"
#include "cmsis_os.h"
#include "stm32f4xx_hal.h"

Classes
struct	_marlin_client_t

Macros
#define	DBG   _dbg1
#define	DBG_REQ(...)
#define	DBG_EVT   DBG
#define	DBG_EVT_MSK   (MARLIN_EVT_MSK_ALL & ~MARLIN_EVT_MSK(MARLIN_EVT_Acknowledge))
#define	DBG_VAR(...)

Typedefs
typedef struct _marlin_client_t	marlin_client_t

Functions
void	_wait_server_started (void)
void	_send_request_to_server (uint8_t client_id, const char *request)
uint32_t	_wait_ack_from_server (uint8_t client_id)
void	_process_client_message (marlin_client_t *client, variant8_t msg)
marlin_client_t *	_client_ptr (void)
marlin_vars_t *	marlin_client_init (void)
void	marlin_client_shdn (void)
void	marlin_client_loop (void)
int	marlin_processing (void)
int	marlin_busy (void)
uint32_t	marlin_command (void)
void	marlin_stop_processing (void)
void	marlin_start_processing (void)
int	marlin_motion (void)
int	marlin_wait_motion (uint32_t timeout)
void	marlin_gcode (const char *gcode)
int	marlin_gcode_printf (const char *format,...)
void	marlin_gcode_push_front (const char *gcode)
int	marlin_event (uint8_t evt_id)
int	marlin_event_set (uint8_t evt_id)
int	marlin_event_clr (uint8_t evt_id)
uint64_t	marlin_events (void)
int	marlin_change (uint8_t var_id)
int	marlin_change_set (uint8_t var_id)
int	marlin_change_clr (uint8_t var_id)
uint64_t	marlin_changes (void)
int	marlin_error (uint8_t err_id)
int	marlin_error_set (uint8_t err_id)
int	marlin_error_clr (uint8_t err_id)
uint64_t	marlin_errors (void)
variant8_t	marlin_get_var (uint8_t var_id)
variant8_t	marlin_set_var (uint8_t var_id, variant8_t val)
marlin_vars_t *	marlin_vars (void)
marlin_vars_t *	marlin_update_vars (uint64_t msk)
uint8_t	marlin_get_gqueue (void)
uint8_t	marlin_get_gqueue_max (void)
uint8_t	marlin_get_pqueue (void)
uint8_t	marlin_get_pqueue_max (void)
float	marlin_set_target_nozzle (float val)
float	marlin_set_target_bed (float val)
float	marlin_set_z_offset (float val)
uint8_t	marlin_set_fan_speed (uint8_t val)
uint16_t	marlin_set_print_speed (uint16_t val)
uint16_t	marlin_set_flow_factor (uint16_t val)
uint8_t	marlin_set_wait_heat (uint8_t val)
uint8_t	marlin_set_wait_user (uint8_t val)
void	marlin_do_babysteps_Z (float offs)
void	marlin_settings_save (void)
void	marlin_settings_load (void)
void	marlin_manage_heater (void)
void	marlin_quick_stop (void)
void	marlin_print_abort (void)
void	marlin_print_pause (void)
void	marlin_print_resume (void)
void	marlin_park_head (void)
uint8_t	marlin_message_received (void)
host_prompt_type_t	marlin_host_prompt_type (void)
uint8_t	marlin_host_button_count (void)
host_prompt_button_t	marlin_host_button_type (uint8_t index)
void	marlin_host_button_click (host_prompt_button_t button)
int	marlin_reheating (void)

Variables
osThreadId	marlin_client_task [MARLIN_MAX_CLIENTS]
osMessageQId	marlin_client_queue [MARLIN_MAX_CLIENTS]
marlin_client_t	marlin_client [MARLIN_MAX_CLIENTS]
uint8_t	marlin_clients = 0
osThreadId	marlin_server_task
osMessageQId	marlin_server_queue
osSemaphoreId	marlin_server_sema

Macro Definition Documentation

DBG

#define DBG   _dbg1

DBG_REQ

#define DBG_REQ

(

...

)

DBG_EVT

#define DBG_EVT   DBG

DBG_EVT_MSK

#define DBG_EVT_MSK   (MARLIN_EVT_MSK_ALL & ~MARLIN_EVT_MSK(MARLIN_EVT_Acknowledge))

DBG_VAR

#define DBG_VAR

(

...

)

Typedef Documentation

marlin_client_t

typedef struct _marlin_client_t marlin_client_t

Function Documentation

_wait_server_started()

void _wait_server_started

(

void

)

                                {
    while (marlin_server_task == 0)
        osDelay(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_send_request_to_server()

void _send_request_to_server	(	uint8_t	client_id,
		const char *	request
	)

                                                                     {
    int ret = 0;
    int len = strlen(request);
    osMessageQId queue = 0;
    int i;
    osSemaphoreWait(marlin_server_sema, osWaitForever); // lock
    if ((queue = marlin_server_queue) != 0) // queue valid
    {
        marlin_client[client_id].events &= ~MARLIN_EVT_MSK(MARLIN_EVT_Acknowledge);
        while (ret == 0) {
            if (osMessageAvailableSpace(queue) >= (uint32_t)(len + 1)) // check available space
            {
                osMessagePut(queue, '0' + client_id, osWaitForever); // one character client id
                for (i = 0; i < len; i++) // loop over every characters
                    osMessagePut(queue, request[i], osWaitForever); //
                if ((i > 0) && (request[i - 1] != '\n')) // automatically terminate with '\n'
                    osMessagePut(queue, '\n', osWaitForever);
                ret = 1;
            } else {
                osSemaphoreRelease(marlin_server_sema); // unlock
                osDelay(10);
                osSemaphoreWait(marlin_server_sema, osWaitForever); // lock
            }
        }
    }
    osSemaphoreRelease(marlin_server_sema); // unlock
    DBG_REQ("CL%c: REQ %s", '0' + client_id, request);
    //return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_wait_ack_from_server()

uint32_t _wait_ack_from_server

(

uint8_t

client_id

)

                                                  {
    while ((marlin_client[client_id].events & MARLIN_EVT_MSK(MARLIN_EVT_Acknowledge)) == 0) {
        marlin_client_loop();
        if (marlin_client[client_id].last_count == 0)
            osDelay(10);
    }
    marlin_client[client_id].events &= ~MARLIN_EVT_MSK(MARLIN_EVT_Acknowledge);
    return marlin_client[client_id].ack;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_process_client_message()

void _process_client_message	(	marlin_client_t *	client,
		variant8_t	msg
	)

                                                                      {
    char var_str[16];
    uint8_t id = msg.usr8 & MARLIN_USR8_MSK_ID;
    if (msg.usr8 & MARLIN_USR8_VAR_FLG) // variable change received
    {
        marlin_vars_set_var(&(client->vars), id, msg);
        client->changes |= ((uint64_t)1 << id);
        marlin_vars_value_to_str(&(client->vars), id, var_str);
#ifdef DBG_VAR_MSK
        if (DBG_VAR_MSK & ((uint64_t)1 << id))
#endif //DBG_VAR_MSK
            DBG_VAR("CL%c: VAR %s %s", '0' + client->id, marlin_vars_get_name(id), var_str);
    } else if (msg.type == VARIANT8_USER) // event received
    {
        client->events |= ((uint64_t)1 << id);
        switch (id) {
        case MARLIN_EVT_MeshUpdate: {
            uint8_t x = msg.usr16 & 0xff;
            uint8_t y = msg.usr16 >> 8;
            float z = msg.flt;
            client->mesh.z[x + client->mesh.xc * y] = z;
        } break;
        case MARLIN_EVT_HostPrompt:
            marlin_host_prompt_decode(msg.ui32, &(client->prompt));
            break;
        case MARLIN_EVT_StartProcessing:
            client->flags |= MARLIN_CFLG_PROCESS;
            break;
        case MARLIN_EVT_StopProcessing:
            client->flags &= ~MARLIN_CFLG_PROCESS;
            break;
        case MARLIN_EVT_Busy:
            client->flags |= MARLIN_CFLG_BUSY;
            break;
        case MARLIN_EVT_Ready:
            client->flags &= ~MARLIN_CFLG_BUSY;
            break;
        case MARLIN_EVT_Error:
            client->errors |= MARLIN_ERR_MSK(msg.ui32);
            break;
        case MARLIN_EVT_CommandBegin:
            client->command = msg.ui32;
            break;
        case MARLIN_EVT_CommandEnd:
            client->command = MARLIN_CMD_NONE;
            break;
        case MARLIN_EVT_Message:
            client->flags |= MARLIN_CFLG_MESSAGE;
            break;
        case MARLIN_EVT_Reheat:
            client->reheating = (uint8_t)msg.ui32;
            break;
        case MARLIN_EVT_Acknowledge:
            client->ack = msg.ui32;
            break;
        }
#ifdef DBG_EVT_MSK
        if (DBG_EVT_MSK & ((uint64_t)1 << id))
#endif
            switch (id) {
            // Event MARLIN_EVT_MeshUpdate - ui32 is float z, ui16 low byte is x index, high byte y index
            case MARLIN_EVT_MeshUpdate: {
                uint8_t x = msg.usr16 & 0xff;
                uint8_t y = msg.usr16 >> 8;
                float z = msg.flt;
                DBG_EVT("CL%c: EVT %s %d %d %.3f", '0' + client->id, marlin_events_get_name(id),
                    x, y, (double)z);
                x = x;
                y = y;
                z = z; //prevent warning
            } break;
            // Event MARLIN_EVT_CommandBegin/End - ui32 is encoded command
            case MARLIN_EVT_CommandBegin:
            case MARLIN_EVT_CommandEnd:
                DBG_EVT("CL%c: EVT %s %c%u", '0' + client->id, marlin_events_get_name(id),
                    (msg.ui32 >> 16) & 0xff, msg.ui32 & 0xffff);
                break;
            // Event MARLIN_EVT_Acknowledge - ui32 is result (not used in this time)
            case MARLIN_EVT_Reheat:
            case MARLIN_EVT_Acknowledge:
                DBG_EVT("CL%c: EVT %s %lu", '0' + client->id, marlin_events_get_name(id), msg.ui32);
                break;
            // Other events and events without arguments
            default:
                DBG_EVT("CL%c: EVT %s", '0' + client->id, marlin_events_get_name(id));
                break;
            }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_client_ptr()

marlin_client_t * _client_ptr

(

void

)

                                   {
    osThreadId taskHandle = osThreadGetId();
    int client_id;
    for (client_id = 0; client_id < MARLIN_MAX_CLIENTS; client_id++)
        if (taskHandle == marlin_client_task[client_id])
            return marlin_client + client_id;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_client_init()

marlin_vars_t* marlin_client_init

(

void

)

                                        {
    int client_id;
    marlin_client_t *client = 0;
    _wait_server_started();
    osSemaphoreWait(marlin_server_sema, osWaitForever);
    for (client_id = 0; client_id < MARLIN_MAX_CLIENTS; client_id++)
        if (marlin_client_task[client_id] == 0)
            break;
    if (client_id < MARLIN_MAX_CLIENTS) {
        client = marlin_client + client_id;
        memset(client, 0, sizeof(marlin_client_t));
        osMessageQDef(clientQueue, 32, uint32_t);
        marlin_client_queue[client_id] = osMessageCreate(osMessageQ(clientQueue), NULL);
        client->id = client_id;
        client->flags = 0;
        client->events = 0;
        client->changes = 0;
        marlin_clients++;
        client->flags |= (MARLIN_CFLG_STARTED | MARLIN_CFLG_PROCESS);
        client->errors = 0;
        client->mesh.xc = 4;
        client->mesh.yc = 4;
        client->command = MARLIN_CMD_NONE;
        client->reheating = 0;
        marlin_client_task[client_id] = osThreadGetId();
    }
    osSemaphoreRelease(marlin_server_sema);
    return (client) ? &(client->vars) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_client_shdn()

void marlin_client_shdn

(

void

)

                              {
    //TODO
}

marlin_client_loop()

void marlin_client_loop

(

void

)

                              {
    uint16_t count = 0;
    osEvent ose;
    variant8_t msg;
    int client_id;
    marlin_client_t *client;
    osMessageQId queue;
    osThreadId taskHandle = osThreadGetId();
    for (client_id = 0; client_id < MARLIN_MAX_CLIENTS; client_id++)
        if (taskHandle == marlin_client_task[client_id])
            break;
    if (client_id >= MARLIN_MAX_CLIENTS)
        return;
    client = marlin_client + client_id;
    if ((queue = marlin_client_queue[client_id]) != 0)
        while ((ose = osMessageGet(queue, 0)).status == osEventMessage) {
            if (client->flags & MARLIN_CFLG_LOWHIGH) {
                *(((uint32_t *)(&msg)) + 1) = ose.value.v; //store high dword
                _process_client_message(client, msg); //call handler
                count++;
            } else
                *(((uint32_t *)(&msg)) + 0) = ose.value.v; //store low dword
            client->flags ^= MARLIN_CFLG_LOWHIGH; //flip flag
        }
    client->last_count = count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_processing()

int marlin_processing

(

void

)

                            {
    marlin_client_t *client = _client_ptr();
    if (client)
        return (client->flags & MARLIN_CFLG_PROCESS) ? 1 : 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_busy()

int marlin_busy

(

void

)

                      {
    marlin_client_t *client = _client_ptr();
    if (client)
        return (client->flags & MARLIN_CFLG_BUSY) ? 1 : 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_command()

uint32_t marlin_command

(

void

)

                              {
    marlin_client_t *client = _client_ptr();
    if (client)
        return client->command;
    return MARLIN_CMD_NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_stop_processing()

void marlin_stop_processing

(

void

)

                                  {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!stop");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_start_processing()

void marlin_start_processing

(

void

)

                                   {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!start");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_motion()

int marlin_motion

(

void

)

                        {
    marlin_vars_t *vars = marlin_update_vars(MARLIN_VAR_MSK(MARLIN_VAR_MOTION));
    return (vars->motion) ? 1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_wait_motion()

int marlin_wait_motion

(

uint32_t

timeout

)

                                         {
    marlin_vars_t *vars = marlin_update_vars(MARLIN_VAR_MSK(MARLIN_VAR_MOTION));
    uint32_t tick = HAL_GetTick();
    while ((vars->motion == 0) && ((HAL_GetTick() - tick) < timeout))
        marlin_update_vars(MARLIN_VAR_MSK(MARLIN_VAR_MOTION));
    return (vars->motion) ? 1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_gcode()

void marlin_gcode

(

const char *

gcode

)

                                     {
    char request[MARLIN_MAX_REQUEST];
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    strcpy(request, "!g ");
    strcat(request, gcode);
    _send_request_to_server(client->id, request);
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_gcode_printf()

int marlin_gcode_printf	(	const char *	format,
			...
	)

                                                 {
    int ret;
    char request[MARLIN_MAX_REQUEST];
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return 0;
    strcpy(request, "!g ");
    va_list ap;
    va_start(ap, format);
    ret = vsprintf(request + 3, format, ap);
    va_end(ap);
    _send_request_to_server(client->id, request);
    _wait_ack_from_server(client->id);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_gcode_push_front()

void marlin_gcode_push_front

(

const char *

gcode

)

                                                {
    char request[MARLIN_MAX_REQUEST];
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    snprintf(request, MARLIN_MAX_REQUEST, "!ig %p", gcode);
    _send_request_to_server(client->id, request);
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_event()

int marlin_event

(

uint8_t

evt_id

)

                                 {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << evt_id;
    if (client)
        ret = (client->events & msk) ? 1 : 0;
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_event_set()

int marlin_event_set

(

uint8_t

evt_id

)

                                     {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << evt_id;
    if (client) {
        ret = (client->events & msk) ? 1 : 0;
        client->events |= msk;
    }
    return ret;
}

Here is the call graph for this function:

marlin_event_clr()

int marlin_event_clr

(

uint8_t

evt_id

)

                                     {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << evt_id;
    if (client) {
        ret = (client->events & msk) ? 1 : 0;
        client->events &= ~msk;
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_events()

uint64_t marlin_events

(

void

)

                             {
    marlin_client_t *client = _client_ptr();
    return (client) ? client->events : 0;
}

Here is the call graph for this function:

marlin_change()

int marlin_change

(

uint8_t

var_id

)

                                  {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << var_id;
    if (client)
        ret = (client->changes & msk) ? 1 : 0;
    return ret;
}

Here is the call graph for this function:

marlin_change_set()

int marlin_change_set

(

uint8_t

var_id

)

                                      {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << var_id;
    if (client) {
        ret = (client->changes & msk) ? 1 : 0;
        client->changes |= msk;
    }
    return ret;
}

Here is the call graph for this function:

marlin_change_clr()

int marlin_change_clr

(

uint8_t

var_id

)

                                      {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << var_id;
    if (client) {
        ret = (client->changes & msk) ? 1 : 0;
        client->changes &= ~msk;
    }
    return ret;
}

Here is the call graph for this function:

marlin_changes()

uint64_t marlin_changes

(

void

)

                              {
    marlin_client_t *client = _client_ptr();
    return (client) ? client->changes : 0;
}

Here is the call graph for this function:

marlin_error()

int marlin_error

(

uint8_t

err_id

)

                                 {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << err_id;
    if (client)
        ret = (client->errors & msk) ? 1 : 0;
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_error_set()

int marlin_error_set

(

uint8_t

err_id

)

                                     {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << err_id;
    if (client) {
        ret = (client->errors & msk) ? 1 : 0;
        client->errors |= msk;
    }
    return ret;
}

Here is the call graph for this function:

marlin_error_clr()

int marlin_error_clr

(

uint8_t

err_id

)

                                     {
    int ret = 0;
    marlin_client_t *client = _client_ptr();
    uint64_t msk = (uint64_t)1 << err_id;
    if (client) {
        ret = (client->errors & msk) ? 1 : 0;
        client->errors &= ~msk;
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_errors()

uint64_t marlin_errors

(

void

)

                             {
    marlin_client_t *client = _client_ptr();
    return (client) ? client->errors : 0;
}

Here is the call graph for this function:

marlin_get_var()

variant8_t marlin_get_var

(

uint8_t

var_id

)

                                          {
    marlin_client_t *client = _client_ptr();
    return (client) ? marlin_vars_get_var(&(client->vars), var_id) : variant8_empty();
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_var()

variant8_t marlin_set_var	(	uint8_t	var_id,
		variant8_t	val
	)

                                                          {
    variant8_t retval = variant8_empty();
    char request[MARLIN_MAX_REQUEST];
    int n;
    marlin_client_t *client = _client_ptr();
    if (client) {
        retval = marlin_vars_get_var(&(client->vars), var_id);
        marlin_vars_set_var(&(client->vars), var_id, val);
        n = sprintf(request, "!var %s ", marlin_vars_get_name(var_id));
        marlin_vars_value_to_str(&(client->vars), var_id, request + n);
        _send_request_to_server(client->id, request);
        _wait_ack_from_server(client->id);
    }
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_vars()

marlin_vars_t* marlin_vars

(

void

)

                                 {
    marlin_client_t *client = _client_ptr();
    if (client)
        return &(client->vars);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_update_vars()

marlin_vars_t* marlin_update_vars

(

uint64_t

msk

)

                                                {
    char request[MARLIN_MAX_REQUEST];
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return 0;
    marlin_client_loop();
    client->changes &= ~msk;
    sprintf(request, "!update %" PRIu64, msk);
    _send_request_to_server(client->id, request);
    _wait_ack_from_server(client->id);
    return &(client->vars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_get_gqueue()

uint8_t marlin_get_gqueue

(

void

)

                                {
    return marlin_get_var(MARLIN_VAR_GQUEUE).ui8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_get_gqueue_max()

uint8_t marlin_get_gqueue_max

(

void

)

                                    {
    //TODO: variable gqueue_max should be part of marlin_consts structure transmited from server
    //Marlin/queue, BUFSIZE - 1
    return 8 - 1;
}

marlin_get_pqueue()

uint8_t marlin_get_pqueue

(

void

)

                                {
    return marlin_get_var(MARLIN_VAR_PQUEUE).ui8;
}

Here is the call graph for this function:

marlin_get_pqueue_max()

uint8_t marlin_get_pqueue_max

(

void

)

                                    {
    //TODO: variable pqueue_max should be part of marlin_consts structure transmited from server
    //Marlin/planner, BLOCK_BUFFER_SIZE - 1
    return 16 - 1;
}

marlin_set_target_nozzle()

float marlin_set_target_nozzle

(

float

val

)

                                          {
    return marlin_set_var(MARLIN_VAR_TTEM_NOZ, variant8_flt(val)).flt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_target_bed()

float marlin_set_target_bed

(

float

val

)

                                       {
    return marlin_set_var(MARLIN_VAR_TTEM_BED, variant8_flt(val)).flt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_z_offset()

float marlin_set_z_offset

(

float

val

)

                                     {
    return marlin_set_var(MARLIN_VAR_Z_OFFSET, variant8_flt(val)).flt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_fan_speed()

uint8_t marlin_set_fan_speed

(

uint8_t

val

)

                                          {
    return marlin_set_var(MARLIN_VAR_FANSPEED, variant8_ui8(val)).ui8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_print_speed()

uint16_t marlin_set_print_speed

(

uint16_t

val

)

                                              {
    return marlin_set_var(MARLIN_VAR_PRNSPEED, variant8_ui16(val)).ui16;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_flow_factor()

uint16_t marlin_set_flow_factor

(

uint16_t

val

)

                                              {
    return marlin_set_var(MARLIN_VAR_FLOWFACT, variant8_ui16(val)).ui16;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_set_wait_heat()

uint8_t marlin_set_wait_heat

(

uint8_t

val

)

                                          {
    return marlin_set_var(MARLIN_VAR_WAITHEAT, variant8_ui8(val)).ui8;
}

Here is the call graph for this function:

marlin_set_wait_user()

uint8_t marlin_set_wait_user

(

uint8_t

val

)

                                          {
    return marlin_set_var(MARLIN_VAR_WAITUSER, variant8_ui8(val)).ui8;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_do_babysteps_Z()

void marlin_do_babysteps_Z

(

float

offs

)

                                       {
    char request[MARLIN_MAX_REQUEST];
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    sprintf(request, "!babystep_Z %.4f", (double)offs);
    _send_request_to_server(client->id, request);
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_settings_save()

void marlin_settings_save

(

void

)

                                {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!save");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_settings_load()

void marlin_settings_load

(

void

)

                                {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!load");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

marlin_manage_heater()

void marlin_manage_heater

(

void

)

                                {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!updt");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_quick_stop()

void marlin_quick_stop

(

void

)

                             {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!qstop");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

marlin_print_abort()

void marlin_print_abort

(

void

)

                              {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!pabort");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_print_pause()

void marlin_print_pause

(

void

)

                              {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!ppause");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_print_resume()

void marlin_print_resume

(

void

)

                               {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!presume");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_park_head()

void marlin_park_head

(

void

)

                            {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    _send_request_to_server(client->id, "!park");
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_message_received()

uint8_t marlin_message_received

(

void

)

                                      {
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return 0;
    if (client->flags & MARLIN_CFLG_MESSAGE) {
        client->flags &= ~MARLIN_CFLG_MESSAGE;
        return 1;
    } else
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_host_prompt_type()

host_prompt_type_t marlin_host_prompt_type

(

void

)

                                                 {
    marlin_client_t *client = _client_ptr();
    if (client)
        return client->prompt.type;
    return HOST_PROMPT_None;
}

Here is the call graph for this function:

marlin_host_button_count()

uint8_t marlin_host_button_count

(

void

)

                                       {
    marlin_client_t *client = _client_ptr();
    if (client)
        return client->prompt.button_count;
    return 0;
}

Here is the call graph for this function:

marlin_host_button_type()

host_prompt_button_t marlin_host_button_type

(

uint8_t

index

)

                                                            {
    marlin_client_t *client = _client_ptr();
    if (client && (index < client->prompt.button_count))
        return client->prompt.button[index];
    return HOST_PROMPT_BTN_None;
}

Here is the call graph for this function:

marlin_host_button_click()

void marlin_host_button_click

(

host_prompt_button_t

button

)

                                                           {
    char request[MARLIN_MAX_REQUEST];
    marlin_client_t *client = _client_ptr();
    if (client == 0)
        return;
    sprintf(request, "!hclick %d", (int)button);
    _send_request_to_server(client->id, request);
    _wait_ack_from_server(client->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

marlin_reheating()

int marlin_reheating

(

void

)

                           {
    marlin_client_t *client = _client_ptr();
    if (client)
        return client->reheating;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

marlin_client_task

osThreadId marlin_client_task[MARLIN_MAX_CLIENTS]

marlin_client_queue

osMessageQId marlin_client_queue[MARLIN_MAX_CLIENTS]

marlin_client

marlin_client_t marlin_client[MARLIN_MAX_CLIENTS]

marlin_clients

uint8_t marlin_clients = 0

marlin_server_task

osThreadId marlin_server_task

marlin_server_queue

osMessageQId marlin_server_queue

marlin_server_sema

osSemaphoreId marlin_server_sema