2023 Group 11 – White Rabbit Top Hat

Group Members

Our brief was to make a ‘user-interactive theatrical prop’ that an actor can use to interject life into the scene and engage with the audience. Using an Arduino micro-controller, sensors and actuators, we wanted to design and make a wearable prop that could be used to better convey an emotion or action on stage.

Project Planning

Maker Manual

Materials used:

• A broken umbrella
• A baby jumpsuit/second hand fluffy material of your choice
• A top hat
• String
• Wooden dow

Tools used:

• Glue gun
• Stanley knife
• Wire cutters
• Wood file

Recycled components:

• The umbrella (utilising from a broken/unusable product)
• The top hat (found second hand)
• The material used for the ears – was a baby jumpsuit found in a charity shop

Circuit components needed:

• Wires x 20
• Micro servo SG90-HV x2
• 6V cell x1
• Push-button x4
• 220 ohm resistor x4
• Arduino and breadboard x1

Arduino breadboard layout:

Building Instructions

Making the bunny ear mechanism

• – Locate hinge mechanism from umbrella (this can be seen in the picture above).
• – Using wire cutters cut the mechanism so you have two pieces of metal connected by the hinge between them.
• – Where the hinge is there should be a small hole which you can tie string through. This enables the hinge to be pulled via the string.
• – Then get a wooden dowel and cut it to roughly 1 inch long.
• – Use a file to make a notch in the dowel (slightly larger than the width of the string) and secure it at the bottom of the mechanism (with hot glue or duct tape). The string connected at the hinge should be behind the dowel, so the system acts as pulley.
• – Now add two bits of card roughly 1.5 inches thick and 1 inch in height above and below the hinge. This will act as the frame which will retain the shape of the bunny ear underneath the fabric.
• – Cut out 2 bunny ear shaped patterns that match the size of the mechanism and width of the cardboard.
• – Glue these two bits of bunny ear together and fit it over the mechanism like a sleeve.
• – Repeat this process again for the other ear.

Attaching the bunny ear to hat

• – Cut a hole for the bunny ear to be pushed into the rim of the hat to maintain its position.
• – Now with the bit of cardboard acting as the ear frame, cut along the ear where it would protrude sideways so that it can be seen.
• – Cut on the hat where this cardboard lines up against it, and then slip the cardboard into the hat.
• – Inside the hat cut along the seam of the cardboard and secure it with duct tape or glue.
• – Do the same process for the other ear.

Attaching servo to bunny ear mechanism

• – Locate the servo and attach the string from the bunny ear to the pivot.
• – Make sure the string is pulled taught to allow for the string to move the hinge when pulled.
• – Where the string is taught, mark the location of the servo and cut out a rectangle that matches the size of the servo (slightly smaller to ensure a secure fit).
• – Place the servo inside the hole so that it stays in place.
• – Brace the servo with duct tape so It doesn’t get pulled out under the tension of the string.
• – Apply same process for the other servo/ear.

Building the circuit

• Follow the breadboard layout shown above and attach the wires, buttons, and resistors to their correlating position on the breadboard (avoid connecting the servo wires to the board yet).

Attaching circuit to hat

• – When the Arduino board is all connected attach it to the back of the hat with duct tape.
• – Then get the cell and position it on the top of the hat and also fasten it with duct tape.
• – Connect the Arduino board to a computer with a cable and run the code provided below then disconnect the cable.
• – Connect the cell to the Arduino board.
• – Pierce two holes in the hat for the servo wires to come out from and then connect these wires to the bread board (the wires are colour coded so match them to the correlating colour).

The Code

//creates two servo objects for the ear controls

#include <Servo.h>

Servo rightEar;

Servo leftEar;

//variables to save positions of servos

int pos = 0;

int leftPos = 0;

int rightPos = 0;

//button pin numbers

int defButt = 2;

int surpButt = 3;

int sadButt  = 4;

int confButt = 5;

//code setup

void setup(){

  //opens the serial line for testing

  Serial.begin(9600);

  //connects the servos to their pin

  rightEar.attach(9);

  leftEar.attach(10);

  //button pin setup

  pinMode(defButt, INPUT);

  pinMode(surpButt, INPUT); 

  pinMode(sadButt, INPUT); 

  pinMode(confButt, INPUT);

}

//main code loop

void loop() {

  //if statement setups, depending on the button pressed

  //each button correlates to an emotion

  if(digitalRead(defButt) == LOW){

    // Serial.println(“DEFAULT”);

    defaultEmote();

  }

  if(digitalRead(surpButt) == LOW){

    //Serial.println(“SURPRISED”);

    surprised();

  }

  if(digitalRead(sadButt) == LOW){

    // Serial.println(“SAD”);

    sad();

  }

  if(digitalRead(confButt) == LOW){

    // Serial.println(“CONFUSED”);

    confused();

  }

}

//the “default” position which the actor would set the ears to

void defaultEmote(){

  //the servo angle that pulls the ears raised

  pos = 145;

  //writing that angle to the servos so they move to the correct angle

  leftEar.write(pos);  

  rightEar.write(pos);             

}

//fully raised ears, showing surprise

void surprised(){

  pos = 270;

  leftEar.write(pos);  

  rightEar.write(pos); 

}

//ears all the way down, showing sadness

void sad(){

  pos = 50;

  leftEar.write(pos);  

  rightEar.write(pos); 

}

//one ear goes up and the other down in a small cycle, showing confusion

void confused(){

  //separate angles for left and right ear

  int rightPos = 0;

  int leftPos = 270;

  //for loop that cycles one ear up and down twice as a small animation

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

    leftEar.write(rightPos);  

    rightEar.write(leftPos);

    //pause between ear changes

    delay(1500);

    leftEar.write(leftPos);  

    rightEar.write(rightPos); 

    delay(1500);

  }

}

Design And Making Process

When deciding what we wanted to make for out theater prop we all recalled pantomimes, stories and comic book cliches which would be familiar and wildly recognised as well as fun and interactive. We thought of birds circling ones head when being dizzy or knocked out, a glowing, beating or broken heart, a mask that would have LEDs or moving parts, a ratatouille movie inspired chef hat, and an iconic Alice in wonderland top hat. We all got excited by the idea of decorating a mad hatter/white rabbit prop and having folding bunny ears that would correspond with the emotion of the actor on stage.

Our first idea for the mechanism was to have four servos, two per ear. The ones on the base of the hat would move the hat left and right, while the ones in the middle of the ear would fold up-and-down.

Creating And Testing The Mechanism

When looking at the servos which we wanted to use, and considering the weight of them, the power that would be needed by the base servo and the internal supporting structure of the ear to stand up right with the second servo would be reasonably large and unpractical. We therefore adapted the design shown in the sketch above to have one servo to control the entire ear.

This is what pushed us to start considering a different mechanism using strings and pulleys. We looked into different hinges and found that the folding system of an umbrella worked very well with our desired mechanism.

We attached the string from this mechanism to a servo and with simple code were able to test that the mechanism would work when combined with Arduino.

We moved onto adding the ear material to the mechanism skeleton. After prototyping with scrap fabric we were confident that the servo had enough power to support the added weight, and therefore moved onto using a fluffy white material, which we recycled from baby jumpsuit found in a charity shop, to begin making.

We found that the bunny ear sock lost its shape with only the thin metal mechanism inside and so we incorporated a cardboard skeleton to retain the ear form despite movement.

How we connected the mechanism to the top hat

As well as the bunny ear material, we were also able to find a top hat from a charity shop. Here is Carl modelling it for us.

First, we marked on the brim of the hat where we wanted to position each ear and made a small hole to poke the metal skeleton of the mechanism into. At this point, we also added a small wooden dow with a notch in it at the bottom of the metal ear component to regulate the movement of the string when it was being pulled.

Next, we added the material component of the ear and braced it to the side of the top har to add further support and to make sure the ear wouldn’t be pulled by the force of the servo, since if the ear moved it would compromise the tension of the string operating the pulley. We did this by cutting a slit through the material, revealing the cardboard frame we had implemented earlier, and, using a Stanley knife, cut through the hat to thread this cardboard into the main body of the hat where we then secured it with gorilla tape.

Once the ear was firmly attached to the hat, we connected the servo to the Arduino board and marked where we should secure it to the hat in order to best ensure complete and reliable movement of the ear. We then cut the shape of the servo out of the hat with the Stanley knife and fitted the servo inside.

The tension of the string connecting the servo and the ear was the most important factor regarding the mechanism performing to how we wanted. We experimented to find the best string length which, when at full extension, did not have a force large enough to break the servo. Even when the pivoting limb of the servo did not pop off under the tension of the string, the main body of the servo would begin to be pulled out of the hat and even distort the shape of the hat. When wearing it, the contracting hat would apply pressure to the user and so we considering different techniques of bracing the hat in order to maintain its shape and to make it more comfortable.

At first we tried using criss-crossing wooden dowels inside the hat to add some internal support to the hat, not only did it fail to solve the issue with the servo, but the dowels itself were distorting the geometry of the hat and made it sit uncomfortably and awkwardly on the head. Since having a self contained prop which the actor can actually wear on stage was biggest priority while making we did not use the criss-crossing dowels. Instead we tried securing the servo differently to the hat. We glued the servo to be adjacent to the hat instead of perpendicular, allowing there to be a balancing force against the tension of the string. This stopped the servo being pulled as much as it had been before, however it did not remove all issues with the servo pivot popping off under extreme tension, and so we had to be careful not to overuse the mechanism at one go and increase the delay of the servo moving.

Attaching the arduino board and the battery to the hat

Since we wanted to make this prop self-contained, we removed our laptops as the power source and replaced it with a battery pack. To do this we had to solder the connecting cables between the cell and the arduino board to elongate the wire so it could reach .

We used gorilla tape to secure the breadboard at the back of the hat so that it wouldn’t be seen from the front and placed the battery pack on the top. Ideally we would have wanted to hide the breadboard and the battery pack so create an overall sleeker design, but due to the lack of time and the size of the hat we were working with we were limited with how we could conceal these components, and is something we would change in a future iteration.

Mapping the buttons to the emotions

Once everything was attached to the hat we focussed our attention on adding signifiers on the buttons to match the corresponding emotions. We considered the position, colour and symbol on each button to enhance the intuitive interaction of the sensors.

Consideration of Position:

Assuming most users will be right handed, we placed the default, most used button furthest to the right in order for it to be in easiest reach for the user behind their head. We then ranked the emotions according to what we assumed would be most to least used emotion from right to left. The most left button, furthest out of reach would then be the least used while the most used button will be easiest to access.

Consideration of Colour:

Mapping colour and emotion can be reasonably controversial. Having ‘sad’ as blue was the most obvious choice. We decided on yellow for ‘surprised’ as it is a bright, strong colour for a sudden and strong emotional response. For ‘confused’ we chose green, and for ‘default’ we chose black.

Consideration of Symbols:

