In this tutorial, you will learn how to integrate Cudo Compute into your workflow for scalable, cost-effective computing.

Objectives

• Create virtual machines (VMs) with CUDO’s CLI

• SSH into these VMs to run a benchmark test via the CLI

• Destroy the VMs via the CLI

Get your API key

You will need to obtain your API keys from the API Keys section on your CUDO dashboard.

Click on the “Create an API Key” button and assign a name to your API key. Your chosen API key name must be in lowercase and can be hyphenated for readability.

On doing this, you’ll be given an API key. Take note of this section of the app, as you’ll need to copy your API key and use it in your CLI.

Create your billing account

Billing accounts pay for the use of resources in Cudo Compute. To use the cloud resources in a project, the project must be linked to an active billing account. An active billing account has a credit balance; the minimum deposit is $10.

Setup CUDO CLI

CUDO Compute has a CLI tool called cudoctl to manage all of your resources within the platform. Follow the steps below to get started.

Step 1: Download the binary file

To access the CLI’s functionality, you must download the binary file onto your local machine. To do this, go to the download page.

Step 2: Install the binary file

After successfully downloading the binary file, you have to move it to the right path on your machine.

chmod +x <filepath> 
sudo mv <filepath> /usr/local/bin/
sudo mv /usr/local/bin/<filename> /usr/local/bin/<newname>

Replace <filepath> with the path to the downloaded binary and <newname> with cudoctl.

Step 3: Initialise the installation

Run cudoctl init and follow the steps.

cudoctl init
   ✔ api key: my-api-key
   ✔ project: my-project
   ✔ billing account: my-billing-account
   ✔ context: default
   config file saved ~/.config/cudo/cudo.yml

A config file will be maintained in $HOME/.config/cudo/cudo.yml.

Step 4: Add SSH Key

An SSH key is used to securely access a VM over the Internet or a private network. If you don’t have an existing SSH key, follow the instructions here to generate a new one on your local machine.

Run the following to initialise CUDO with your SSH key:

cudoctl ssh-keys init

Select your desired SSH key and proceed with <enter/return

Executing the Bash Script

Here’s a Bash script that uses only the Cudos CLI to meet the objectives of this tutorial:

