Have you ever seen those Instagram or Youtube videos of powder magically changing color after being heated? Don’t know what I mean? See below.

Well, that’s something is called embossing. I stumbled upon it years ago back in high school, as I was starting to get into making cards that were more than just copy paper folded in half. I figured that embossing would take my cards to the next level —as it reminded me of the colorful, textured letterings you find on professional Hallmark cards. But you know what’s even better? You can emboss almost anything — glass, clay pots, acrylic, stone, and more…meaning, endless possibilities of customized gifts!

So how can you get started? Luckily, I was actually embossing something recently, and realized I would love to share my process for those who were in my position. Here’s what you’ll need to get started, along with my product recommendations. (Bear in mind, I’m in no way a professional embosser/crafter, I just make cool cards as a hobby)

Materials:

1. Embossing powder
   (Ranger Embossing Powder)
2. Embossing Ink/Pen
   (Ranger Embossing pen clear + black two pack)
3. Heat gun
   (Can’t find my one anymore, but here is a low price one )
4. Cardstock/Paper/Material to emboss
   (The green cardstock I use here is part of this collection)
5. Powder bag (optional)
   (Inkadinko Powder Tool)

How to emboss (step by step)

1. Optional Step: First, powder the material you will be embossing on. This removes static and prevents stray powders on your surface.

2. Now, using your embossing ink, or pen, draw out the design you want to emboss.

3. Once you’re done, pour the powder onto the design. Like glitter, pour the remaining powder back into the bottle.

4. To remove any excess material, try tapping the back of the surface or blowing at the powder to remove loose pieces.

5. Optional Step: Remove flecks of unwanted powder using a dry brush/toothpick/q-tip/blunt edge.

6. Plug in your heat gun, making sure no unwanted powder is nearby. Make sure to twist the cap on the embossing powder bottle tightly.

7. Turn on the heat gun and wait a few seconds for it to warm up before facing it towards the powdered design.

8. Watch as the powder melts! Make sure not to overheat it, as it may cause crumbling.

That’s it! Practice, practice, practice. Try to figure out how long you need to emboss your powder, the type of powders you want to get, the type of pen nib, and the materials you like!

This week, our paper bag contained three items: copper tape, a battery, and a LED pin. Our prompt? To use our 3D printers and create a wearable that lit up an LED as a button was pressed. The task seemed simple, but there was a twist — we would have to create our own button, and design our wearable such that it would be easy to replace and remove the battery.

Materials given:

1. Copper tape
2. 3V Lithium Coin Battery
3. LED

The Prompt:

A 3D printed wearable that lights up an LED with a push of a button.

Our End Result:

Designing our Button

Our first step was designing our button. We had many ideas on how to do this — and they all involved making a spring buttons, since these were buttons we dealt with on a daily basis. The only issue was printing a spring flexible enough to support the button without snapping or being too stiff. We had PLA and Flashforge printers to our disposal, but our resources could not easily handle the flexibility and subsequent resolution we needed. We ended up printing many different springs, and limited by the material and quality of our printer, as well as time, we decided to go an entirely different route.

We figured — all our button needed to be able to do was move down, and go back up.

1. Manual Push Pin: Our first alternative idea was a “push pin” where the user would push the button pin down into a hole and would have to pull it back up in order to push it again. Therefore, the button would go back up by using manual labor, instead of a spring.

Nevertheless, we thought this idea was too simple. We still had over 24 hours left before the deadline, so we kept this idea as our last resort and went back to the drawing table. That’s when we thought about flexible plastic items, and one in particular was a ruler. We discussed how plastic rulers are still able to move up and down even though they are not thin pieces of plastic. When anchored at one side, with the other side of the ruler dangling, a ruler bounces up and down when the dangling side is pressed, similar to a diving board. Using that, we figured that by experimenting with different proportions, we could implement our “button.”

2. Diving Board: We though of many different ways to implement the diving-board like button as shown below. We played with many different proportions of thickness and sizes, as our “button” either kept breaking off at the base, or rarely budged. We also thought of ways we could reduce the amount of force needed to press the button by extending the end of the button, as shown below.

Yet, we realized we could reduce our button even further. Our button didn’t need to protrude outward like a diving board — it could be like a “ruler” cut out of our base.

3. Press Button: We then decided to make the shape a circle to make it more button-like, and we realized that we had seen buttons like this before in real life products.

In the end, we also decided to add a handle to our button since it was a bonus to make a “latched” button — one that stayed down when pressed down. Therefore, we made it so that the handle was the right length in order to make it somewhat “stiff ”when pressed down. The handle would then be used to raise it back up.