We did not assign default a symbol. Surprised had an exclamation mark, ‘!’. Confused was a question mark ‘?’, and sad was ‘:(‘.

Summary of testing conducted

When testing the hinge mechanism, we played with different powers of servo to accommodate the strength needed to pull the string. We had a very large servo initially but then opted for the smaller servo that comes in the Arduino kit as its reduced size allowed for the hat to be worn more comfortably whilst still providing the power we required.

Additionally, the tension of the string between the ear and servo was changed so that the hinge could be fully extended and closed. Furthermore, with the different emotions we gave different angles of rotation to display different emotions more clearly.

Shortcomings

Our aim with this project was to make the hat wearable as well as expressive for it to be a functional theatre prop. While we were able to do this, the arduino board including all the wires remain exposed and so take away from the fully automated, ‘Wizard of Oz’ magic which can be impressive. The user has to reach to the back of the hat in order to initiate a change in the ear movement, this action may hinder their performance and be a distraction to the audience. Ideally we would want wires that could run down the actor’s sleeve to buttons where the ears can be quietly controlled in their hand. Since the buttons are also out of sight from the user, even though the buttons are labelled, they would have to memorise the positioning of each emotion, and since these emotions have no natural cognitive mapping this would require memory work and could be a point of failure.

The ears of the bunny are also not completely straight and angle inwards. This was to do with the positioning of the ear against the hat. When the ‘confused’ function would be activated the ears would sometimes clash and prevent movement.

Also over time the servos began to get weaker and struggled to pull the mechanism efficient. A potential solution to this would be using more robust, powerful servos. This could be implemented into a next iteration where the hat would be bigger and we would have more space to conceal a bigger servo.

2023 Group 10 – Bo The Bear

Ayana Bazzy, Riva Lakkadi, and Safiya Menk

Project Overview:
No child loves anything more than havign a personal stuffed animal. Most stuffed animals are inanimate, but Bo the Bear is an interactive teddy bear that engaged with its owner to make them feel loved and happy. Bo is a comfort best friend to a designated child, providing them with loyal protection and support in times of need!

Project Brief:
Bo the Bear comes with two key tags, a blue round tag and a white card. The blue tag is the friendly tag and the white tag is the enemy tag. The child owner of the bear keeps the blue tag. When they scan the blue tag to the bear’s chest, the eyes will light up green, happy music will play, and the bear’s right arm will move. Since the child keeps the blue tag, if anyone else tries to play with the bear by using the white tag, the eyes will turn red, angry music will play, and both arms will flap around.

…

Our Aims:
We intended to create a product that would engage with the child through three primary interactions: audio, visual, and movement. These are some of the interactions that children tend to recognize and understand best. Some light colors have universal meanings that children can understand, and lights also appeal to a child’s eye. Children also love hearing sound and are often attracted to it, so we wanted Bo to also play music. Lastly, movement is a form of interaction that will make the child believe that the bear is alive and real, so they will truly feel as if the bear is a real-life friend! We also wanted Bo to only be loyal to its owner, so any other person who tries to interact with Bo will receive the same feedback, but it won’t be friendly.

…

Target Audience:
Bo is created for children ages 3-10. This is the age range where children typically engage with stuffed animals. Children get emotional support from Bo, a play toy, a sleep companion, and unconditional love from Bo.

…

Project Planning:

Project Task List:

Ayana Bazzy	Psuedocode for Speakers Arduino Board  Bought Teddy Bear Inserted components into bear Tested Code
Safiya Menk	Updated document with project progress/updates Pseudcode for Servos Arduino Board Commented code Tested Code Finalized Code
Riva Lakkadi	Pseudcode for RFID Tag and LED Ordered components  Soldiered wires into RFID Card Reader and RGB LEDs Arduino Board Tested Code

Brainstorming & Low-fi Prototyping:

Brainstorm

Lo-Fi Prototype

Research:

Because we’ve worked with most of the parts utilized in the project in class, all we had to do was follow the circuit diagram for each part (servo, RGB LEDs, speaker). Linked below is the circuitry for each part:

RGB LED: https://www.instructables.com/How-to-use-an-RGB-LED-Arduino-Tutorial/

Servo: https://learn.adafruit.com/experimenters-guide-for-metro/circ04-wiring

Speaker: https://learn.adafruit.com/experimenters-guide-for-metro/circ06-wiring

However, one of our most difficult struggles was getting the RGB LED to display the appropriate colors. Although we tried to make sure the wiring was okay, we had to take apart the circuitry multiple times to get it to work. We used this video along with following the Professor’s advice to get the RGB LED to work properly

Writing 0 (analogue) to turn a pin on and 255 to turn it on helped us get the appropriate colors to show.

RFID Tag

Because the RFID MFRC522 was unfamiliar to all of us, we had to look at multiple resources detailing how to set it up.

https://www.instructables.com/Use-MFRC522-RFID-Reader-With-Arduino/

Design Decisions:

• RGB LEDs: We wanted to provide visual feedback to the user as children are easily able to recognize visual signals. We chose to use an RGB LED because it is the best way to be able to display multiple colors onto one LED. We can display red, green, blue, purple, no colors, etc. As green is a universal symbol of friendliness, approachability, and acceptance, we purposely chose to display green to the user when they scan the friendly tag. The bright color will make the child feel welcome, and they will be able to recognize green as a sign of goodness. On the other hand, red is a universal symbol of evilness or anger. Therefore, when someone who is not the child owner tries to scan with the white tag, the eyes will turn red. The person scanning the tag will understand that the bear is angry due to the color of the eyes.
• Speaker: We wanted to provide auditory feedback to the user as children tend to also interact with sound. We chose to order a speaker from Amazon instead of using the Piezo as our speaker provided more quality noise. When the friendly tag is scanned, happy music plays. The child recognizes that this is a good tune, and they will feel welcomed by the bear. On the other hand, when the enemy tag is scanned, a deeper angry tune is played, which signifies to the user that the bear does not welcome them and that the bear does not want to interact with them.
• Servo: We wanted to provide motion feedback to the user as motion signals are an additional way of conveying emotion. We chose to use servos as they were the one motion actuators we were familiar with, and we thought they would get the job done. Unfortunately, one of our failures was that we didn’t make it so that the servo would move the entire arm/hand of the bear. We assumed that the servo would be powerful enough to move just the hand, but after inserting it, we realized there was very limited motion. There was also not enough time left to find a way to be able to increase the motion. We thought of attaching something to the bear’s hand so it moves with the sensor, but we weren’t able to carry this action out in time with the available materials. We could improve this by adapting our code to make the servos more powerful and make the motion more visible.

Principles of Interactive Design

• Feedback: As mentioned above, we provided various forms of feedback to the user to convey the intentions and purpose of Bo.
• Visibility: Each aspect of the project is visible to the user. The RGB LEDs are inserted into the eyes, the card tags come with the product, and the user can see the speaker and servos. Although they may not be familiar with the speaker and servo, once they start up the product, they will understand what each part does
• Learnability: Our product is extremely easy to learn to use. We provide instructions with the product that state which key tag belongs to the owner, and we notify them that all they have to do is tap their tag on the bear’s chest. It is also easy for children to just tap a tag onto a bear, so there is no difficulty in executing the action.
• Efficiency: The user only needs to take one step to make the bear work. All they have to do is scan the tag, and the bear takes over from there

Day By Day Blog Updates

November 15-16:
Group members decided that the Interactive Teddy Bear is our top choice for the final project

November 17-21:
Did background research on the project and decided that the three main functionalities will be the teddy bear’s eyes lighting up (RBG LEDs), the hands of the teddy bear waving (servo motors), and audio feedback (speaker). We found that we could used recycled items for the servo motors, wires, resistors, and RGBs, but we had to buy all the other components.

November 20:
We created a brainstorm diagram that took into consideration the material, aesthetic, consumers, function, cost, safety, environment, and size of our project. We also created a lo-fi prototype in the form of a storyboard detailing the two different states the teddy bear can be in (friendly and unfriendly).

November 25-27:
We bought the RFID tags and speaker from amazon after researching what models would work best with our project

December 4:
We started working with the RBG LEDs but had some difficulty getting the correct colors to show up. After lots of trial and error, we went to the professor for advice and did more research online.

December 5:
The RGB code started working and all the correct colors were lighting up. We also soldered long wires to both RGBs because they needed to reach the board from all the way inside of the teddy bear’s eyes. Next, we got the servo motors and speaker to work in both a friendly mode and an unfriendly mode. For the friendly servo, we moved the right motor back and forth to simulate a hand waving. The unfriendly servos had both motors moving in a frenzy to show that the bear would be upset. For the speaker, we chose a happy tune for the friendly mode and a lower register dark tune for the unfriendly mode.

December 6:
We soldered 8 long wires to the RFID scanner so that it could sit inside of the bear and still reach the board. This took a long time because at first, all the soldered wires were touching each other and the scanner was not working, After going back and forth trying to fix the soldering, we finally got the RFID tag to recognize and scan both the blue and white tags.

December 7-9:
We spend these last few days testing and finalizing our code before the presentation. We initially tested each component separately, so we finally combined the RBG, servo, and speaker code and got rid of any bugs we found.

December 10:
We put the RBG LEDs inside the eyes of the bear, the servo motors inside the arms of the bear, and the RFID tag in the chest of the bear. We decided to leave the speaker outside of the bear so that the user could hear the audio more clearly.

December 11:
We presented our final presentation to the class and demonstrated our interactive teddy bear to the instructors.

Maker Manual:

Tools & Supplies:

• 1 Arduino Uno
• 2 Breadboards
• 6 Resistors 220Ω (Red-Red-Brown)
• 2 RGB LED lights
• 2 Servo Motors (X-shaped horns)
• 1 Speaker (3 Watts)
• 1 MFRC-RC522 RFID Reader with 2 Tags
• Wires
• USB Cable
• Stuffed Teddy Bear

• Soldering Iron
• Scissors
• Cutting Knife
• Duck tape

…

Circuit Diagram:

…

Building the Final Product:

1. Soldering the Wires:
   – Solder wires into RFID card reader
   – Solder longer wires for the LEDs to fit into the bear

2. Build the Circuit According to the Diagram:
– the RFID reader should activate the correct LEDs, music and servo motions

3. Stuffing the Bear:
– Slit the back of the bear using a knife cutter/scissors
– Cut small holes into the bear’s eyes for the LEDs to fit in
– Remove the stuffing from the body, arms and most of the head
– Cut small holes into the bear’s hands for the servos to fit in
– Slide each servo into the right arm and attach the horn from the outside through the hole cut
– Restuff the bear’s arms to keep the motors in place
– Carefully slide each LED light into the correct hole and restuff the head to secure the position
– Use duck tape to stick the RFID reader on the bear’s belly and restuff to secure its position

Our Final Product:

Complete Code:

//libraries for the RFID Tag
#inlcude <SPI.h>
#inlcude <MFRC522.h>

//library for the servo
#include <Servo.h>

//create Servo objects for the arms of the teddy bear
Servo rightArm;
Servo leftArm;

//variable for speaker pin
int speakerPin = 6;

//Pins 9 and 10 communicate the RFID tags to the Arduino Board
#define SS_PIN 10
#define RST_PIN 9
MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class

MFRC522::MIFARE_Key key;

// Init array that will store new NUID
byte nuidPICC[4];

//utilized a built in Arduino file called NUID that when you scan tags, it returns the UID of both tags.
String happy_user = “F0 76 80 10”;
String angry_user = “C3 64 1A 03”;
//variable for which user is logged in. there are two options: the user the bear recognizes or the user the bear doesn’t
int loggedIn = 0;

void setup() {
//setupRFID
Serial.begin(9600);
SPI.begin(); // Init SPI bus
rfid.PCD_Init(); // Init MFRC522
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF;
}

//setupRGBLEDs
//left eye
pinMode(A0,OUTPUT);
pinMode(A1,OUTPUT);
pinMode(A2,OUTPUT);
//right eye
pinMode(A3,OUTPUT);
pinMode(A4,OUTPUT);
pinMode(A5,OUTPUT);

//setupServo
//left arm
leftArm.attach(3);
//right arm
rightArm.attach(5);

//setupSpeaker
pinMode (speakerPin, OUTPUT);
}

void loop() {
//initialize the state of the bear to neutral. no lights should be on
neutralLights();

//all of this code is used to verify the presence of the correct RFID Tags
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
if ( ! rfid.PICC_IsNewCardPresent()) //only execute the code if a different card is presented
return;

// Verify if the NUID has been readed
if ( ! rfid.PICC_ReadCardSerial())
return;

Serial.print(F(“PICC type: “));
MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
Serial.println(rfid.PICC_GetTypeName(piccType));

// Check is the PICC of Classic MIFARE type
if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&
piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
Serial.println(F(“Your tag is not of type MIFARE Classic.”));
return;
}

//write whatever is scanned in hex form to the currentState variable. this variable is used later to compare against actual tag name
String currentState = “”;

if (rfid.uid.uidByte[0] != nuidPICC[0] ||
rfid.uid.uidByte[1] != nuidPICC[1] ||
rfid.uid.uidByte[2] != nuidPICC[2] ||
rfid.uid.uidByte[3] != nuidPICC[3] ) {
Serial.println(F(“A new card has been detected.”));

// Store NUID into nuidPICC array
for (byte i = 0; i < 4; i++) {
nuidPICC[i] = rfid.uid.uidByte[i];
}

//Feedback to the serial monitor to ensure that the RFID Tag is scanning
Serial.println(F(“The NUID tag is:”));
Serial.print(F(“In hex: “));
printHex(rfid.uid.uidByte, rfid.uid.size);
Serial.println();
Serial.print(F(“In dec: “));
printDec(rfid.uid.uidByte, rfid.uid.size);
Serial.println();

//takes in the UID read and concatenates each index to the currentState string
for (byte i = 0; i < rfid.uid.size; i++) {
currentState.concat(String(rfid.uid.uidByte[i] < 0x10 ? ” 0″ : ” “));
currentState.concat(String(rfid.uid.uidByte[i], HEX));
}
currentState.toUpperCase();
}
else {Serial.println(F(“Card read previously.”));
// Halt PICC
rfid.PICC_HaltA();
// Stop encryption on PCD
rfid.PCD_StopCrypto1();
}

//compare the currentState against the tag UID and play the appropriate bear mood based on that
if(currentState.substring(1) == happy_user){
Serial.println(“Inside happy state”);
int y = 0;
while (y <2) {
happyLights();
happyMusic();
happyArms();
y+=1;
delay(100);
}
}

else if(currentState.substring(1) == angry_user){
//if bear recognizes user, play happy music, lights, and wave nicely
Serial.println(“Inside angry state”);
//use a loop to increase duration of angry state
int x = 0;
while (x<2) {
Serial.println(x);
angryLights();
angryArms();
angryMusic();
x+=1;
delay(100);
}
}
else {
//this means a tag was not scanned. the bear can remain in a neutral state
Serial.println(“inside neutral state”);
neutralLights();
}
}

// Helper routine to dump a byte array as hex values to Serial.
void printHex(byte *buffer, byte bufferSize) {
for (byte i = 0; i < bufferSize; i++) {
Serial.print(buffer[i] < 0x10 ? ” 0″ : ” “);
Serial.print(buffer[i], HEX); }
}

// Helper routine to dump a byte array as dec values to Serial.
void printDec(byte *buffer, byte bufferSize) {
for (byte i = 0; i < bufferSize; i++) {
Serial.print(buffer[i] < 0x10 ? ” 0″ : ” “);
Serial.print(buffer[i], DEC); }
}

void printLogin(String id){
Serial.println(“You are logged in as “+id+” .”);
}

//SERVO

void angryArms() {
Serial.println(“Angry arms”);
for (int pos = 0; pos <= 90; pos +=15) { // goes from 0 degrees to 90 degrees in steps of 15 degrees
rightArm.write(pos); // write both arms to the position
leftArm.write(pos);
delay(25); // waits 25ms for the servo to reach the position
}
for (int pos = 90; pos >= 0; pos -= 15) { // goes from 90 degrees to 0 degrees
rightArm.write(pos); // write both arms to the position
leftArm.write(pos);
delay(25); // waits 25ms for the servo to reach the position
}
}

void happyArms() {
Serial.println(“Happy arms”);
//only move the right arm to wave
for (int pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees in steps of 1 degree
rightArm.write(pos); // tell servo to go to position in variable ‘pos’
delay(20); // waits 20ms for the servo to reach the position
}
delay(1000);
for (int pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
rightArm.write(pos); // tell servo to go to position in variable ‘pos’
delay(20); // waits 20ms for the servo to reach the position
}
}

