Category: Final Project

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

• eSun PLA Filament 1.75mm
• Tilt ball switch
• Arduino Nano ESP32 Board
• 2 NeoPixel Stick
• A power cable
• 3D printer
• Wiring
• Solder
• Soldering tools
• Solder-able Breadboard
• Tracing Paper
• Elmers Glue & Water
• Plastic Bowl
• Masking Tape
• Petroleum Jelly
• Paper Towels
• X-Acto Knife
• Hot Glue Gun
• Modge Podge Acrylic Sealer Spray (optional)

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 🙂

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. A 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.

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

I’m bad at sports betting so I made a Magic 8-Ball to recommend bets for me. For all the ink that has been spilled over how to lock in a sure-fire bet, the fact of the matter is that even the most successful sports bettors in the world only hit on 60% of their bets. When we can’t trust our gut and we can’t trust logic, we might as well outsource these decisions to machines and let the fates decide.

Here’s how it is intended to work: With an integrated vibration sensor, the device detects when a person is shaking the object and queries ChatGPT through an API Key with a prompt that asks ChatGPT to scour the daily betting markets and identify inefficiencies in the market that can be exploited. This takes into account betting markets, performance trends, opponent analysis, and similar game scenarios to identify one bet at a time. I was able to complete a prototype that surfaces a random bet, because I had trouble with OpenAI’s terms of service. With more experimentation with the prompt, I believe this would work as designed. My goal for this project was to immerse myself in AI tools so that I can begin to understand how they can be best integrated into devices.

Improvements:

I decided to add a Draftkings Sportsbook vinyl sticker to make the 8-ball look more legitimate. Going forward, I would probably use a more sensitive vibration switch because the medium-strength switch requires a very firm shake.

Instructables Link

Video Storyboard

Timing is really important for this video to pick up views. I am going to film and post this during Sunday NFL Football and the video will be submitted before Dec 17th.

Sample Social Media Post to IG/Reddit:

“buddy cracked the code. magic 8-ball that tells you what bets to place @draftkings @houseofhighlights @barstoolsports”

Well I did it!!

Honestly I thought this would be a somewhat manageable project, however I was very very wrong. This project caused me so much frustration and took almost double the amount of time I had anticpated.

Okay now that I’ve gotten that out of the way let me introduce you to Acceptus!

Idk why this photo always look so low quality when uploading to the internet…

Introducing the Acceptus wall sconce—an organic, sculptural lighting solution designed to transform your home’s ambiance. This innovative sconce mounts seamlessly on any wall, creating an instant welcome as you enter a room. Perfect for those weary from long workdays, especially during the dark and cold winter months when returning home can feel uninspiring.

The Acceptus features intelligent motion-sensing technology that brings warmth and comfort to your living space. As you open the door or walk by, the sconce detects your presence, gently fading on to create a soft, inviting glow. No more harsh overhead lights or dark, unwelcoming entryways—just a subtle, comforting illumination that greets you and instantly makes your space feel more welcoming.

Here is the link to my Instructable:

https://www.instructables.com/Organic-Motion-Sensor-Wall-Sconce-Light

Here is the short video ad I made for my project:

Social Media Messaging Samples:

Slogans/Taglines

Where intelligent motion sensing meets sculptural minimalism.

Illumination that understands the art of welcome.

Caption

Precision meets poetry in our latest architectural lighting solution. More than a mere fixture, Acceptus represents a sophisticated intersection of technology and design.

Intelligent motion-sensing technology crafts an environment that anticipates and adapts.

Final Remarks:

This project could not have been possible without a few key people…

• Becky (obviously): Thank you for helping me finalize my code and troubleshooting! But basically thank you for your support throughout the entire project.
• Kyle: Thank you for training me on the CNC machine plus answering all of my circuit related questions!
• Tashea: Thank you for giving me your extra nano board after killing mine! And I’m sorry I killed that one the next morning 🙂
• My sister: Thank you for letting me take my frustrations out on you throughout this process and talking me off the ledge multiple times.

This was one of the most challenging projects I have done yet!

The Moon Phase Lamp Video

Link to My Instructables Project

Link to the Instructable Preview

The Idea

I wanted to make a moon cycle lamp that shows you the cycle/phase of the current moon.

How it works

A light is placed in the middle of the box and a dome spins around it casting a shadow on the moon. This allows you to see the current cycle of the motor.

The Process

The Box

I built a wooden box in the VFL, it was quite challenging because I wanted the box to be seamless and had to miter the edges to achieve that look.

3D Printing

I designed and 3d printed the domes, both the outer dome, which is the moon, and the inner dome that casts the shadow.

I had to design the inner dome a few times because of balance issues.

The Circuit

I have a stepper motor, a motor breakout board, an Arduino Nano, an LED light, and a 100-ohm resistor. I soldered the Arduino nano and the motor breakout board to the “solderable” breadboard and soldered wires to connect everything together.

