Ana’s Long Distance Hug Plush

Everyone has someone they miss. Maybe it’s distance, maybe it’s conflicting schedules, but seeing loved ones in adulthood is hard. If you miss someone and want to get love and spread some love, here’s how! Instructables Link

SHOPPING LIST

To make this project, you will need 2x of each:

Electronics:

  1. Adafruit MPRLS Ported Pressure Sensor Breakout – 0 to 25 PSI
  2. Adafruit ESP32-S3 Reverse TFT Feather – 4MB Flash, 2MB PSRAM, STEMMA QT
  3. Lithium Ion Polymer Battery – 3.7v 2500mAh
  4. Silicone Tubing for Peristaltic Liquid Pump – 1 Meter

Fabric:

  1. Line Texture Fabric
  2. FUZZY Fluffy sweater

Plus these tools:

  • Soldering tools and supplies
  • Silicone adhesive
  • Hot glue gun with glue sticks

Circuit Diagram

The Adafruit MPRLS Ported Pressure Sensor Breakout and Li-ion battery are attached to the Adafruit ESP32-S3 Reverse TFT Feather.

Attach Tubing to Sensor

Make sure to use a silicone adhesive when attaching the tube to your sensor, because the only thing that makes silicone stick is silicone. 

I personally had a lot of trouble with this one. The first one attached like bread to butter, perfection! The second tube on the other hand….. Messy.

Connect to Arduino IoT Cloud

In order to connect my board, I created a boolean variable for my Thing through the Arduino IoT Cloud. By inputting my network and device information within the code, I was able to connect.

Patterns & Sewing

For the patterns, I was originally going to make a stingray and an octopus, but due to time constraints, I am going with my mom’s favorite shape, a triangle!

Genuinely making the pattern to sew for this was pretty intuitive. I just cut out two large triangle pieces then cut out the strips that go in between the two triangles to create volume.

Hug Code

// Long Distance Hug by Ana Jay, code from Parihug IoT Hug project by Xyla Foxlin, adapted 2023 & 2024 by Becky Stern

// Watch the video: https://youtu.be/u6gj8VzrHBo

// Tutorial: https://beckystern.com/2023/11/27/hug-sensing-iot-parihug-toy-w-xyla-foxlin/

// This code is in the Public Domain

#define SECRET_SSID "Internet of Things Class"

#define SECRET_OPTIONAL_PASS "iheartarduino"

#define SECRET_DEVICE_KEY "gg0N8MV!wlYjIqlA8m#Db@yW@"

#include <ArduinoIoTCloud.h>

#include <Arduino_ConnectionHandler.h>

#include <Adafruit_GFX.h>    // Core graphics library

#include <Adafruit_ST7789.h> // Hardware-specific library for ST7789

#include <SPI.h>

// Use dedicated hardware SPI pins

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);

const char DEVICE_LOGIN_NAME[]  = "15f3eccb-0c6f-46a8-8ef1-183a610a3a3c";

const char SSID[]               = SECRET_SSID;    // Network SSID (name)

const char PASS[]               = SECRET_OPTIONAL_PASS;    // Network password (use for WPA, or use as key for WEP)

const char DEVICE_KEY[]  = SECRET_DEVICE_KEY;    // Secret device password

void onHugChange();

bool hug;

void initProperties(){

 ArduinoCloud.setBoardId(DEVICE_LOGIN_NAME);

 ArduinoCloud.setSecretDeviceKey(DEVICE_KEY);

 ArduinoCloud.addProperty(hug, READWRITE, ON_CHANGE, onHugChange);

}

WiFiConnectionHandler ArduinoIoTPreferredConnection(SSID, PASS);

#include <Wire.h>

#include "Adafruit_MPRLS.h"

// You dont *need* a reset and EOC pin for most uses, so we set to -1 and don't connect

#define RESET_PIN  -1  // set to any GPIO pin # to hard-reset on begin()

#define EOC_PIN    -1  // set to any GPIO pin to read end-of-conversion by pin

Adafruit_MPRLS mpr = Adafruit_MPRLS(RESET_PIN, EOC_PIN);