//SPEAKER

//function that plays a certain tone
void playTone(int frequency, int duration) {
tone(speakerPin, frequency, duration);
delay(duration); // Wait for the tone to finish before playing the next one
noTone(speakerPin);
}

//function2 that plays a certain tone
void playNote(char note, int duration) {
char names[] = { ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘A’, ‘B’ };
int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014 };
// play the tone corresponding to the note name
for (int i = 0; i < 7; i++) {
if (names[i] == note) {
tone(speakerPin, tones[i], duration);
}
}
}

//function that plays happy music in happy state
void happyMusic(){
int length = 20; // the number of notes
char notes[] = “EDCDEEEDDEFGGGFEEDDD “; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 4 };
int tempo = 300;
for (int i = 0; i < length; i++) {
if (notes[i] == ‘ ‘) {
delay(beats[i] * tempo); // rest
} else {
playNote(notes[i], beats[i] * tempo);
}
// pause between notes
delay(tempo / 2);
}
}

//functiont that plays angry music in angry state
void angryMusic(){
playTone(220, 300); // A4
playTone(220, 300); // A4
playTone(220, 300); // A4
playTone(185, 300); // F4
delay(100);
playTone(196, 300); // G4
playTone(196, 300); // G4
playTone(196, 300); // G4
playTone(174, 300); // B4
delay(500); // pause before playing again
}

//LEDs

void happyLights(){
Serial.println(“Initializing happy lights…”);
//left eye
analogWrite(A0,255);
analogWrite(A1,0);
analogWrite(A2,255);
//right eye
analogWrite(A3,255);
analogWrite(A4,0);
analogWrite(A5,255);
}

void angryLights(){
Serial.println(“Initializing angry lights…”);
//left eye
analogWrite(A0,0);
analogWrite(A1,255);
analogWrite(A2,255);
//right eye
analogWrite(A3,0);
analogWrite(A4,255);
analogWrite(A5,255);
}

void neutralLights(){
//right eye
//Serial.println(“Initializing neutral lights…”);
analogWrite(A0, 255);
analogWrite(A1,255);
analogWrite(A2,255);
//left eye
analogWrite(A3,255);
analogWrite(A4,255);
analogWrite(A5,255);
}

Limitations

• All of the wires and board stick out of the bear, so the bear isn’t cuddly friendly
• Aesthetic shortcomings due to the wiring
• Limited motion due to ineffective attachment of the servos. We could have placed the servos more effectively or tried one of various methods in order to make it so that the servo moves the entire bear’s hands/arms.

Suggestions

• Rip out a bit of the bear’s paw and attach it to the Servo so the actual hands move
• Get a bigger bear so that all of the wiring and the boards can fit inside
• Add more features such as talking, dancing, and customization to the child

2023 Group 9 – SmartLeaf

Project by Benjamin Gaunt, Jessica Malek, Catriona Gholami

Selected Project Brief:

Our brief was on the basis of monitoring your plants, by which we must create an automatic irrigation system with sensors for plant conditions. 

You care about your plants, right? Then, why not try Arduino to help you monitor and water them? This project should include a soil humidity sensor that alerts (through some beeping sound or LCD display) when the humidity is too low or too high. It also has to include some automatic irrigation system (see some examples here: https://all3dp.com/2/arduino-watering-system-plant-irrigation-project/). You can also add a light sensor for the amount of light available and an indicator to the user (the carer) in case they need to change the position of the plant accordingly, among other sensors you think would help to keep your plant healthy. Design for providing long term behaviours like the plant thanking you if you have been treating them well (for example, by watering them the last couple of days) and then showing a “Thank you!” message in the display.

Design Process

Based on our selected project brief, we researched the market and audience and how such a product would be beneficial in creation of an interactive plant watering system. We recognize the importance of maintenance of optimal conditions in aiding plant growth and decided to focus our project on the development of an intelligent monitoring system for plant care with feedback to the user.

Plant wellfare is intricately tied to numerous biotic and abiotic factors which consist of light exposure, soil moisture, temperature and just general conditions of the surrounding environment. Our solution to this brief is the creation of an integrated approach and sense of autonomy in plant care systems, to ensure conditions can remain optimum with minumum effort on the client/user based side; meaning the plant can be kept well and alive, even if the user has forgotten about it. Traditional plant care relies solely on periodic human interaction and intervention of conditioning, meaning the parameters of care can be fluctuating and inconsistent, becoming easily overseen. This is where our idea of providing physical and realtime feedback of interaction stemmed from; aiming to notify the user of watering system activations and how the plant is holding up.

The main aspects of our design choices were to ensure effective usability and reliability, interaction (some kind of user experience aspect that makes it fun), and feedback to the user,.

Selection of components:

We ordered the kit giving us things necessary for the completion of the system such as a capacitive soil moisture sensor, a 1-channel 5V relay module, a mini water pump, and vinyl tubing. This integration reduces the complexity of sourcing individual components, ensuring compatibility amongst the system components and functions:

Graphical Display Selection:

We were unsure of whether to select an LCD graphical display or an OLED graphical display for our system, but we decided to go with an OLED graphical display module. The OLED would enable us to provide our visual feedback to the user and due to the properties of an OLED it means we would be able to display graphics with a fast response and contrast/brightness compared to an LCD. It ensures accessibility at all times even in lower light conditions where the user may not be able to see well. The response time is also much faster, allowing us to display our feedback in a swift manner; which is important particularly if a change of an optimum condition is drastic and urgent action or notification to the user is necessary.

Component Trials:

We wanted to get started despite not having all our components arrived, so we began through testing the things we did have. Our first experiments began with the DHT sensor (detection of humidity and temperature). We tested the functionality of the sensor and how it responds to different conditions, different rooms etc. The wiring was as below:

Our initial wiring was incorrect and the sensor was heating up due to a large voltage and current being passed through which resulted us in implementing a resistor. This was our initial attempt of setting up the sensor; which we later adjusted and corrected the wiring to no longer require a resistor.

To ensure accurate readings, calibration was required and we tested to ensure that it could provide reliable data by changing conditions. This allowed us to begin setting up our arduino environment for the final hard coding of the system.

Configuration of the DHT sensor:

#include "DHT.h"
#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

To allow the sensor to work we had to include the DHT library in arduino; providing pre-written code for this specific component and allowing functionality to be activated; abstracting the communication protocols and readings. Inclusion of this library means that we can instantise functions such as ‘readTemperature()’ and ‘readHumiditity()’ in our code testing. We then assigned it to a digital pin (in this picture, it was 7, although in later testing we switched to 4 to accomodate our other components). The sensor type we were using was established as DHT11.

Library reference: https://www.arduino.cc/reference/en/libraries/dht11/

Setup function:

void setup() {
  Serial.begin(9600); // Initialize serial communication
  dht.begin();
  }
}

Initialising the serial communication for the DHT sensor to activate outputs and confirm readings are viable and reliable.

Loop function:

void loop() {
  ReadSoil();     // Reads soil moisture
  ReadHumidity(); // Reads humidity and temperature
}

Calls the functions which we shall define to be in a loop, so that measurements can be consistently taken and updated; to make sure system is in real-time.

ReadHumidity function:

void ReadHumidity(){
  // read humidity
  float humi  = dht.readHumidity();
  // read temperature as Celsius
  float tempC = dht.readTemperature();
  Serial.println();
  // check if any reads failed
  if (isnan(humi) || isnan(tempC)) {
    Serial.println("Failed to read from DHT sensor!");
  } else {
    Serial.print("Humidity: ");
    Serial.print(humi);
    Serial.print("%");

    Serial.print("  |  ");

    Serial.print("Temperature: ");
    Serial.print(tempC);
    Serial.print("°C ~ ");
  }

}

In this function we use the pre-defined functions from the DHT library to obtain the readings from the sensor. We print out the results in the serial monitor so that we can track the changes. By making sure we include the isnan() function, we check to make sure the readings are number values that can be printed and reflected from the physical environment – allowing a route for display of error messages and communication. This means the system can be aware of potential issues with the reading, ensuring reliability of the future monitoring system.

ReadSoil function:

void ReadSoil(){
  int sensorSoilValue = analogRead(soilSensorPin); // Read soil analog value
  float moisturePercentage = map(sensorSoilValue, 0, 1023, 0, 100); // Map to percentage
  //code to print moisture level to LED sensor

  delay(1000); // Wait for a second before the next reading

}

ReadSoil represents the part of the water pump system responsible for the soil moisture level. We decided to use the analog value and conversion of it through mapping into a percentage for better readability and more intuitive representation of soil moisture to the user. This is the basis of the main code which we will later use to make the irrigation system activate when soil moisture falls below a certain threshold (where optimum conditions of the plant can no longer be satisfied). It is also necessary to incorporate a delay so that there is space between consecutive readings, to allow adjustments of soil as required.

Visual feedback experimentation:

After setting up the hardware and phsyical architecture of pump and system, we decided to experiment with the sensor detections and how we can map them onto visual feedback for example an RGB LED.

This is the code we had to add to activate the functionality of our feedback RGB LED light. In our void setup function we added:

for(int i = 0; i < 3; i++){
    //  set the 3 pins as outputs
    pinMode(ledDigitalOne[i], OUTPUT);

We established the threshold of humidity in which feedback must be shown. The choice of humidity values are relative to the plant optimum conditions required. A response will be triggered when the humidity is too low. Within our ReadHumidity function we added:

 if (humi > 80 || humi < 40) {
    setColor(ledDigitalOne, RED);
  } else {
    setColor(ledDigitalOne, GREEN);
  }

setColor function:

Allows seting up of the LEDs by iteration of the respective pins to visually indicate the conditions like the soil humidity detection

void setColor(int* led, const boolean* color) {
  for(int i = 0; i < 3; i++){
    digitalWrite(led[i], color[i]);
  }
}

Main system architecture design:

For the design we decided to use all recycled materials; with our thought process being resembling of a smal garden made with an eco-conscious approach. The garden design aimed to create a visual aesthetic/appeal for the user, furthermore aligning with the purpose and intention of the project – a familiar and pleasant environment for interactivity and accessibility. By creating a miniature representation of a garden with the automatic plant irrigation system, we foster a sense of engagement and enjoyment; a wholesome experience for a user when making use of the system.

As for the base/foundation of all the components we decided to use a recycled tin foil tray for stability and mounting all our required components on. The shallow edges of the tray also ensured for any potential spill-offs to be caught and overall organizing the appearance of our structure.

We also used scrap paper to create decorative elements on this foil tray resembling of flowers and plants to enhance the aesthetic appeal of the system, likewise with the water tray looking like a watering bucket or can adding a thematic touch to the whole system.

Combining components and feedbacks and testing:

After combining all the elements which we worked on/tested individually beforehand, we had to figure out which feedback would be most approapriate for our system.

Initially we incorporated and additional blue LED in the system, which would dim/brighten in response/correlation with the light sensor detections. However we did not proceed with this as it was rather redundant as this data is already displayed on the OLED screen and isn’t such a drastic influential factor to the irrigation system. This also allowed more simplicity and only the necessary feedback/most useful remained.

Addition of RGB LED:

As a visual feedback choice we enhance the user experience with an RGB LED providing immediate visual feedback without the need for users to wait for the values/confirmation on the OLED screen. This means users instantly gauge the conditions of the plant by the colouring of the LED. This allows for intuitive color recognition and real-time monitoring, making the overall experience rather user-friendly. It is complementary to the OLED display which allows for a comprehensive visual feedback system.

OLED Screen testing:

The OLED screen is our main instant visual feedback that the user can rely on; displaying swift feedback about the plant conditions in an intuitive way. The real-time values are presented (converted to percentages) alongside the temperature in Celsius. We created three separate display screens that cycle through to show to the user.

Add to our void loop:

 //cycles through the 3 different displays
  if (displaynum == 1){
    DisplayFace();
    displaynum = 2;
  }
  else if(displaynum == 2){
    DisplayText();
    displaynum=3;
  }
  else if(displaynum == 3){
    DisplayGoodBad();
    displaynum = 1;
  }

Coding the display of the values:

void DisplayText(){
  display.setTextSize(1); //set the size of the text
  display.setTextColor(WHITE); //color setting
  display.setCursor(0,0); //The string will start at 0,0 (x,y)
  display.clearDisplay(); //Erase the previous display on the screen
  display.print("Soil Moisture: ");
  display.print(100 - soilPercentage); //displays the inverse of the soil percentage as reading a high percentage as water increases is more human friendly
  display.println("%");
  display.print("Humidity: ");
  display.print(humi);
  display.println("%");
  display.print("Temperature: ");
  display.print(tempC);
  display.println("C");
  display.print("Light: ");
  display.print(100 - lightPercentage);
  display.println("%");
  display.display(); //send the text to the screen
}

In another representation we have the numerical values stripped and “Good” or “Bad” messages streamlining communication the user on the plant conditions. This enhances the user-friendly environment by which especially users without technical expertise can grasp the plant healthy without the need of delving into specific numerical readings. Due to this, the system aligns with the goal of making it accessible in many ways to a wide range of users. If a user is not familiar with plant metrics this is ideal and the user will not need to be overwhelmed by any technical details. The indicators are clear and concise and along with the piezo buzzer notification too make it much more inclusive.

Coding the display of good/bad indicators:

/This display shows if the values on the previous display are good or bad, cycling through the facefactors array to see if they are 1(good) or 0(bad)
void DisplayGoodBad(){
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.clearDisplay();
  display.print("Soil Moisture: ");
  if(FaceFactors[0] == 1){
    display.println("Good");
  }
  else if(FaceFactors[0] == 0){
    display.println("Bad");
  }
  display.print("Humidity: ");
  if(FaceFactors[1] == 1){
    display.println("Good");
  }
  else if(FaceFactors[1] == 0){
    display.println("Bad");
  }
  display.print("Temperature: ");
  if(FaceFactors[2] == 1){
    display.println("Good");
  }
  else if(FaceFactors[2] == 0){
    display.println("Bad");
  }
  display.print("Light: ");
  if(FaceFactors[3] == 1){
    display.println("Good");
  }
  else if(FaceFactors[3] == 0){
    display.println("Bad");
  }
  display.display(); //send the text to the screen

}

The user will be alerted with the piezo buzzer, and the OLED display which will display and tell the user if the watering can is empty and if it need to be refilled in order for the plant to be watered once again/ for the automatic irrigation system to continue.

We added a Smiley/Sad face display on the OLED as a graphical representation of plant status/ if optimum conditions are reached or not. This enables the user to understand the status at a quick glance without needing to interpret any of the numerical values if they do not want to. This also in a way humanizes the interaction with the plant system, making users more likely to care for and engage with the plant when presented with a communication of a friendly and approachable manner. A smiley face provides a positive reinforcement for users to continue engaging in the plant care and highlights the idea of the users efforts contributing to their plant well-being.

Coding the display of the faces:

void DisplayFace(){
  //check how many of the 4 factors for plant growth are good(1)/bad(0)
  int counter = 0; //sets a counter as a local variable, which gets incremented by 1 as per each factor is good
  for(int i = 0; i <=3; i++){
    if(FaceFactors[i] == 1){ //loops through all 4 items in the global array named facefactors
      counter+=1;
    }
  }

  display.clearDisplay();
  //face
  display.drawCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 30, WHITE); // circle drawn at midpoint of screen with radius 30
  //eyes
  display.drawCircle(SCREEN_WIDTH / 2 - 10, SCREEN_HEIGHT / 2 - 5, 5, WHITE);
  display.drawCircle(SCREEN_WIDTH / 2 + 10, SCREEN_HEIGHT / 2 - 5, 5, WHITE);

  //smily face drawn when all 4 factors are good
  if(counter == 4){
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 7, 6, WHITE);
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 6, 6, BLACK); // black circle drawn just above the mouth circle to leave a smily face
  }
  //midface drawn when 1 or 2 factors are bad
  else if (counter > 1 && counter <=3){
    display.fillRect(SCREEN_WIDTH / 2 - 15, SCREEN_HEIGHT / 2 + 10, 30, 3, WHITE);
  }
  //sadface drawn when 3 or 4 factors are bad
  else if(counter <=1){
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 9, 6, WHITE);
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 11, 6, BLACK); //black circle drawn just below the mouth circle to leave a frowny face
  }
  display.display();
}