Designing the wearable

Our next step was designing the wearable. The first thing that came to our mind was a watch, with circles to fit the wrist. We decided to make a rectangular shape to hold the different compartments that we needed, which was a battery, a LED, and a resistor. We also needed a place to implement our button — we decided to incorporate our button into a lid. We designed a slide-in lid in order to make the battery easily replaceable, but also out of sight.

We decided to use press fits to fit the button, so we measured our items and in created a divider that would separate the battery and LED. We also thought this would be nice as the divider would serve as the elevated platform that the button would touch. We decided to use an elevated platform in order to reduce the amount of force needed to push the button down. For the divider, we also decided to leave space on one side in order to have a place to put the resistor.

Since our primary objective was to make an LED light up, we also thought it would be nice to have the LED be poking out of the wearable. Since our lid was detachable, we decided to make it poke out of the side instead of from the top. Lastly, we added ridges in order to implement our sliding mechanism for our lid.

After sketching our compartments, we then created our 3D model.

Connecting our circuit

Lastly, we needed to connect our circuit. We first wanted to put tape on the sides of the wearable, in order to have a clean look, but our copper tape did not conduct electricity well. We discovered that not all tape is created equal, as some parts of the tape worked, while others didn’t. We rethought our tape design and came up with this:

We wanted to reduce the amount of tape we needed to rely on by using the tape to stick the ends of the resistor to the short end of the LED and the positive side of the battery, as shown above.

Yet, even implementing this design was long. After grabbing our tweezers and placing the tape on carefully, making sure every part of the tape was touching other parts, our circuit still wasn’t working. We knew this wasn’t our button as even putting tape to complete the circuit didn’t work. Something deceptively simple turned into hours of mindless re-taping.

With just a few hours left, and no voltmeter or soldering available to us, we grabbed our tweezers and dissected the board methodically. With our hands we connected the metals together and placed the other ends at different parts of the circuit to determine when connection was being lost. After hours of fiddling and trying out different pieces of tape and different orientations, we managed to pull it all together.

Our advice — get better tape, or just use metal. Also, always have a voltmeter on hand to do continuity tests.

End Result

This was the end result of our wearable!

For class I was given two mystery sensors, and was given the vague instructions to figure them out and create a demo. One of the sensors was a rotary encoder, and I thought I would share the demo. Our other sensor was a joystick, and the tutorial can be found here.

The following article is structured like so:

1. Overview: Input & Output pins of the rotary encoder
2. Understanding a Rotary Encoder: How a rotary encoder works
3. Connecting it to an Arduino: Step-by-step wiring
4. Demo + How to Code: Creating the demo

(Disclaimer: These tutorials were made by my wonderful team and I. The following has been edited slightly for sharing.)

Overview

A rotary encoder is a sensor used for determining the angular position of a shaft, similar to a potentiometer.

Pins and what they mean:

• CLK: Output A (Digital)
• DT: Output B (Digital)
• SW: button press (Digital)
• +: VCC — Voltage supply
• GND: Ground

Understanding a Rotary Encoder

A rotary encoder can essentially be used for the same purpose as the potentiometer. However, a potentiometer typically has a default point past which the shaft cannot rotate, while a rotary encoder can rotate in one direction for as long as we want. To reset the position reading, we can push the shaft down to press the reset button. The rotary encoder we have produces digital signals.

The rotary encoder determines the angular position of a rotating shaft through a series of square wave pulses. It essentially has evenly spaced contact zones connected to a common pin, as well as two contact pins called A and B that are 90 degrees out of phase. When the rotary encoder is manually rotated, pins A and B make contact with the common pin, and generate the pulse. By counting the amount of pulses (or square waves) of either of these outputs, we can determine the rotary position. To determine direction and check if the pin is rotating clockwise or counterclockwise, we do the following:

If the rotary encoder is moving clockwise, output A is ahead of output B. As a result, at the same points in time, A and B will be on opposite parts of the square wave function (when A is being activated, B is inactive, and vice versa).

If the rotary encoder is moving counterclockwise, Output B is ahead of output A. As a result, at the same points in time, because it is moving 90 degrees ahead, A and B will both be activated and deactivated at the same time, albeit B will be ahead by those 90 degrees.

Connecting it to an Arduino

Here are what the 5 pins for the rotary encoder mean:

• CLK: Output A (digital)
• DT: Output B (digital)
• SW: button press (digital)
• +: VCC — Voltage supply
• GND: Ground