void setup() {

 // Initialize serial and wait for port to open:

 Serial.begin(9600);

 //pinMode(12, OUTPUT);

 // This delay gives the chance to wait for a Serial Monitor without blocking if none is found

 delay(1500);

 // Defined in thingProperties.h

 initProperties();

 // Connect to Arduino IoT Cloud

 ArduinoCloud.begin(ArduinoIoTPreferredConnection);

 /*

    The following function allows you to obtain more information

    related to the state of network and IoT Cloud connection and errors

    the higher number the more granular information you’ll get.

    The default is 0 (only errors).

    Maximum is 4

 */

 setDebugMessageLevel(2);

 ArduinoCloud.printDebugInfo();

  Serial.println("Testing MPRLS sensor...");

 if (! mpr.begin()) {

   Serial.println("Failed to communicate with MPRLS sensor, check wiring?");

   while (1) {

     delay(10);

   }

 }

 Serial.println("Found MPRLS sensor");

 // turn on backlite

 pinMode(TFT_BACKLITE, OUTPUT);

 digitalWrite(TFT_BACKLITE, HIGH);

 // turn on the TFT / I2C power supply

 pinMode(TFT_I2C_POWER, OUTPUT);

 digitalWrite(TFT_I2C_POWER, HIGH);

 delay(10);

 // initialize TFT

 tft.init(135, 240); // Init ST7789 240x135

 tft.setRotation(3);

 tft.fillScreen(ST77XX_BLACK);

// large block of text

 tft.fillScreen(ST77XX_BLACK);

 testdrawtext(

     "Booting hugs... ",

     ST77XX_WHITE);

 delay(1000);

tft.fillScreen(ST77XX_BLACK);

 Serial.println(F("Initialized"));

}

void loop() {

 ArduinoCloud.update();

  float pressure_hPa = mpr.readPressure();

 Serial.print("Pressure (hPa): "); Serial.println(pressure_hPa);

 Serial.print("Pressure (PSI): "); Serial.println(pressure_hPa / 68.947572932);

   if (pressure_hPa > 1100){

   hug=true;

   Serial.println("Hug = true");

 //    Serial.println("buzz buzz loop");

 //  digitalWrite(12, HIGH);

 //  delay(1000);

 //  digitalWrite(12, LOW);

 // large block of text

 tft.fillScreen(ST77XX_BLACK);

 testdrawtext(

     "Hugs! I love you. ",

     ST77XX_WHITE);

 delay(5000);

 tft.fillScreen(ST77XX_BLACK);

 }else{

   hug=false;

   Serial.println("Hug = false");

 }

 delay(1000);

}

/*

 Since Hug is READ_WRITE variable, onHugChange() is

 executed every time a new value is received from IoT Cloud.

*/

void onHugChange()  {

 if(hug==true){

  Serial.println("onHugChange has been called");

 //  digitalWrite(12, HIGH);

 //  delay(1000);

 //  digitalWrite(12, LOW);

   tft.fillScreen(ST77XX_BLACK);

 testdrawtext(

     "Hugs! I love you. ",

     ST77XX_WHITE);

 delay(5000);

 tft.fillScreen(ST77XX_BLACK);

 }

 }

void testdrawtext(char *text, uint16_t color) {

 tft.setCursor(0, 0);

 tft.setTextColor(color);

 tft.setTextWrap(true);

 tft.print(text);

}

FINAL VIDEO

Sofia’s Final Synth

Ready to build your very own synth but don’t know where to start? No worries – you’re in the right place!

 Welcome to the Fish Synth Docs, your step-by-step guide to creating the Fish Synth! This unique synth comes with a convenient strap, making it easy to take your sound on the go for all your events. 

It features 3 adjustable dials, sound-controlling buttons, and a headphone jack for personal listening. Plus, it has a pedal plug for connecting other effects and creating a daisy-chain setup. Let’s dive in and get started!

WHAT YOU’LL NEED

HOW TO BUILD

Step 1: Order the DaisySeed and Wait for Delivery
The first step in building your Fish Synth is to order the DaisySeed online. This component, which acts as the “brain” of your synth, is where all the code will be loaded. Be patient as it will take some time to arrive from California.

Step 2: Choose Your Effects
While waiting for the DaisySeed to arrive, start planning what effects you want your synth to have. Explore the DaisySeed coding library to find the effects that suit your needs. Once you’ve selected the desired effects, you’ll need to wire them to the appropriate switches.

Dial 1 – Switch Sound Effect

Dial 2 – Volume

Dial 3 – Miscellaneous / Tone

Button 1 – On/Off

Button 2 – Chord C major 7

Button 3 – Chord G major 7

Button 4 – E major 7

Step 2.5: Set Up Daisy Seed and Code

When using Arduino for coding, it is essential to follow the DaisyDuino Set-Up Guide. A variety of video tutorials are available on the ElectroSmith YouTube channel, as well as a comprehensive Start-Up guide on GitHub.

Start-Up Tips:

  1. Ensure the “Extra Step” STM32 package is downloaded, as it is crucial for the setup. If unable to obtain it, request it from another source.
  2. In Arduino, select “DFU” as the upload method.
  3. It may be necessary to press and hold the Boot button while pressing the Reset button a few times to allow Arduino to properly recognize the board.