Finalising and putting it all together:

We also decided to implement a controlled watering mechanism, where the water pump only dispenses the water in limited bursts with frequency adjusted based on the plant current conditions. The water pump is limited to only two pumps to prevent the soil from becoming waterlogged and that there is sufficient moisture throughout in this automatic irrigation system; preventing the risk of overwatering and excessing water accumulation which tends to be a frequent cause in plant struggle under manual human care. An automatic irrigation system also avoids water stress on a plant; the adaptive nature means the soil moisture is monitored and if failed and remains dry after the initial watering, will be watered again or detected that the watering can is empty.

Project Task List

Week 9	– selection of topic for project – creation of low fidelity design prototype – project objectives and scope definition alongside research – finalising selection of approapriate components	-All members -Ben, Cat -All members -Ben, Jess
Week 10	– ordered all components necessary – sorting out code structure and logic – designing overall system architecture and arduino code – planning layout of physical components for when they arrive – testing of separate functions for the different components used	-Ben, Jess -Cat -All members -All members -Ben, Jess
Week 11	– design of final outcome and ensuring functionalities – finalising and organisation of code + comments – blog creation to compile all previous documentation together – blog design – video final product – final product design/aesthetics – debugging	-All members -Ben -Jess -Jess -Ben -Cat -Ben, Cat

Maker Manual

Overview

SmartLeaf! Automatic Irrigation, arduino-based system combining technology and commitment to sustainability. A user-friendly graphical interface with an automatic irrigation system designed to revolutionize plant care.

Tools and Supplies

• Tin foil tray (base of project) – recycled material
• Scrap paper – recycled material
• Sellotape
• Scissors
• Plastic cups – recycled material
• Plant in a pot
• Soil
• Arduino board
• Wires
• Resistors (x4)
• Piezo buzzer
• RGB LED
• Soil moisture sensor
• DHT (humidity and temperature sensor)
• Light sensor
• Water pump
• Relay module
• OLED Display
• Laptop/USB as power supply

Circuit Diagram

Arduino breadboard layout and circuit diagram:

Building System

In crafting the physical aspects of the system we prioritized sustainability through opting to use recyclable materials to pose emphasise on the eco-friendly approach of the project. For the base structure and foundation we used a tin foil tray; a recyclable material providing a foundation for the components and structural integrity. Scrap paper also used for decorative purposes of paper plants/flowers alongside plastic cups to hold the water.

Code

#include "DHT.h"
#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
const int soilSensorPin = A0; // Analog input pin for the sensor
const int relayPin = 2;  // Digital output pin connected to the relay module
int ledDigitalOne[] = {6, 3, 7};
const boolean RED[] = {LOW, LOW, HIGH};  //sets the red and green colours for rgb led
const boolean GREEN[] = {LOW, HIGH, LOW};
int lightPin = A1;
int speakerPin = 5;
int displaynum = 1;
int sensorSoilValue ; //global values are created for sensor values so they can read throughout
int FaceFactors[] = {1,1,1,1}; //good(1)/bad(0) for {moisture,humidity,temp,light}
float humi;
float tempC;
int lightLevel;
float lightPercentage;
float soilPercentage;

//sets up screen
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// Declaration for SSD1306 display connected using software SPI (default case):
#define OLED_MOSI   9
#define OLED_CLK   10
#define OLED_DC    11
#define OLED_CS    12
#define OLED_RESET 13
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,
  OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);


void setup() {
  Serial.begin(9600); // Initialize serial communication
  dht.begin(); //starts humidity/temp sensor
  for(int i = 0; i < 3; i++){
    //  set the 3 pins as outputs on the RGB LED
    pinMode(ledDigitalOne[i], OUTPUT);
  }
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH);
  //screen
  if(!display.begin(SSD1306_SWITCHCAPVCC)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

}


void loop() {
  //lightcode
  ReadLight();
  //soil code
  ReadSoil();
  //humidity and temperature code
  ReadHumidityTemp();
  delay(1000); // Wait for a second before the next reading

  //cycles through the 3 different displays
  if (displaynum == 1){
    DisplayFace();
    displaynum = 2;
  }
  else if(displaynum == 2){
    DisplayText();
    displaynum=3;
  }
  else if(displaynum == 3){
    DisplayGoodBad();
    displaynum = 1;
  }
}


void DisplayFace(){
  //check how many of the 4 factors for plant growth are good(1)/bad(0)
  int counter = 0; //sets a counter as a local variable, which gets incremented by 1 as per each factor is good
  for(int i = 0; i <=3; i++){
    if(FaceFactors[i] == 1){ //loops through all 4 items in the global array named facefactors
      counter+=1;
    }
  }

  display.clearDisplay();
  //face
  display.drawCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 30, WHITE); // circle drawn at midpoint of screen with radius 30
  //eyes
  display.drawCircle(SCREEN_WIDTH / 2 - 10, SCREEN_HEIGHT / 2 - 5, 5, WHITE);
  display.drawCircle(SCREEN_WIDTH / 2 + 10, SCREEN_HEIGHT / 2 - 5, 5, WHITE);

  //smily face drawn when all 4 factors are good
  if(counter == 4){
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 7, 6, WHITE);
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 6, 6, BLACK); // black circle drawn just above the mouth circle to leave a smily face
  }
  //midface drawn when 1 or 2 factors are bad
  else if (counter > 1 && counter <=3){
    display.fillRect(SCREEN_WIDTH / 2 - 15, SCREEN_HEIGHT / 2 + 10, 30, 3, WHITE);
  }
  //sadface drawn when 3 or 4 factors are bad
  else if(counter <=1){
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 9, 6, WHITE);
    display.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 11, 6, BLACK); //black circle drawn just below the mouth circle to leave a frowny face
  }
  display.display();
}


void DisplayText(){
  display.setTextSize(1); //set the size of the text
  display.setTextColor(WHITE); //color setting
  display.setCursor(0,0); //The string will start at 0,0 (x,y)
  display.clearDisplay(); //Erase the previous display on the screen
  display.print("Soil Moisture: ");
  display.print(100 - soilPercentage); //displays the inverse of the soil percentage as reading a high percentage as water increases is more human friendly
  display.println("%");
  display.print("Humidity: ");
  display.print(humi);
  display.println("%");
  display.print("Temperature: ");
  display.print(tempC);
  display.println("C");
  display.print("Light: ");
  display.print(100 - lightPercentage);
  display.println("%");
  display.display(); //send the text to the screen
}

//This display shows if the values on the previous display are good or bad, cycling through the facefactors array to see if they are 1(good) or 0(bad)
void DisplayGoodBad(){
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.clearDisplay();
  display.print("Soil Moisture: ");
  if(FaceFactors[0] == 1){
    display.println("Good");
  }
  else if(FaceFactors[0] == 0){
    display.println("Bad");
  }
  display.print("Humidity: ");
  if(FaceFactors[1] == 1){
    display.println("Good");
  }
  else if(FaceFactors[1] == 0){
    display.println("Bad");
  }
  display.print("Temperature: ");
  if(FaceFactors[2] == 1){
    display.println("Good");
  }
  else if(FaceFactors[2] == 0){
    display.println("Bad");
  }
  display.print("Light: ");
  if(FaceFactors[3] == 1){
    display.println("Good");
  }
  else if(FaceFactors[3] == 0){
    display.println("Bad");
  }
  display.display(); //send the text to the screen

}

void ReadLight(){
  lightLevel = analogRead(lightPin);  
  lightPercentage = map(lightLevel, 0, 1023, 0, 100); //maps the lightlevel to a percentage
  if(lightPercentage > 78){ //If the percentage of light is less than 22%(Value on OLED), then thats bad
    FaceFactors[3] = 0;
  }
  else{
    FaceFactors[3] = 1;
  }
}

void ReadHumidityTemp(){
  // read humidity
  humi  = dht.readHumidity();  //uses dht library
  // read temperature as Celsius
  tempC = dht.readTemperature();
  Serial.println();
  // check if any reads failed
  if (isnan(humi) || isnan(tempC)) { //if not a number returned, alert developer that the dht sensor is not working
    Serial.println("Failed to read from DHT sensor!");
  } else {
  }
  if (humi > 80 || humi < 40) {  //led set to let the user know if the humidity is good or bad
    setColor(ledDigitalOne, RED);
    FaceFactors[1] = 0;
  } else {
    setColor(ledDigitalOne, GREEN); //calls set colour with the green boolean array created
    FaceFactors[1] = 1;
  }
    if (tempC<15 || tempC >25) {
    FaceFactors[2] = 0;
  } else {
    FaceFactors[2] = 1;
  }
}


void setColor(int* led, const boolean* color) {
  for(int i = 0; i < 3; i++){ //cycles though the LED pins in the rgb led and sets based on the values written in the colour array specified
    digitalWrite(led[i], color[i]);
  }
}


//function to acitivate the pump
void activatePump(){
  for(int i = 0; i <2;i++){ //pump lets out 2 squirts of water
    digitalWrite(relayPin, LOW);  // Turn on the relay, which activates the pump
    delay(1000);      
    digitalWrite(relayPin, HIGH);   // Turn off the relay, turning off the pump
    delay(1000);
  }

  sensorSoilValue = analogRead(soilSensorPin);
  soilPercentage = map(sensorSoilValue, 200, 600, 0, 100);
  if (soilPercentage >50) { //after reading the moisture sensor again after watering, it lets you know if its still dry(water can is empty)
    tone(speakerPin, 1600, 2000); //annoying noise is played to annoy the user into filling the can
    display.setTextSize(2); //makes larger text
    display.setCursor(0, 0);
    display.clearDisplay();
    display.print("Watering  Can is    empty!");
    FaceFactors[0] = 0; //sets moisture to bad
    display.display();
  }
  else{ // it was successfully watered, shown by a melody
    tone(speakerPin, 1400, 700); //1400 pitch at a duration of 700
    delay(150);
    tone(speakerPin, 1800, 300);
    delay(150);
    tone(speakerPin, 1600, 700);
    delay(150);
  }
}


void ReadSoil(){
  sensorSoilValue = analogRead(soilSensorPin); // Read soil analog value
  soilPercentage = map(sensorSoilValue, 200, 600, 0, 100);// the readings we found were between 200 and 600 so we mapped this to a percentage
  FaceFactors[0] = 1;
  if (soilPercentage >45) {  //if the soil moisture is less than 55%(print screen) then water the plant
    // Activate the water pump using the relay
    activatePump();
  }
  else{
    delay(2000);
  }

}

Testing and Shortcomings

As seen in the design blog, there was many testing conducted of the different components and their effectivity or redundancy in demonstrating our project

• Single threshold for humidity: different types of plants have varying optimal humidity conditions therefore system may not be adequate or suitable for all the kinds of plants available.
  • One way this could be overcome in further development is by the creation of a more rigorous algoerithm with customisable thresholds for the possible types of plants used.