CLK, DT, and SW should be connected to digital pins on the Arduino, + should be connected to the 5V and GND, like always, to ground.

Step by Step Instructions

1. CLK: Place one end of a wire at the CLK pin on the rotary encoder to any digital pin on the Arduino (Orange wire — )

2. DT: Place one end of a wire at the DT source pin on the rotary encoder to any digital pin on the Arduino (Yellow wire — )

3. SW: Place one end of a wire at the SW pin on the rotary encoder to any digital pin on the Arduino (Sky Blue wire — )

4. +: Place one end of a wire at the + pin on the rotary encoder to the +5V pin on the Arduino (Red wire — )

5. GND: Place one end of a wire at the GND pin on the rotary encoder to the GND pin on the Arduino. (Black wire — )

Demo + How to Code

This code alters pitch based on which direction the encoder is turned. When it is turned counter-clockwise we decrease the pitch, and when it is turned clockwise, we increase it.

Here is a demo video for reference:

What you will need:

• Rotary Encoder sensor
• Arduino
• Piezo
• Wires

int buzzer_pin = 3;
int pinA = 7;
int pinB = 6;
int pinC = 5;
int pitch = 956;
int aState;
int aLastState;  

void setup() { 
   pinMode (pinA,INPUT);
   pinMode (pinB,INPUT);
   //pinMode (pinC,INPUT);
   //digitalWrite(pinC, HIGH);
   pinMode(buzzer_pin, OUTPUT);
   Serial.begin (9600);
   // Starts output
   aLastState = digitalRead(pinA);   
} 

void loop() { 
   aState = digitalRead(pinA); 

   if (aState != aLastState){     
     // outputB != outputA state, encoder is rotating clockwise
     if (digitalRead(pinB) != aState) { 
      movedClockwise();
       //counter ++;
     } 
     else {
       //counter --;
       movedCounterClockwise();
     }
     play_specific_pitch(pitch);
   } 
   aLastState = aState;
}

void movedClockwise() {
  if ((pitch) < 3000) {
    pitch = pitch + 100;
  }
}

void movedCounterClockwise() {
  if ((pitch) > 100) {
    pitch = pitch - 100;
  }
}

void play_specific_pitch(int pitch) {
  for (long i = 0; i < 300000L; i += pitch * 2) {
    digitalWrite(buzzer_pin, HIGH);
    delayMicroseconds(pitch);
    digitalWrite(buzzer_pin, LOW);
    delayMicroseconds(pitch);
  }
  Serial.println(pitch);
}

I hope you enjoyed this tutorial and found it thorough and useful!

For class I was handed two mystery sensors, and was given the vague instructions to figure them out and create a demo. One of the sensors that I easily recognized was a joystick, and I thought I would share the demo and tutorial here. (Our other sensor was a rotary encoder, and that tutorial can be found here.)

The following article is structured like so:

1. Overview: Input & Output pins of the joystick
2. Understanding a Joystick: How a joystick works
3. Connecting it to an Arduino: Step-by-step wiring
4. Demo + How to Code: Creating the demo

(Disclaimer: These tutorials were made by my wonderful team and I. The following has been edited slightly for sharing.)

Overview

The joystick is useful for reading and interpreting 2D motion through two analog variables, which represent the position of the sensor on a 2D plane. The joystick can also be pressed inwards like a button, which is useful for functions such as selecting items in menus.

• Input 1: Moving the stick
• Output 1: position of handle relative to its center, X and Y axis
• Input 2: Pressing the button
• Output 2: Whether the button is pressed or not

Understanding a Joystick

Before we go in to how to connect a sensor and use it in code, it is important to understand how a joystick works internally.

The analog joystick has a handle and two slotted shafts around the handle (along the x-axis and y-axis). The handle can be pushed to any point in a plane, which will cause one or both of the slotted shafts to pivot. Each slotted shaft is attached to a potentiometer on the side, which converts the angular displacement of the shaft to an analog signal.

The data for each axis is determined in analog using a potentiometer, communicating position in the form of voltage. This is possible because the shaft is connected to a wiper and resistive strip inside the potentiometer.

As the wiper moves further along the resistive strip, more current passes through the strip to complete the circuit, thereby increasing the total resistance of the circuit.

Therefore, twisting the potentiometer will change the voltage of its output. In its default position along an axis, the joystick will output half the voltage input. As we move along an axis, the voltage of the output will move either to the maximum inputted voltage, or to zero, signaling how far we have moved the shaft of the joystick.