To code the effects, start by reviewing the multiple Daisy Seed examples available in the Arduino environment. 

 The goal is to combine the relevant portions of each example into a single, cohesive file.


By doing this, you’ll be able to tailor the code to your specific needs and create the desired effects. The example code is available through the link provided below, offering a starting point to help guide the process.

Step 3: Solder Buttons, Dials, and Plugs
Begin by soldering the various buttons, dials, and plugs onto the board. Ensure you connect the correct wires to the outside dials so they correspond to the effects you wish to control. Take your time to ensure each connection is accurate.

Step 4: Create the Case
You have two options for the case:

  • 3D Print the Case: Use the provided file to 3D print your case. If you don’t have access to a 3D printer, check with your local public library to see if they offer printing services. This file was made with TinkerCAD.
  • Cardboard Case: Alternatively, you can fold a custom cardboard case. If you choose this route, follow the instructions for cardboard assembly provided below. Note that, regardless of the case type, only the placement of knobs and buttons matters.

Step 5: Wire the External Components
Solder the switches, dials, and other external components using wires. Ensure that all switches and dials are connected properly to the board and that they align with the designated holes in the case.

Step 6: Assemble the Synth Case
Once everything is wired correctly, screw the components into the case. Double-check that all connections are secure before moving on.

Step 7: Test the Synth
Before sealing the case by drilling or gluing it shut, test the synth to ensure everything is working properly. This is your last chance to make adjustments if needed.

Step 8: Add a Strap
For convenience, sew a bag strap using any fabric you have available. A jewelry chain was used in this example!

Step 9: Final Steps
Congratulations! The Fish Synth is now complete. You should have a better understanding of musical synthesizers and can start creating music! Enjoy the process and the sounds you create!

Retrospective:

Do not do audio. Do not do audio. DO not do audio. DO not do audio. Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.Do not do audio. Do not do audio. DO not do audio. DO not do audio.

  1. Find way to attach buttons to case
  2. Cut breadboard to fit in case
  3. Adjust code to actually sound good

Company Pitch:

The Fish Synth is a DIY, portable synthesizer designed for on-the-go music creation and exploration. This compact, user-friendly device allows enthusiasts to build their own unique synth by assembling the components, offering a hands-on experience for both beginners and experienced creators. With its battery-powered design, the Fish Synth is perfect for spontaneous jam sessions, street performances, or personal audio experimentation, providing a versatile range of sounds and effects. Its easy-to-customize features and portable nature make it an ideal tool for music lovers who want to enjoy creative synthesis anytime and anywhere.

https://www.instructables.com/Build-Your-Own-Synth

🎶✨ Introducing the Fish Synth! 🎹 A DIY, portable synthesizer that lets you build your own unique sound and take it on the go. Perfect for spontaneous jams, street performances, or just vibing wherever you are! 🚀🔊

Easy to assemble, fun to customize, and ready for any adventure. Get yours and start creating music on the move! 🎧💡

#FishSynth #DIYMusic #PortableSynth #MusicOnTheGo #CreateEverywhere

Tong’s Final Project

When you want to build a habit or achieve a goal, you can use this box I designed to help! Our box has 7 switches, and each day you complete a task, you can flip one switch. After successfully completing tasks for 7 consecutive days, the box will release colorful confetti to celebrate! It encourages you to cultivate your habits in 7-day cycles.

Video

Mode

Here’s how the circuit works:

7 Switches: Each switch corresponds to an LED. When a switch is toggled, it lights up the respective LED, indicating that the task for the day is completed.

UNO Board: All switches and LEDs are connected to an Arduino UNO board, which monitors the status of the switches. The Arduino ensures the logic for tracking task completion across the 7-day cycle.

Electromagnet: The electromagnet is also connected to the Arduino. When all 7 switches are toggled (indicating the completion of the 7-day cycle), the UNO board cuts power to the electromagnet, causing it to lose its magnetic hold and release the iron piece attached to a balloon. This action releases colorful confetti to celebrate the achievement.

Here is my code:

int celebrationState = false;
int previousCelebrationState = false;

void setup()
{
pinMode(5, INPUT_PULLUP);
pinMode(6, INPUT_PULLUP);
pinMode(7, INPUT_PULLUP);
pinMode(8, INPUT_PULLUP);
pinMode(10, INPUT_PULLUP);
pinMode(11, INPUT_PULLUP);
pinMode(12, INPUT_PULLUP);

pinMode(4, OUTPUT); // 控制EG的引脚

digitalWrite(4, HIGH); // 默认保持EG通电

Serial.begin(9600);
}

