Lab 1: The Artemis Board and Bluetooth

Task 1: ECHO command round-trip

The laptop sends an ECHO command with a payload string. The Artemis extracts the payload and writes it back on the notify string characteristic.

// Arduino (ECHO)
case ECHO: {

    char char_arr[MAX_MSG_SIZE];

    success = robot_cmd.get_next_value(char_arr);
    if (!success)
        return;

    Serial.print("ECHO: ");
    Serial.print(char_arr);

    tx_estring_value.clear();
    tx_estring_value.append(char_arr);
    tx_characteristic_string.writeValue(tx_estring_value.c_str());

    break;
}

# Jupyter (ECHO)
ble.send_command(CMD.ECHO, "Howdy y'all")
s = ble.receive_string(ble.uuid["RX_STRING"])
print(s)

Figure: Jupyter output showing echoed string returned over BLE.

Figure: Artemis serial output showing the received payload.

Task 2: SEND_THREE_FLOATS parsing on Artemis

The laptop sends three floats separated by |. The Artemis extracts three floats and verifies correct parsing via serial output.

// Arduino (SEND_THREE_FLOATS)
case SEND_THREE_FLOATS: {

    float fl_a, fl_b, fl_c;

    success = robot_cmd.get_next_value(fl_a);
    if (!success)
        return;

    success = robot_cmd.get_next_value(fl_b);
    if (!success)
        return;

    success = robot_cmd.get_next_value(fl_c);
    if (!success)
        return;

    Serial.print("Three Floats: ");
    Serial.print(fl_a);
    Serial.print(", ");
    Serial.print(fl_b);
    Serial.print(", ");
    Serial.print(fl_c);
    Serial.print(", ");

    break;
}

# Jupyter (SEND_THREE_FLOATS)
ble.send_command(CMD.SEND_THREE_FLOATS, "3.1|23.9|1.1")

Figure: Artemis serial output confirming correct float extraction order.

Task 3: GET_TIME_MILLIS returns a timestamp string

The Artemis replies to GET_TIME_MILLIS with a string containing the current millisecond counter.

// Arduino (GET_TIME_MILLIS)
case GET_TIME_MILLIS: {

    int TIME;
    TIME = millis();

    Serial.print("T:");
    Serial.println(millis());

    tx_estring_value.clear();
    tx_estring_value.append("T:");
    tx_estring_value.append(TIME);
    tx_characteristic_string.writeValue(tx_estring_value.c_str());

    break;
}

# Jupyter (GET_TIME_MILLIS)
ble.send_command(CMD.GET_TIME_MILLIS, "")
s = ble.receive_string(ble.uuid["RX_STRING"])
print(s)

Figure: Timestamp string received in Jupyter from the RX_STRING notify characteristic.

Figure: Artemis serial output showing the same timestamp being generated.

Task 4: Notification handler parses time values

A notification callback was registered on the string characteristic. Each notification is decoded and the millisecond field is extracted.

# Jupyter (notification handler for RX_STRING)
def parse_t(s):
    return int(s.split(":", 1)[1])

def handler(uuid, notif):
    s = ble.bytearray_to_string(notif).strip()
    print(parse_t(s))

ble.start_notify(ble.uuid["RX_STRING"], handler)  # run once per kernel session

Figure: Handler output printing parsed millisecond values.

Task 5: Message throughput measurement

The Artemis repeatedly writes a float notification for a fixed window, counts the number of writes, and reports the average rate in messages per second.

// Arduino (MESSAGE_SPEED)
case MESSAGE_SPEED: {

    speed_test_active = true;

    unsigned long start_ms = millis();
    unsigned long now_ms = start_ms;

    int count = 0;

    while ((now_ms - start_ms) < 10000) {
        now_ms = millis();

        tx_characteristic_float.writeValue(1.0f);

        count++;

        delay(1);
    }

    float rate = count / 10.0f;

    Serial.print("Messages Per Second are ");
    Serial.println(rate);
    Serial.print("every second, averaged over 10 seconds.");

    speed_test_active = false;

    break;
}

# Jupyter (trigger MESSAGE_SPEED)
def float_handler(uuid, notif):
    pass