We begin with the script shebang (#!/bin/bash), which specifies that the script should be executed using Bash. The set -e command ensures that the script exits immediately if any command fails. Next, the user is prompted to enter a project name, which is used to create a project. Since all resources in Cudo Compute must be associated with a project, a VM cannot be made without first setting up a project.

#!/bin/bash
set -e
read -p "Enter the project name: " project_name
cudoctl projects create $project_name
...

The CONFIGS array stores multiple VM configurations, with each entry following a structured format: VM name, data center, machine type, OS image, number of vCPUs, memory size, and disk size. Additional configuration parameters can be found in the documentation if needed.

...
CONFIGS=(
  "benchmarkvm1 us-santaclara-1 intel-broadwell ubuntu-2204-nvidia-535-docker-v20241017 1 1 10"
  "benchmarkvm2 us-santaclara-1 intel-broadwell ubuntu-2204-nvidia-535-docker-v20241017 2 2 15"
  "benchmarkvm3 us-santaclara-1 intel-broadwell ubuntu-2204-nvidia-535-docker-v20241017 4 4 20"
)
...

We create a file (benchmark_results.txt) to store the benchmark results and add a header row (VM Name, VCPU, Memory, Disk_Size, CPU Events/sec) to ensure the data is easily identifiable.

...
RESULTS_FILE="benchmark_results.txt"
echo "VM Name, VCPU, Memory, Disk_Size, CPU Events/sec" > $RESULTS_FILE
...

We define the Bash function create_vm() using local variables to store the function arguments, representing the array’s VM configuration details. The function uses echo to display status messages, providing feedback on the VM creation process. The VM_ID variable captures the output of the cudoctl vm create command, allowing us to verify whether the VM was successfully created.

...
create_vm() {
  local vm_name=$1
  local data_center=$2
  local machine_type=$3
  local image=$4
  local vcpu=$5
  local memory=$6
  local disk_size=$7

  echo "Creating VM: $vm_name ($vcpu CPUs, $memory RAM, $disk_size Disk) in $data_center..."

  VM_ID=$(cudoctl vm create -project "$project_name" -id "$vm_name" -data-center "$data_center" -machine-type "$machine_type" \
          -image "$image" -vcpus "$vcpu" -memory "$memory" -boot-disk-size "$disk_size")

  if [[ $VM_ID -gt 0 ]]; then
      echo "Failed to create VM: $vm_name"
      exit 1
  fi

  echo "creating vm"
  echo $vm_name
}
...

The run_benchmark() function automates the benchmarking process for a VM by using local variables to store the necessary parameters. It retrieves the list of VMs using cudoctl vm list and extracts the VM’s external IP address using grep and awk. If no IP is found, the function waits and retries once. If the IP is still not found, it returns 1, indicating a failure.

...
run_benchmark() {
  local vm_id=$1
  local vcpu=$2
  local memory=$3
  local disk_size=$4

  echo "Running benchmark on (VM ID: $vm_id)..."

  IPS=($(cudoctl vm list | grep -A 2 "$vm_id" | grep externalIP | awk '{print $2}'))

  if [[ ${#IPS[@]} -eq 0 ]]; then
    echo "No IPs found for VM $vm_id, waiting 30 seconds and trying again..."
    sleep 30
    IPS=($(cudoctl vm list | grep -A 2 "$vm_id" | grep externalIP | awk '{print $2}'))

    if [[ ${#IPS[@]} -eq 0 ]]; then
      echo "Still no IPs found for VM $vm_id"
      return 1
    fi
  fi
...

If an IP is found, the next part of the run_benchmark() function checks whether SSH access is available. If SSH is accessible, it connects to the VM, updates system packages, installs sysbench (a benchmarking tool), and runs a CPU stress test with four threads. The function extracts the benchmark result and saves it to the results file.

...
  echo "Found ${#IPS[@]} IP(s) for VM $vm_id"

  for ip in "${IPS[@]}"; do
    echo "Attempting to connect to IP: $ip"

    if ssh -o ConnectTimeout=5 -o StrictHostKeyChecking=no -o BatchMode=yes root@$ip echo "SSH Ready" &>/dev/null; then
      echo "SSH connection to $ip successful"

      OUTPUT=$(ssh -o StrictHostKeyChecking=no -o ConnectTimeout=30 root@$ip -v << 'EOF'
export DEBIAN_FRONTEND=noninteractive
sudo apt-get update -y
sudo apt-get install -y sysbench
sysbench cpu --threads=4 run
EOF
      ) || { echo "Benchmark failed on $ip"; continue; }

      CPU_EVENTS=$(echo "$OUTPUT" | grep "events per second" | awk '{print $4}')

      if [[ -n "$CPU_EVENTS" ]]; then
        echo "$vm_id, $vcpu, $memory, $disk_size, $CPU_EVENTS" >> $RESULTS_FILE
        echo "Benchmark completed successfully: $CPU_EVENTS events/sec"
        return 0
      else
        echo "Failed to extract benchmark results from $ip"
      fi
    else
      echo "SSH connection to $ip failed, trying next IP if available..."
    fi
  done

  echo "Failed to run benchmark on any available IP for VM $vm_id"
  return 1
}
...

The destroy_vm() function is responsible for deleting a virtual machine (VM). It takes a single argument, vm_id which represents the unique identifier of the VM, to be deleted. This function helps prevent resource wastage.

...
destroy_vm() {
  local vm_id=$1
  echo "Destroying VM: (VM ID: $vm_id)..."
  cudoctl vm delete "$vm_id"
}
...

We iterate through each configuration in the CONFIGS array to create the corresponding VM.

...
for CONFIG in "${CONFIGS[@]}"; do
  set -- $CONFIG
  VM_NAME=$1
  DATA_CENTER=$2
  MACHINE_TYPE=$3
  IMAGE=$4
  VCPU=$5
  MEMORY=$6
  DISK_SIZE=$7

  create_vm "$VM_NAME" "$DATA_CENTER" "$MACHINE_TYPE" "$IMAGE" "$VCPU" "$MEMORY" "$DISK_SIZE"
  echo "Waiting for VM to initialize..."

  echo "---------------------------------------"
done
...

We wait 60 seconds to ensure the VMs have fully booted, preventing benchmarking failures due to uninitialised instances. The SSH known hosts file is cleared to avoid connection mismatches. The script then loops through each configuration in the CONFIGS array, runs the benchmark using the specified parameters, and saves the results. After benchmarking, each VM is deleted to free up resources. Finally, a confirmation message is displayed to indicate successful completion.

...
sleep 60
echo '' > ~/.ssh/known_hosts

for CONFIG in "${CONFIGS[@]}"; do
  set -- $CONFIG
  VM_NAME=$1
  VCPU=$5
  MEMORY=$6
  DISK_SIZE=$7

  run_benchmark "$VM_NAME" "$VCPU" "$MEMORY" "$DISK_SIZE"
  destroy_vm "$VM_NAME"
done
echo "Benchmarking complete. Results saved in $RESULTS_FILE and VMs deleted."

exit 0

To run the entire script using the GitHub gist, run the following:

#save the script
curl -sSL https://gist.github.com/yomaokobiah/5da837f38fe9d1d9423ce55d34a034f9/raw > cudobenchscript.sh
#make the script executable
chmod +x cudobenchscript.sh
#run the script
./cudobenchscript.sh

Here’s what it looks like upon successful execution:

Using the Cudo Compute CLI enables you to efficiently manage the entire lifecycle of virtual machines, from creation to benchmarking and deletion. Start experimenting today and unlock the full potential of decentralised cloud computing with Cudo Compute!

If you read the first part and tried it out, I hope it was without hitches. If you did not but are interested in learning how to get the body of the email, you can follow from here. So let's jump right in.

Prerequisites

• Python 3
• Pandas
• A Gmail account

Getting The Data

This was covered in Part I, which involves making changes to your Gmail account for IMAPLib to work with it.

Step 1: Importing the required libraries to get the email data

Here we import the libraries we need, which are imaplib, email, getpass, and pandas. You may want to install pandas using pip install pandas if you do not have it.

import imaplib
import email
import getpass
import pandas as pd

Step 2: Gaining access to the email server

Here we log into the email server with our credentials.

username =  input("Enter the email address: ")
password = getpass.getpass("Enter password: ")
mail = imaplib.IMAP4_SSL('imap.gmail.com')
mail.login(username, password)

Step 3: Specifying the mailbox to get data from.

Here we print out the mail list to see the available mailboxes, and we select one.

print(mail.list())
mail.select("inbox")

Step 4: Searching and Fetching the data

The block of code below searches the selected mailbox with the given criteria fetches the emails and stores them to the variable messages. Here I am searching for emails from FreeCodeCamp.

result, numbers = mail.search(None, '(FROM "quincy@freecodecamp.org")')
uids = numbers[0].split()
uids = [id.decode("utf-8") for id in uids ]
result, messages = mail.fetch(','.join(uids) ,'(RFC822)')

Step 5: Preparing the data to be exported

The block of code below loops through the fetched emails gets the date it was received, who sent it, the subject of the mail, and the body of the mail.

• We use the walk() method in the email library to get the parts and subparts of the message.
• We use the get_content_type() method to get the email body maintype/subtype.
• We use the get_payload() to get a string or message instance of the part.

body_list =[]
date_list = []
from_list = [] 
subject_list = []
for _, message in messages[::2]:
  email_message = email.message_from_bytes(message)
  email_subject = email.header.decode_header(email_message['Subject'])[0]
  for part in email_message.walk():
    if part.get_content_type() == "text/plain" :
        body = part.get_payload(decode=True)
        body = body.decode("utf-8")
        body_list.append(body)
    else:
        continue
    if isinstance(email_subject[0],bytes):
      decoded = email_subject.decode(errors="ignore")
      subject_list.append(decoded)
    else:
      subject_list.append(email_subject[0])
  date_list.append(email_message.get('date'))
  fromlist = email_message.get('From')
  fromlist = fromlist.split("<")[0].replace('"', '')
  from_list.append(fromlist)

Here we convert the objects in date_list to DateTime objects using the to_datetime() method; because the time has its UTC format attached, we sliced off the UTC format. The retrieved information is then converted to a pandas DataFrame and exported to a CSV file.

date_list = pd.to_datetime(date_list)
date_list = [item.isoformat(' ')[:-6]for item in date_list]
data = pd.DataFrame(data={'Date':date_list,'Sender':from_list,'Subject':subject_list, 'Body':body_list})
data.to_csv('emails.csv',index=False)

Data Cleaning

Now we are going to view the data and clean it where necessary to make it readable. But, first, we read in the CSV file and view it:

data = pd.read_csv("\emails.csv")
data.head()

The output can be seen below, going through there are escape characters in the Body column:

The function below removes the escape characters in the text. In this case,"\r\n" as seen in the screenshot above. This makes the text more readable.

def clean_data(data, column, i):
    data.loc[i, column] = data.loc[i, column].split("\r\n")
    new_string = " ".join(data.loc[i, column])
    new_string = new_string.split("'',")
    data[column][i:i+1] = pd.DataFrame(data = new_string)
    return data

The code below is using the function above to clean every email body in the file.

for n in range(len(data)):
    new_data = clean_data(data, column = "Body", i = n)

The output can be seen below:

You are advised to rewrite a new function according to the escape characters you may find in the Subject or Body of the email you retrieved.

Conclusion

I encountered ERRORS while writing this, and the most recurring one was being unable to sign in even after following the instructions on the Google help page. This problem was encountered because I have more than one Gmail account signed in, and I was not using my default email. In case you encounter the same, the solution is outlined below:

• The instruction said, "If the tips above didn't help, visit https://www.google.com/accounts/DisplayUnlockCaptcha and follow the steps on the page." This opens on a new tab.
• The link on the new tab was "https://accounts.google.com/b/0/DisplayUnlockCaptcha" where the digit 0 is for the default account logged in.
• Check your accounts in the order in which they are listed and change the digit accordingly (e.g.,”1" is the next email and so on).

You can find the full code on GitHub below:

Thank you for getting to the end of this article. I hope you had fun trying it out.

References

• Stack Overflow; How to fetch an email body using imaplib in python?
• Email Library Documentation
• IMAP Library Documentation

Now I know Gmail has a delete feature, but I believe we're meant to "automate the boring stuff with python," and you may learn something new or not.

In this article, I will show you how to set up a script to send unread/unwanted messages from your inbox to trash using IMAPlib and how to delete unread/unwanted messages using IMAPClient permanently.

Let's jump right into it!

Prerequisites

• Python
• Gmail account
• ImapClient [optional]

Setting up your Gmail account

IMAP stands for Internet Mail Access protocol. According to Wikipedia, it is "an Internet standard protocol used by email clients to retrieve email messages from a mail server over a TCP/IP connection.”

To get started, we need to set up a Gmail account for the process to be successful. I made the following changes to my Gmail account, which enabled IMAP and turned on less secured apps.

1. First, open Gmail, click on the settings ⚙️ icon and click See all settings to enable IMAP.
2. On the next page, click on the Forwarding and POP/IMAP tab.
3. In the IMAP Access section, select Enable IMAP. Then click Save changes. If you need more help, kindly visit this Gmail help page.
4. To turn on less secured apps, navigate to your Google dashboard by clicking on your account avatar in the upper right-hand corner of your screen and then click My Account or navigate to myaccount.google.com.
5. Then choose Sign-in & security, scroll down until you see the option Allow less secure apps, and turn the access on.

If you still can’t log in after doing the above, kindly visit here for official Google help support.

How to trash your emails using IMAPlib

The IMAP library is an inbuilt python library used for accessing and manipulating emails over IMAP. The code below logs you into the desired email address. After logging in, we select the desired mailbox to see a list of all available mailboxes to select from using print(mail.list()).

Starter code for IMAPlib

The criterion for emails to be sent to the trash in this section are:

• Unread emails.
• Emails based on a specific subject.
• Emails based on a specific sender.

import imaplib
import getpass
username =  input("Enter the email address: ")
password = getpass.getpass("Enter password: ")
mail = imaplib.IMAP4_SSL('imap.gmail.com')
mail.login(username, password)
mail.select("INBOX")

Trashing all unread emails

The code below sends all unread emails to the trash. You never can tell if you need any email, so you have thirty (30) days before Gmail removes it from the trash. First, we search through the emails setting the criteria to "UNSEEN" (which is the flag for unread messages). The variable result is an exit code of the command, while messages are a list that contains an object of type byte. Finally, we loop through the emails in the list and put them in the trash folder.

results, messages = mail.search(None, 'UNSEEN')
messages = messages[0].split()
for x in messages:
  result, message = mail.store(x, '+X-GM-LABELS', '\\Trash')
mail.close()
mail.logout()

Trashing all emails with a particular subject

Here, we search the selected mailbox using our desired criteria. You should replace "Title" with your desired subject in the code below:

results, messages = mail.search(None, '(SUBJECT "Title")')
messages = messages[0].split()
for x in messages:
  result, message = mail.store(x, '+X-GM-LABELS', '\\Trash')
mail.close()
mail.logout()

Trashing all emails from a specific sender

Here, we search the mailbox using our desired criteria. It would be best if you replaced"abc@xyz.com" with your preferred email address in the code below:

results, messages = mail.search(None, '(FROM "abc@xyz.com")')
messages = messages[0].split()
for x in messages:
  result, message = mail.store(x, '+X-GM-LABELS', '\\Trash')
mail.close()
mail.logout()

Here I'll briefly talk about the methods used.

• search() is a method used to look through the selected mailbox, it takes two arguments; a charset and a criterion. The charset can be set to None.
• store() is a method used to change the flag or label of a message; it takes three arguments; the message, the command, and the flag.
• close() is a method used to close the selected mailbox.
• logout() is a method used to close the connection to the server.
• '+X-GM-LABELS' a label is treated as a folder to make changes to messages using IMAP commands.

How to permanently delete your emails using IMAPClient

While researching this article, I came across the IMAPClient library. From its official documentation, I discovered that: "although IMAPClient actually uses the imaplib module from the Python standard library under the hood, it provides a different API."

Using IMAPClient to delete emails will not send the emails to the trash folder; they will be permanently deleted. Therefore, you should BE SURE you want to delete your emails before using any code snippets here permanently.

Starter Code for IMAPClient

To use IMAPClient, you have to install the package using the command below:

pip install imapclient

Next, we import the library and set the server of our email address.

from imapclient import IMAPClient
import getpass
server = IMAPClient('imap.gmail.com', use_uid=True)
username =  input("Enter the email address: ")
password = getpass.getpass("Enter password: ")
server.login(username, password)
select_info = server.select_folder("INBOX")

The criterion for emails to be sent to the trash in this section are:

• Unread emails.
• Emails based on a specific subject.
• Emails based on a specific sender.

Permanently deleting all unread emails

The code below permanently deletes all unread emails.

messages = server.search("UNSEEN")
for x in messages:
  server.delete_messages(x)
server.logout()

Permanently deleting all emails with a particular subject

We search the selected mailbox using our desired criteria. You should replace "Title" with your desired subject in the code below:

messages = server.search(['SUBJECT', 'Title'])
for x in messages:
  server.delete_messages(x)
server.logout()

Permanently deleting all emails from a specific sender

We search the mailbox using our desired criteria. It would be best if you replaced"abc@xyz.com" with your preferred email address in the code below:

messages = server.search(['FROM', 'abc@xyz.com'])
for x in messages:
  server.delete_messages(x)
server.logout()

Note

• Logging out of the server is important
• To access all emails while using IMAPlib, use mail.select('"[Gmail]/All Mail"').
• Ensure you turn off less secure apps.
• A lot of emails were harmed in the process of making this tutorial 😂.

Conclusion

I had fun writing this, and I hope you did too while reading it. I also encountered ERRORS while writing the script. The most recurring one was being unable to sign in even after following the instructions on the Google help page. This problem was encountered because I have more than one Gmail account signed in, and I was not using my default email. In case you encounter the same, the solution is outlined below:

• The instruction said, "If the tips above didn't help, visit https://www.google.com/accounts/DisplayUnlockCaptcha and follow the steps on the page." This opens on a new tab.
• The link on the new tab was "https://accounts.google.com/b/0/DisplayUnlockCaptcha" where the digit 0 is for the default account logged in.
• Check your accounts in the order in which they are listed and change the digit accordingly (e.g.,”1" is the next email and so on).

You can find the complete script on GitHub below:

Thank you for reading this tutorial!

References

• IMAP Library Documentation
• Giovane Liberato Github Gist
• IMAPClient Documentation

Requirements

• Three red LEDs
• Three 220 ohm resistors
• Temperature sensor
• Jumper wires

The project description as written in the project's book;

You'll be using a temperature sensor to measure how warm your skin is. This component outputs a changing voltage depending on the temperature it senses. It has three pins: one that connects to the ground, another that connects to power, and a third that outputs a variable voltage to your Arduino. In the sketch for this project, you'll read the sensor's output and use it to turn LEDs on and off, indicating how warm you are. There are several different models of temperature sensors. This model, the TMP36, is convenient because it outputs a voltage that changes directly proportional to the temperature in degrees Celsius.

The Arduino software (IDE) comes with a serial monitor tool that enables you to report back results from the microcontroller. Using the serial monitor, you can get information about the status of the sensors and get an idea about what is happening in your circuit and code as it runs.

The breadboard and circuit schematics as drawn in the project's book;

The Code

We covered the structure of Arduino code in project 02, where we talked about the setup() and the loop() functions. We also dealt with variables and digital pins. In this project, in addition, we will be dealing with analog pins and constants.

Analog systems, unlike digital systems, which transmit information in either 0 or 1 format, transmit the information as electric pulses of different amplitude. The Arduino has a built-in Analog-to-Digital Converter (ADC). Analog pins A0-A5 have values that range from 0-1023 Constants are different from variables in the sense that they cannot change.

Let's run through the code below.

• We start by defining our constants. The sensorPin is the analog pin on which the sensor is connected. The baselineTemp is the temperature in your current environment. If you have no means of measuring the temperature, let's give it the default value for room temperature, 25 degrees Celsius.
• In the setup(), we use Serial.begin() to allow the Arduino to send messages via the Serial monitor. It takes two arguments Serial.begin(speed, config), the latter is optional. In this case, we're telling the Arduino to communicate at a rate of 9600 bits per second.
• We use a for() loop to set the pins we connected to the LEDs, unlike project 02, where we defined each pin one after the other, here we set everything in the loop LOW, pin 2 to 4.
• In the loop(), we defined a variable sensorVal which stores the value of the sensorPin, which is our analog pin. Then, we use analogRead() to get the value from the analog pin.
• Serial.print() displays human-readable data on the serial monitor. It can display the value of a variable or of anything you type in quotation marks.
• Here's a formula for converting ADC reading to voltage.

In this case, we're looking for the voltage value, making that the subject of the formula, we store the value in the variable named voltage. Then we print it out to the serial monitor.

• We then convert the voltage to temperature(Celsius) using the formula "(voltage - .5) * 100", then we print this value to the serial monitor using the Serial.println() this is different from the Serial.print() as it creates a new line.
• We then use the temperature to set up our if and else statements. If the temperature is less than our baselineTemp incremented by 2, we set all three LEDs off. Then, we start turning each LED on as the temperature rises.
• We set a delay so we can easily read the values on the serial monitor.

The code as written in the project's book:

const int sensorPin = A0;
const float baselineTemp = 25.00;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  for(int pinNumber=2; pinNumber <5; pinNumber++){
    pinMode(pinNumber, OUTPUT);
    digitalWrite(pinNumber, LOW);
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  int sensorVal = analogRead(sensorPin);
  Serial.print("Sensor Value: ");
  Serial.print(sensorVal);

  // convert ADC reading to Voltage
  float voltage = (sensorVal/1024.0) * 5.0;
  Serial.print(", Volts: ");
  Serial.print(voltage);
  Serial.print(", degrees C: ");

  // convert the voltage to temperature in degrees
  float temperature = (voltage - 0.5) * 100;
  Serial.println(temperature);
  if(temperature < baselineTemp+2){
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
  }
  else if(temperature >= baselineTemp+2 && temperature < baselineTemp+4){
    digitalWrite(2, HIGH);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
  }
  else if(temperature >= baselineTemp+4 && temperature < baselineTemp+6){
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW);
  }
  else if(temperature >= baselineTemp+6){
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);}
  delay(1);
}

The steps to upload the program to your board;

• Save the sketch

• From the menubar, click tools;

  • Make sure you have the right board selected
  • Select a port
  • Set the programmer to ArduinoISP
• The upload button is the right arrow.

Let's check out the Serial monitor:

If you weren't sure of your baselineTemp before you touch the sensor, the temperature reading is that of your environment, and you can update your baselineTemp and upload the code again.

Your body temperature is always higher than your environment; if you hold the sensor for a while, one or more LEDs should light up.

My body temperature was hot enough to make one LED light up.

Using LCD

I decided to use a 16x2 LCD to display the temperature and a Potentiometer to control the contrast on the LCD screen.

Requirements

• One potentiometer (optional)
• One 220 ohm resistor
• Temperature sensor
• 16x2 LCD
• Jumper wires

Schematics

Something to note: The LCD is labeled from 1 to 16. In this diagram, one is at the bottom and 16 at the top.

The Code

Let's jump into the differences here.

• Here, we import the LiquidCrystal library and initialize it by telling it what pins to use to communicate. We don't need the baselineTemp here.
• We use the lcd.print() to display content to the LCD screen. It works the same way as Serial.print(); the difference is that we're displaying to the LCD and the Serial Monitor, respectively.
• Then, we delay for 2 seconds to keep the LCD from flashing the values the way the values flash in the Serial Monitor. Finally, we use the lcd.clear() so that each value stands alone on the screen.

#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,5,4,3,2);
const int sensorPin = A0;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  lcd.begin(16,2);
  }

void loop() {
  // put your main code here, to run repeatedly:
  int sensorVal = analogRead(sensorPin);
  Serial.print("Sensor Value: ");
  Serial.print(sensorVal);

  float voltage = (sensorVal/1024.0) * 5.0;
  Serial.print(", Volts: ");
  Serial.print(voltage);
  Serial.print(", degrees C: ");

  float temperature = (voltage - .5) * 100;
  Serial.println(temperature);

  lcd.print(temperature);
  lcd.print(" degrees C");
  delay(2000); //two seconds delay

  lcd.clear();
  delay(50);
}

After uploading your program, the temperature you see on display is the temperature of the environment. Place your finger over the sensor and observe the changes in the temperature values displayed on the screen.

References

Arduino Projects Book

Temperature on an LCD

If you haven't gotten your Arduino IDE installed yet follow the official guide.

Requirements

• Three LEDs (1 green, 2 red)
• Three 220 ohm resistor
• 10 kilohm resistor
• Switch

The description for project 02 is as follows;

You'll be building something that could have been a spaceship interface in a 1970's science fiction movie. You'll make a cool control panel with a switch and lights that turn on when you press the switch. You can decide whether the lights mean "Engage Hyperdrive" or "Fire the lasers!". A green LED will be on, until you press a button. When the Arduino gets a signal from the button, the green light will turn off and 2 other lights will start blinking.

Here are a few things to note as you make connections to your breadboard;

• The longer leg of the LED is the anode (+ve) while the shorter leg is the cathode (-ve).
• The button should be placed at the center of the breadboard.

Here's a view of the breadboard and Uno

Here's a schematic of the circuit

I took a course in school in my 5th semester called Digital Electronics and Logic Design, in that course I learnt about system states of digital systems which could be LOW or HIGH, INPUT or OUTPUT, 0 or 1.

Each program in the Arduino IDE is called a sketch. A sketch has two required functions for it to work the setup() and the loop().

Before declaring the functions we define variables, the syntax seems similar to C++ (I say C++ because that's a language I recently started learning) where we define variables by variable_type variable_name = variable;

The setup() function runs only once, here we design the state of the digital pins to be inputs or outputs using the pinMode() function. In this case our button is input.

The loop() function runs continuously as the name implies. The loop is where the bulk of the program lies, this is where we check for;

• The voltage of the input using the digitalRead() function which checks the chosen pin passed as an argument for voltage. In this case we store it in the switchState variable.
• If there is a voltage on the pin, switchState will have a value of 1 which is HIGH, if there is no voltage switchState will have a value of 0 which is LOW. If switchState is LOW it means the button
• We use the digitalWrite() function to send voltage to a pin either HIGH or LOW. HIGH would be the voltage we have selected on our board (5V in this case) and LOW would be 0V. digitalWrite() takes two arguments, the pin and what value to give it.
• The else statement is there if switchState is HIGH, then we set the green LED and one red LED to LOW, we delay and toggle the red LEDs.

The code we'll be uploading to our Board;

int switchState = 0;
void setup() {
  // put your setup code here, to run once:
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(2, INPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  switchState = digitalRead(2);
  if (switchState == LOW ) {
    // the button is not pressed
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);}
   else {
      // the button is pressed
      digitalWrite(3, LOW);
      digitalWrite(4, LOW);
      digitalWrite(5, HIGH);

      delay(250);
      digitalWrite(4, HIGH);
      digitalWrite(5, LOW);
      delay(250);
    }
}

The steps to upload the program to your board;

• Save your sketch

• From the menubar, click tools;

  • Make sure you have the right board selected
  • Select a port
  • Set the programmer to ArduinoISP
• The upload button is the right arrow.

The output:

The cover below came with the Arduino Starter Kit.

References

• Arduino Projects Book

The Arduino starter kit came with the Arduino Uno, a breadboard, a base and loads of other cool components. I particularly love the breadboard as it means no soldering and all components are reusable and the circuit is temporary.

Requirements

• 220 ohm Resistor
• LED
• Two push button switches
• 5V power supply

Without a push button.

Here's the schematic circuit diagram below;

The Uno has a 5V power supply pin and a 3.3V pin, I used the 5V power supply pin and connected the Uno to my laptop with a cable. The longer leg of the LED is the anode (+end) and the shorter leg is the cathode (-end).

Here's how it looks;

With one push button.

Here's the schematic circuit diagram below;

Note: The button is placed at the center of the breadboard with one part at the other side of the ravine to keep the horizontal part on the same row.

On the left hand side the button hasn't been pressed hence the LED is still off, and on the right hand side the button is pressed, so the LED is on.

With two push buttons, serial circuit.

Here's the schematic circuit diagram below;

On the left hand side no button is pressed hence the LED is off. On the right hand side both buttons have to be pressed for the LED to come on because they're connected in series and the same current flows through them.

With two push buttons, parallel circuit.

Here's the schematic circuit diagram below;

On the left hand side no button is pressed hence the LED is off. On the right hand either button can be pressed for the LED to come on because they're connected in parallel and the current is split between both of them.

One exciting part of junior secondary school was learning about Ohms law in Integrated Science class which states that:

The current through a conductor between two points is directly proportional to the voltage across the two points.

Hence V = IR, using ohms law to calculate the current passing through the LED, where V = 5 and R = 220, we have approximately 0.02 amps. We used the 220 ohm resistor because 0.02 amps is just about the maximum current for common LEDs.

When you explore further, note;

• Always turn off your power supply before making connections.
• If you want to use two LEDs do not connect them in parallel to one resistor.

References:

• Arduino Projects Book

Prerequisites

• Python 3
• Pandas
• Matplotlib
• Seaborn
• Wordcloud
• A Gmail account

Getting The Data

There are several ways to achieve the aim of this article; find below how I did mine.

Here a Gmail account is being used; for the imaplib script to work, I made the following changes to my account; enabled IMAP and turned on less secured apps.

1. First, open Gmail, click on the settings ⚙️ icon and click See all settings to enable IMAP.
2. On the next page, click on the Forwarding and POP/IMAP tab.
3. In the IMAP Access section, select Enable IMAP. Then click Save changes. If you need more help, kindly visit this Gmail help page.
4. To turn on less secured apps, navigate to your Google dashboard by clicking on your account avatar in the upper right-hand corner of your screen and then click My Account or navigate to myaccount.google.com.
5. Then choose Sign-in & security, scroll down until you see the option Allow less secure apps, and turn the access on.

If you still can’t log in after doing the above, kindly visit here for official Google help support.

Step 1: Importing the required libraries to get the email data

• imaplib is an Internet Message Access Protocol (IMAP) library

• email is a python library that parses, handles, and generates email messages.

• getpass is a python library that contains utilities to get a password or current username

• pandas is a python library for data manipulation and analysis.

import imaplib
import email
import getpass
import pandas as pd

Step 2: Gaining access to the email server

• username is the email address.
• password is the password to the email address when prompted. [If you don't want to use the getpass package, you can enter your password as a string.]
• mail is the email server we're going to connect to, and it varies; for this tutorial, we're using Gmail.
• mail.login logs into the server using the provided credentials.

username =  input("Enter the email address: ")
password = getpass.getpass("Enter password: ")
mail = imaplib.IMAP4_SSL('imap.gmail.com')
mail.login(username, password)

Step 3: Specifying the mailbox to get data from.

• mail.list() is a method that gives a list of the mailboxes - i.e., inbox, draft, and so on in the email address.
• mail.select() is a method that takes an argument of the mailbox you want to get data from.

print(mail.list())
mail.select("inbox")

Step 4: Searching and Fetching the data

• Line 1: mail.uid() is a method whose first argument is the command you want to execute; in this case, the command is "search." The rest of the arguments are used for the search. (Search gives from oldest to recent)
• Line 1: result is an exit code of the command while numbers is a list that contains an object of type byte.
• Line 2: is a list of every section in numbers.
• Line 3: is a list of decoded bytes
• Line 4: is a slice of the recent 100 items (recall that search orders it from oldest to recent).
• Line 5: the command we want to execute is "fetch" and store it in messages. We're fetching the subject of the messages in this case.

result, numbers = mail.uid('search', None, "ALL")
uids = numbers[0].split()
uids = [id.decode("utf-8") for id in uids ]
uids = uids[-1:-101:-1]
result, messages = mail.uid('fetch', ','.join(uids), '(BODY[HEADER.FIELDS (SUBJECT FROM DATE)])')

Step 5: Preparing the data to be exported

• Line 1-3: empty lists for the data we specified in messages.
• Line 4: looping through the content of the message we fetched. Using a step of two because it returned a tuple of two items.
• Line 5: parsing the bytes email to message object.
• Line 6-11: msg is in bytes; to use it, it had to be decoded to a format we can read.
• Line 12: adding the dates to date_list.
• Line 13-15: getting the sender detail, it's in the format "Sender name" hence the split and replace methods are used to get only the "Sender name".
• Line 16-19: converting the objects in date_list to DateTime objects, because the time has its UTC format attached, a new list was created, and the UTC format was sliced off from each object in the list.
• Line 20-22: checking the length of created lists because arrays have to be the same length.
• Line 23-25: converting the lists to a dictionary and then a pandas data frame, viewing it, and saving it for download.

date_list = []
from_list = [] 
subject_text = []
for i, message in messages[::2]:
    msg = email.message_from_bytes(message)
    decode = email.header.decode_header(msg['Subject'])[0]
    if isinstance(decode[0],bytes):
        decoded = decode[0].decode()
        subject_text.append(decoded)
    else:
        subject_text.append(decode[0])
    date_list.append(msg.get('date'))
    fromlist = msg.get('From')
    fromlist = fromlist.split("<")[0].replace('"', '')
    from_list1.append(fromlist)
date_list = pd.to_datetime(date_list)
date_list1 = []
for item in date_list:
    date_list1.append(item.isoformat(' ')[:-6])
print(len(subject_text))
print(len(from_list))
print(len(date_list1))
df = pd.DataFrame(data={'Date':date_list1, 'Sender':from_list, 'Subject':subject_text})
print(df.head())
df.to_csv('inbox_email.csv',index=False)

Visualisation

Now that we have the email data in CSV format, we can read it using pandas and visualize it. There are several Python data visualization libraries, but here I used Wordcloud, Matplotlib, and Seaborn. I wanted to see an infographic on the most used words in the subjects of my emails, and here is how I did it.

Step 1: Reading and viewing the CSV

Step 2: Getting statistical data

I used the describe method to get the statistical data, unique values, and insight into the data.

Step 3: Creating new variables

I created two variables; Time and SinceMid. SinceMid is the number of hours after midnight.

(Note: The time can be deleted from the date column)

from DateTime import datetime
FMT = '%H:%M:%S'
emails['Time'] = emails['Date'].apply(lambda x: datetime.strptime(x, '%Y-%m-%-d%H:%M:%S').strftime(FMT))
emails['SinceMid'] = emails['Time'].apply(lambda x: (datetime.strptime(x, FMT) - datetime.strptime("00:00:00", FMT)).seconds) / 60 / 60

Step 4: The plots

I created a wordcloud image of the most used words in the subjects of my emails. In this example, there are no stopwords; stopwords are usually filtered out like they're usually not informative.

from wordcloud import WordCloud
import matplotlib.pyplot as plt


# Create a list of words
text = ""
for item in emails["Subject"]:
    if isinstance(item,str):
        text += " " + item
    text.replace("'", "")
    text.replace(",","")
    text.replace('"','')


# Create the wordcloud object
wordcloud = WordCloud(width=800, height=800, background_color="white")

# Display the generated image:
wordcloud.generate(text)
plt.figure(figsize=(8,8))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.margins(x=0, y=0)
plt.title("Most Used Subject Words", fontsize=20,ha="center", pad=20)
plt.show()

Here's the output:

I created a histogram of the hours after midnight using seaborn.

import seaborn as sns
sns.distplot(emails["SinceMid"],bins=20)
plt.title("Hours since midnight")

Here is the histogram:

You can check out python gallery for more possible visualizations.

Conclusion

I had fun writing this. I hope you did too while reading it. This goes without saying, and I encountered ERRORS while doing this [some of them I had never seen before]. When you get error messages, a good starting point is using the print statement to get insight and then googling the error message. Part II will also be published on this blog; it would focus on getting the body of the mail and not the subject as this one.

The full code can be found below:

Thank you for reading up to this point.

Disclaimer: I encourage you to experiment outside what's written here. If you encounter bugs and you feel like getting me involved [after Googling], send me a DM on Twitter. I'd be happy to learn something new. Thank you in anticipation.

References/Credits

• An IBM tutorial on pattern email analysis using python 2

• IMAPLib Documentation

• Email package Documentation