void loop()
{
bool sunday = digitalRead(12);
bool monday = digitalRead(11);
bool tuesday = digitalRead(10);
bool wednesday = digitalRead(8);
bool thursday = digitalRead(7);
bool friday = digitalRead(6);
bool saturday = digitalRead(5);

// 检查所有灯是否亮了(所有输入为LOW)
if (sunday == LOW && monday == LOW && tuesday == LOW && wednesday == LOW && thursday == LOW && friday == LOW && saturday == LOW) {
celebrationState = true;

if (celebrationState == true && previousCelebrationState == false) {

  // 切断EG电源
  digitalWrite(4, LOW);
}

} else {
celebrationState = false;

digitalWrite(4, HIGH);

}

previousCelebrationState = celebrationState;
}

Instructables Link

https://www.instructables.com/HabitSpark-7

Haosen’s Final Project

My final project is inspired by one of my favorite movies, Ponyo on the Cliff by the Sea. The brave Ponyo from the film left a deep impression on me. My product is called the “Ponyo Night Light.” It can automatically adjust its brightness based on the surrounding light levels, saving users the hassle of manual adjustments. It also solves issues such as the night light being too dim or forgetting to turn it off after sunrise.

Instructables Link

https://www.instructables.com/PonYo-Night-Light

Let the video Talk

Arduino Function:

My code:

Reflection:

During the soldering process, I failed countless times, which taught me the importance of patience. If I were to further improve my project, I would first add more seaweed to the base. Additionally, I would include an alarm clock feature to remind people to wake up when the light is turned off. Thank you, everyone!

Eva ‘s library Light — ZipLight

I’m super excited to share my latest project: a smart lamp that reacts to sound! It’s not just any lamp though; it’s a lamp that lights up when it detects noise. So why did I decide to build this? Well, I’m someone who tends to talk or make noise in quiet places like libraries. I often wish there was a way for someone to subtly remind me that it’s not the best time to chat. That’s where the idea for this lamp came from. I thought, what if I could create a lamp that reacts to sound and gives me a little “warning” when I’m being too loud? This idea turned into a fun and challenging project that I’m so proud of!

The Process

I started by modeling the lamp in three parts: the lamp shade, the stand, and the connector. Once that was done, I began setting up the circuit. I initially used an Arduino Nano, but ran into issues, so I switched to an Arduino Uno. After that, I connected the sound sensor, but it wasn’t working right at first. After a bit of trial and error, I replaced the sensor, and everything clicked! The circuit finally worked, and I was so relieved!

Assembly was tricky too. The soldering was delicate, and I spent quite a bit of time ensuring everything was securely connected. With help from friends, I managed to get everything put together, and the lamp was ready to go!

Here is my code

#define SOUND_SENSOR_PIN 2    // Sound sensor connected to digital pin 2
#define LED_STRIP_PIN 9       // LED strip connected to digital pin 9

void setup() {
  Serial.begin(9600);           // Start serial communication
  pinMode(SOUND_SENSOR_PIN, INPUT);  // Sound sensor as input
  pinMode(LED_STRIP_PIN, OUTPUT);   // LED control pin as output
  digitalWrite(LED_STRIP_PIN, HIGH);  // Ensure LED is off by default
}

void loop() {
  int soundDetected = digitalRead(SOUND_SENSOR_PIN); // Check sound sensor

  if (soundDetected == HIGH) { // If sound is detected
    Serial.println("Sound detected! Blinking the LED strip...");
    for (int i = 0; i < 10; i++) { // Blink the LED 10 times
      digitalWrite(LED_STRIP_PIN, LOW);  // Turn LED on
      delay(100);                       // Wait 100ms
      digitalWrite(LED_STRIP_PIN, HIGH); // Turn LED off
      delay(100);                       // Wait 100ms
    }
  } else {
    digitalWrite(LED_STRIP_PIN, HIGH); // Keep LED on if no sound
  }

  delay(100); // Delay to avoid fast detection
}

https://www.instructables.com/ZipLight

(Thank you QI and Haosen!!!!!)

sophia’s final rotating pill lamp

we did it. we made it to the end. here is my final rotating pill lamp that I am incredibly excited to share with you all 🙂

here is “A Tough Pill to Swallow” … I really liked this name at first but wasn’t sure if it was too serious so for the sake of the product title on Instructables it is “Rotating Pill Lamp”

This project is a large pill-shaped lamp that reminds users to take their medicine. When the pill lamp is rotated 180 degrees the lamp turns off and then when rotated again it will turn back on. This links the action of turning off the lamp before going to sleep with taking one’s pills before bed. This lamp is a great way to remember to take your medicine while also adding a unique light to any room!

