add -Wshadow

CMakeLists.txt

     -Wall
     -Wextra
     -Werror
+    -Wshadow
 )
 
 # suppress some warnings for borked 3rd party files in Pico SDK
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/avdtp_util.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/goep_client.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/goep_server.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
+set_source_files_properties(pico-sdk/src/rp2_common/hardware_flash/flash.c PROPERTIES COMPILE_FLAGS -Wno-shadow)
 
 # pull in common dependencies
 target_link_libraries(gadget

src/console.c

             DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            int8_t r = volcano_set_target_temp(v);
+            int8_t t = volcano_set_target_temp(v);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing target temp %d", r);
+            if (t < 0) {
+                println("error writing target temp %d", t);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            int8_t r = volcano_set_heater_state(val == 1);
+            int8_t t = volcano_set_heater_state(val == 1);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing heater state %d", r);
+            if (t < 0) {
+                println("error writing heater state %d", t);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            int8_t r = volcano_set_pump_state(val == 1);
+            int8_t s = volcano_set_pump_state(val == 1);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing pump state %d", r);
+            if (s < 0) {
+                println("error writing pump state %d", s);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            int8_t r = volcano_set_unit((val == 'C') ? UNIT_C : UNIT_F);
+            int8_t u = volcano_set_unit((val == 'C') ? UNIT_C : UNIT_F);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing value %d", r);
+            if (u < 0) {
+                println("error writing value %d", u);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            int8_t r = volcano_set_vibration(val == 1);
+            int8_t v = volcano_set_vibration(val == 1);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing value %d", r);
+            if (v < 0) {
+                println("error writing value %d", v);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            int8_t r = volcano_set_display_cooling(val == 1);
+            int8_t c = volcano_set_display_cooling(val == 1);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing value %d", r);
+            if (c < 0) {
+                println("error writing value %d", c);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
 #endif // TEST_CRAFTY_AUTO_CONNECT
 
-            int8_t r = crafty_set_target_temp(v);
+            int8_t t = crafty_set_target_temp(v);
 
 #ifdef TEST_CRAFTY_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_CRAFTY_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing target temp %d", r);
+            if (t < 0) {
+                println("error writing target temp %d", t);
             } else {
                 println("success");
             }
             DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
 #endif // TEST_CRAFTY_AUTO_CONNECT
 
-            int8_t r = crafty_set_heater_state(val == 1);
+            int8_t s = crafty_set_heater_state(val == 1);
 
 #ifdef TEST_CRAFTY_AUTO_CONNECT
             ble_disconnect();
 #endif // TEST_CRAFTY_AUTO_CONNECT
 
-            if (r < 0) {
-                println("error writing heater state %d", r);
+            if (s < 0) {
+                println("error writing heater state %d", s);
             } else {
                 println("success");
             }

src/log.c

 #include "log.h"
 
 static uint8_t log_buff[4096] = {0};
-static struct ring_buffer log = RB_INIT(log_buff, sizeof(log_buff), 1);
+static struct ring_buffer log_rb = RB_INIT(log_buff, sizeof(log_buff), 1);
 
 static uint8_t line_buff[256] = {0};
 static volatile bool got_input = false;
 #endif // PICOWOTA
 
 static void add_to_log(const void *buff, size_t len) {
-    rb_add(&log, buff, len);
+    rb_add(&log_rb, buff, len);
 }
 
 struct ring_buffer *log_get(void) {
-    return &log;
+    return &log_rb;
 }
 
 #ifndef PICOWOTA
 static void log_dump_to_x(void (*write)(const void *, size_t)) {
-    if (rb_len(&log) == 0) {
+    if (rb_len(&log_rb) == 0) {
         return;
     }
 
         write(line_buff, l);
     }
 
-    rb_dump(&log, write, 0);
+    rb_dump(&log_rb, write, 0);
 
     l = snprintf((char *)line_buff, sizeof(line_buff), "\r\n\r\nlive log:\r\n");
     if ((l > 0) && (l <= (int)sizeof(line_buff))) {
         return;
     }
 
-    rb_dump(&log, log_file_write_callback, 0);
+    rb_dump(&log_rb, log_file_write_callback, 0);
 
     res = f_close(&log_file_fat);
     if (res != FR_OK) {
 
 #endif // PICOWOTA
 
-void debug_log_va(bool log, const char *format, va_list args) {
+void debug_log_va(bool do_log, const char *format, va_list args) {
     int l = vsnprintf((char *)line_buff, sizeof(line_buff), format, args);
 
     if (l < 0) {
 #endif // NDEBUG
 #endif // PICOWOTA
 
-        if (log) {
+        if (do_log) {
             add_to_log(line_buff, l);
         }
     }
 }
 
-void debug_log(bool log, const char* format, ...) {
+void debug_log(bool do_log, const char* format, ...) {
     va_list args;
     va_start(args, format);
-    debug_log_va(log, format, args);
+    debug_log_va(do_log, format, args);
     va_end(args);
 }
 

src/workflow.c

     return mem_data()->wf[index].count;
 }
 
-void wf_move_step_down(uint16_t index, uint16_t step) {
+void wf_move_step_down(uint16_t index, uint16_t step_i) {
     if (index >= mem_data()->wf_count) {
         debug("invalid index %d", index);
         return;
     }
-    if ((step < 1) || (step >= mem_data()->wf[index].count)) {
-        debug("invalid step %d", step);
+    if ((step_i < 1) || (step_i >= mem_data()->wf[index].count)) {
+        debug("invalid step %d", step_i);
         return;
     }
 
-    struct wf_step tmp = mem_data()->wf[index].steps[step - 1];
-    mem_data()->wf[index].steps[step - 1] = mem_data()->wf[index].steps[step];
-    mem_data()->wf[index].steps[step] = tmp;
+    struct wf_step tmp = mem_data()->wf[index].steps[step_i - 1];
+    mem_data()->wf[index].steps[step_i - 1] = mem_data()->wf[index].steps[step_i];
+    mem_data()->wf[index].steps[step_i] = tmp;
 }
 
-void wf_move_step_up(uint16_t index, uint16_t step) {
+void wf_move_step_up(uint16_t index, uint16_t step_i) {
     if (index >= mem_data()->wf_count) {
         debug("invalid index %d", index);
         return;
     }
-    if (step >= (mem_data()->wf[index].count - 1)) {
-        debug("invalid step %d", step);
+    if (step_i >= (mem_data()->wf[index].count - 1)) {
+        debug("invalid step %d", step_i);
         return;
     }
 
-    struct wf_step tmp = mem_data()->wf[index].steps[step + 1];
-    mem_data()->wf[index].steps[step + 1] = mem_data()->wf[index].steps[step];
-    mem_data()->wf[index].steps[step] = tmp;
+    struct wf_step tmp = mem_data()->wf[index].steps[step_i + 1];
+    mem_data()->wf[index].steps[step_i + 1] = mem_data()->wf[index].steps[step_i];
+    mem_data()->wf[index].steps[step_i] = tmp;
 }
 
-struct wf_step *wf_get_step(uint16_t index, uint16_t step) {
+struct wf_step *wf_get_step(uint16_t index, uint16_t step_i) {
     if (index >= mem_data()->wf_count) {
         debug("invalid index %d", index);
         return NULL;
     }
-    return &mem_data()->wf[index].steps[step];
+    return &mem_data()->wf[index].steps[step_i];
 }
 
-const char *wf_step_str(struct wf_step *step) {
+const char *wf_step_str(struct wf_step *step_p) {
     static char buff[20];
 
-    switch (step->op) {
+    switch (step_p->op) {
     case OP_SET_TEMPERATURE:
         snprintf(buff, sizeof(buff),
-                 "set temp %.1f C", step->val / 10.0f);
+                 "set temp %.1f C", step_p->val / 10.0f);
         break;
 
     case OP_WAIT_TEMPERATURE:
         snprintf(buff, sizeof(buff),
-                 "wait temp %.1f C", step->val / 10.0f);
+                 "wait temp %.1f C", step_p->val / 10.0f);
         break;
 
     case OP_WAIT_TIME:
     case OP_PUMP_TIME:
         snprintf(buff, sizeof(buff),
                  "%s time %.1f s",
-                 (step->op == OP_WAIT_TIME) ? "wait" : "pump",
-                 step->val / 1000.0f);
+                 (step_p->op == OP_WAIT_TIME) ? "wait" : "pump",
+                 step_p->val / 1000.0f);
         break;
     }