Minecraft Potion Bottle

Greetings everyone and welcome back, Here's something fun: the Potion Bottle from minecraft. This full scaled model is equipped with an WS2812B Circuit which are all running a Blue-sky-blue color animations in a loop which imitates the liquid inside the potion bottle from the game.

In this case, the system is powered by an internal 3.7V 2600mAh Li-on Cell coupled with a Power Management IC. It also features an XIAO microcontroller connected to eight WS2812B LEDs, all housed in a custom 3D printed shell or body.

Furthermore, we have added a second compartment to the bottle neck, which is designed to hold little items like rings, SD cards, pen drives, and so on.

The objective of this project was to create a full-size potion bottle from scratch that would be placed on display in my room next to my previous Minecart sword project.

This Article is about the whole build process of this project, so let's get started with the build.

Materials Required

These were the materials used in this build:

• Custom PCB (Provided by Seeed Studio Fusion)
• WS2812B LEDs
• XIAO SAMD21 Microcontroller
• IP5306 Power Management IC
• LED 0805 Blue
• 1uF Capacitors 0805 Package
• Micro USB Through Hole version
• Li-ion Cell 3.7V, 2600mAh
• Li-ion Cell Holder, SMD 18650
• 1uH Inductor SMD
• Rocker Switch (Push Button Type)
• Custom 3D-printed parts

3D Design

The first step in the design process was getting a clear picture of the Minecart Potion Bottle so that we could create a rough sketch of it using our CAD software.

Once the perfect image was found, we imported it into Fusion360 and calibrated the settings such that the entire bottle length—including the cap—would be 190mm.

After sketching out its general design, we hollowed it out and turned it into a boxy body that resembled a bottle.

The front portion of the bottle and the back lid were separated. Everything will be placed in the front section, including the cap, the part-holding tray, and the LED circuit.

We also drilled a keyhole in the rear of the lid, which will enable us to hang the bottle on a wall using a nail.

We modeled a tray that will be used to store tiny items in the bottle neck area. We modeled the bottle's cap, which slides into its proper position from the top face, to cover the tray.

Following design completion, transparent PLA was used to print the front portion of the bottle, the back lid, and the tray using a 0.8mm nozzle, 20% infill, and 0.3mm layer height.

The cap part was printed using the same parameters but with wood PLA.

Circuit

The LED circuit is then developed. It consists of an XIAO SAMD21 board connected to eight WS2812B LEDs connected in parallel. The first LED's Dout is connected to the second LED's Din, the second LED's Dout is connected to the third LED's Din, and so on up to the eighth LED.

We used the IP5306 IC Setup, a power management IC that can provide stable 5V 2.4A with a 3.7V Li-ion Cell, to power the XIAO and the LEDs. Furthermore, this IC offers charging functions, such as a battery fuel indicator and charging cutoff (low- and high-cut).

Regarding the board design, we took the layout from the cad design and used it to create the outline, the mechanical holes, and even the placement of the components.

After completion of the PCB design, a Gerber file was generated and then sent to Seeed Studio Fusion for samples.

Seeed Studio Fusion

An order was placed for a white solder mask with black silkscreen.

The quality was super good considering the rate, which was also pretty low.

Seeed Fusionoffers one-stop prototyping for PCB manufacture and PCB assembly, and as a result, they produce superior-quality PCBs and fast-turnkey PCBA within 7 working days.

Seeed Studio Fusion PCB Assembly Servicetakes care of the entire fabrication process, from PCB manufacturingto parts sourcing, assembly, and testing services, so you can be sure that they are getting a quality product.

After gauging market interest and verifying a working prototype, Seeed Propagate Service can help you bring the product to market with professional guidance and a strong network of connections.

PCB Assembly Process

• Employing a solder paste dispensing needle, the assembly process began with the addition of solder paste to each component pad.
• Next, we use a tweezer to pick and position each SMD component in its designated location.
• The circuit was added to the reflow hotplate once the components had been assembled. The reflow hotplate heats the PCB from below to the temperature at which solder paste melts, leading the components to be soldered onto their pads.
• After assembling the SMD components, we utilized a soldering iron to add the THT components, which included the USB port, the Li-ion cell holder, and header pins for the XIAO SAMD21 microcontroller, from the bottom of the board.
• Subsequently, the Push Style Rocker switch is attached to the circuit via the switch pads. The IP5306 Circuit can be turned on or off with this rocker switch.