Step 0: Sketch it Out!

Step 1: Parts, Tools, and Materials

Step 2: 3D Modeling 

Step 3: Paper Mache

Step 4: Circuit Diagram and Code

#include <Adafruit_NeoPixel.h>

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN    5

#define SENSOR_PIN    3

// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 12

// Variables will change:
int buttonPushCounter = 0;  // counter for the number of button presses
int buttonState = 1;        // current state of the button
int lastButtonState = 0;    // previous state of the button

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)

void setup()
{
  pinMode(SENSOR_PIN, INPUT_PULLUP);
  //pinMode(LED_BUILTIN, OUTPUT);
  
  strip.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)
  strip.show();            // Turn OFF all pixels ASAP
  strip.setBrightness(175); // Set BRIGHTNESS to about 1/5 (max = 255)
  
  Serial.begin(9600);
}

void loop()
{
  // read the state of the pushbutton value
  buttonState = digitalRead(SENSOR_PIN);
  
  
    // compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == LOW) {
      // if the current state is LOW then the button went from off to on:
      buttonPushCounter++;
      Serial.println("on");
      Serial.print("number of button pushes: ");
      Serial.println(buttonPushCounter);
      colorAll(strip.Color(  255,   25, 25));
      delay(2000);

    } else {
      // if the current state is LOW then the button went from on to off:
      Serial.println("off");
      colorAll(strip.Color(  0,   0, 0));
      delay(2000);
    }
    // Delay a little bit to avoid bouncing
    delay(50);
  }
  
  // save the current state as the last state, for next time through the loop
  lastButtonState = buttonState;
}

// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
  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);                           //  Pause for a moment
  }
}

// Fill strip with a color without animating. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above).
void colorAll(uint32_t color) {
  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
}

Step 5: Circuit Construction 

Step 6: Assemble and Enjoy!

I chose to go with a bright pink for my pill lamp but the beauty of this lamp is that it is customizable and can be changed at any time by editing the code. This lamp creation is still an ongoing process so I would love any feedback for those reading. My goal is to add strong magnets in the top and bottom of the pill and the base as it is a little top-heavy, but please let me know if there is anything else you would add! Thank you!

Instructables: https://www.instructables.com/Rotating-Pill-Lamp

I learned a lot from this experience. I think the top 3 were first that things always go wrong. You have to have the patience and the time because you will make mistakes and need to pivot and do something different. second is that you can’t be a perfectionist when making a prototype it will never be exactly what you see in your head. third is that I need to be proud of the work that I do and the effort I put into it. I am still trying on that one.

Thanks 🙂

Qi‘s Final Project

Introduction

Do you listen to music with Bluetooth earphones—on the road, on the subway, in the classroom…? When you’re listening to music, do you ever find it difficult to hear the sounds around you? When others try to talk to you, they may not realize you’re using Bluetooth earphones, and you can’t hear them. This can lead to awkward situations and misunderstandings.

My product is a stylish headset-style ear accessories with a fashionable design and blinking lights. When you’re listening to music, simply wear them to signal to others—”I’m using Bluetooth earphones and can’t hear you. If you want to get my attention, please tap my shoulder.”

Process and light

The main body of the product is made using 3D printing, and after printing, it is processed with colored cellophane. Then, I attach the main body to the ear hook, which supports the weight of the product.

Regarding the lighting, I have set up three lighting modes, which can be switched using a touch sensor. People can choose different lighting modes according to their preferences, and this is the customizable feature of the product.

Blue and Green Flashing with Meteor effects
White Flashing Light
Dark and light pink Flashing with water effect

Instructables

https://www.instructables.com/FlashTone-lighting-Airpods-Earring

Story for project

Development

There are several aspects to explore for the future development of the project.

First, improving the user experience. Currently, my ear accessories are quite heavy due to the many components inside. In the future, I hope it can become lighter and more comfortable to encourage people to wear it.

Second, the product could have more diverse shapes. Right now, it is a functional product, but I believe it can integrate with fashion and styling, becoming a part of people’s accessories.

Third, the current lighting requires users to switch modes using the touch sensor. I hope that in the future, the lighting can change color and rhythm based on different songs, making the product more intelligent.

Conclusion

In conclusion, this is a great and innovative start. It encourages us to incorporate lighting elements into everyday wearable accessories, creating more possibilities for wearable designs. Throughout this project, I learned a lot about soldering, sewing, and Arduino programming, which will be very helpful for my future product designs. Although I faced many challenges this semester, my classmates and teachers supported me, and I learned a lot from them.

Qian Jessie Wang’s Final Project

