Discussion:

The performed tasks were very insightful and helpful in teaching us how to navigate the Arduino IDE environment, and with the "C" speaker assignment, practice playing with the provided code to create new functionalities.

Introduction:

This section of the lab focuses on establishing a Bluetooth connection between the Artemis board and the computer. The environments used for this part of the lab were Arduino IDE and Jupyter Lab in order for the bluetooth connection to be established.

Prelab 1B: Installation of Python and Virtual Environment

Before implementing Bluetooth communication, the necessary libraries were installed, including ArduinoBLE (Bluetooth Low Energy, which refers to circumstances of Bluetooth optimization that do not need large data transfers). These libraries allow the Artemis board to act as a BLE peripheral, enabling it to send and receive data wirelessly.

The newest version of Python - Python 3.13 - as well as pip were installed. The versions were verified by the commands:

 python3 --version 

Afterwards, we may set up the Jupyter Lab environment for the computer interface, which is enabled through the following code snippet:

 python3 -m pip install --user virtualenv
 python3 -m venv FastRobots_ble 

Furthermore, virtual environment ought to be activated in order for Jupyter Notebooks to be used:

 .\FastRobots_ble\Scripts\activate 

Another significant aspect of the Prelab 1B was the installation of ArduinoBLE, which thus enabled loading and burning of ble_arduino.ino. My device's MAC address was thus printed out on the Serial Monitor, after which connections.yaml file in Jupyter Lab was edited to reflect the MAC address.

Lab 1B: Tasks

Throughout these lab 1B tasks, I had to connect to the Artemis Device in Jupyter Notebook whenever the Bluetooth connection ought to be established.

Furtermore, with every case initiation, we update enums in both ble_arduino.ino on the Arduino side, and cmd_types.py on the Jupyter Notebook side.

Task 1: ECHO

The first task aimed to send an echo command that holds a string to the Artemis board, and afterwards receive the augmented version of the string back to the computer, testing the mutual communication. Below are snippets of Arduino IDE code and Jupyter Notebook code, and the Serial Monitor Output, in order.

Task 2: Send_THREE_FLOATS

Similarly to the previous task, in this task we send three floats instead. Arduino IDE code, Jupyter Notebook code, and the Serial Monitor output are in order.

Task 3: GET_TIME_MILLIS

This task asks for the Artemis to reply with a string representing current time. Arduino IDE code, Jupyter Notebook code, and the Serial Monitor output are in order. It can be seen that the Python code sends the GET_TIME_MILLIS command and receives a string representing the current time. The time is thus also reflected on the Serial Monitor.

Task 4: Notification Handler

The notification handler integrates ble.start_notify() function, which calls the handler whenever a message is received from the Artemis board. The received string is printed out. Arduino IDE code, Jupyter Notebook code, and the Serial Monitor output are in order. It can be seen that the Python code sends the GET_TIME_MILLIS command and receives a string representing the current time. The time is thus also reflected on the Serial Monitor.

Task 5: Looped version of GET_TIME_MILLIS

The loop function named TIME_LOOP is created in order to consistently run GET_TIME_MILLIS and determine how fast the data is sent. Arduino IDE code, Jupyter Notebook code and output, and the Serial Monitor output are in order.

The looped function sent exactly 406 samples in 6.93 seconds, hence averaging at about 58.6 messages/s.

Task 6: SEND_TIME_DATA

This function stores timestamps in an array of 128, looping through the array and thus sending the entries fast. As opposed to the previous function TIME_LOOP, as in this case we gather the data and then send it in different loops. Arduino IDE code, Jupyter Notebook code and output are in order. Two new global variables of time_data representing an array and data_array are instantiated.

Therefore, 128 time stamps were sent ranging from 2496060 ms to 2496064 ms. This method enhances frequency of the time stamps due to the fact that messages do not have to wait for the time stamps in between.

Task 7: GET_TEMP_READINGS

This task is very similar to the previous task, except that now we are incorporating temperature values as well with the time stamps. Arduino IDE code, Jupyter Notebook code and output are in order. A new global variable of temperature_data representing an array is instantiated.

Task 8: Advantages and disadvantages between the methods

From what can be observed, the first method, that is the method of the TIME_LOOP function, cannot send data as fast as SEND_TIME_DATA, due to the fact that it can be observed it has a bigger difference in-between consecutive timestamps. This method can send about 60 messages/s as calculated. Hence, even though it may not be able to send high-resolution data as well, it is the preferred method in the cases where we want the data to be transferred in the exact moment, yet we do not mind for the quality of it as much. This is due to the fact that TIME_LOOP can consistently send the last sample as the most recent sample of the data.

On the other hand, the second method utilized by SEND_TIME_DATA as well as GET_TEMP_READINGS is much better at sending high resolution data, and can send thousands of samples/s. However, unlike TIME_LOOP, this methodology cannot be used for most recent, or real-time data sending, as it distributes and collects data into different loops. Furthermore, those arrays and loops instantiated can take up a lot of memory. Considering that Artemis board has 384 kB of RAM, and a float uses 4 bytes of RAM, then we have in total of 96 000 data points available. If we sample 16-bit values at 150 Hz every 5 seconds, we would use 1500 bytes. Hence, 384 kB/1500 bytes would be equal to about 256 5-second intervals of data that are available in the memory.*

Additional tasks for 5000-level students

Effective Data Rate and Overhead

My idea behind this was to send a message from the computer and then receive a reply from the Artemis. The sent_bytes were incremented in increments of 5 from 0 to 120. The first screenshot represents the Jupyter Notebook code, after which we can see a screenshot representing the packets being sent (from 80 bytes to 120 bytes in this screenshot example) with their data rate displayed, as well as the duration of transmission. Lastly, a graph can be seen, showing the data rate versus the packet size. From the graph, it can be inferred that the curve is almost linear with a few outliers, where with the increase of the bytes sent to the Artemis, we have an increase in the data rate as well as the duration of transmission.

Short packets cause overhead because the transmission has a fixed size, and thus with sending 5-byte packets we have a lower effective data rate. On the other hand, larger packets definitely do improve the efficiency because there is a higher effective data rate and the transmission is more efficient as the overhead is spread out more across the actual data.