add simplistic crafty support

CMakeLists.txt

     src/menu.c
     src/state_volcano_workflow.c
     src/state_volcano_run.c
+    src/crafty.c
+    src/state_crafty.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/config.h

 #endif // DEBUG_DISK_WRITE_SOURCES
 
 //#define TEST_VOLCANO_AUTO_CONNECT "xx:xx:xx:xx:xx:xx 1"
+//#define TEST_CRAFTY_AUTO_CONNECT "xx:xx:xx:xx:xx:xx 0"
 
 #endif // __CONFIG_H__

include/crafty.h

+/*
+ * crafty.h
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CRAFTY_H__
+#define __CRAFTY_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+// in 1/10th degrees C, or < 0 on error
+int16_t crafty_get_current_temp(void);
+int16_t crafty_get_target_temp(void);
+
+// v in 1/10th degrees C, returns < 0 on error
+int8_t crafty_set_target_temp(uint16_t v);
+
+// returns < 0 on error
+int8_t crafty_set_heater_state(bool value);
+
+// in percent, or < 0 on error
+int8_t crafty_get_battery_state(void);
+
+#endif // __CRAFTY_H__

include/state.h

     STATE_SCAN,
     STATE_VOLCANO_WORKFLOW,
     STATE_VOLCANO_RUN,
+    STATE_CRAFTY,
 };
 
 void state_switch(enum system_state next);

include/state_crafty.h

+/*
+ * state_crafty.h
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __STATE_CRAFTY_H__
+#define __STATE_CRAFTY_H__
+
+#include <ble.h>
+
+void state_crafty_target(bd_addr_t addr, bd_addr_type_t type);
+
+void state_crafty_enter(void);
+void state_crafty_exit(void);
+void state_crafty_run(void);
+
+#endif // __STATE_CRAFTY_H__

src/ble.c

 #include "util.h"
 #include "ble.h"
 
-#define BLE_READ_TIMEOUT_MS 500
-#define BLE_SRVC_TIMEOUT_MS 500
-#define BLE_CHAR_TIMEOUT_MS 2000
-#define BLE_WRTE_TIMEOUT_MS 500
+#define BLE_READ_TIMEOUT_MS (2 * 500)
+#define BLE_SRVC_TIMEOUT_MS (2 * 500)
+#define BLE_CHAR_TIMEOUT_MS (2 * 2000)
+#define BLE_WRTE_TIMEOUT_MS (2 * 500)
 #define BLE_MAX_SCAN_AGE_MS (10 * 1000)
 #define BLE_MAX_SERVICES 8
 #define BLE_MAX_CHARACTERISTICS 8
         uint32_t now = to_ms_since_boot(get_absolute_time());
         if ((now - start_time) >= BLE_READ_TIMEOUT_MS) {
             debug("timeout waiting for read");
+            cyw43_thread_enter();
+            state = TC_READY;
+            cyw43_thread_exit();
             return -3;
         }
 
             uint32_t now = to_ms_since_boot(get_absolute_time());
             if ((now - start_time) >= BLE_SRVC_TIMEOUT_MS) {
                 debug("timeout waiting for service");
+                cyw43_thread_enter();
+                state = TC_READY;
+                cyw43_thread_exit();
                 return -3;
             }
 
             uint32_t now = to_ms_since_boot(get_absolute_time());
             if ((now - start_time) >= BLE_CHAR_TIMEOUT_MS) {
                 debug("timeout waiting for characteristic");
+                cyw43_thread_enter();
+                state = TC_READY;
+                cyw43_thread_exit();
                 return -5;
             }
 
         uint32_t now = to_ms_since_boot(get_absolute_time());
         if ((now - start_time) >= BLE_WRTE_TIMEOUT_MS) {
             debug("timeout waiting for write");
+            cyw43_thread_enter();
+            state = TC_READY;
+            cyw43_thread_exit();
             return -7;
         }
 

src/console.c

 #include "models.h"
 #include "workflow.h"
 #include "console.h"
+#include "crafty.h"
 
 #define CNSL_BUFF_SIZE 64
 #define CNSL_REPEAT_MS 500
 
-#define VOLCANO_AUTO_CONNECT {                                    \
+#define DEV_AUTO_CONNECT(s) {                                     \
     ble_scan(BLE_SCAN_OFF);                                       \
     bd_addr_t addr;                                               \
     bd_addr_type_t type;                                          \
-    const char *foo = TEST_VOLCANO_AUTO_CONNECT;                  \
+    const char *foo = s;                                          \
     sscanf(foo, "%02hhX:%02hhX:%02hhX:%02hhX:%02hhX:%02hhX %hhu", \
             &addr[0], &addr[1], &addr[2], &addr[3],               \
             &addr[4], &addr[5], &type);                           \
         println("   vrtt - Volcano read target temperature");
         println(" vwtt X - Volcano write target temperature");
         println("  vwh X - Set heater to 1 or 0");
-        println("  vwp X - Set heater to 1 or 0");
+        println("  vwp X - Set pump to 1 or 0");
         println("");
         println("    wfl - List available workflows");
         println("   wf X - Run workflow");
         println("");
+        println("   crct - Crafty read current temperature");
+        println("   crtt - Crafty read target temperature");
+        println(" cwtt X - Crafty write target temperature");
+        println("  cwh X - Set heater to 1 or 0");
+        println("    crb - Crafty read battery state");
+        println("");
         println("Press Enter with no input to repeat last command.");
         println("Use repeat to continuously execute last command.");
         println("Stop this by calling repeat again.");
         draw_battery_indicator();
     } else if (strcmp(line, "vrct") == 0) {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-        VOLCANO_AUTO_CONNECT
+        DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
         int16_t r = volcano_get_current_temp();
 #endif // TEST_VOLCANO_AUTO_CONNECT
     } else if (strcmp(line, "vrtt") == 0) {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-        VOLCANO_AUTO_CONNECT
+        DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
         int16_t r = volcano_get_target_temp();
             uint16_t v = val * 10.0;
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-            VOLCANO_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
             int8_t r = volcano_set_target_temp(v);
             println("invalid input (%d %d)", r, val);
         } else {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-            VOLCANO_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
             int8_t r = volcano_set_heater_state(val == 1);
             println("invalid input (%d %d)", r, val);
         } else {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-            VOLCANO_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
             int8_t r = volcano_set_pump_state(val == 1);
                 println("workflow in progress");
             } else {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-                VOLCANO_AUTO_CONNECT
+                DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
                 println("starting workflow");
 #endif // TEST_VOLCANO_AUTO_CONNECT
             }
         }
+    } else if (strcmp(line, "crct") == 0) {
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+        DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
+#endif // TEST_CRAFTY_AUTO_CONNECT
+
+        int16_t r = crafty_get_current_temp();
+        println("crafty current temp: %.1f", r / 10.0);
+
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+        ble_disconnect();
+#endif // TEST_CRAFTY_AUTO_CONNECT
+    } else if (strcmp(line, "crtt") == 0) {
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+        DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
+#endif // TEST_CRAFTY_AUTO_CONNECT
+
+        int16_t r = crafty_get_target_temp();
+        println("crafty target temp: %.1f", r / 10.0);
+
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+        ble_disconnect();
+#endif // TEST_CRAFTY_AUTO_CONNECT
+    } else if (str_startswith(line, "cwtt ")) {
+        float val;
+        int r = sscanf(line, "cwtt %f", &val);
+        if (r != 1) {
+            println("invalid input (%d)", r);
+        } else {
+            uint16_t v = val * 10.0;
+
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
+#endif // TEST_CRAFTY_AUTO_CONNECT
+
+            int8_t r = 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);
+            } else {
+                println("success");
+            }
+        }
+    } else if (str_startswith(line, "cwh ")) {
+        int val;
+        int r = sscanf(line, "cwh %d", &val);
+        if ((r != 1) || ((val != 0) && (val != 1))) {
+            println("invalid input (%d %d)", r, val);
+        } else {
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
+#endif // TEST_CRAFTY_AUTO_CONNECT
+
+            int8_t r = 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);
+            } else {
+                println("success");
+            }
+        }
+    } else if (strcmp(line, "crb") == 0) {
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+        DEV_AUTO_CONNECT(TEST_CRAFTY_AUTO_CONNECT);
+#endif // TEST_CRAFTY_AUTO_CONNECT
+
+        int16_t r = crafty_get_battery_state();
+        println("crafty battery: %d %%", r);
+
+#ifdef TEST_CRAFTY_AUTO_CONNECT
+        ble_disconnect();
+#endif // TEST_CRAFTY_AUTO_CONNECT
     } else {
         println("unknown command \"%s\"", line);
     }

src/crafty.c

+/*
+ * crafty.c
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "log.h"
+#include "ble.h"
+#include "crafty.h"
+
+// serviceUuidCrafty1      "00000001-4c45-4b43-4942-265a524f5453"
+// characteristicWriteTemp "00000021-4c45-4b43-4942-265a524f5453"
+// charactersiticCurrTemp  "00000011-4c45-4b43-4942-265a524f5453"
+// characteristicPower     "00000041-4c45-4b43-4942-265a524f5453"
+// characteristicHeaterOn  "00000081-4c45-4b43-4942-265a524f5453"
+// characteristicHeaterOff "00000091-4c45-4b43-4942-265a524f5453"
+
+// "000000xx-4c45-4b43-4942-265a524f5453"
+static uint8_t uuid_base[16] = {
+    0x00, 0x00, 0x00, 0xFF, 0x4c, 0x45, 0x4b, 0x43,
+    0x49, 0x42, 0x26, 0x5a, 0x52, 0x4f, 0x54, 0x53,
+};
+static uint8_t uuid_base2[16] = {
+    0x00, 0x00, 0x00, 0xFF, 0x4c, 0x45, 0x4b, 0x43,
+    0x49, 0x42, 0x26, 0x5a, 0x52, 0x4f, 0x54, 0x53,
+};
+
+// Crafty UUIDs are always the same, except for the 4th byte
+#define UUID_WRITE_SRVC   0x01
+#define UUID_CURRENT_TEMP 0x11
+#define UUID_TARGET_TEMP  0x21
+#define UUID_BATTERY      0x41
+#define UUID_HEATER_ON    0x81
+#define UUID_HEATER_OFF   0x91
+
+int16_t crafty_get_current_temp(void) {
+    uuid_base[3] = UUID_CURRENT_TEMP;
+
+    uint8_t buff[2];
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
+        debug("ble_read unexpected value %ld", r);
+        return -1;
+    }
+
+    uint16_t *v = (uint16_t *)buff;
+    return *v;
+}
+
+int16_t crafty_get_target_temp(void) {
+    uuid_base[3] = UUID_TARGET_TEMP;
+
+    uint8_t buff[2];
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
+        debug("ble_read unexpected value %ld", r);
+        return -1;
+    }
+
+    uint16_t *v = (uint16_t *)buff;
+    return *v;
+}
+
+int8_t crafty_set_target_temp(uint16_t value) {
+    uuid_base[3] = UUID_WRITE_SRVC;
+    uuid_base2[3] = UUID_TARGET_TEMP;
+
+    uint8_t buff[2];
+    uint16_t *v = (uint16_t *)buff;
+    *v = value;
+
+    int8_t r = ble_write(uuid_base, uuid_base2, buff, sizeof(buff));
+    if (r != 0) {
+        debug("ble_write unexpected value %d", r);
+    }
+    return r;
+}
+
+int8_t crafty_set_heater_state(bool value) {
+    uuid_base[3] = UUID_WRITE_SRVC;
+
+    if (value) {
+        uuid_base2[3] = UUID_HEATER_ON;
+    } else {
+        uuid_base2[3] = UUID_HEATER_OFF;
+    }
+
+    uint16_t d = 0;
+    int8_t r = ble_write(uuid_base, uuid_base2, (uint8_t *)&d, sizeof(d));
+    if (r != 0) {
+        debug("ble_write unexpected value %d", r);
+    }
+    return r;
+}
+
+int8_t crafty_get_battery_state(void) {
+    uuid_base[3] = UUID_BATTERY;
+
+    uint8_t buff[2];
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
+        debug("ble_read unexpected value %ld", r);
+        return -1;
+    }
+
+    uint16_t *v = (uint16_t *)buff;
+    return *v;
+}

src/state.c

 #include "state_scan.h"
 #include "state_volcano_workflow.h"
 #include "state_volcano_run.h"
+#include "state_crafty.h"
 #include "state.h"
 
 static enum system_state state = STATE_INIT;
         state_volcano_run_exit();
         break;
 
+    case STATE_CRAFTY:
+        debug("leaving STATE_CRAFTY");
+        state_crafty_exit();
+        break;
+
     default:
         break;
     }
         state_volcano_run_enter();
         break;
 
+    case STATE_CRAFTY:
+        debug("entering STATE_CRAFTY");
+        state_crafty_enter();
+        break;
+
     default:
         break;
     }
         state_volcano_run_run();
         break;
 
+    case STATE_CRAFTY:
+        state_crafty_run();
+        break;
+
     default:
         debug("invalid main state %d", state);
         state_switch(STATE_SCAN);

src/state_crafty.c

+/*
+ * state_crafty.c
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "config.h"
+#include "buttons.h"
+#include "crafty.h"
+#include "log.h"
+#include "state.h"
+#include "state_crafty.h"
+
+#include "menu.h"
+
+#define CRAFTY_UPDATE_TIME_MS 1000
+
+static bd_addr_t ble_addr = {0};
+static bd_addr_type_t ble_type = 0;
+static bool wait_for_connect = false;
+static bool wait_for_disconnect = false;
+static bool heater_state = false;
+static int16_t target_temp = 0;
+
+static void crafty_buttons(enum buttons btn, bool state) {
+    if (state && (btn == BTN_Y)) {
+        if ((!wait_for_connect) && (!wait_for_disconnect)) {
+            debug("crafty disconnect");
+            ble_disconnect();
+            wait_for_disconnect = true;
+        } else {
+            debug("invalid state for disconnect");
+        }
+    } else if (state && (btn == BTN_A)) {
+        heater_state = !heater_state;
+        debug("crafty heater %s", heater_state ? "on" : "off");
+        crafty_set_heater_state(heater_state);
+    } else if (state && (btn == BTN_LEFT)) {
+        target_temp -= 10;
+        if (target_temp < 400) {
+            target_temp = 400;
+        } else if (target_temp > 2100) {
+            target_temp = 2100;
+        }
+        debug("crafty temp to %.1f", target_temp / 10.0f);
+        crafty_set_target_temp(target_temp);
+    } else if (state && (btn == BTN_RIGHT)) {
+        target_temp += 10;
+        if (target_temp < 400) {
+            target_temp = 400;
+        } else if (target_temp > 2100) {
+            target_temp = 2100;
+        }
+        debug("crafty temp to %.1f", target_temp / 10.0f);
+        crafty_set_target_temp(target_temp);
+    }
+}
+
+void state_crafty_target(bd_addr_t addr, bd_addr_type_t type) {
+    memcpy(ble_addr, addr, sizeof(bd_addr_t));
+    ble_type = type;
+}
+
+void state_crafty_enter(void) {
+    debug("crafty connect");
+    ble_connect(ble_addr, ble_type);
+    wait_for_connect = true;
+
+    buttons_callback(crafty_buttons);
+}
+
+void state_crafty_exit(void) {
+    buttons_callback(NULL);
+}
+
+static void draw(struct menu_state *menu) {
+    if (wait_for_connect) {
+        snprintf(menu->buff, MENU_MAX_LEN, "Connecting...");
+    } else if (wait_for_disconnect) {
+        snprintf(menu->buff, MENU_MAX_LEN, "Disconnecting...");
+    } else {
+        target_temp = crafty_get_target_temp();
+        int16_t ct = crafty_get_current_temp();
+        int8_t bs = crafty_get_battery_state();
+
+        snprintf(menu->buff, MENU_MAX_LEN,
+                 "Target: %.1f C\n"
+                 "Current: %.1f C\n"
+                 "Battery: %d %%",
+                 target_temp / 10.0f, ct / 10.0f, bs);
+    }
+}
+
+void state_crafty_run(void) {
+    if (wait_for_connect && ble_is_connected()) {
+        wait_for_connect = false;
+        debug("crafty start");
+    }
+
+    static uint32_t last = 0;
+    uint32_t now = to_ms_since_boot(get_absolute_time());
+    if (((now - last) >= CRAFTY_UPDATE_TIME_MS) || (last == 0)) {
+        last = now;
+        menu_run(draw);
+    }
+
+    if (wait_for_disconnect && !ble_is_connected()) {
+        wait_for_disconnect = false;
+        debug("crafty done");
+        state_switch(STATE_SCAN);
+    }
+}

src/state_scan.c

 #include "menu.h"
 #include "state.h"
 #include "state_volcano_run.h"
+#include "state_crafty.h"
 #include "state_scan.h"
 
 static struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
             if (dev == DEV_VOLCANO) {
                 state_volcano_run_target(results[i].addr, results[i].type);
                 state_switch(STATE_VOLCANO_WORKFLOW);
+            } else if (dev == DEV_CRAFTY) {
+                state_crafty_target(results[i].addr, results[i].type);
+                state_switch(STATE_CRAFTY);
             }
             return;
         }

src/state_volcano_run.c

 
 #include "menu.h"
 
-static uint16_t wf_index;
-static bd_addr_t ble_addr;
-static bd_addr_type_t ble_type;
+static uint16_t wf_index = 0;
+static bd_addr_t ble_addr = {0};
+static bd_addr_type_t ble_type = 0;
 static bool wait_for_connect = false;
 static bool wait_for_disconnect = false;
 
 static void draw(struct menu_state *menu) {
     struct wf_state state = wf_status();
     snprintf(menu->buff, MENU_MAX_LEN, "%d / %d", state.step, state.count);
+    // TODO visualize
 }
 
 void state_volcano_run_run(void) {

src/volcano.c

 
 #include "config.h"
 #include "log.h"
-#include "util.h"
 #include "ble.h"
 #include "volcano.h"
 
     uuid_base[3] = UUID_CURRENT_TEMP;
 
     uint8_t buff[4];
-    int32_t r = ble_read(uuid_base, buff, 4);
-    if (r != 4) {
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
         debug("ble_read unexpected value %ld", r);
         return -1;
     }
     uuid_base[3] = UUID_TARGET_TEMP;
 
     uint8_t buff[4];
-    int32_t r = ble_read(uuid_base, buff, 4);
-    if (r != 4) {
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
         debug("ble_read unexpected value %ld", r);
         return -1;
     }
     uint32_t *v = (uint32_t *)buff;
     *v = value;
 
-    int8_t r = ble_write(uuid_base, uuid_base2, buff, 4);
+    int8_t r = ble_write(uuid_base, uuid_base2, buff, sizeof(buff));
     if (r != 0) {
         debug("ble_write unexpected value %d", r);
     }
     }
 
     uint8_t d = 0;
-    int8_t r = ble_write(uuid_base, uuid_base2, &d, 1);
+    int8_t r = ble_write(uuid_base, uuid_base2, &d, sizeof(d));
     if (r != 0) {
         debug("ble_write unexpected value %d", r);
     }
     }
 
     uint8_t d = 0;
-    int8_t r = ble_write(uuid_base, uuid_base2, &d, 1);
+    int8_t r = ble_write(uuid_base, uuid_base2, &d, sizeof(d));
     if (r != 0) {
         debug("ble_write unexpected value %d", r);
     }