Designer: Qian Jessie Wang

Introducing the vibrant and interactive airplane meal tray, designed to enhance the dining experience of air travelers with a delightful visual reward system. As you enjoy your meal, each dish you finish triggers a delightful Led light show of your personal meal tray, celebrating the passenger’s accomplishment. This feature is designed to encourage meal completion, which helps in reducing food wastage and providing a satisfying mealtime experience.

Photo Credit: BingDuo Liu (ADA)

Embrace a new era of in-flight dining with SkyBites, where technology and tradition blend seamlessly to deliver a memorable sky-high culinary adventure.

Materials / Tools List:

  • 3D printing PLA (Polylactic Acid)
  • Photoresistors
  • Led strip
  • Solderful breadboard
  • Soviet red gloss spray paint
  • Portable Charger
  • Wires
  • Arduino Uno

Modeling with Rhino and 3D Printing.

Circuit Connection using Arduino Nano ESP32, a photoresistor was employed to achieve functionality where removing an obstruction causes the LED strip to light up, enhancing the user interaction with the tray. Challenges with Soldering the Circuit Board; Switching to Arduino Uno.

Attach the photoresistor to the underside of the meal tray using a strong adhesive.

Instructables: https://www.instructables.com/SkyBites-Qian-Jessie-Wang

Video Credit: EVA

Behind the scene: spray paint

TWA hotel (Connie Cocktail Lounge): MCR and MORSE Development have reignited the magic of Eero Saarinen’s landmark 1962 TWA Flight Center at JFK Airport, restoring and reimagining it as a first-class hotel. At the center of the hotel is Eero Saarinen’s iconic TWA Flight Center, where restaurants, bars and retail outlets have taken flight. Two hotel wings, designed to reflect and defer to the landmark TWA Flight Center, sit behind the historic building and contain 512 guestrooms with views of JFK’s runways and the TWA Flight Center.

https://drive.google.com/file/d/1E6X5NXKp-BM1UhNvETkA334aC9Z1eEF1/view?usp=drive_link

Monty’s Ferry Schedule Ticker – Final

If I had more time, I would have made a shorter video.

New York, New York, it’s a wonderful town. The Bronx is up, and the Battery’s down! The people ride in a hole in the ground… and sometimes, on the water. (Lyrics from New York, New York, On The Town, 1949)

In this project, I iterated on the concept of a subway clock and created a version that displays the current schedule of the NYC ferry— for those who ride in style!

This product was created for my boyfriend who takes the ferry from the same stop every day to get to work. The design incorporates a perpetual scroll display that shares the next 3 departure times from his stop (North Williamsburg). He can glance over at the ferry times in the morning and determine which ferry to catch, and whether to walk, bike, or skateboard to catch his ferry. Using this clock reduces the likelihood that he will be distracted when looking up the schedule on the NYC Ferry’s mobile app. It’s a great way to start the day for anyone who relies on the ferry schedule with regularity 🙂 

My Instructables Project

https://www.instructables.com/NYC-Ferry-Schedule-Ticker-Clock

The Idea

Image source.
This project was inspired by a subway clock I saw at a friend’s house– and I have since discovered a few Arduino projects that recreate this product.

Prototype circuit and form

I sketched a few ideas for the encasement– some using corrugated wavy plastic (it’s giving waves!), others using acrylic sheets. I designed the case to fit in a very specific space on my boyfriend’s desk, and ultimately mis-measured 😀 when I cut the final. I used a 1/8″ pearlescent blue acrylic from Canal Plastics, and landed on a tab and slot pattern which I cut with a laser cutter in the VFL.

Materials

The materials that I used for this project are as follows:

  1. Arduino ESP32
  2. Arduino UNO and a solderless breadboard
  3. 1 16×32 LED RGB matrix
  4. 5V / 2A power cable
  5. jumper wires
  6. soldering equipment
  7. Acrylic sheets for the encasement (I used this!)
  8. A laser cutter

Setting Up The Display


Initially, I had planned to use an ESP32 to run my RGB matrix display and make my API call. However, because of the power requirements of the display, I switched to an Arduino UNO and a breadboard to provide the extra grounding required.

I used the Adafru.it RGB Matrix tutorial to get my display set up and working. I followed the pinout guides and wiring in the Connecting with Jumper Wires tutorial for the RGB matrix in order to create my circuit, making sure to adjust as specified in the tutorial for the UNO. Then I ran the test code examples to make sure my circuit was working and to get familiar with how to program the display.

After testing that my circuit was working, I began to customize the text on the display.

Display Circuit Construction & Code

