Skip to content

Commit c57f3d2

Browse files
jtguggedaljtguggedal
committed
modules: Remove STATE_* macros
Remove the STATE_* macros to make SMF use more explicit. At the same time, state objects are made local to each module thread. Signed-off-by: Jan Tore Guggedal <jantore.guggedal@nordicsemi.no>
1 parent d530383 commit c57f3d2

File tree

7 files changed

+82
-140
lines changed

7 files changed

+82
-140
lines changed

‎app/src/common/modules_common.h

-52
This file was deleted.

‎app/src/main.c

+22-23
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,6 @@
1010
#include <zephyr/task_wdt/task_wdt.h>
1111
#include <zephyr/smf.h>
1212

13-
#include "modules_common.h"
1413
#include "message_channel.h"
1514
#include "button.h"
1615
#include "network.h"
@@ -154,8 +153,6 @@ struct main_state {
154153
enum location_msg_type location_status;
155154
};
156155

157-
static struct main_state main_state;
158-
159156
/* Construct state table */
160157
static const struct smf_state states[] = {
161158
[STATE_RUNNING] = SMF_CREATE_STATE(
@@ -333,11 +330,11 @@ static void running_entry(void *o)
333330
if (state_object->status == CLOUD_CONNECTED_READY_TO_SEND ||
334331
state_object->status == CLOUD_PAYLOAD_JSON ||
335332
state_object->status == CLOUD_POLL_SHADOW) {
336-
STATE_SET(main_state, STATE_TRIGGERING);
333+
smf_set_state(SMF_CTX(state_object), &states[STATE_TRIGGERING]);
337334
return;
338335
}
339336

340-
STATE_SET(main_state, STATE_IDLE);
337+
smf_set_state(SMF_CTX(state_object), &states[STATE_IDLE]);
341338
}
342339

343340
static void running_run(void *o)
@@ -346,7 +343,7 @@ static void running_run(void *o)
346343

347344
if (state_object->chan == &FOTA_CHAN &&
348345
state_object->fota_status == FOTA_DOWNLOADING_UPDATE) {
349-
STATE_SET(main_state, STATE_FOTA);
346+
smf_set_state(SMF_CTX(state_object), &states[STATE_FOTA]);
350347
return;
351348
}
352349
}
@@ -389,7 +386,7 @@ static void idle_run(void *o)
389386

390387
if ((state_object->chan == &CLOUD_CHAN) &&
391388
(state_object->status == CLOUD_CONNECTED_READY_TO_SEND)) {
392-
STATE_SET(main_state, STATE_TRIGGERING);
389+
smf_set_state(SMF_CTX(state_object), &states[STATE_TRIGGERING]);
393390
return;
394391
}
395392
}
@@ -433,7 +430,7 @@ static void triggering_run(void *o)
433430
if ((state_object->chan == &CLOUD_CHAN) &&
434431
((state_object->status == CLOUD_CONNECTED_PAUSED) ||
435432
(state_object->status == CLOUD_DISCONNECTED))) {
436-
STATE_SET(main_state, STATE_IDLE);
433+
smf_set_state(SMF_CTX(state_object), &states[STATE_IDLE]);
437434
return;
438435
}
439436

@@ -469,12 +466,12 @@ static void requesting_location_run(void *o)
469466

470467
if (state_object->chan == &LOCATION_CHAN &&
471468
(state_object->location_status == LOCATION_SEARCH_DONE)) {
472-
STATE_SET(main_state, STATE_REQUESTING_SENSORS_AND_POLLING);
469+
smf_set_state(SMF_CTX(state_object), &states[STATE_REQUESTING_SENSORS_AND_POLLING]);
473470
return;
474471
}
475472

476473
if (state_object->chan == &BUTTON_CHAN) {
477-
STATE_EVENT_HANDLED(main_state);
474+
smf_set_handled(SMF_CTX(state_object));
478475
return;
479476
}
480477
}
@@ -483,28 +480,28 @@ static void requesting_location_run(void *o)
483480

484481
static void requesting_sensors_and_polling_entry(void *o)
485482
{
486-
ARG_UNUSED(o);
483+
const struct main_state *state_object = (const struct main_state *)o;
487484

488485
LOG_DBG("%s", __func__);
489486

490487
sensor_and_poll_triggers_send();
491488

492-
LOG_DBG("Next trigger in %lld seconds", main_state.interval_sec);
489+
LOG_DBG("Next trigger in %lld seconds", state_object->interval_sec);
493490

494-
k_work_reschedule(&trigger_work, K_SECONDS(main_state.interval_sec));
491+
k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
495492
}
496493