Connecting it to an Arduino

Here are what the 5 pins of the analog joystick mean:

• GND: Ground
• +5V: 5V power source
• VRx: X-direction reading (Analog)
• VRy: Y-direction reading (Analog)
• SW: Button press (Digital)

VRx and VRy should be connected to analog pins on the Arduino, and SW should be connected to a digital pin. As usual, +5V should be connected to 5V, and the GND pin should be connected to GND.

Step by Step Instructions

1. GND: Place one end of a wire at the GND pin on the joystick to the GND pin on the arduino (Black Wire)

2. +5V: Place one end of a wire at the 5V source pin on the joystick (+5V) to the 5V pin on the arduino (Red Wire)

3. VRx: Place one end of a wire at the VRx pin on the joystick to any analog pin on the arduino (Orange Wire — We connected it to pin A3)

4. VRy: Place one end of a wire at the VRy pin on the joystick to any analog pin on the arduino (Yellow Wire — We connected it to pin A1)

5. SW: Place one end of a wire at the SW pin on the joystick to any digital pin on the arduino. (Sky Blue Wire — We connected it to pin D5)

Demo + How to Code

This code moves the servo hand in X degree intervals based on Joystick positioning. For example, if joystick is held to the left continuously, the servo hand will move in 180 degree intervals.

Here is a demo video where I describe how it works:

What you will need:

• Analog joystick sensor
• Arduino
• LED pin
• Continuous servo motor
• Wires

For this demo, we used a continuous servo motor. Ideally we would use a non-continuous servo motor for this demo since it works with degree coordinates. However, since we only had a continuous servo, we had to use delays in the code to control movement. Although a delay of 500ms may theoretically be correct based on the speed of servo movement, 600ms worked better after experimentation.

/* Setup */
#include <math.h>
#include <Servo.h>

/* Pins */
int servo_pin = 3; 
int joyPin1 = 1;  // slider variable connected to analog pin 1
int joyPin2 = 3;  // slider variable connected to analog pin 3
int led = 2;      // led light connected to digital pin 2
 
int SW_pin = 5;  // digital pin connected to switch output
int y = 0;       // variable to read the value from the analog pin 0
int x = 0;       // variable to read the value from the analog pin 1

Servo servo_motor;

void setup() {
  pinMode(SW_pin, INPUT);
  digitalWrite(SW_pin, HIGH);
  Serial.begin(9600); //Start printing to the console
  servo_motor.attach(servo_pin); 
  pinMode(led, OUTPUT);
 }

int getDegree(int raw_x, int raw_y) {
  raw_x = (raw_x - 2457);
  raw_y = (raw_y - 2541);
  
  /* Convert Raw Values to Degree */

//convert radians to degree
  double val = atan2(raw_y, raw_x) * 180/3.14159265358979; 
  if (val < 0) {
    val += 360;
  }
  
  //convert to a double
  double new_x = raw_x / 100.0;
  double new_y = raw_y / 100.0;
  double distance = sqrt((new_x * new_x) + (new_y * new_y));
  
  //15 is a distance threshold that determines when to move the servo
  if (distance > 15) { 
    return val;
  }
  return -1; // joystick has not moved far enough to move servo
}

void loop() {

  /* Get x and y raw values*/
  y = (analogRead(joyPin1) * 4.9);   
  delay(50); // small pause needed between reading
  x = (analogRead(joyPin2) * 4.9 );  
  delay(50);    
  
  /* Print Raw Coordinates */
  Serial.print(y);
  Serial.print('-');
  Serial.print(x);
  Serial.print("-");
  Serial.println(digitalRead(SW_pin));
  
  /* If pressed down, light up pin */
  if (digitalRead(SW_pin) == 0) { // when pressed, SW_pin returns 0
    digitalWrite(led, HIGH); 
  }
  else {
    digitalWrite(led, LOW);
  }
  
  /* Translate x and y into a degree */
  int deg = getDegree(x, y);
  Serial.print("Degree");
  Serial.println(deg);
  
  /* If deg is -1, don't move */
  if (deg == -1) {
    servo_motor.write(90);
  }
  /* If deg is not -1, move that # of degrees*/
  else {
    Serial.println("move");
    servo_motor.write(0); //Move servo at maximum speed
    delay(600 * (deg/360.0)); //Experimental value
    servo_motor.write(90); //Stop servo movement after delaying a certain amount of time
  }
}

I hope you enjoyed this tutorial and found it thorough and useful!