• Power dependency: the system relies on a usb connection to a computer for example, meaning it isnt completely versatile and limits the ability of outdoor location use.
  • Could be overcome by design of waterproof enclosure for the physical electronic components (like the power supply); meaning system can be used outdoors and protected from natural elemental conditions.
• Scalability: the system is designed for a singular area of plant/soil based on the detectors and sensore therefore it is limited for larger setups.

2023 Group 8 – Ball Maze Game

Group Members:

• Emir Savas
• Logan Shalloe
• Matthew Su

Project Brief

Our chosen brief was to create an ‘escape room puzzle’, with ‘interactive game design.’ We chose to go with a ball maze puzzle game, where you use the joystick to tilt the maze, to try and get the ball from the start to the finish, avoiding the holes in the ground. After completing the puzzle, the maze reveals a code which you use to escape the room.

---

Project Planning

---

Design Process

Low-fidelity prototypes: 

In the idea stage, we made a spin puzzle and concluded it would be too simple to solve, and difficult to detect when it is solved using electronic components that we had access to.

This model shows the first maze idea, where a ball will move from point A to point B with the user’s input. There will be potholes to make the game more challenging. We have variation in difficulty by setting two routes by which the user can undergo, one is more difficult and the other is easier to go through, but both lead to the same finish.

We chose to go with a square maze, as the symmetry will help with the balance of the servos, the maze is a 12×12 grid with gaps of at least a half square.

The design of the maze includes multiple routes to the end, the easier and harder ways marked out, the easier ways have larger gaps to allow more space, with the harder ways made tighter with more frequent holes in the ground.

The first concept uses two servos, stuck to each other to allow for movements in both directions. This was going to be placed underneath the centre of the maze. The second concept, which we followed through with is one that uses four servos, two on each level controlling the x or y direction tilt.

Started the making of the final maze.

Extending joystick length for greater control, attaching it to wooden base, hiding wiring with black cloth.

---

Maker Manual

Materials:

• 4mm thick plywood
• 3mm thick plywood
• 4mm diameter metal ball bearing
• 8mm diameter wood dowel
• spare 5V USB cable

Circuit components:

• 5x Micro servo SG90-HV
• 1x Joystick
• 1x PNP transistor

Tools:

• Hand saw
• Sandpaper
• Glue gun
• Hand drill

Sizes of wooden pieces:

Pieces cut from 4mm plywood:

• 180x180mm (x2)
• 180x8mm (x2)
• 180x41mm (x2)
• 188x45mm (x2)

Breadboard Layout:

A – Connect each one to a bare wire, which are placed at the ending of the maze close enough that the ball bearing will connect them

B – Joystick component.

• purple wire to GND
• blue to +5V
• green to VRx
• yellow to VRy

C – Connect to 5V USB cable for additional power. Connect the red and black wires from within the cable to the like-coloured wires plugged into the breadboard.

The Code

#include <Servo.h>

//transistor jumpstart

#define JMPSTART 11

//joystick

#define JOY_X A1

#define JOY_Y A2

//x servos

#define X_SERVO1 1

#define X_SERVO2 2

//y servos

#define Y_SERVO1 3

#define Y_SERVO2 4

//winning

#define WIN_SENSOR 7

#define WIN_SERVO 9

Servo xServo1;

Servo xServo2;

Servo yServo1;

Servo yServo2;

Servo winServo;

void setup() {

  pinMode(WIN_SENSOR, INPUT_PULLUP);

  pinMode(JMPSTART, OUTPUT);

  xServo1.attach(X_SERVO1);

  xServo2.attach(X_SERVO2);

  yServo1.attach(Y_SERVO1);

  yServo2.attach(Y_SERVO2);

  winServo.attach(WIN_SERVO);

  delay(20);

  digitalWrite(JMPSTART, HIGH);

  delay(20);

  digitalWrite(JMPSTART, LOW);

}

void loop() {

  if (digitalRead(WIN_SENSOR) == LOW) {

    winServo.write(130);

  } else {

    winServo.write(0);

  }

  int joyX = analogRead(JOY_X);

  int joyY = analogRead(JOY_Y);

  int xVal = map(joyX, 0, 1023, 0, 50);

  int yVal = map(joyY, 0, 1023, 0, 50);

  xServo1.write(xVal);

  xServo2.write(180 – xVal);

  yServo1.write(yVal);

  yServo2.write(180 – yVal);

}

2023 Group 6: Apres-ski Party Hat

design blog

Project goals

Project Brief

Dance your cares away…

‘Create an e-textile with interactive LEDs that are set to flash to the beats of the music.’

Purpose

Skiers love to party and what is an après ski party without a light-up hat? Our warm, cosy hat is perfect for partying in the cold, snowy mountains and it lights up to the beat of the music! Wearing this hat will make you the envy of the slopes.

Requirements And Objectives

• Create an e-textile (t-shirt, bag, skirt, etc) with interactive LEDs that can be set to either flash to the music’s beats or the wearer’s movement
• Fit in a skiing environment
• Interact with different types of music and beats
• Program reactions using sensors and actuators (LEDs) with Arduino
• Ensure physical components (such as Arduino Uno) do not make the user uncomfortable while wearing the hat
• Consider sound for lighting schemes

Target audience

Skiers who love to party! The target demographic is skiers of all ages. The hat fits all sizes so any user can put it on and become the life of the party at any event.

Market Research

design decisions and processes

Brainstorming and Lofi prototypes

Brainstorming LED placement

Paper models

Design decisions

Colour – the colour changes based on volume of sound

Patterns – the patterns change based on the volume (colour)

• Quiet: Blue and turquoise – LEDs change to this colour (they just turn on)
• Medium: Orange and yellow – LEDs have a flashing dissolving pattern
• Loud: Red – LEDs have a dissolving loop pattern

Brightness – the brightness changes based on the volume (colour)

• Blue: 10
• Green/blue: 20
• Turquoise: 30
• Green: 40
• Yellow: 60
• Orange: 80
• Red: 100

Hifi Prototypes and Testing

First, we tested the LED strip and the sound sensor separately:

---

final product

Making

Final product

Project planning

GANTT Chart

makers manual

Components

• Recycled WS2812B RGB LED strip (the main component of the project) x1
• Arduino IDE x1
• Breadboard x1
• DAOKAI 5PCS High Sensitivity Microphone Sensor x1
• Capacitor x1
• Resistor x1
• Wires x9
• Fur hat x1
• Battery pack x1
• Power wire to attach Arduino IDE to battery pack x1

Tools

• Soldering machine
• Sewing kit

Breadboard Layout

How To Build

Building the circuit

• Follow the circuit diagram above, attaching each component to their appropriate position
• Ensure the sound sensor and the LEDs work before continuing to the next step. Also check that the wires on the LED are soldered correctly and are not touching to make sure there is no short circuiting

Attaching the circuit to the hat

• Cut a hole at the top of the hat for the Arduino and the breadboard. The Arduino and the breadboard should fit into the seam of the hat so it cannot be seen on the outside or be touching the users head. Sew this in place
• Attach the battery to Arduino Uno
• Sew the LED strip around the front of the hat
• Cut a hole on the side of the hat for the sound sensor to be attached. Sew the sound sensor in place so the sensor is on the outside of the hat
• Attach the battery pack to the back of the hat

project evaluation

Shortcomings

• The sensor in itself is quite basic, it measures the amplitude but not the frequency. 
• After rigorous testing, we discovered that the range of values that it can output is around 5 variations. For example, ranging from 40 to 45, where 40 would be quiet and 45 would be loud. This did not give us a lot of space to be able to respond to the many variations of tones/frequencies/loudness of music. Before we had wanted to output darker, bluer colours for low frequencies and lighter, redder colours for higher frequencies, now we could only do so with amplitude and not frequency.
• Improve aesthetics by improving the precision of sewing and incisions on the hat.
• The sound sensor is exposed meaning the hat is not waterproof and also anything that touches the sensor will interfere with it.

Future Considerations

• Incorporate gesture control with ultrasonic sound sensors that could provide an extra interactive layer.
• Enabling users to customise patterns or animation with varying amplitude levels.

Conclusion

While the current sound sensor setup has its limitations in measuring only amplitude and providing a narrow range of values, the use of smaller Arduino and ultrasonic sound sensors could enhance the product by adding gesture control and customisable sound profiles and there is potential to overcome current constraints and responsive aspects of the project.

code

#include <FastLED.h>

#define SENSOR_PIN A0
#define LED_PIN 7
#define NUM_LEDS 47

// millis setup
unsigned long startTime;
unsigned long interval = 100;
unsigned long soundDetectionInterval = 1000;

// colours 
const CRGB red = CRGB(255, 0, 0);
const CRGB orange = CRGB(255, 128, 0);
const CRGB greenBlue = CRGB(0, 102,102);
const CRGB yellow = CRGB(255, 255, 0);
const CRGB green = CRGB(0, 153, 0);
const CRGB blue = CRGB(0, 0, 255);
const CRGB purple = CRGB(51, 0, 102);
const CRGB turqouise = CRGB(0, 102, 102);
const CRGB white = CRGB(255, 255, 255);

// default colour
CRGB colour = CRGB(0,0,0);
// initialise leds array
CRGB leds[NUM_LEDS];
// choose brightness
int brightness = 50;

void setup()
{
  pinMode(SENSOR_PIN, INPUT);
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
  Serial.begin(9600);
  // turn off/reset LEDs
  clearLeds();
  fill_solid(leds, NUM_LEDS, red);
  FastLED.show(); // lights up all LEDs at once
}


void loop()
{ 
  delay(2);
  lightUp();
}

void lightUp() {
  CRGB colourDetermined = determineColour();
  FastLED.setBrightness(brightness);
  fill_solid(leds, NUM_LEDS, colourDetermined);
  FastLED.show(); // lights up all LEDs at once
}

CRGB determineColour(){
  unsigned long currentTime = millis();
  // read volume
  String volume = readSound();
  // choose which colour and pattern to display based on the volume
  if (currentTime - startTime >= interval) {
    if (volume == "ppp") {
      colour = blue;
      brightness = 10;
    }
    else if (volume == "pp") {
      colour = greenBlue;
      brightness = 20;
    }
    else if (volume == "p") {
      colour = turqouise;
      brightness = 30;
    }
    else if (volume == "mp") {
      colour = green;
      brightness = 40;
    }
    else if (volume == "mf") {
      colour = yellow;
      brightness = 60;
      dissolve(10, 10, 10);
    }
    else if (volume == "f") {
      colour = orange;
      brightness = 80;
      dissolve(10, 10, 10);
    }
    else if (volume == "ff") {
      colour = red;
      brightness = 100;
      displayLoopPattern(colour, 7);
      dissolve(10, 10, 7);
    }
    startTime = currentTime;
  }
  return colour;
}

void displayLoopPattern(CRGB patternColor, int patternSize) {
  FastLED.setBrightness(brightness);
  for (int i = 0; i < NUM_LEDS; i += patternSize) {
    for (int j = 0; j < patternSize && i + j < NUM_LEDS; j++) {
      leds[i + j] = patternColor;
    }
    FastLED.show();
    FastLED.delay(20);
    clearLeds();
  }
}

// turn off/reset LEDs
void clearLeds() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = CRGB::Black;
  }
}

// read the volue of the sensor
String readSound()
{
  int inputVolume = analogRead(SENSOR_PIN);
  String dynamicMarking = "";

  if (inputVolume < 42) {
    Serial.println("|");
    dynamicMarking =  "ppp";
  }
  else if (inputVolume == 42) {
    Serial.println("||");
    dynamicMarking =  "pp";
  }
  else if (inputVolume == 43) {
    Serial.println("|||");
    dynamicMarking =  "mf";
  }
  else if (inputVolume == 44 ) {
    Serial.println("|||||");
    dynamicMarking =  "f";
  }
  else if (inputVolume > 44) {
    Serial.println("||||||||||||||||||||||||||||||");
    dynamicMarking = "ff";
  }
  return dynamicMarking;
}

// Random dissolve colors
void dissolve(int simultaneous, int cycles, int speed){
  //delay(10);
  for(int i=0; i<cycles; i++){
    for(int j=0; j<simultaneous; j++){
      int idx = random(NUM_LEDS);
      leds[idx] = CRGB::Black;
    }
    FastLED.show();
    delay(speed);
  }
  allColor(CRGB::Black);
}

// Changes all LEDS to given color
void allColor(CRGB c){
  for(int i=0; i<NUM_LEDS; i++){
    leds[i] = c;
  }
  FastLED.show();
}

2023 Group 4 – Angel Hat and Glove Set

Created by Nimat Choudhury, Sahra Yusuf, Shahd Ahmed

Do you wish to make heads turn everytime you step in the room? Well, we’ve got you covered with our newest release: The Angelic Hat and Magic Glove set! With a cute design and unique never-before-seen features, this hat will quickly become the most prized item in your wardrobe. Interactions such as moving your head to flap the wings or triggering a colour change with a single touch are sure to make everyone jealous of the power you’ll possess after owning this set.

Motion Tracking Fashionable Wearable

We chose to create a motion-tracking fashionable wearable, in the form of a hat and glove, syncing wirelessly. Our brief was to design a garment capable of tracking body movement and provide outputs based on collected data, whilst also focusing on being practical for everyday use and maintaining aesthetics. Our project revolves around a hat with wings and LEDs, which are controlled by movement, and the wearer pressing sensors on a glove. The sensors control the LED colour and light sequence, and head movement makes the wings flap. A hat perfect for making heads turn!

Design Blog

Week 7

Brainstorming

After choosing our brief, we began brainstorming and expanding on initial ideas.

We came up with numerous ideas such as a dress, a skirt, a glove, a hat, and glasses. After discussion, we decided to use a hat as our project base. Designs included a costume-style hat, similar to Captain Hook, with large feathers and suitable for dress-up parties, a ship’s captain-style hat with matching gloves, and various styles of hats with wings.