497494
static void requesting_sensors_and_polling_run(void *o)
498495
{
499496
const struct main_state *state_object = (const struct main_state *)o;
500497

501498
if (state_object->chan == &TIMER_CHAN) {
502-
STATE_SET(main_state, STATE_REQUESTING_LOCATION);
499+
smf_set_state(SMF_CTX(state_object), &states[STATE_REQUESTING_LOCATION]);
503500
return;
504501
}
505502

506503
if (state_object->chan == &BUTTON_CHAN) {
507-
STATE_SET(main_state, STATE_REQUESTING_LOCATION);
504+
smf_set_state(SMF_CTX(state_object), &states[STATE_REQUESTING_LOCATION]);
508505
return;
509506
}
510507
}
@@ -540,7 +537,7 @@ static void fota_run(void *o)
540537
case FOTA_DOWNLOAD_TIMED_OUT:
541538
__fallthrough;
542539
case FOTA_DOWNLOAD_FAILED:
543-
STATE_SET(main_state, STATE_RUNNING);
540+
smf_set_state(SMF_CTX(state_object), &states[STATE_RUNNING]);
544541
return;
545542
default:
546543
/* Don't care */
@@ -558,10 +555,11 @@ static void fota_downloading_run(void *o)
558555
if (state_object->chan == &FOTA_CHAN) {
559556
switch (state_object->fota_status) {
560557
case FOTA_SUCCESS_REBOOT_NEEDED:
561-
STATE_SET(main_state, STATE_FOTA_NETWORK_DISCONNECT);
558+
smf_set_state(SMF_CTX(state_object),
559+
&states[STATE_FOTA_NETWORK_DISCONNECT]);
562560
return;
563561
case FOTA_IMAGE_APPLY_NEEDED:
564-
STATE_SET(main_state, STATE_FOTA_APPLYING_IMAGE);
562+
smf_set_state(SMF_CTX(state_object), &states[STATE_FOTA_APPLYING_IMAGE]);
565563
return;
566564
default:
567565
/* Don't care */
@@ -596,7 +594,7 @@ static void fota_network_disconnect_run(void *o)
596594

597595
if (state_object->chan == &NETWORK_CHAN &&
598596
state_object->network_status == NETWORK_DISCONNECTED) {
599-
STATE_SET(main_state, STATE_FOTA_REBOOTING);
597+
smf_set_state(SMF_CTX(state_object), &states[STATE_FOTA_REBOOTING]);
600598
return;
601599
}
602600
}
@@ -639,7 +637,7 @@ static void fota_applying_image_run(void *o)
639637

640638
} else if (state_object->chan == &FOTA_CHAN &&
641639
state_object->fota_status == FOTA_SUCCESS_REBOOT_NEEDED) {
642-
STATE_SET(main_state, STATE_FOTA_REBOOTING);
640+
smf_set_state(SMF_CTX(state_object), &states[STATE_FOTA_REBOOTING]);
643641
return;
644642
}
645643
}
@@ -671,14 +669,15 @@ int main(void)
671669
const uint32_t execution_time_ms =
672670
(CONFIG_APP_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
673671
const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
672+
struct main_state main_state;
674673

675674
main_state.interval_sec = CONFIG_APP_MODULE_TRIGGER_TIMEOUT_SECONDS;
676675

677676
LOG_DBG("Main has started");
678677

679678
task_wdt_id = task_wdt_add(wdt_timeout_ms, task_wdt_callback, (void *)k_current_get());
680679

681-
STATE_SET_INITIAL(main_state, STATE_RUNNING);
680+
smf_set_initial(SMF_CTX(&main_state), &states[STATE_RUNNING]);
682681

683682
while (1) {
684683
err = task_wdt_feed(task_wdt_id);
@@ -726,9 +725,9 @@ int main(void)
726725
}
727726

728727
/* State object updated, run SMF */
729-
err = STATE_RUN(main_state);
728+
err = smf_run_state(SMF_CTX(&main_state));
730729
if (err) {
731-
LOG_ERR("STATE_RUN(), error: %d", err);
730+
LOG_ERR("smf_run_state(), error: %d", err);
732731
SEND_FATAL_ERROR();
733732

734733
return err;

‎app/src/modules/cloud/cloud_module.c

+14-17
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,6 @@
1717
#include <memfault/core/trace_event.h>
1818
#endif /* CONFIG_MEMFAULT */
1919

20-
#include "modules_common.h"
2120
#include "cloud_module.h"
2221
#include "message_channel.h"
2322
#include "network.h"
@@ -230,9 +229,6 @@ struct cloud_state {
230229
uint32_t backoff_time;
231230
};
232231

233-
static struct cloud_state cloud_state;
234-
235-
236232
/* Static helper function */
237233
static void task_wdt_callback(int channel_id, void *user_data)
238234
{
@@ -242,7 +238,7 @@ static void task_wdt_callback(int channel_id, void *user_data)
242238
SEND_FATAL_ERROR_WATCHDOG_TIMEOUT();
243239
}
244240

245-
static void connect_to_cloud(void)
241+
static void connect_to_cloud(const struct cloud_state *state_object)
246242
{
247243
int err;
248244
char buf[NRF_CLOUD_CLIENT_ID_MAX_LEN];
@@ -259,15 +255,15 @@ static void connect_to_cloud(void)
259255

260256
err = nrf_cloud_coap_connect(APP_VERSION_STRING);
261257
if (err == 0) {
262-
STATE_SET(cloud_state, STATE_CONNECTED);
258+
smf_set_state(SMF_CTX(state_object), &states[STATE_CONNECTED]);
263259

264260
return;
265261
}
266262

267263
/* Connection failed, retry */
268264
LOG_ERR("nrf_cloud_coap_connect, error: %d", err);
269265

270-
STATE_SET(cloud_state, STATE_CONNECTING_BACKOFF);
266+
smf_set_state(SMF_CTX(state_object), &states[STATE_CONNECTING_BACKOFF]);
271267
}
272268

273269
static uint32_t calculate_backoff_time(uint32_t attempts)
@@ -335,7 +331,7 @@ static void state_running_run(void *o)
335331
struct network_msg msg = MSG_TO_NETWORK_MSG(state_object->msg_buf);
336332

337333
if (msg.type == NETWORK_DISCONNECTED) {
338-
STATE_SET(cloud_state, STATE_DISCONNECTED);
334+
smf_set_state(SMF_CTX(state_object), &states[STATE_DISCONNECTED]);
339335

340336
return;
341337
}
@@ -369,7 +365,7 @@ static void state_disconnected_run(void *o)
369365
struct network_msg msg = MSG_TO_NETWORK_MSG(state_object->msg_buf);
370366

371367
if ((state_object->chan == &NETWORK_CHAN) && (msg.type == NETWORK_CONNECTED)) {
372-
STATE_SET(cloud_state, STATE_CONNECTING);
368+
smf_set_state(SMF_CTX(state_object), &states[STATE_CONNECTING]);
373369

374370
return;
375371
}
@@ -397,7 +393,7 @@ static void state_connecting_attempt_entry(void *o)
397393

398394
state_object->connection_attempts++;
399395

400-
connect_to_cloud();
396+
connect_to_cloud(state_object);
401397
}
402398

403399
/* Handler for STATE_CONNECTING_BACKOFF */
@@ -421,7 +417,7 @@ static void state_connecting_backoff_run(void *o)
421417
const enum priv_cloud_msg msg = *(const enum priv_cloud_msg *)state_object->msg_buf;
422418

423419
if (msg == CLOUD_BACKOFF_EXPIRED) {
424-
STATE_SET(cloud_state, STATE_CONNECTING_ATTEMPT);
420+
smf_set_state(SMF_CTX(state_object), &states[STATE_CONNECTING_ATTEMPT]);
425421

426422
return;
427423
}
@@ -526,11 +522,11 @@ static void state_connected_ready_run(void *o)
526522

527523
switch (msg.type) {
528524
case NETWORK_DISCONNECTED:
529-
STATE_SET(cloud_state, STATE_CONNECTED_PAUSED);
525+
smf_set_state(SMF_CTX(state_object), &states[STATE_CONNECTED_PAUSED]);
530526
break;
531527

532528
case NETWORK_CONNECTED:
533-
STATE_EVENT_HANDLED(cloud_state);
529+
smf_set_handled(SMF_CTX(state_object));
534530
break;
535531

536532
case NETWORK_QUALITY_SAMPLE_RESPONSE:
@@ -692,7 +688,7 @@ static void state_connected_paused_run(void *o)
692688
struct network_msg msg = MSG_TO_NETWORK_MSG(state_object->msg_buf);
693689

694690
if ((state_object->chan == &NETWORK_CHAN) && (msg.type == NETWORK_CONNECTED)) {
695-
STATE_SET(cloud_state, STATE_CONNECTED_READY);
691+
smf_set_state(SMF_CTX(state_object), &states[STATE_CONNECTED_READY]);
696692

697693
return;
698694
}
@@ -708,13 +704,14 @@ static void cloud_module_thread(void)
708704
const uint32_t execution_time_ms =
709705
(CONFIG_APP_CLOUD_MSG_PROCESSING_TIMEOUT_SECONDS * MSEC_PER_SEC);
710706
const k_timeout_t zbus_wait_ms = K_MSEC(wdt_timeout_ms - execution_time_ms);
707+
struct cloud_state cloud_state;
711708

712709
LOG_DBG("cloud module task started");
713710

714711
task_wdt_id = task_wdt_add(wdt_timeout_ms, task_wdt_callback, (void *)k_current_get());
715712

716713
/* Initialize the state machine to STATE_RUNNING, which will also run its entry function */
717-
STATE_SET_INITIAL(cloud_state, STATE_RUNNING);
714+
smf_set_initial(SMF_CTX(&cloud_state), &states[STATE_RUNNING]);
718715

719716
while (true) {
720717
err = task_wdt_feed(task_wdt_id);
@@ -736,9 +733,9 @@ static void cloud_module_thread(void)
736733
return;
737734
}
738735

739-
err = STATE_RUN(cloud_state);
736+
err = smf_run_state(SMF_CTX(&cloud_state));
740737
if (err) {
741-
LOG_ERR("STATE_RUN(), error: %d", err);
738+
LOG_ERR("smf_run_state(), error: %d", err);
742739
SEND_FATAL_ERROR();
743740

744741
return;

0 commit comments

Comments
 (0)