Power Source

• We use a single 3.7V 2600mAh Li-ion cell that was added to the Li-ion cell holder with the right orientation.
• Afterwards, we toggle the rocker switch. which will cause the IP5306 IC to be switched on; a double tap will cause it to switch off.
• We measure the IP5306 IC's output voltage using a multimeter; it is 5.1V, indicating that our configuration is functional. At this point, we can add XIAO to the device's header pins and proceed with the programming process.

CODE

We loaded the following sketch into the XIAO SAMD21 microcontroller after completing the circuit. One of the sketches from the FastLED example is the Pacifica.

#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
FASTLED_USING_NAMESPACE

#define DATA_PIN            D0
#define NUM_LEDS            8
#define MAX_POWER_MILLIAMPS 700
#define LED_TYPE            WS2812B
#define COLOR_ORDER         GRB

//////////////////////////////////////////////////////////////////////////

CRGB leds[NUM_LEDS];

void setup() {
  delay( 3000); // 3 second delay for boot recovery, and a moment of silence
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS)
        .setCorrection( TypicalLEDStrip );
  FastLED.setMaxPowerInVoltsAndMilliamps( 5, MAX_POWER_MILLIAMPS);
}

void loop()
{
  EVERY_N_MILLISECONDS( 20) {
    pacifica_loop();
    FastLED.show();
  }
}

//////////////////////////////////////////////////////////////////////////
//
// The code for this animation is more complicated than other examples, and 
// while it is "ready to run", and documented in general, it is probably not 
// the best starting point for learning.  Nevertheless, it does illustrate some
// useful techniques.
//
//////////////////////////////////////////////////////////////////////////
//
// In this animation, there are four "layers" of waves of light.  
//
// Each layer moves independently, and each is scaled separately.
//
// All four wave layers are added together on top of each other, and then 
// another filter is applied that adds "whitecaps" of brightness where the 
// waves line up with each other more.  Finally, another pass is taken
// over the led array to 'deepen' (dim) the blues and greens.
//
// The speed and scale and motion each layer varies slowly within independent 
// hand-chosen ranges, which is why the code has a lot of low-speed 'beatsin8' functions
// with a lot of oddly specific numeric ranges.
//
// These three custom blue-green color palettes were inspired by the colors found in
// the waters off the southern coast of California, https://goo.gl/maps/QQgd97jjHesHZVxQ7
//
CRGBPalette16 pacifica_palette_1 = 
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117, 
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x14554B, 0x28AA50 };
CRGBPalette16 pacifica_palette_2 = 
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117, 
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x0C5F52, 0x19BE5F };
CRGBPalette16 pacifica_palette_3 = 
    { 0x000208, 0x00030E, 0x000514, 0x00061A, 0x000820, 0x000927, 0x000B2D, 0x000C33, 
      0x000E39, 0x001040, 0x001450, 0x001860, 0x001C70, 0x002080, 0x1040BF, 0x2060FF };


void pacifica_loop()
{
  // Increment the four "color index start" counters, one for each wave layer.
  // Each is incremented at a different speed, and the speeds vary over time.
  static uint16_t sCIStart1, sCIStart2, sCIStart3, sCIStart4;
  static uint32_t sLastms = 0;
  uint32_t ms = GET_MILLIS();
  uint32_t deltams = ms - sLastms;
  sLastms = ms;
  uint16_t speedfactor1 = beatsin16(3, 179, 269);
  uint16_t speedfactor2 = beatsin16(4, 179, 269);
  uint32_t deltams1 = (deltams * speedfactor1) / 256;
  uint32_t deltams2 = (deltams * speedfactor2) / 256;
  uint32_t deltams21 = (deltams1 + deltams2) / 2;
  sCIStart1 += (deltams1 * beatsin88(1011,10,13));
  sCIStart2 -= (deltams21 * beatsin88(777,8,11));
  sCIStart3 -= (deltams1 * beatsin88(501,5,7));
  sCIStart4 -= (deltams2 * beatsin88(257,4,6));

  // Clear out the LED array to a dim background blue-green
  fill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));

  // Render each of four layers, with different scales and speeds, that vary over time
  pacifica_one_layer( pacifica_palette_1, sCIStart1, beatsin16( 3, 11 * 256, 14 * 256), beatsin8( 10, 70, 130), 0-beat16( 301) );
  pacifica_one_layer( pacifica_palette_2, sCIStart2, beatsin16( 4,  6 * 256,  9 * 256), beatsin8( 17, 40,  80), beat16( 401) );
  pacifica_one_layer( pacifica_palette_3, sCIStart3, 6 * 256, beatsin8( 9, 10,38), 0-beat16(503));
  pacifica_one_layer( pacifica_palette_3, sCIStart4, 5 * 256, beatsin8( 8, 10,28), beat16(601));

  // Add brighter 'whitecaps' where the waves lines up more
  pacifica_add_whitecaps();

  // Deepen the blues and greens a bit
  pacifica_deepen_colors();
}