Ultimately, we went with a casual hat suitable for everyday wear. We also wanted to combine a scrapped idea with this hat, so we brought back the glove. The glove, along with the addition of wings, will communicate with the hat wirelessly through hand gestures. The end product would give the wearer an accessory to wear on any occasion, whilst having unique features, adding interactive elements, as well as customisation.

Week 8

Components Research

After completing the design of our project, we researched components that we would utilise to develop a better understanding of how they work and how to implement them with Arduino.

Wireless Module

We researched wireless modules and how they can be used with Arduino, so we can use them to make our hat and glove communicate with each other. We ended up ordering a NRF24L01, a good module for wireless communication between 2 Arduinos with close proximity.

Gyroscope

A gyroscope to be used to detect movement in angles, which will determine the movements of the wings on the hat. Specified angle ranges would result in different wing movements. We decided the MPU6050 module would be most suitable to meet our task’s goals as it can detect angles and acceleration.

Mini Servo

We saw mini servos as the best way to make the wings move and most suitable for the movements we wanted to implement. They would also be small enough to fit into the hat while also managing to hold up the wings.

NeoPixel Ring 16

We wanted to add LEDs placed in the shape of a heart on our hat and glove, but instead we found that a NeoPixel Ring would be much more efficient to use as it would connect to one pin, as opposed to multiple LEDs which would be a hassle to keep control of. The NeoPixel can have various colours and different light animations, which would work well with our project and can be controlled with sensors in the glove.

GSR Sensor

We knew we wanted additional features that would add a small health aspect to our product. Because of this, we also chose to incorporate a GSR sensor which measures the amount of sweat produced. Along with being able to indicate if someone has just done exercise, the amount of sweat can also correspond to the user’s emotional state. We plan to use this to manage change in hues of the NeoPixel on the glove.

Week 9

Prototype

We began prototyping the wings first, in order to attach them to servos and test their movement. The wings were crocheted by Sahra, and originally were white and light blue. The next wing prototype was a larger size, to better match the hat. After considering our hat’s aesthetics and asking a couple stakeholders on their preference, we decided to use wings with brown stitching instead of light blue, to better match the colour scheme.

Week 10

After prototyping, we started to implement the real functionalities of the final product. To ensure a proper functionality of each component, each was tested separately and then each functionality was combined with another until all functionalities are working out simultaneously. Unfortunately, not all features worked well with the wireless module. The servo and animation feature would not send from transmitter to receiver so we had to compromise by limiting servo movements to the gyroscope and switching animations from being triggered by the glove sensors to being activated by a button on the hat.

Week 11

We were working on combining multiple features and debugging errors we came across. Further investigation of enhancing the code and using more comprehensive commands has been done to enable the better functionality performance.

Project Task List

Week	Task	Member(s)
7	Topic selection Project brainstorm, exploring ideas	All members
8	Research components: Wireless module Gyroscope/Servo Galvanic sensors, LDR	All members Shahd Sahra Nimat
9	Prototypes Order components Hard coding, testing separate functions and components	All members
10	Assembling circuits Making wings Coding functions Order components Plan/organise portfolio	All members Sahra All members Shahd Nimat
11	Debugging Further assembling of components Combining materials to components Portfolio/design blog Testing	Sahra, Shahd All members Sahra Nimat Sahra, Shahd

Maker Manual

Overview

Tools and Components

Circuit Layout

Transmitter

Receiver

How To Build

Code

Transmitter

// Code 1: Sending Text (Transmitter)
#include <SPI.h>
#include <RF24.h> //Wireless Module Libraries
#include <nRF24L01.h>
#include <Adafruit_NeoPixel.h> //RGB 16 LED Ring Library
RF24 radio(9, 8); //Pins for wireless module (CE, CSN)
const byte address [10] = "ADDRESS01"; //Address for radio communication
char color [][7] = {"C0", "C1", "C2", "C3", "C4", "C5"}; //Array of colour numbers to be sent to Receiver
const int FSR_THUMB = A0; //Pin for force sensor at the thumb
const int FSR_RING = A1; //Pin for force sensor at the ring finger
int thumbReading = 0; //Reading from thumb's force sensor
int ringReading = 0; //Reading from ring finger's force sensor
int countColour = 0; //Pointer for color array


const int GSR = A5; //Pin for sweat sensor
int sensorValue; //Reading from sweat sensor
int LED_PIN = 6; //NeoPixel Pin
int LED_COUNT = 16; //Number of LEDs on the NeoPixel
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); //Declare NeoPixel strip object
int brightness = 20; //brightness of NeoPixel
int ledColour; //Colour of NeoPixels
int blueColour = 0; //Blue hue of NeoPixel
int greenColour = 60; //Green hue of NeoPixel
int redColour = 60; //Red hue of NeoPixel
unsigned long timer = 0; //Variable used with millis() when tracking GSR reading


void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openWritingPipe(address); //Set destination address
  radio.setPALevel (RF24_PA_MIN); //Adjust power level to minimum as modules will be close together
  radio.stopListening(); //The Transmitter does not receive data
  strip.begin();
}
void loop(){
  sweatBlue(); //Call function for using GSR sensor
  sensorTapping(); //Call function for reading force sensors and sending data to receiver
}
void showColour(uint32_t color, int brightness) { //Function to show a given colour and brightness
  for (int i = 0; i < strip.numPixels(); i++) {
    uint8_t red = (color >> 16) & 0xFF;
    uint8_t green = (color >> 8) & 0xFF;
    uint8_t blue = color & 0xFF;


    strip.setPixelColor(i, strip.Color(red * brightness / 255, green * brightness / 255, blue * brightness / 255));
    strip.show();
  }
}
void sweatBlue() { //Function to change colour of NeoPixel on glove to display level of sweat
  if (millis() - timer >= 100) { //This should happen every 100ms
    sensorValue=analogRead(GSR);
    blueColour = map(sensorValue, 0, 800, 255, 0); //Map the sweat sensor value to be used as the blue hue for the NeoPixel's colour
    Serial.println(sensorValue);
    ledColour = strip.Color(redColour, greenColour, blueColour);
    showColour(strip.Color(redColour, greenColour, blueColour), brightness); //Put the new blue value into the NeoPixel
    timer = millis(); //Update timer
  }
}
void sensorTapping() { //Function to check if ring finger and thumb are pressed together
  thumbReading = analogRead(FSR_THUMB);
  ringReading = analogRead(FSR_RING);
  Serial.println("thumb" + String(thumbReading)); //Used for testing if sensors are being read correctly
  Serial.println("ring" + String(ringReading));
  delay(1000); //Delay of 1 second to make sure one finger tap isnt registered as multiple taps
  if ((thumbReading > 400) && (ringReading > 400)) { //Colour change when force exceeds 400
    if (countColour < 5) {
      countColour++; //Increment pointer in color array
    } 
    else {
      countColour = 0; //reset pointer to index 0 when it exceeds index 4
    }
    radio.write(&color[countColour], sizeof(color[countColour])); //Send the new colour to Receiver
    Serial.print("Text: ");
    Serial.println(color[countColour]); //Used to test if pointer at color array has been changed
    delay(500); //Delay of 0.5 seconds to make sure one finger tap isnt registered as multiple taps
  }
}

Receiver

// Code 1: Sending Text (Receiver)
// Library: TMRh20/RF24 (https://github.com/tmrh20/RF24/)
#include <SPI.h>
#include <RF24.h> //Wireless Module Libraries
#include <nRF24L01.h>
#include <Adafruit_NeoPixel.h>//RGB 16 LED Ring Library
#ifdef __AVR__
#include <avr/power.h> //Required for 16 MHz Adafruit Trinket
#endif
#define LED_PIN    6 //NeoPixel pin
#define LED_COUNT 16 //Number of LEDs on the NeoPixel
#define BUTTON_PIN   7 //Pin for button
#include <Servo.h> //Servo Library
#include <MPU6050_tockn.h> //Gyroscope/Accelerometer module
#ifdef __AVR__
 #include <avr/power.h> //Required for 16 MHz Adafruit Trinket
#endif
bool oldState = HIGH; //Variable to store the button's old state
int showType = 0; //Variable for the animation number used to as an argument for startshow function


Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); //Declare NeoPixel strip object


int pos = 0; //Initialise position of servo
int brightness = 50; //Initialise brightness of NeoPixel
RF24 radio (9, 8); //CE and CSN pins
const byte address [10] = "ADDRESS01"; //Variable for the host and receiver
int animation_count = 0; //Pointer for animation array
int countColour = 0; //Pointer for colours array
uint32_t colours[] = { //Array of colours to be 
  strip.Color(0, 255, 0), //Green
  strip.Color(255, 0, 0), //Red
  strip.Color(0, 0, 255), //Blue
  strip.Color(255, 255, 0), //Yellow
  strip.Color(255, 0, 255), //Magenta
  strip.Color(0, 0, 0) //Off
};


MPU6050 mpu6050(Wire); //Creating MPU6050 object
float x; //x rotation value from MPU6050 module
float y; //y rotation value from MPU6050 module
float z; //z rotation value from MPU6050 module
float prevX; //Saving the x rotation value from the previous 1/2 second
float prevY; //Saving the y rotation value from the previous 1/2 second
float prevZ; //Saving the z rotation value from the previous 1/2 second
float xDiff; //Difference in x rotation within 1 second
float zDiff; //Difference in z rotation within 1 second
unsigned long timer = 0; 
unsigned long timer2 = 0; //Variables to be used when implementing millis() for multitasking
unsigned long timer3 = 0;


//Class for multitasking servos reused from https://learn.adafruit.com/multi-tasking-the-arduino-part-1/overview


class Sweeper { //Declaring a class for the servos to work with multitasking


  Servo servo; //The servo 
  int pos; //Current servo position  
  int increment; //Increment to move for each interval 
  int  updateInterval; //Interval between updates 
  unsigned long lastUpdate; //Last update of position 


public:
  Sweeper(int interval, int inputIncrement) { //Method to create instance of Sweeper class
    updateInterval = interval;
    increment = inputIncrement;
  } 


  void Attach(int pin) { //Method that causes wings to move
    servo.attach(pin); //Attach servo in order to move
  } 


  void Detach() { //Method that causes wings to stop moving
    servo.detach(); //Detach servo in order to halt it
  } 


  void Update() {  //Increment servo using the argument
    if((millis() - lastUpdate) > updateInterval) { //Using millis() to allow for multitasking
      lastUpdate = millis(); 
      pos += increment; //Move wing forwards until it reaches 80 degrees
      servo.write(pos); 
      if ((pos >= 80) || (pos <= 0)) { //Wing moves 80 degrees backwards
        increment = -increment; //Reverse direction 
      } 
    } 
  } 
};


Sweeper sweeper1(5, 5); //Left wing will move 5 degrees every 5 milliseconds
Sweeper sweeper2(5, 5); //Right wing will move 5 degrees every 5 milliseconds


