/* Precalculate all three rows of an image and start the rendering. */
static void start_image(struct mb_display *disp, const struct mb_image *img)
{
int row, col;
for (row = 0; row < DISPLAY_ROWS; row++) {
disp->row[row] = 0;
for (col = 0; col < DISPLAY_COLS; col++) {
if (GET_PIXEL(img, map[row][col].x, map[row][col].y)) {
disp->row[row] |= BIT(LED_COL1_GPIO_PIN + col);
}
}
disp->row[row] = ~disp->row[row] & col_mask;
disp->row[row] |= BIT(LED_ROW1_GPIO_PIN + row);
}
disp->cur = 0;
if (disp->duration == K_FOREVER) {
disp->expiry = K_FOREVER;
} else {
disp->expiry = k_uptime_get() + disp->duration;
}
k_timer_start(&disp->timer, K_NO_WAIT, K_MSEC(4));
}
static void eswifi_spi_poll_thread(void *p1)
{
struct eswifi_dev *eswifi = p1;
while (1) {
k_sleep(K_MSEC(1000));
eswifi_spi_read_msg(eswifi);
}
}
static int loopback_send(struct net_if *iface, struct net_pkt *pkt)
{
struct net_pkt *cloned;
int res;
if (!pkt->frags) {
SYS_LOG_ERR("No data to send");
return -ENODATA;
}
/* We need to swap the IP addresses because otherwise
* the packet will be dropped.
*/
if (net_pkt_family(pkt) == AF_INET6) {
struct in6_addr addr;
net_ipaddr_copy(&addr, &NET_IPV6_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV6_HDR(pkt)->src,
&NET_IPV6_HDR(pkt)->dst);
net_ipaddr_copy(&NET_IPV6_HDR(pkt)->dst, &addr);
} else {
struct in_addr addr;
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
&NET_IPV4_HDR(pkt)->dst);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->dst, &addr);
}
/* We should simulate normal driver meaning that if the packet is
* properly sent (which is always in this driver), then the packet
* must be dropped. This is very much needed for TCP packets where
* the packet is reference counted in various stages of sending.
*/
cloned = net_pkt_clone(pkt, K_MSEC(100));
if (!cloned) {
res = -ENOMEM;
goto out;
}
res = net_recv_data(iface, cloned);
if (res < 0) {
SYS_LOG_ERR("Data receive failed.");
goto out;
}
net_pkt_unref(pkt);
out:
/* Let the receiving thread run now */
k_yield();
return res;
}
static void eth_rx(struct eth_context *ctx)
{
int ret;
LOG_DBG("Starting ZETH RX thread");
while (1) {
if (net_if_is_up(ctx->iface)) {
ret = eth_wait_data(ctx->dev_fd);
if (!ret) {
read_data(ctx, ctx->dev_fd);
} else {
eth_stats_update_errors_rx(ctx->iface);
}
}
k_sleep(K_MSEC(50));
}
}
static int telnet_console_init(struct device *arg)
{
#ifdef CONFIG_NET_IPV4
struct sockaddr_in any_addr4 = {
.sin_family = AF_INET,
.sin_port = htons(TELNET_PORT),
.sin_addr = INADDR_ANY_INIT
};
static struct net_context *ctx4;
#endif
#ifdef CONFIG_NET_IPV6
struct sockaddr_in6 any_addr6 = {
.sin6_family = AF_INET6,
.sin6_port = htons(TELNET_PORT),
.sin6_addr = IN6ADDR_ANY_INIT
};
static struct net_context *ctx6;
#endif
#ifdef CONFIG_NET_IPV4
telnet_setup_server(&ctx4, AF_INET,
(struct sockaddr *)&any_addr4,
sizeof(any_addr4));
#endif
#ifdef CONFIG_NET_IPV6
telnet_setup_server(&ctx6, AF_INET6,
(struct sockaddr *)&any_addr6,
sizeof(any_addr6));
#endif
k_thread_spawn(&telnet_stack[0],
TELNET_STACK_SIZE,
(k_thread_entry_t)telnet_run,
NULL, NULL, NULL,
K_PRIO_COOP(TELNET_PRIORITY), 0, K_MSEC(10));
SYS_LOG_INF("Telnet console initialized");
return 0;
}
static int work_in_time_slice(struct flash_op_desc *p_flash_op_desc)
{
u8_t instance_index;
u8_t ticker_id;
int result;
u32_t err;
struct flash_context *context = p_flash_op_desc->context;
ll_timeslice_ticker_id_get(&instance_index, &ticker_id);
err = ticker_start(instance_index,
3, /* user id for thread mode */
/* (MAYFLY_CALL_ID_PROGRAM) */
ticker_id, /* flash ticker id */
ticker_ticks_now_get(), /* current tick */
0, /* first int. immediately */
/* period */
HAL_TICKER_US_TO_TICKS(context->interval),
/* period remainder */
HAL_TICKER_REMAINDER(context->interval),
0, /* lazy, voluntary skips */
HAL_TICKER_US_TO_TICKS(context->slot),
time_slot_callback_helper,
p_flash_op_desc,
NULL, /* no op callback */
NULL);
if (err != TICKER_STATUS_SUCCESS && err != TICKER_STATUS_BUSY) {
result = -ECANCELED;
} else if (k_sem_take(&sem_sync, K_MSEC(FLASH_TIMEOUT_MS)) != 0) {
/* wait for operation's complete overrun*/
result = -ETIMEDOUT;
} else {
result = p_flash_op_desc->result;
}
return result;
}
static void lwm2m_rd_client_service(void)
{
int index;
while (true) {
for (index = 0; index < client_count; index++) {
switch (get_sm_state(index)) {
case ENGINE_INIT:
sm_do_init(index);
break;
case ENGINE_DO_BOOTSTRAP:
sm_do_bootstrap(index);
break;
case ENGINE_BOOTSTRAP_SENT:
/* wait for bootstrap to be done */
break;
case ENGINE_BOOTSTRAP_DONE:
sm_bootstrap_done(index);
break;
case ENGINE_DO_REGISTRATION:
sm_do_registration(index);
break;
case ENGINE_REGISTRATION_SENT:
/* wait registration to be done */
break;
case ENGINE_REGISTRATION_DONE:
sm_registration_done(index);
break;
case ENGINE_UPDATE_SENT:
/* wait update to be done */
break;
case ENGINE_DEREGISTER:
sm_do_deregister(index);
break;
case ENGINE_DEREGISTER_SENT:
break;
case ENGINE_DEREGISTER_FAILED:
break;
case ENGINE_DEREGISTERED:
break;
default:
SYS_LOG_ERR("Unhandled state: %d",
get_sm_state(index));
}
k_yield();
}
/*
* TODO: calculate the diff between the start of the loop
* and subtract that from the update interval
*/
k_sleep(K_MSEC(STATE_MACHINE_UPDATE_INTERVAL));
}
}
