Bairan.Zhang/AI_Printer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e141b8de0887c3f12d054912ba8dcf3928eb16d
AI_Printer/main/domain/src/printer_protocol.c
admin 9e141b8de0 init
2026-02-24 18:10:40 +08:00

932 lines
27 KiB
C
Raw Blame History

#include "printer_protocol.h"
#include "printer_protocol_internal.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ble_printer_client.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#define PROTO_ADDR 0x01
#define CMD_POWER 0x00
#define CMD_GET_STATUS 0x01
#define CMD_SET_DISTANCE 0x02
#define CMD_SET_PARAM 0x03
#define CMD_SEND_DATA 0x04
#define EVT_ACK BIT0
#define JOB_QUEUE_LEN 8
#define JOB_SLOT_MAX 16
#define MAX_RASTER_BYTES (384 * 3000 / 8)
typedef struct {
bool used;
bool cancel_requested;
uint32_t id;
print_job_state_t state;
uint8_t progress;
uint16_t width;
uint16_t height;
size_t data_len;
char density[16];
char error[96];
int64_t created_ms;
int64_t started_ms;
int64_t finished_ms;
uint8_t *data;
} job_slot_t;
typedef struct {
bool has_paper;
uint8_t battery;
float temperature;
int64_t updated_ms;
} parsed_status_t;
static SemaphoreHandle_t s_mutex;
static QueueHandle_t s_job_queue;
static EventGroupHandle_t s_evt;
static uint32_t s_busy_refcnt;
static parsed_status_t s_status = {
.has_paper = true,
.battery = 100,
.temperature = 25.0f,
.updated_ms = 0,
};
static uint8_t s_last_rsp_cmd;
static uint16_t s_last_rsp_payload_len;
static uint8_t s_last_rsp_payload[252];
static uint32_t s_next_job_id = 1;
static job_slot_t s_jobs[JOB_SLOT_MAX];
static int find_job_idx_locked(uint32_t id) {
for (int i = 0; i < JOB_SLOT_MAX; ++i) {
if (s_jobs[i].used && s_jobs[i].id == id) {
return i;
}
}
return -1;
}
static int alloc_job_slot_locked(void) {
for (int i = 0; i < JOB_SLOT_MAX; ++i) {
if (!s_jobs[i].used) {
return i;
}
}
/* Reuse completed slot when table is full. */
for (int i = 0; i < JOB_SLOT_MAX; ++i) {
if (s_jobs[i].state == PRINT_JOB_STATE_SUCCESS ||
s_jobs[i].state == PRINT_JOB_STATE_FAILED ||
s_jobs[i].state == PRINT_JOB_STATE_CANCELED) {
free(s_jobs[i].data);
memset(&s_jobs[i], 0, sizeof(s_jobs[i]));
return i;
}
}
return -1;
}
static bool is_terminal_state(print_job_state_t state) {
return state == PRINT_JOB_STATE_SUCCESS ||
state == PRINT_JOB_STATE_FAILED ||
state == PRINT_JOB_STATE_CANCELED;
}
bool printer_protocol_acquire_control_lane(uint32_t timeout_ms, char *err, size_t err_len) {
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(timeout_ms)) != pdTRUE) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "lock timeout");
}
return false;
}
if (s_busy_refcnt != 0) {
xSemaphoreGive(s_mutex);
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "printer busy");
}
return false;
}
s_busy_refcnt = 1;
xSemaphoreGive(s_mutex);
return true;
}
void printer_protocol_release_control_lane(void) {
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
return;
}
if (s_busy_refcnt > 0) {
--s_busy_refcnt;
}
xSemaphoreGive(s_mutex);
}
static uint8_t checksum8(const uint8_t *data, size_t len) {
uint32_t sum = 0;
for (size_t i = 0; i < len; ++i) {
sum += data[i];
}
return (uint8_t)(sum & 0xFF);
}
static esp_err_t send_frame(uint8_t cmd, const uint8_t *payload, uint16_t payload_len, bool with_checksum) {
uint8_t frame[260];
size_t total = 4 + payload_len + (with_checksum ? 1 : 0);
if (total > sizeof(frame)) {
return ESP_ERR_INVALID_SIZE;
}
frame[0] = PROTO_ADDR;
frame[1] = cmd;
frame[2] = (uint8_t)((payload_len >> 8) & 0xFF);
frame[3] = (uint8_t)(payload_len & 0xFF);
if (payload_len > 0 && payload != NULL) {
memcpy(&frame[4], payload, payload_len);
}
if (with_checksum) {
frame[4 + payload_len] = checksum8(frame, 4 + payload_len);
}
return ble_printer_client_write(frame, total);
}
static void clear_ack_signal(void) {
xEventGroupClearBits(s_evt, EVT_ACK);
}
static bool wait_response(uint8_t cmd,
uint8_t *out_payload,
size_t out_payload_cap,
uint16_t *out_payload_len,
uint32_t timeout_ms) {
int64_t deadline = esp_timer_get_time() / 1000 + timeout_ms;
while (true) {
int64_t now = esp_timer_get_time() / 1000;
if (now >= deadline) {
return false;
}
uint32_t wait_ms = (uint32_t)(deadline - now);
EventBits_t bits = xEventGroupWaitBits(s_evt,
EVT_ACK,
pdTRUE,
pdFALSE,
pdMS_TO_TICKS(wait_ms));
if (!(bits & EVT_ACK)) {
return false;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(200)) != pdTRUE) {
continue;
}
uint8_t rsp_cmd = s_last_rsp_cmd;
uint16_t rsp_len = s_last_rsp_payload_len;
uint8_t rsp_copy[sizeof(s_last_rsp_payload)];
if (rsp_len > sizeof(rsp_copy)) {
rsp_len = sizeof(rsp_copy);
}
if (rsp_len > 0) {
memcpy(rsp_copy, s_last_rsp_payload, rsp_len);
}
xSemaphoreGive(s_mutex);
if (rsp_cmd == cmd) {
if (out_payload != NULL && out_payload_cap > 0 && rsp_len > 0) {
size_t copy_len = rsp_len;
if (copy_len > out_payload_cap) {
copy_len = out_payload_cap;
}
memcpy(out_payload, rsp_copy, copy_len);
}
if (out_payload_len != NULL) {
*out_payload_len = rsp_len;
}
return true;
}
}
}
static bool wait_ack(uint8_t cmd, uint32_t timeout_ms) {
uint8_t payload[252];
uint16_t payload_len = 0;
if (!wait_response(cmd, payload, sizeof(payload), &payload_len, timeout_ms)) {
return false;
}
return payload_len >= 1 && payload[0] == 0x01;
}
static bool send_cmd_with_ack(uint8_t cmd,
const uint8_t *payload,
uint16_t payload_len,
bool with_checksum,
uint32_t timeout_ms) {
clear_ack_signal();
if (send_frame(cmd, payload, payload_len, with_checksum) != ESP_OK) {
return false;
}
return wait_ack(cmd, timeout_ms);
}
esp_err_t printer_protocol_send_cmd_wait_response(uint8_t cmd,
const uint8_t *payload,
uint16_t payload_len,
bool with_checksum,
uint32_t timeout_ms,
bool expect_ack,
uint8_t *out_payload,
size_t out_payload_cap,
uint16_t *out_payload_len,
char *err,
size_t err_len) {
clear_ack_signal();
if (send_frame(cmd, payload, payload_len, with_checksum) != ESP_OK) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "send frame failed");
}
return ESP_FAIL;
}
uint8_t rsp[252];
uint16_t rsp_len = 0;
if (!wait_response(cmd, rsp, sizeof(rsp), &rsp_len, timeout_ms)) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "response timeout");
}
return ESP_ERR_TIMEOUT;
}
if (expect_ack && (rsp_len < 1 || rsp[0] != 0x01)) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "cmd 0x%02X rejected", cmd);
}
return ESP_FAIL;
}
if (out_payload != NULL && out_payload_cap > 0 && rsp_len > 0) {
size_t copy_len = rsp_len;
if (copy_len > out_payload_cap) {
copy_len = out_payload_cap;
}
memcpy(out_payload, rsp, copy_len);
}
if (out_payload_len != NULL) {
*out_payload_len = rsp_len;
}
return ESP_OK;
}
static bool request_status_sync(uint32_t timeout_ms) {
int64_t old_ms;
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(200)) != pdTRUE) {
return false;
}
old_ms = s_status.updated_ms;
xSemaphoreGive(s_mutex);
uint8_t payload = 0x00;
if (send_frame(CMD_GET_STATUS, &payload, 0, true) != ESP_OK) {
return false;
}
int64_t deadline = esp_timer_get_time() / 1000 + timeout_ms;
while ((esp_timer_get_time() / 1000) < deadline) {
vTaskDelay(pdMS_TO_TICKS(20));
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(100)) != pdTRUE) {
continue;
}
bool updated = s_status.updated_ms > old_ms;
xSemaphoreGive(s_mutex);
if (updated) {
return true;
}
}
return false;
}
static uint16_t density_to_hot_time(const char *density) {
if (density == NULL) {
return 2000;
}
if (strcmp(density, "较淡") == 0) {
return 1000;
}
if (strcmp(density, "中等") == 0) {
return 1500;
}
if (strcmp(density, "较浓") == 0) {
return 2000;
}
if (strcmp(density, "最深") == 0) {
return 3000;
}
return 2000;
}
static bool precheck_printer_ready(char *err, size_t err_len) {
if (!request_status_sync(1200)) {
snprintf(err, err_len, "status timeout");
return false;
}
parsed_status_t status;
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(200)) != pdTRUE) {
snprintf(err, err_len, "status lock failed");
return false;
}
status = s_status;
xSemaphoreGive(s_mutex);
if (!status.has_paper) {
snprintf(err, err_len, "printer out of paper");
return false;
}
if (status.battery <= 40) {
snprintf(err, err_len, "battery too low");
return false;
}
if (status.temperature >= 60.0f) {
snprintf(err, err_len, "temperature too high");
return false;
}
return true;
}
static bool run_print_job(job_slot_t *job) {
char err[96];
err[0] = '\0';
if (!ble_printer_client_is_connected()) {
snprintf(job->error, sizeof(job->error), "printer not connected");
return false;
}
if (!precheck_printer_ready(err, sizeof(err))) {
snprintf(job->error, sizeof(job->error), "%s", err);
return false;
}
if (job->cancel_requested) {
snprintf(job->error, sizeof(job->error), "job canceled");
return false;
}
uint8_t power_on = 0x01;
if (!send_cmd_with_ack(CMD_POWER, &power_on, 1, true, 1500)) {
snprintf(job->error, sizeof(job->error), "power on failed");
return false;
}
uint16_t hot_time = density_to_hot_time(job->density);
uint8_t param[4] = {
0x01,
0x02,
(uint8_t)((hot_time >> 8) & 0xFF),
(uint8_t)(hot_time & 0xFF),
};
if (!send_cmd_with_ack(CMD_SET_PARAM, param, sizeof(param), true, 1500)) {
snprintf(job->error, sizeof(job->error), "set print param failed");
return false;
}
const size_t chunk_max = 240;
size_t total_chunks = (size_t)ceil((double)job->data_len / (double)chunk_max);
for (size_t i = 0; i < total_chunks; ++i) {
if (job->cancel_requested) {
snprintf(job->error, sizeof(job->error), "job canceled");
return false;
}
size_t start = i * chunk_max;
size_t remain = job->data_len - start;
size_t chunk_len = remain > chunk_max ? chunk_max : remain;
if (!send_cmd_with_ack(CMD_SEND_DATA,
&job->data[start],
(uint16_t)chunk_len,
false,
2500)) {
snprintf(job->error, sizeof(job->error), "send chunk timeout at %u", (unsigned)i);
return false;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(200)) == pdTRUE) {
job->progress = (uint8_t)(((i + 1) * 90) / total_chunks);
if (job->progress < 5) {
job->progress = 5;
}
xSemaphoreGive(s_mutex);
}
}
uint8_t power_off = 0x00;
(void)send_cmd_with_ack(CMD_POWER, &power_off, 1, true, 1200);
uint8_t feed_payload[3] = {0x2B, 0x00, 0x0C};
(void)send_cmd_with_ack(CMD_SET_DISTANCE, feed_payload, sizeof(feed_payload), true, 1200);
return true;
}
static void worker_task(void *arg) {
(void)arg;
while (true) {
uint32_t job_id;
if (xQueueReceive(s_job_queue, &job_id, portMAX_DELAY) != pdTRUE) {
continue;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
continue;
}
int idx = find_job_idx_locked(job_id);
if (idx < 0) {
xSemaphoreGive(s_mutex);
continue;
}
if (s_jobs[idx].state == PRINT_JOB_STATE_CANCELED) {
free(s_jobs[idx].data);
s_jobs[idx].data = NULL;
if (s_jobs[idx].finished_ms == 0) {
s_jobs[idx].finished_ms = esp_timer_get_time() / 1000;
}
xSemaphoreGive(s_mutex);
continue;
}
if (s_busy_refcnt != 0) {
xSemaphoreGive(s_mutex);
xQueueSendToFront(s_job_queue, &job_id, 0);
vTaskDelay(pdMS_TO_TICKS(20));
continue;
}
s_jobs[idx].state = PRINT_JOB_STATE_RUNNING;
s_jobs[idx].started_ms = esp_timer_get_time() / 1000;
s_jobs[idx].progress = 1;
s_busy_refcnt = 1;
xSemaphoreGive(s_mutex);
bool ok = run_print_job(&s_jobs[idx]);
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
continue;
}
if (s_busy_refcnt > 0) {
--s_busy_refcnt;
}
s_jobs[idx].finished_ms = esp_timer_get_time() / 1000;
if (s_jobs[idx].state != PRINT_JOB_STATE_CANCELED) {
s_jobs[idx].progress = 100;
}
if (ok) {
s_jobs[idx].state = PRINT_JOB_STATE_SUCCESS;
s_jobs[idx].error[0] = '\0';
} else if (s_jobs[idx].cancel_requested) {
s_jobs[idx].state = PRINT_JOB_STATE_CANCELED;
if (s_jobs[idx].error[0] == '\0') {
strlcpy(s_jobs[idx].error, "job canceled", sizeof(s_jobs[idx].error));
}
} else {
s_jobs[idx].state = PRINT_JOB_STATE_FAILED;
}
free(s_jobs[idx].data);
s_jobs[idx].data = NULL;
xSemaphoreGive(s_mutex);
}
}
static void status_poll_task(void *arg) {
(void)arg;
while (true) {
bool can_poll = false;
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(50)) == pdTRUE) {
can_poll = (s_busy_refcnt == 0);
xSemaphoreGive(s_mutex);
}
if (ble_printer_client_is_connected() && can_poll) {
uint8_t dummy = 0x00;
(void)send_frame(CMD_GET_STATUS, &dummy, 0, true);
}
vTaskDelay(pdMS_TO_TICKS(5000));
}
}
static void on_rx_frame(const uint8_t *data, size_t len) {
if (data == NULL || len < 4) {
return;
}
if (data[0] != PROTO_ADDR) {
return;
}
uint8_t cmd = data[1];
uint16_t payload_len = ((uint16_t)data[2] << 8) | data[3];
size_t required = (size_t)payload_len + 4;
if (len < required) {
return;
}
const uint8_t *payload = &data[4];
if (cmd == CMD_GET_STATUS && payload_len >= 5) {
bool has_paper = payload[0] != 0;
uint8_t battery = payload[1];
int sign = (payload[2] == 0x2D) ? -1 : 1;
int temp_x10 = ((int)payload[3] << 8) | payload[4];
float temperature = (float)(sign * temp_x10) / 10.0f;
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(100)) == pdTRUE) {
s_status.has_paper = has_paper;
s_status.battery = battery;
s_status.temperature = temperature;
s_status.updated_ms = esp_timer_get_time() / 1000;
xSemaphoreGive(s_mutex);
}
return;
}
if (payload_len >= 1) {
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(100)) == pdTRUE) {
s_last_rsp_cmd = cmd;
s_last_rsp_payload_len = payload_len;
if (s_last_rsp_payload_len > sizeof(s_last_rsp_payload)) {
s_last_rsp_payload_len = sizeof(s_last_rsp_payload);
}
memcpy(s_last_rsp_payload, payload, s_last_rsp_payload_len);
xSemaphoreGive(s_mutex);
}
xEventGroupSetBits(s_evt, EVT_ACK);
}
}
esp_err_t printer_protocol_init(void) {
s_mutex = xSemaphoreCreateMutex();
if (s_mutex == NULL) {
return ESP_ERR_NO_MEM;
}
s_evt = xEventGroupCreate();
if (s_evt == NULL) {
return ESP_ERR_NO_MEM;
}
s_job_queue = xQueueCreate(JOB_QUEUE_LEN, sizeof(uint32_t));
if (s_job_queue == NULL) {
return ESP_ERR_NO_MEM;
}
esp_err_t err = ble_printer_client_init(on_rx_frame);
if (err != ESP_OK) {
return err;
}
BaseType_t ok = xTaskCreate(worker_task, "print_worker", 6144, NULL, 6, NULL);
if (ok != pdPASS) {
return ESP_ERR_NO_MEM;
}
ok = xTaskCreate(status_poll_task, "status_poll", 4096, NULL, 4, NULL);
if (ok != pdPASS) {
return ESP_ERR_NO_MEM;
}
return ESP_OK;
}
esp_err_t printer_protocol_connect(const char *target_name, uint32_t timeout_ms) {
return ble_printer_client_connect(target_name, timeout_ms);
}
void printer_protocol_disconnect(void) {
ble_printer_client_disconnect();
}
void printer_protocol_get_runtime_status(printer_runtime_status_t *out_status) {
if (out_status == NULL) {
return;
}
memset(out_status, 0, sizeof(*out_status));
ble_link_state_t link = {0};
ble_printer_client_get_link_state(&link);
out_status->connected = link.connected;
out_status->notify_ready = link.notify_ready;
out_status->mtu = link.mtu;
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(200)) == pdTRUE) {
out_status->busy = s_busy_refcnt > 0;
out_status->has_paper = s_status.has_paper;
out_status->battery_percent = s_status.battery;
out_status->temperature = s_status.temperature;
out_status->last_status_ms = s_status.updated_ms;
out_status->queue_depth = (uint32_t)uxQueueMessagesWaiting(s_job_queue);
xSemaphoreGive(s_mutex);
}
}
esp_err_t printer_protocol_submit_raster_job(const uint8_t *raster,
size_t raster_len,
uint16_t width,
uint16_t height,
const char *density,
uint32_t *out_job_id,
char *err,
size_t err_len) {
if (raster == NULL || raster_len == 0 || width == 0 || height == 0) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "invalid args");
}
return ESP_ERR_INVALID_ARG;
}
if (width != 384) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "width must be 384");
}
return ESP_ERR_INVALID_ARG;
}
if (raster_len > MAX_RASTER_BYTES) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "raster too large");
}
return ESP_ERR_INVALID_SIZE;
}
size_t expected_len = ((size_t)width / 8u) * (size_t)height;
if (expected_len != raster_len) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "size mismatch exp=%u got=%u",
(unsigned)expected_len,
(unsigned)raster_len);
}
return ESP_ERR_INVALID_SIZE;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "lock timeout");
}
return ESP_ERR_TIMEOUT;
}
int idx = alloc_job_slot_locked();
if (idx < 0) {
xSemaphoreGive(s_mutex);
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "job table full");
}
return ESP_ERR_NO_MEM;
}
uint8_t *copy = (uint8_t *)malloc(raster_len);
if (copy == NULL) {
xSemaphoreGive(s_mutex);
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "malloc failed");
}
return ESP_ERR_NO_MEM;
}
memcpy(copy, raster, raster_len);
uint32_t id = s_next_job_id++;
if (s_next_job_id == 0) {
s_next_job_id = 1;
}
memset(&s_jobs[idx], 0, sizeof(s_jobs[idx]));
s_jobs[idx].used = true;
s_jobs[idx].id = id;
s_jobs[idx].state = PRINT_JOB_STATE_QUEUED;
s_jobs[idx].progress = 0;
s_jobs[idx].width = width;
s_jobs[idx].height = height;
s_jobs[idx].data_len = raster_len;
s_jobs[idx].created_ms = esp_timer_get_time() / 1000;
s_jobs[idx].data = copy;
strlcpy(s_jobs[idx].density, density != NULL ? density : "中等", sizeof(s_jobs[idx].density));
xSemaphoreGive(s_mutex);
if (xQueueSend(s_job_queue, &id, pdMS_TO_TICKS(500)) != pdTRUE) {
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {
int rollback_idx = find_job_idx_locked(id);
if (rollback_idx >= 0) {
free(s_jobs[rollback_idx].data);
memset(&s_jobs[rollback_idx], 0, sizeof(s_jobs[rollback_idx]));
}
xSemaphoreGive(s_mutex);
}
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "job queue full");
}
return ESP_ERR_TIMEOUT;
}
if (out_job_id != NULL) {
*out_job_id = id;
}
return ESP_OK;
}
bool printer_protocol_get_job(uint32_t job_id, print_job_info_t *out_info) {
if (out_info == NULL || job_id == 0) {
return false;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(500)) != pdTRUE) {
return false;
}
int idx = find_job_idx_locked(job_id);
if (idx < 0) {
xSemaphoreGive(s_mutex);
return false;
}
memset(out_info, 0, sizeof(*out_info));
out_info->id = s_jobs[idx].id;
out_info->state = s_jobs[idx].state;
out_info->progress = s_jobs[idx].progress;
out_info->width = s_jobs[idx].width;
out_info->height = s_jobs[idx].height;
out_info->data_len = s_jobs[idx].data_len;
out_info->created_ms = s_jobs[idx].created_ms;
out_info->started_ms = s_jobs[idx].started_ms;
out_info->finished_ms = s_jobs[idx].finished_ms;
strlcpy(out_info->density, s_jobs[idx].density, sizeof(out_info->density));
strlcpy(out_info->error, s_jobs[idx].error, sizeof(out_info->error));
xSemaphoreGive(s_mutex);
return true;
}
esp_err_t printer_protocol_list_jobs(print_job_info_t *out_jobs, size_t max_jobs, size_t *out_count) {
if (out_count == NULL) {
return ESP_ERR_INVALID_ARG;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(500)) != pdTRUE) {
return ESP_ERR_TIMEOUT;
}
size_t count = 0;
for (int i = 0; i < JOB_SLOT_MAX; ++i) {
if (!s_jobs[i].used || s_jobs[i].state == PRINT_JOB_STATE_NONE) {
continue;
}
if (out_jobs != NULL && count < max_jobs) {
memset(&out_jobs[count], 0, sizeof(out_jobs[count]));
out_jobs[count].id = s_jobs[i].id;
out_jobs[count].state = s_jobs[i].state;
out_jobs[count].progress = s_jobs[i].progress;
out_jobs[count].width = s_jobs[i].width;
out_jobs[count].height = s_jobs[i].height;
out_jobs[count].data_len = s_jobs[i].data_len;
out_jobs[count].created_ms = s_jobs[i].created_ms;
out_jobs[count].started_ms = s_jobs[i].started_ms;
out_jobs[count].finished_ms = s_jobs[i].finished_ms;
strlcpy(out_jobs[count].density, s_jobs[i].density, sizeof(out_jobs[count].density));
strlcpy(out_jobs[count].error, s_jobs[i].error, sizeof(out_jobs[count].error));
}
++count;
}
xSemaphoreGive(s_mutex);
*out_count = count;
return ESP_OK;
}
esp_err_t printer_protocol_cancel_job(uint32_t job_id, char *err, size_t err_len) {
if (job_id == 0) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "invalid job id");
}
return ESP_ERR_INVALID_ARG;
}
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(500)) != pdTRUE) {
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "lock timeout");
}
return ESP_ERR_TIMEOUT;
}
int idx = find_job_idx_locked(job_id);
if (idx < 0) {
xSemaphoreGive(s_mutex);
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "job not found");
}
return ESP_ERR_NOT_FOUND;
}
if (is_terminal_state(s_jobs[idx].state)) {
xSemaphoreGive(s_mutex);
if (err != NULL && err_len > 0) {
snprintf(err, err_len, "job already finished");
}
return ESP_ERR_INVALID_STATE;
}
s_jobs[idx].cancel_requested = true;
if (s_jobs[idx].state == PRINT_JOB_STATE_QUEUED) {
s_jobs[idx].state = PRINT_JOB_STATE_CANCELED;
s_jobs[idx].finished_ms = esp_timer_get_time() / 1000;
s_jobs[idx].progress = 0;
strlcpy(s_jobs[idx].error, "job canceled", sizeof(s_jobs[idx].error));
free(s_jobs[idx].data);
s_jobs[idx].data = NULL;
} else if (s_jobs[idx].state == PRINT_JOB_STATE_RUNNING) {
strlcpy(s_jobs[idx].error, "cancel requested", sizeof(s_jobs[idx].error));
}
xSemaphoreGive(s_mutex);
return ESP_OK;
}
size_t printer_protocol_cleanup_jobs(bool include_success, bool include_failed, bool include_canceled) {
if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(500)) != pdTRUE) {
return 0;
}
size_t removed = 0;
for (int i = 0; i < JOB_SLOT_MAX; ++i) {
if (!s_jobs[i].used) {
continue;
}
bool match = false;
if (include_success && s_jobs[i].state == PRINT_JOB_STATE_SUCCESS) {
match = true;
}
if (include_failed && s_jobs[i].state == PRINT_JOB_STATE_FAILED) {
match = true;
}
if (include_canceled && s_jobs[i].state == PRINT_JOB_STATE_CANCELED) {
match = true;
}
if (!match) {
continue;
}
free(s_jobs[i].data);
memset(&s_jobs[i], 0, sizeof(s_jobs[i]));
++removed;
}
xSemaphoreGive(s_mutex);
return removed;
}
Reference in New Issue View Git Blame Copy Permalink