void setup() {
  pinMode(BUTTON_PIN, INPUT); //Set button pin mode to input
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address); //Set up radio to listen on pipe 0 with address "ADDRESS01"
  radio.setPALevel(RF24_PA_MIN); //Adjust power level to minimum as modules will be close together
  radio.startListening(); //The Transmitter does not receive data
  Wire.begin();
  mpu6050.begin();
  mpu6050.calcGyroOffsets(true); //Used to remove the other forces acting on the gryoscope
  sweeper1.Attach(3); //Attach left servo to pin 3
  sweeper2.Attach(5); //Attach right servo to pin 5
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  strip.begin();
  strip.show();
  showColour(strip.Color(255, 255, 255), 50); //Start program by setting colour to white and brightness to 50
  strip.setBrightness(50); //Set the LEDs brightness to 50
}
void loop() {
  changecolor(); //Call function that changes colour when a message is sent from the transmitter
  gyroServo(); //Call function that combines MPU6050 and servos
  animationButton(); //Call function that uses a button to change light animations
}
void changecolor() { //Function to change the colour of light when message is sent from the transmitter
  while (radio.available()) { //While the transmitter and receiver are connected
    char txt[4] = ""; //Create a blank array of characters where the message sent from the transmitter will be stored
    radio.read(&txt, sizeof(txt)); //Read the message being sent from transmitter and store it in the txt array
    Serial.println(txt); //Display to see if anything is being sent from the transmitter
    if (txt[0] == 'C') { //If a colour change is being initiated...
      if (txt[1] == '1') { //(Number corresponds to how many times user has pressed force sensor)
        Serial.print("text: "); 
        Serial.print(txt[0]); //Display to see if what's being sent from the transmitter is being received
        Serial.println(txt[1]);
        showColour(colours[0], 50); //Display the appropriate colour from the array according to the number that's being received
      } else if (txt[1] == '2') {
        Serial.print("text: ");
        Serial.print(txt[0]); //Display to see if what's being sent from the transmitter is being received
        Serial.println(txt[1]);
        showColour(colours[1], 50); //Display the appropriate colour from the array according to the number that's being received
      } else if (txt[1] == '3') {
        Serial.print("text: ");
        Serial.print(txt[0]); //Display to see if what's being sent from the transmitter is being received
        Serial.println(txt[1]);
        showColour(colours[2], 50); //Display the appropriate colour from the array according to the number that's being received 
      } else if (txt[1] == '4') {
        Serial.print("text: ");
        Serial.print(txt[0]); //Display to see if what's being sent from the transmitter is being received
        Serial.println(txt[1]);
        showColour(colours[3], 50); //Display the appropriate colour from the array according to the number that's being received
      } else if (txt[1] == '5') {
        Serial.print("text: ");
        Serial.print(txt[0]); //Display to see if what's being sent from the transmitter is being received
        Serial.println(txt[1]);
        showColour(colours[4], 50); //Display the appropriate colour from the array according to the number that's being received
      } else if (txt[1] == '0') {
        Serial.print("text: ");
        Serial.print(txt[0]); //Display to see if what's being sent from the transmitter is being received
        Serial.println(txt[1]);
        showColour(colours[5], 50); //Display the appropriate colour from the array according to the number that's being received
      }
    }
  }
}
void showColour(uint32_t color, int brightness) { //Function to show a given colour and brightness
  for (int i = 0; i < strip.numPixels(); i++) {
    uint8_t red = (color >> 16) & 0xFF;
    uint8_t green = (color >> 8) & 0xFF;
    uint8_t blue = color & 0xFF;
    strip.setPixelColor(i, strip.Color(red * brightness / 255, green * brightness / 255, blue * brightness / 255));
    strip.show();
  }
}
void gyroServo() { //Function to move servos according to the gyroscope movements
  sweeper1.Update(); 
  sweeper2.Update(); //Update state of servos everytime the gyroscope is checked
  mpu6050.update();  //Update gyroscope to check position of the board(hat)
  x = mpu6050.getAngleX(); //Read rotation on x axis
  y = mpu6050.getAngleY(); //Read rotation on y axis
  z = mpu6050.getAngleZ(); //Read rotation on z axis
  if (millis() - timer > 500) { //Every 1/2 second, record the gyroscope position
    prevX = x;
    prevZ = z;
    timer = millis();
  }
  if (millis() - timer2 > 1000) { //Every second, record the difference between the previous gyroscope position and current one
    xDiff = prevX - x;
    zDiff = prevZ - z;
    timer2 = millis();
  }
  if (zDiff>15 || zDiff<-15) { //Move both wings when the hat is moved at least 15 degrees on the z axis in a second
    sweeper1.Attach(3);
    sweeper2.Attach(5);
    Serial.println(zDiff);
  } else if (xDiff>20 || xDiff<-20) { //Move both wings when the hat is moved at least 15 degrees on the z axis in a second
    sweeper1.Attach(3);
    sweeper2.Attach(5);
    Serial.println(xDiff);
  } else if (y>30) { //Rotating hat past 30 degrees to the right on the y axis causes left wing to move
    sweeper1.Attach(3);
  } else if (y<-30) { //Rotating hat past 30 degrees to the left on the y axis causes right wing to move
    sweeper2.Attach(5);
  } else { //If none of these conditions are met, wings do not move
    sweeper1.Detach();
    sweeper2.Detach();
  }
  if (millis() - timer3 > 3000) { //Used to see if gyroscope is responding and working correctly
    Serial.print("angleX : ");Serial.print(x);
    Serial.print("  angleY : ");Serial.print(y);
    Serial.print("  angleZ : ");Serial.print(z);
    Serial.println("");
    timer3 = millis(); //millis() used instead of delay() to not interfere with multitasking features
  } 
}
void animationButton() { //Function that changes animation when button is pressed
  bool newState = digitalRead(BUTTON_PIN); //Get current button state
  if (newState == LOW && oldState == HIGH) { //Check if button is pressed
    delay(20); //Short delay to debounce button
    newState = digitalRead(BUTTON_PIN); //Check if button is still low after debounce
    if (newState == LOW) { //If button is pressed, increment variable that keeps track of the animation type
      showType++; 
      if (showType > 9) //Theres 9 animations, so reset variable to 0
        showType=0;
      startShow(showType);
    }
  }
  oldState = newState; //Set the last button state to the old state
}
void startShow(int i) { //Function used to display different animations
  switch(i){
    case 0: colorWipe(strip.Color(0, 0, 0), 50); //Off
            break;
    case 1: colorWipe(strip.Color(255, 0, 0), 50); //Red
            break;
    case 2: colorWipe(strip.Color(0, 255, 0), 50); //Green
            break;
    case 3: colorWipe(strip.Color(0, 0, 255), 50); //Blue
            break;
    case 4: theaterChase(strip.Color(127, 127, 127), 50); //White
            break;
    case 5: theaterChase(strip.Color(127,   0,   0), 50); //Red
            break;
    case 6: theaterChase(strip.Color(  0,   0, 127), 50); //Blue
            break;
    case 7: rainbow(20);
            break;
    case 8: theaterChaseRainbow(50);
            break;
  }
}


//Animation function - Reused from Adafruit NeoPixel example code 'strandtest'


void colorWipe(uint32_t color, int wait) { //Animation 1
  for(int i=0; i<strip.numPixels(); i++) { //For each pixel in strip...
    strip.setPixelColor(i, color); //Set pixel's color (in RAM)
    strip.show(); //Update strip to match
    delay(wait);
  }
}
void theaterChase(uint32_t color, int wait) { //Animation 2
  for(int a=0; a<10; a++) {  // Repeat 10 times...
    for(int b=0; b<3; b++) { //'b' counts from 0 to 2...
      strip.clear(); //Set all pixels in RAM to 0 (off)
      //'c' counts up from 'b' to end of strip in steps of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        strip.setPixelColor(c, color); //Set pixel 'c' to value 'color'
      }
      strip.show(); //Update strip with new contents
      delay(wait);  //Pause for a moment
    }
  }
}
void rainbow(int wait) { //Animation 3
  for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
    strip.rainbow(firstPixelHue);
    strip.show(); //Update strip with new contents
    delay(wait);
  }
}
void theaterChaseRainbow(int wait) { //Animation 4
  int firstPixelHue = 0; //First pixel starts at red (hue 0)
  for(int a=0; a<30; a++) { //Repeat 30 times...
    for(int b=0; b<3; b++) { //'b' counts from 0 to 2...
      strip.clear(); //Set all pixels in RAM to 0 (off)
      //'c' counts up from 'b' to end of strip in increments of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        //hue of pixel 'c' is offset by an amount to make one full
        //revolution of the color wheel (range 65536) along the length
        //of the strip (strip.numPixels() steps):
        int      hue   = firstPixelHue + c * 65536L / strip.numPixels();
        uint32_t color = strip.gamma32(strip.ColorHSV(hue)); //hue -> RGB
        strip.setPixelColor(c, color); //Set pixel 'c' to value 'color'
      }
      strip.show(); //Update strip with new contents
      delay(wait); //Pause for a moment
      firstPixelHue += 65536 / 90; //One cycle of color wheel over 90 frames
    }
  }
}
uint32_t Wheel(byte WheelPos) { //Animation 4
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else if(WheelPos < 170) {
    WheelPos -= 85;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  } else {
   WheelPos -= 170;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  }
}

Testing & Shortcomings

Multitasking with Arduino

Servo Rotation

Initially we utilized For loops in order to make the servos move. However, this proved to not work very well in the grand scheme of the project, as we had many features that required multitasking. In order to combat this issue, we added a Sweeper class that used millis() in one of the methods. Using millis(), the servo is incremented by 5 degrees every 5 milliseconds after creating 2 Sweeper objects such that Sweeper sweeper1(5, 5) and Sweeper sweeper2(5, 5).

Animation Control

Each animation is a sequence of LEDs with changing colors. There is a delay for each sequence to be displayed. We tried to use millis(), but it could not break out of the while or for loops when the button is triggered. To overcome this limitation, we opted to reduce the animation duration instead of endlessly looping, in order to allow the button to trigger a change in the animation sequence. The animation functions are called in switch cases instead of while loops.

Wireless Communication

The NRF24L01 transceiver disconnected while testing. The two microcontrollers for the host and transmitter had to be reset before starting to send texts. When another functionality was implemented to change the color animation based on a different text message, the receiver could not configure it. The communication lagging happened due to various reason such as noise interference and short distance between the host and receiver.

For future improvements, ESP-01 WiFi or HC-12 SI4463 is recommended to establish the wireless communication because of the high noise prevention. Additionally, instead of altering animations using a button, another force sensor can be implemented on the glove so that with thumb and index tapping, the ring displays various animations.

Components and Batteries Assembly:

The weight of components is not convenient for a hat-glove set, so it is recommended to design a PCB that has all components mounted to it. The glove would also benefit if an Arduino Nano was used instead of an Uno, but our Nano had compatibility issues which is why we stuck to using an Uno. The batteries assembly is unsafe to be right next to the wearer’s head or hand as they might explode. For safety, a couple of fuses or battery switches should implemented.

2023 Group 2 – KEITH Plant Monitor

---

dESIGN BLOG

November 13, 2023

Today we made our final decision on what our first and back up choices are, “Monitoring your plants” and “Your Own Talking and loving Teddy Bear” respectively. We also did some brainstorming of some ideas for each project:

I also emailed Laurissa to confirm our group members and our first and backup choices. In the evening I received an email confirmation from Laurissa that the “Monitoring your plants” project is ours to work on.
Atanas

November 17, 2023

After it was confirmed that we can start working on the plant monitor project, I came up with a starting idea that we could try and prototype on Monday during the lab. 

A single container that would contain the Arduino board, the sensors/actuators, the water container and pump and that would have a round space in the middle for the user to insert their plastic pot and plant. We will also need to decide how to power Keith, our plant monitor, with a USB cable, AC adapter or batteries.
Atanas

November 20, 2023

During today’s lab, we started to create prototypes based on my starting design to see how it might function and look. I researched the components we will need. We need to add them to our order today so we can get them early and start putting them together.
A list of what we need:

• an OLED screen
• a humidity sensor
• an easier to use potentiometer and button than the one provided with the Arduino kit
• Velcro tape
• plant
• a large selection of wires – male-to-male, male-to-female, female-to-female that come with enough red and black wires for connecting voltage and ground
• a light sensor(reuse from Arduino kit)
• soil moisture sensor
• water pump
• relay
• water container
• tubing
• resistors (reuse from Arduino kit)

While Bryle was researching for parts and components, Stanley and I started working on prototypes. 

Prototype of the rough physical appearance of the plant monitor:

This gave us an idea of what each part of the casing would be dedicated to. And how the user would interact with the monitor.

OLED screen user interface prototype:

We wanted to provide the users of our monitor to be able to get in depth analysis of the their plant’s immediate surrounding area so they can take better care of it. Different bars on the screen would represent the temperature, light, humidity and soil moisture. Each bar would also have indicators of what the current value of that bar is and what is the optimal condition of the plant. So if there wasn’t enough light in the room, the user would have the move their plant pot and monitor somewhere else. Or if the humidity was really low they would get a humidifier or give their plant a few spritzes with a mister.

The bars would also be accompanied by a flower character that would provide additional indication of how the plant is doing.

We also had the idea that the plant monitor could be adapted by the user so they can take care of any plant with it, by adjusting the optimal levels for each bar through a potentiometer and a button. 

The user would use the potentiometer to go to the setting levels option and press confirm with the button. Then they would scroll through each bar which would be indicated with an icon displayed over the flower character. Pressing the button again would confirm their choice and they will be able to set the relevant bar to the required level and once again press the button to confirm their choice.

After the prototypes were we all collectively started researching components and by the end of the day had found the majority we required and had them ordered. The most difficult one to decide on was the OLED screen because there were so many options, but it was difficult to decide which would work with our Arduino and which library they would require. We also had to consider the number of pixels we would need, as the bigger screens that we originally thought we would use, it turned out would eat up most of our budget as they cost over £40-£50.

Atanas

November 27, 2023

Today, we received our components that we had ordered for Keith, so I tested them to make sure that they worked and how they would work.

First thing I tested was the light sensor.

The light sensor used one analog pin to work, outputting a value representing the ambient light level. It has a LDR soldered on at the end of the circuit board to read the light level.

The temperature and humidity sensor needed one digital pin along with the two pins for voltage and ground to work. Using the DHT11 library for the Arduino, I was able to get readings for both the humidity and temperature.

These two sensors will be recording the ambient factors surrounding the plant, so they needed to be exposed to correctly record values.

The next sensor I tested was the soil moisture sensor.

This came with the components for the irrigation system (water pump, relay etc). This didn’t need any libraries so I could use standard Arduino code to get readings from the sensor. The readings for this sensor worked where the drier the soil, the higher the reading which would be important to keep in mid when coding. It uses one analog pin for reading the value into the code.

This sensor would be placed in the soil of our plant to get its readings.

The next component I tested was the OLED screen. It has a 128×64 resolution and is 2.42 inches.

The Driver IC (Intergrated Circuit Chip) in the OLED screen is 1309, so I used the ‘u8g2’ library to run code that would display images on the screen. The image above is the standard coding test of outputting ‘Hello World’ using example code that came with the library. Using an example code file called ‘Graphics Test’, I tested what kind of shapes the screen could output. Below is a bitmap example from the code.

The screen required 7 pins to work. 5 pins were needed for the screen to work, along with the power and ground wires.

Bryle

28 November, 2023

Following some of the component testing from yesterday, Stanley and Atanas began building the circuit in order to get a feel for how the components would need to be wired together on the Arduino. While they did this, I tested the relay and water pump to make sure that they worked since they were essential for the irrigation system of the project.

The relay was used in conjunction with the water pump and would be activated using code with digitalWrite, going between high and low. The relay uses a digital pin in order to receive the high or low signal to run the pump. For the irrigation system, we’ll be using the reading from the soil moisture sensor in an if statement to check whether the plant needs water.

Bryle

1 December, 2023

Today, I began coding the program we would be using for the final product.

I started with making sure that all readings that I need from the sensors can be read in. For the temperature and humidity sensor, I used the DHT Sensor library by Adafruit to read the values. Even though only one digital pin is used to connect the sensor to the Arduino, the library allows for the humidity and temperature to be pulled separately and assigns to different variables. The variables would be defined at the top of the program, outside of setup, and then the value would be taken in every time the code in the loop section is run, so that the readings are constantly refreshed.