👉 In general, staring at an LED display for hours on end at all times of day/night can be hard on the eyes, so the first thing I’d recommend doing while you’re tweaking your code is changing your text to red which is less abrasive. 👈

The following libraries are required for this project. When you install them, make sure to install their dependencies too 🙂 

  1. RGB Matrix Panel x Adafruit (all the functions I needed to control my display)
  2. Adafruit GFX. Adafruit GFX library has a bunch of fonts that you can import and use to customize your display. You can futz with the cursor’s starting position depending on the height of the font. 
  3. The Adafruit Protomatter library is designed to make the LED matrix display work with the ESP32. As I mentioned, I had some issues with voltage and also connecting the ESP32 and the display, so ultimately I didn’t use this library. But maybe you’ll have better luck 🙂

For my code, I used the scroll_text_16x32 sketch from the RGB matrix panel example, and customized from there:

  1. Thinking ahead to the information I wanted my ferry clock to display, I hardcoded in an example message so that I could make aesthetic adjustments to accommodate the desired text.
  2. I tried out some different fonts for the text using the GFX library mentioned above, ultimately landing on FreeSans 9pt 7b.
  3. Out of the box, text on the display zooms by very quickly, so incorporating a scroll delay was important for legibility. I introduced the delay as a variable upfront and then called it directly in my loop(), working from the code in this forum post.
  4. I adjusted the position of the cursor for optimal legibility of the text on the display.
  5. I changed the color of my text to blue, to go with the case that I designed for it.

This sketch allowed me to finish a “looks like” prototype, which served as a guide for me when it came to incorporating real data from the NYC ferry schedule.

// scrolltext demo for Adafruit RGBmatrixPanel library.
// Demonstrates double-buffered animation on our 16x32 RGB LED matrix:
// http://www.adafruit.com/products/420
// DOUBLE-BUFFERED ANIMATION DOES NOT WORK WITH ARDUINO UNO or METRO 328.

// Written by Limor Fried/Ladyada & Phil Burgess/PaintYourDragon
// for Adafruit Industries.
// BSD license, all text above must be included in any redistribution.

#include <Arduino.h>
#include <RGBmatrixPanel.h>
#include <Fonts/FreeSans9pt7b.h> // best: matrix.setCursor(textX, 12) cuts of fragmented pxls at top

#define CLK  8 
#define OE   9
#define LAT 10
#define A   A0
#define B   A1
#define C   A2

// Last parameter = 'true' enables double-buffering, for flicker-free,
// buttery smooth animation.  Note that NOTHING WILL SHOW ON THE DISPLAY
// until the first call to swapBuffers().  This is normal.
RGBmatrixPanel matrix(A, B, C, CLK, LAT, OE, false);

// Similar to F(), but for PROGMEM string pointers rather than literals
#define F2(progmem_ptr) (const __FlashStringHelper *)progmem_ptr

const char str[] PROGMEM = "ER S at N WBURG in 9min...17 min...29 min..."; //hardcode in example text
int16_t textX = matrix.width();
int16_t textMin = (int16_t)sizeof(str) * -12;
uint16_t hue = 0;

const uint8_t CHAR_SPACING = 1;
const uint8_t SCROLL_DELAY = 5; // Adjust for speed control


void setup() {
  matrix.begin();
  matrix.setTextWrap(false); // Allow text to run off edges
  matrix.setFont(&FreeSans9pt7b); // Set the custom font
  // matrix.setTextColor(matrix.Color333(7, 0, 0)); // Set text color to red while debugging
  matrix.setTextColor(matrix.Color333(0, 0, 7)); // Set text color to blue 
}

// void loop() with slow down
void loop() {
  // Clear background
  matrix.fillScreen(0);

  // Set the text cursor + print the string
  matrix.setCursor(textX, 12); // Position text (for use with custom font size 9pt)
  matrix.print(F2(str));

  // Move text left (w/wrap)
  if ((--textX) < textMin) textX = matrix.width();

  // Update display
  matrix.swapBuffers(false);

  // Add delay to control scroll speed
  delay(SCROLL_DELAY); // Adjust this value to control the speed. Larger value = slower scroll
}

GETting the Background on GET Requests

The New York City Ferry Service uses GTFS (General Transit Feed Specification), which is a standard format for sharing transit system data. You can read more about GTFS here. This makes it possible for us to get an up-to-date ferry schedule by making an API call.

In order to work with GTFS directly, you need to spin up a server to manage the rate/volume of data when you make your query. (Follow Robert Boscacci’s subway clock tutorial for steps.)

However, after digging around on the internet, I found Transit.Land— an open data platform that collects GTFS and other open data feeds from transit providers around the world. Transitland makes all of this data queryable via REST APIs. There are feeds from over 2,500 operators in over 55 countries, including the NYC ferry!