ble.start_notify(ble.uuid["RX_FLOAT"], float_handler)
ble.send_command(CMD.MESSAGE_SPEED, "")

Figure: Artemis serial output reporting average messages per second over the 10 second window.

Task 6: Buffered timestamp array and SEND_TIME_DATA

Instead of streaming each timestamp immediately, timestamps are stored into a global fixed-size buffer during a recording window. After recording, SEND_TIME_DATA transmits each stored timestamp as a string to the laptop.

// Arduino globals (buffers)
const int TIME_BUF_LEN = 2000;

unsigned long time_buf[TIME_BUF_LEN];
int time_buf_count = 0;

float temp_buf[TIME_BUF_LEN];

// Arduino (RECORD_TIME_DATA)
case RECORD_TIME_DATA: {

    time_buf_count = 0;

    unsigned long start_ms = millis();
    unsigned long now_ms = start_ms;

    while ((now_ms - start_ms) < 10000) {
        now_ms = millis();

        if (time_buf_count >= TIME_BUF_LEN) {
            break;
        }

        time_buf[time_buf_count] = now_ms;

        float tC = getTempDegC();
        temp_buf[time_buf_count] = tC;

        time_buf_count++;

        delay(1);
    }

    Serial.print("RECORDED ");
    Serial.print(time_buf_count);
    Serial.println(" (time,temp) samples");

    break;
}

// Arduino (SEND_TIME_DATA)
case SEND_TIME_DATA: {

    for (int i = 0; i < time_buf_count; i++) {
        tx_estring_value.clear();
        tx_estring_value.append("T:");
        tx_estring_value.append((int)time_buf[i]);
        tx_characteristic_string.writeValue(tx_estring_value.c_str());
        delay(2);
    }

    tx_characteristic_string.writeValue("Jupyter ping task 6 done");

    break;
}

# Jupyter (Task 6 receive)
time_list = []

def time_handler(uuid, notif):
    s = ble.bytearray_to_string(notif).strip()
    if s.startswith("T:"):
        time_list.append(int(s.split(":", 1)[1]))
    else:
        print(s, "received:", len(time_list))

ble.start_notify(ble.uuid["RX_STRING"], time_handler)

time_list.clear()
ble.send_command(CMD.RECORD_TIME_DATA, "")
ble.send_command(CMD.SEND_TIME_DATA, "")

Figure: Jupyter output showing the final count of timestamps received.

Figure: Artemis serial output confirming buffer fill count during recording.

Task 7: Buffered temperature readings paired with timestamps

A second buffer stores temperature values at the same indices as the timestamp buffer. GET_TEMP_READINGS transmits paired records formatted as T:<ms>|C:<degC>. The laptop parses the pairs into two lists.

// Arduino (GET_TEMP_READINGS)
case GET_TEMP_READINGS: {

    for (int i = 0; i < time_buf_count; i++) {

        tx_estring_value.clear();
        tx_estring_value.append("T:");
        tx_estring_value.append((int)time_buf[i]);
        tx_estring_value.append("|C:");
        tx_estring_value.append(temp_buf[i]);

        tx_characteristic_string.writeValue(tx_estring_value.c_str());
        delay(2);
    }

    tx_characteristic_string.writeValue("DONE");
    Serial.println("SENT TEMP READINGS");

    break;
}

# Jupyter (Task 7 receive)
time_list = []
temp_list = []

def temp_handler(uuid, notif):
    s = ble.bytearray_to_string(notif).strip()
    if s == "DONE":
        print("DONE", len(time_list), len(temp_list))
        return
    if s.startswith("T:") and "|C:" in s:
        left, right = s.split("|C:", 1)
        t = int(left.split(":", 1)[1])
        c = float(right)
        time_list.append(t)
        temp_list.append(c)

ble.start_notify(ble.uuid["RX_STRING"], temp_handler)

time_list.clear()
temp_list.clear()
ble.send_command(CMD.RECORD_TIME_DATA, "")
ble.send_command(CMD.GET_TEMP_READINGS, "")

Figure: Jupyter output showing paired timestamp and temperature parsing.

Figure: Artemis serial output confirming the temperature dataset was transmitted.