The Code

I had a really hard time coding this.

I researched a lot about the moon phases and even tried to create a function that calculates the moon. In the end, I downloaded a library in Arduino called “Moonphase” by Cellie. Then I used an example from their GitHub.

Then I researched how to make a stepper motor move and created a function to make the motor move from The Arduino Website.

Currently, the motor moves, but the moon phase location is not working as I want.

#include <WiFi.h>
#include <moonPhase.h>
#include <Wire.h>
#include <RTClib.h>

const char * wifissid = "WiFi Name";
const char * wifipsk  = "Password";

moonPhase moonPhase;
RTC_DS1307 RTC;

struct tm timeinfo = {0};

// Define motor pins
#define A_OUT_1 9
#define A_OUT_2 10
#define B_OUT_1 11
#define B_OUT_2 12

// Define the delay between steps in milliseconds
const int STEP_DELAY = 100; // Adjust for speed
int stepsMoved = 0;

// Define the step sequence for a bipolar stepper motor
const int stepSequence[4][4] = {
  {HIGH, LOW, HIGH, LOW},  // Step 1
  {LOW, HIGH, HIGH, LOW},  // Step 2
  {LOW, HIGH, LOW, HIGH},  // Step 3
  {HIGH, LOW, LOW, HIGH}   // Step 4
};


void setup() {
  pinMode(2, OUTPUT);
  // put your setup code here, to run once:
    Wire.begin();

  // Set motor pins as outputs
  pinMode(A_OUT_1, OUTPUT);
  pinMode(A_OUT_2, OUTPUT);
  pinMode(B_OUT_1, OUTPUT);
  pinMode(B_OUT_2, OUTPUT);

  //Moon Angle
  //Serial.begin(115200);
  //Serial.println();
  //Serial.println();
  //Serial.println( "moonPhase esp32-sntp example." );
  //Serial.print( "Connecting to " );
  //Serial.println( wifissid );
  //WiFi.begin( wifissid, wifipsk );
  //while ( !WiFi.isConnected() )
  //  delay(100);
  //Serial.println();

  //Serial.println( "Connected. Getting time..." );
  //configTzTime( "CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00", "0.pool.ntp.org" ); // Timezone: Amsterdam, Netherlands

  //while ( !getLocalTime( &timeinfo, 0 ) )
  //  vTaskDelay( 10 / portTICK_PERIOD_MS );
}

void loop() {
  //getLocalTime( &timeinfo );
  //Serial.print( asctime( &timeinfo ) );
  digitalWrite(2, HIGH);
  stepsMoved = moveSteps(20);

  moonData_t moon = moonPhase.getPhase();

  Serial.print( "Moon phase angle: " );
  Serial.print( moon.angle );                       // angle is a integer between 0-360
  Serial.print( " degrees. Moon surface lit: " );
  Serial.printf( "%f%%\n", moon.percentLit * 100 ); // percentLit is a real between 0-1
  Serial.println();
  delay(30000);
}

// Function to move the motor a specific number of steps
int moveSteps(int steps) {
  int stepCount = abs(steps);          // Get the absolute number of steps
  int direction = (steps > 0) ? 1 : -1; // Determine direction (1 = forward, -1 = backward)

  int currentStep = 0; // Track current step in the sequence

  for (int i = 0; i < stepCount; i++) {
    // Calculate the next step index
    currentStep = (currentStep + direction + 4) % 4;

    // Set the motor coils according to the step sequence
    digitalWrite(A_OUT_1, stepSequence[currentStep][0]);
    digitalWrite(A_OUT_2, stepSequence[currentStep][1]);
    digitalWrite(B_OUT_1, stepSequence[currentStep][2]);
    digitalWrite(B_OUT_2, stepSequence[currentStep][3]);

    // Delay to control the speed
    delay(STEP_DELAY);
  }

  // Turn off all coils after motion
  releaseMotor();
  return stepCount; // Return the number of steps moved
}

// Function to release the motor (turn off all coils)
void releaseMotor() {
  digitalWrite(A_OUT_1, LOW);
  digitalWrite(A_OUT_2, LOW);
  digitalWrite(B_OUT_1, LOW);
  digitalWrite(B_OUT_2, LOW);
}

//Moving the Motor in phase with the real moon
// Function that changes position from % to step location f.e. 180° = 100 steps
  // Function (angle) --> (position)
  

// For Loop that moves the motor
  // position = 0;
  // newPosition = 0;
  // for ...
    // if newPosition == position - 1
    // move motor (1)
    // position = newPosition
//

Link to the Google Doc draft tutorial

Link to the Google Doc

Future Constructions

There are many things that I need to fix and do differently in the future.

• I need to fix the moon angle code so it works properly
• Change the blue LED to a white LED light
• Switch out the current motor for a quieter one