// Add one layer of waves into the led array
void pacifica_one_layer( CRGBPalette16& p, uint16_t cistart, uint16_t wavescale, uint8_t bri, uint16_t ioff)
{
  uint16_t ci = cistart;
  uint16_t waveangle = ioff;
  uint16_t wavescale_half = (wavescale / 2) + 20;
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    waveangle += 250;
    uint16_t s16 = sin16( waveangle ) + 32768;
    uint16_t cs = scale16( s16 , wavescale_half ) + wavescale_half;
    ci += cs;
    uint16_t sindex16 = sin16( ci) + 32768;
    uint8_t sindex8 = scale16( sindex16, 240);
    CRGB c = ColorFromPalette( p, sindex8, bri, LINEARBLEND);
    leds[i] += c;
  }
}

// Add extra 'white' to areas where the four layers of light have lined up brightly
void pacifica_add_whitecaps()
{
  uint8_t basethreshold = beatsin8( 9, 55, 65);
  uint8_t wave = beat8( 7 );
  
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    uint8_t threshold = scale8( sin8( wave), 20) + basethreshold;
    wave += 7;
    uint8_t l = leds[i].getAverageLight();
    if( l > threshold) {
      uint8_t overage = l - threshold;
      uint8_t overage2 = qadd8( overage, overage);
      leds[i] += CRGB( overage, overage2, qadd8( overage2, overage2));
    }
  }
}

// Deepen the blues and greens
void pacifica_deepen_colors()
{
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    leds[i].blue = scale8( leds[i].blue,  145); 
    leds[i].green= scale8( leds[i].green, 200); 
    leds[i] |= CRGB( 2, 5, 7);
  }
}

Here, a deep aquatic blue glow that gradually fades into lighter blue tones is given off by the LED.

Make sure to download and install the FastLED sketch before uploading it to your board.

https://fastled.io/

Final Assembly

• The 3D-printed tray portion is right away placed inside the front part to start the main assembly. The neck section of the front part is modeled to keep the tray part in the correct orientation.
• Subsequently, we disconnected the switch's connections from the circuit and inserted the switch into the given Rocker switch slots on the body.
• After that, the circuit is installed using two M2 screws in the correct place.
• Rocker switch wires are then connected to the circuit.
• The lid is then positioned; it is a pressure-fitted part, which means that pressure is applied along the entire perimeter of the back lid section to secure it to the front part.
• The assembly is complete.

RESULT

This is the end result of this little build: a full-sized Minecraft potion bottle that, unexpectedly, does not contain any fast speed, invisibility, or high jump potions. Instead, it has a hidden storage space and constantly glows in order to replicate the liquid within.

This arrangement was mounted on a wall for display. We did not need to add a power wire to power the setup because of the internal power supply. But when the setup discharges, the battery needs to be charged, and it is easy to do because the bottle has a micro USB outlet on the bottom.

Overall, this project was a success and needs no further revision.

Comment if you need any help or information regarding this project.

Checkout my preciously built Minecraft-themed projects-

https://www.hackster.io/Arnov_Sharma_makes/minecraft-torch-ef5757

https://www.hackster.io/Arnov_Sharma_makes/wall-mounted-minecraft-sword-b6edb6

Thanks to Seeed Studio Fusion for supporting this project.

You guys can check them out if you need great PCB and stencil service for less cost and great quality.

And I'll be back with a new project pretty soon!