For the light sensor and the soil moisture sensor, I didn’t need to install any libraries so I used standard Arduino code. Both these sensors used one analog pin each to take a reading. Same as the temperature and humidity, they were defined at the top of the program and then constantly refresh the reading in the loop section.

For the soil moisture sensor, I did have to write a function in order to read a value. This was because the sensor requires power to take a reading so the function essentially sends a high digital signal to power the sensor on, then takes a reading and assigns it to a variable, and then sends a low digital signal to power the sensor off. It returns the reading from the sensor.

Bryle

3 December, 2023

Today me and Stanley tested the pump and relay system and ran into an issue where the relay LEDs were turning on, but the pump was not doing anything. We ordered a new pump and relay with next day delivery to make sure this is sorted out as soon as possible.

Atanas

4 December, 2023

I continued coding the program while Stanley and Atanas begin assemblying the final product.

Stanley and Atanas used this final concept for the product.

Stanley needed to do some work on the watering can pot to fit in the water pump’s pipes so that it goes through the spout of the watering can.

Stanley and Atanas tested the new pump and relays that arrived today and thankfully they were both working successfully. They were then able to add the pump into the watering can to ensure that it works, being successful in doing so.

Regarding the code, I was able to add the if statement block, responsible for checking the soil moisture and activating the pump when the moisture is too low.

Bryle

8 December, 2023

Today, the assembly of the product involving the pots and Arduino was finished.

The product will run using a battery, ensuring that it doesn’t require a mains plug to work, meaning it isn’t restricted to where it can be placed.

10 December, 2023

Today, the coding aspect of the project was wrapped up.

The screen feedback was done today.

The first part of the screen feedback was a show of the current plant factors. Graphics were used to create bars that represent the current state of each factor that needs to be observed when taking of plants. The bars representing the current reading of each factor was done by mapping the readings into a certain range that would allow it to be displayed correctly on the screen. There was also text added below to ensure that the user knew which bar represented which factor.

The second part of the screen feedback is a flower representing a general summary of the plant’s current status. It has three states:

• Full Flower: A flower with all of its petals, representing that all the factors for the plant are optimal.
• Decaying Flower: A flower that has lost some of its petals, representing that one or two of the factors are not optimal.
• Wilted Flower: A flower that has lost all of its petals, representing that all three factors are not optimal for the plant.

These states only depended on three of the factors (temperature, humidity and light) as the irrigation system handled the soil moisture.

The state changing based on the three factors was done using booleans that would check whether the factor’s reading was within a certain range, setting the boolean to true, otherwise being false if it is outside said range. It would then check all three booleans to determine the state of the plant and what is shown to the user.

I also changed the library used for the humidity and temperature sensor, from the adafruit one we were using to the official Arduino one, EduIntro. The Adafruit library we were using stopped working with a sensor so that is what necessitated the change.

Bryle

11 December, 2023

Before the presentation, we uploaded the code into the Arduino and inserted it into the finished product. We did some final testing, making sure everything was working as intended for the demonstration. We also finalised the slides within our group, ready for the presentation.

Below is our final product.

Bryle

project task list

Task List

Group Members: Atanas Ilinov, Bryle Inandan, Stanley Parker

Task	Member/s
Choose Two Briefs – First Choice, Backup Choice	Everyone
Confirm Group Members, First Choice, Backup Choice	Atanas
Brainstorming	Everyone
Initial Design Concepts	Atanas, Stanley
Lo-fi Prototyping	Atanas, Stanley
Researching Circuitry Components	Everyone
Ordering Components and Materials	Everyone
Testing Components	Bryle
Assembling Circuit	Atanas, Stanley
Modifying/Building Casing	Stanley
Coding	Bryle
Assembly	Atanas, Stanley
Testing and Bug-fixing	Everyone
Create Presentation	Everyone
Blog	Everyone

Project Plan

maker manual

Overview

Are you tired of forgetting to water your plants? Tired of them being too hot or too cold? Tired of wilting due to a lack of light? Well, we have a solution for you, and his name is KEITH!

KEITH is a must have for any houseplant parent, he gives you critical information about your plant, including the temperature, humidity and light level of it’s surroundings, he even keeps track of the soil moisture content and waters it for you!

KEITH is the perfect caretaker for all of your green, leafy children, simply hook his moisture sensor up to the soil and adjust his watering hose to the position you need it in and let him get to work! KEITH‘s small module is non-intrusive and can be placed in most areas of your home with ease.

KEITH is perfect for casual hobbyists or more experienced plant owners due to the variety of information he can give you about your plant, and he’s so easy to set up, once he’s hooked up and you’ve filled his reservoir he’ll begin watering your plant whenever it needs it.

KEITH isn’t like those other “self-watering” plant pots you see that rely solely on the plant’s ability absorb water, KEITH will keep your plant watered no matter the conditions, even if your plant is struggling KEITH will be right there with it helping you nurture and care for it.

Tools and Supplies

Tools

Supplies

• Textual Breakdown of Components:
  • Arduino UNO
  • Miniature submersible water pump
  • Arduino 1 channel 5V relay module
  • Velcro Tape
  • 2.42 inch 128X64 OLED Display Module IIC I2C Serial Peripheral Interface
  • 8.6mm PVC pipe
  • M-F, M-M and F-F cables
  • Capacitive Soil Moisture Sensor
  • DHT11 3 Pin Module
  • Epoxy Putty
  • Ceramic Pot + Watering Can
  • Arduino Light Sensor Module
  • 9V battery
  • 9V battery clip with 2.1*5mm Male Plug
  • Fake Grass

Layout and Circuit Diagrams

Breadboard Layout Diagram

Unfortunately the software we used to make the breadboard diagram (Fritzing) was a little outdated, so instead of a water pump image I had to use a motor image. They also did not have a photoresistor module, so we just implemented a regular photoresistor. This is also reflected in the circuit diagram below.

Circuit Diagram

Relay here is treated as a relay module. The diagram above only shows how the module itself is connected to the circuit. Some of the pins on some of the components have also been rearranged for better readability.

How to Build

Code

// libraries
#include <EduIntro.h>
#include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

// dht11 library code for temperature and humidity sensor
DHT11 dht11(D3);

// soil moisture and light pins
const int soilMoistRead = A0;
const int soilMoistPower = 4;
const int lightPin = A1;

// relay connected to pin 2, HIGH will pump water out
int pumpPin = 2;

// potentiometer to scroll between screens
const int scrollPin = A2;

// variables for plant needs
float soilMoist;
int humidity;
int temperature;
float currentLight;

// booleans for flower face
bool optimalTemp = true;
bool optimalHumid = true;
bool optimalLight = true;

// pins for screen
// GND = Ground, VCC = 3/5V, SDL/Clock = 13, SDA/Data = 11, RES/Reset = 8, DC = 9, CS = 10

// constructor for screen
U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);

// used to change between the flower faces and statistics
uint8_t page = 0;

void setup() {
       Serial.begin(9600);

       // power on the screen and prepare everything
       u8g2.begin();
       u8g2_prepare();

       // assign pin modes
       pinMode(soilMoistPower, OUTPUT);
       pinMode(pumpPin, OUTPUT);

       // default state of pump - off
      digitalWrite(soilMoistPower, LOW);
} //end setup

void loop() {
      // Serial.println();

      // updates the temperature and humidity reading every loop for updated reading
      dht11.update();

      humidity = dht11.readHumidity();
      // Serial.print("Humidity (%): ");
      // Serial.println(humidity);

      temperature = dht11.readCelsius();
      // Serial.print("Temperature (celsius): ");
      // Serial.println(temperature);

      // sensor value closer to 0 the more wet it is
      soilMoist = readSensor();
      // Serial.print("Soil Moisture: ");
      // Serial.println(soilMoist);

      currentLight = analogRead(lightPin);
     // Serial.print("Light Level: ");
      // Serial.println(currentLight);

      // drawing the plant stats and current status
      u8g2.clearBuffer();
      plantStatus();
      u8g2.sendBuffer();

      // checks for optimal conditions
      // soil moisture not included as irrigation system is automatic
      if(temperature >= 21 && temperature <= 30){
          optimalTemp = true;
      } else{
          optimalTemp = false;
      } // end if else

      if(humidity >= 40 && humidity <= 70){
          optimalHumid = true;
      } else{
          optimalHumid = false;
      } // end if else

      if(currentLight >= 40 && currentLight <= 70){
          optimalLight = true;
      } else{
          optimalLight = false;
      } // end if else

      // runs pump after checking the soil moisture
      waterPlant(soilMoist);

      // automatically flip between the two pages of flower stats
      page++;

      if(page > 1){
          page = 0;
      } // end if

      delay(2000);
} // end loop

// soil moisture reading
int readSensor(){
      digitalWrite(soilMoistPower, HIGH);
      delay(10);
      int val = analogRead(soilMoistRead);
      digitalWrite(soilMoistPower, LOW);
      return val;
} // end readSensor

// sensor value closer to 0 the more wet it is
// checks water and activates pump when low on water
void waterPlant(float moisture){
      if(moisture > 400){
          digitalWrite(pumpPin, HIGH);
      } else {
          digitalWrite(pumpPin, LOW);
      }
} // end waterPlant

// prepare screen to be used
void u8g2_prepare() {
      u8g2.setFont(u8g2_font_5x8_tf);
      u8g2.setFontRefHeightExtendedText();
      u8g2.setDrawColor(1);
      u8g2.setFontPosTop();
      u8g2.setFontDirection(0);
} // end function

// draw status bar of each plant need
void plantStatusBar(){
      int mapSoilMoist = map(soilMoist, 350, 600, 0, 40);
      int mapHumid = map(humidity, 20, 90, 0, 40);
      int mapTemp = map(temperature, 0, 50, 0, 40);
      int mapLight = map(currentLight, 1023, 0, 0, 40);

      u8g2.drawStr(10, 50, "Water");
      u8g2.drawBox(19, 8+(40-mapSoilMoist), 8, mapSoilMoist); // map values into range of 0 - 40
      u8g2.drawFrame(17, 6, 12, 44);
      u8g2.drawStr(37, 50, "Humid");
      u8g2.drawBox(45, 8+(40-mapHumid), 8, mapHumid);
      u8g2.drawFrame(43, 6, 12, 44);
      u8g2.drawStr(65, 50, "Temp");
      u8g2.drawBox(70, 8+(40-mapTemp), 8, mapTemp);
      u8g2.drawFrame(68, 6, 12, 44);
      u8g2.drawStr(88, 50, "Light");
      u8g2.drawBox(95, 8+(40-mapLight), 8, mapLight);
      u8g2.drawFrame(93, 6, 12, 44);
} // end plantStatusBar

void flowerFace(){
      if(!optimalTemp || !optimalHumid || !optimalLight){
          if(!optimalTemp && !optimalHumid && !optimalLight){
              // wilted flower
              u8g2.drawStr(35, 0, "Wilted Flower");
              u8g2.drawStr(30, 10, "Stats no good...");
              u8g2.drawDisc(64, 40, 9); // main body
          } else {
              // slightly decayed floweru8g2.drawStr(30, 0, "Decayed Flower");
              u8g2.drawStr(35, 10, "Check stats!");
              u8g2.drawDisc(64, 40, 9); // main body
              u8g2.drawCircle(54, 40, 5); // left petal
              // u8g2.drawCircle(74, 40, 5); // right petal
              // u8g2.drawCircle(64, 50, 5); // bottom petal
              u8g2.drawCircle(64, 30, 5); // top petal
              // u8g2.drawCircle(58, 45, 5); // bottom left petal
              u8g2.drawCircle(70, 45, 5); // bottom right petal
              u8g2.drawCircle(58, 35, 5); // top left petal
              // u8g2.drawCircle(70, 35, 5); // top right petal
          }
      } else {
          // full flower
          u8g2.drawStr(35, 0, "Full Flower");
          u8g2.drawStr(30, 10, "All stats good!");
          u8g2.drawDisc(64, 40, 9); // main body
          u8g2.drawCircle(54, 40, 5); // left petal
          u8g2.drawCircle(74, 40, 5); // right petal
          u8g2.drawCircle(64, 50, 5); // bottom petal
          u8g2.drawCircle(64, 30, 5); // top petal
          u8g2.drawCircle(58, 45, 5); // bottom left petal
          u8g2.drawCircle(70, 45, 5); // bottom right petal
          u8g2.drawCircle(58, 35, 5); // top left petal
          u8g2.drawCircle(70, 35, 5); // top right petal
      } // end if else
} // end flowerFace

void plantStatus(){
      u8g2_prepare();

      switch(page){
          case 0: plantStatusBar(); break;
          case 1: flowerFace(); break;
      }
} // end plantStatus

Testing and Shortcomings

Testing

We Tested KEITH’s water pump and soil moisture reading mapping with several different threshold values to try and make sure the range we selected was realistic for the home environment in order to optimise the display to make it more readable for the user as well as to optimise the amount of water KEITH pumps to the plant as there is slight latency in the system.
We rigorously tested all our sensors with both expected and extreme values in order to make sure they were all working well, in the process we discovered some sensors were faulty and replaced them.

Shortcomings

Our aim with KEITH was to make a household friendly plant caretaker. Unfortunately due to time limitations we didn’t get to implement a manual varying of thresholds to allow the user to fine tune KEITH and instead we set more general thresholds which will be suitable for most houseplants but may not be suitable for more exotic or unusual varieties.
KEITH is not weatherproof and is only suitable for indoor use.
KEITH is also limited on his modularity, he is only suitable for one plant at any given time due to how the system is set up.