I read through the Transit.Land documentation, and started to decode the the key/value pair data for ferry stops and ferry routes from the source feeds. I created an account on Interline.co to get a secure API key. Armed with my API key, I started to get to work on the program for my ESP32.

ESP32 API Call Code

Writing the API call and parsing the JSON data was the most complicated part of this project, and required a lot of research. I watched this video, read through ArduinoJSON’s deserialization documentation, and read this tutorial on GET requests, and got a lot of help from @Beckathwia.

We looked at Transitland’s REST API documentation for departures. This outlined how to specify which date we were looking for, and all of the other parameters necessary to include in the call.

I discovered that the returned payload only includes the next 20 departure times from any given stop. If you don’t specify a time, it gives the first 20 departure times for that day. So, I needed to pass in the current time in order to get the upcoming departure times. We did this (thanks @Beckathwia) via concatenation. Here’s a helpful guide.

I used Network Time Protocol to get the current time (more info here), and we defined variables for the base URL, and the current time above the setup(), and then concatenated them together in the loop():

String serverName = "https://transit.land/api/v2/rest/stops/s-dr5rsvh2hf-northwilliamsburg/departures?apikey=X77sYbAjffC4kXqNHkavDFY0mY2hUPP4&relative_date=today&start_time=";

WiFiClientSecure client;
char currentTime[9]; // Buffer to hold HH:MM:SS

// later, in void loop():
String serverPath = serverName + currentTime;

The final code attached here calls the API, parses the returned JSON file, and then prints to the Serial monitor the departure time of the next ferry departing from the station that is specified in the API call parameters.

What this code does not do yet is use Software Serial to connect the ESP32 to the UNO to pass the data along to be displayed on the matrix.

Make the Box

For this design, I went with a tab and slot box because I always find it beneficial to be able to revisit my circuits if I want to improve them in the future, and a tab and slot design avoids the need for glue.

I created a simple vector design for my box in Adobe Illustrator before I learned about MakerCase, which is a web tool that instantly creates box templates for laser cutters from a set of input dimensions. I recommend using MakerCase instead of DIYing it unless you’re hoping to make something really custom 🙂

The file for the encasement I created is attached if you’d like to use it! I had initially planned to include 2 rotary switches in my design, to allow the user to rotate through routes and stops, so there are some holes in the top panel to accommodate those. There is an exit hole in the back panel for the power cord. Everything else (my UNO and all of my cables) fits snugly inside behind the display which serves as the front of the box.

I cut the pieces out of a pearlescent blue acrylic which gives off the feeling of waves. It might not be an accurate depiction of what the East River water looks like, but hey, it’s aspirational 😉

^ the pattern I created in Adobe Illustrator for my tab and slot encasement.

Retrospective & Next Steps:
Software Serial & Soldering (still)

What I learned:

This project was a fantastic refresher on coding in general. It was great to be able to dig into documentation and work at putting the pieces together.

Unfortunately, I wasn’t able to figure out how to pass the results of my API call to my UNO for display. I ran into issues handling some of the time elements, passing messages into program memory, and passing multiple strings to be displayed in sequence on my display. The summary of the steps that remain are as follows:

  1. I need to link up my ESP32 and my UNO, so that the ESP32 can call the API, get the next 3 departure times, and pass them as a message via Software Serial to the UNO to display on the matrix.
  2. Solder my circuits! Right now my display circuit is sitting nicely inside my acrylic box, but it’s not permanent, and I can change that by soldering my ESP32 to a perf board, and soldering my UNO — but this has to wait for the previous step.

Lynn’s Puppy Toy Reacts to Your Call

Creating an interactive plush puppy is an exciting project. Imagine a cuddly companion that’s more than just a soft toy – one that can actually respond to your voice and move toward you!

This project will guide you through designing a unique interactive pet that combines simple mechanical engineering with innovative technology. By integrating Arduino boards, motors, and microphone amplifiers, we’ll transform an ordinary plush toy into a charming, responsive friend that brings a touch of magic to your home.

Here’s the final Instructable post :

https://www.instructables.com/Puppy-Toy-That-Reacts-to-Your-Call

A video shows how it works.

Social Media Messaging Samples:

Caption:
🐾✨ Meet the smartest dog toy ever! This interactive plush responds to your call, just like a real pet. 🐶💡 Plus, it’s DIY! Build it yourself and customize it!
📹 Watch the video to see how it works, and tap the link in the comment for step-by-step instructions.
#InteractiveToy #DIYToy #TechForFun #ArduinoProjects #ArduinoDiy