Pokemon Ball and Monsters

Background

Just a few months ago, many people in the whole world buzzed around playing Pokemon Go. Even my young relatives not more than six years’ old yelled all days for getting their hands on mobile phones. While the game successfully stirred youngsters up leaving the couch and running on streets, it offered not much more than mere passive entertainment. So, I decided to create a project so that kids of various ages can actively participate, collaborate and have fun in making their unique toys. They will gain hands-on experience in esthetic design, electronics, and the use of simple tools. For the work of soldering, drilling and programming; however, the help of adults or teenagers is recommended.

Step 1: ​Homemade Gifts

As Pokemon is one of the most sought-after gifts this holiday season, this instructable introduces how to make a Pokemon ball and Pokemon monsters. The ball is capable of housing one Pokemon monster and playing its respective voice when a button is pressed. In order to reduce difficulty of newbies, I mainly use ready-made circuits. So, the part of electronics basically just requires connection of pins. This project can be separated into two parts.

Step 2: Pokemon Monsters

The first part is the creation of Pokemon monsters according to personal preference of kids. There is a maximum size limitation of about 60mm (L) x 50mm (W) x 40mm (H). It can be made of ordinary stuffed materials or clay. Polymer clay that does not require baking is preferable. (Please refer to the attached BOM list for prices and locations where I bought the materials. I am not sure whether all materials can be bought overseas, but order via the web should be available.) The key component of each Pokemon monster is a rewritable RFID tag, which must be placed inside the body no deeper than 10mm from the surface. Every monster should have one RFID tag embedded before assigning its ID. It is advisable to place it near the bottom or at the back of the monster. In order to ensure proper communication with the RFID sensor, the RFID tag should not be perpendicular to the sensor. For example, in the case of our demo Snorlax, the RFID tag tilts about 45 degree to the ground. In case the monster has outstretching limps or tail, a wire skeleton may help to maintain its posture and shape before the clay hardened.

There are various RFID products using different radio frequencies, sizes, and ranges. I chose the highly affordable and easy-to-use system based on Philips MFRC522 chip working at 13.56MHz. Usually, RFID card comes with permanently encoded UID. There are Chinese UID changeable MIFARE cards which allow rewritable UID. Please fellow the link I included in the BOM list if you cannot locate them. Rewritable RFID tags usually come in two packages; one is housed in a key ring tag, another type is a raw circuit type. I found the key ring type a bit easier to handle. Just peel off the plastic cover and trim the edge as close as possible to the antenna and it will be ready to be embedded. For the raw circuit type, it is necessary to stick it on a supporting plate so that the antenna can maintain its geometry.

One important point to remember is that kids should be allowed to improvise and make their monsters into whatever shapes they like. They should be encouraged to participate in all of the creative activities such as making their very own roaring monster sound track.

If stuffed monsters are preferable, it will be helpful to enroll the hand sewing class together with kids. Instructables Hand Sewing Class

Step 3: Preparation of MP3 Files

I highly recommend kids to impersonate sounds of their favourite monsters. This part is one of the most joyful parts for small kids. Simply stimulate their appetite by watching this video on Youtube Voice ALL the Original Pokemon!!

There are a lot of free wave editing and recording software, and one of the best is Audacity. Audacity® is free, open source, cross-platform audio software for multi-track recording and editing. It is powerful and feature-rich. Besides being free of charge, it has a lot of free tutorials; such as, Audacity: Complete Tutorial Guide to Audacity for Beginners and Audacity Basics: Recording, Editing, Mixing. You can download Audacity at Audacity Download.

Our target is simple. First, create your unique howl and mix with a piece of background sound effect or music. The length of the audio is 8 seconds. You can modify the length by changing delay() in the the playAudio function of the sketch later.

Step 4: Pokemon Ball

The second part is the Pokemon ball where all the electronics, speaker and battery reside. One interesting experience gained in doing this project is that even an adult can learn from kids. At the very beginning, Five years' old boy Nick said he loved Blastoise, his younger brother Karl said he wanted Charmander, … As each kid has his own favourite monster, I thought I only need to use a small plastic sphere in about 6 cm diameter with an ISD1820 chip for recording 8 seconds of voice for a particular monster. Just a few days later, however, both Nick and Karl changed their mind to some other monsters. The fact is that they keep on changing. And I finally realized that a Pokemon ball can be used to house different monsters. Thus, I now know that kids are quick in changing their mind, and a Pokemon ball should be able to play different audio for different monster. Therefore, I chose to use ready-made empty Pokemon ball in 10 cm diameter instead. (Any empty plastic sphere such as candy cases can be modified for use.) In this case, an economical RFID sensor (less than one USDollar) is a suitable solution for detecting different monsters. Once a known monster ID is found and the button pressed, the respective MP3 recorded in a flash memory module will be played. So, the main circuits needed are an Arduino Pro Mini (8MHz, 3.3V), a MFRC522 RFID module, and a JQ8400-FL-10P MP3 module. Details of Arduino Pro Mini board can be found here. For newbies in Arduino, it is suggested they have a crash course in the free class in Arduino. Arduino Class

Step 5: Connection Between MFRC522 & Arduino Pro Mini

MFRC522 MODULE Arduino Pro mini Lithium battery

NSS /SDA <---------- D10

SCK <---------- D13

MOSI <---------- D11

MISO -----------> D12

IRQ N/A

GND ----------> GND

RST <--------- D9

3.3V <--------- 3.3V

Step 6: MFRC522 RFID Module

With a built-in antenna for 13.56MHz RFID, this module supports mifare1 S50, mifare1 S70, mifare UltraLight, mifare Pro, and mifare Desfire cards. It can be used for both reading and writing UID upon rewritable RFID tag. Via SPI connection, it allows high speed bi-directional communication. It is highly affordable at less than one US Dollar (FOB China). It is ubiquitous.

Please refer to a complete introduction of programming the module at Arduino Playground. There are a number of good instructables for applications with an Arduino. Please browse for further details.

Step 7: Connection Between JQ8400-FL-10P & Arduino Pro Mini

JQ8400-FL-10P Arduino Pro mini Lithium battery

GND pin 05 ------------> GND

3.3-5V pin 06 < ---------- 3.3V

TX pin 04 ------------> D4 RX

RX pin 03 < ----------- D5 TX

Spk 1 (+) pin 10 -----------> spr +

Spk 2 (-) pin 09 ----------> spr -

Step 8: JQ8400-FL-10P Module

This is an easy-to-use 32Mbit memory module and MP3 player with UART and one-line control for communication with MCU, and USB port for direct copy of MP3 audio files. It comes with 3W amplifier for direct output to loudspeakers.One of the main reasons I chose this module is that it is highly affordable. The price is less than two US Dollars. When it connects with a PC via USB port, it automatically becomes a USB drive so that normal file operations is convenient. (Beware of the need of additional resistors between its connection with other Arduino boards that run 5v on their output pins.) The catch; however, is that the sequence of the audio files recorded in the flash matters. An ordinal number has to be passed for playback of a particular audio file. In case you need to insert a file with precedence over existing ones, it is advisable to erase all and copy them all again.

For the sake of simplicity, the RFID tag of every Pokemon monster will bears the same ordinal number of the respective audio file stored in the module. Since I need more than one Pokemon ball for kids and I want the same audio to be played whenever the same monster is detected, I have to make sure the copying sequence of MP3 files is the same for all Pokemon balls.

Please save all MP3 file in 8.3 naming convention to the root directory. In this project, I used only numeric as file names (i.e. 1.MP3 to 255.MP3).Bear in mind; however, the file name doesn't really matter. There are a number of different commands for controlling the module, but we will only use at most the playback and volume control commands. All UART control commands start with a first byte of 0xAA. The second byte refers to the ordinal number of commands. In the case of the play command, the second byte is 0x07. The 0x00 at the fourth refers to the root directory. The fifth byte stands for the ordinal number of MP3 file to be played. The last byte contains the lower byte of the sum from the 1st to the 5th byte. Constant byte arrays are defined at the very beginning of the code. Before actuall playing, we only need to replace the fifth and sixth byte with correct values.

// A sequence of bytes started by 0xAA signals the JQ8400FL for performing varioius functions
// Command number 7 for playing specified MP3, command number 13 set volume to specified level<br>byte Cmd07[6]= {0xAA, 0x07, 0x02, 0x00, 0x01, 0xB4}; //play 1st MP3; filename : 01.mp3
// Cmd07[4]= 0x02; Cmd07[5]= 0xB5;  2nd MP3; filename: 02.mp3
byte Cmd13[5]= {0xAA, 0x13, 0x01, 0x14, 0xD2}; // set volume to level 20
// level 0 to 30; default= level 20; {0xAA, 0x13, 0x01, 0x0A, 0xC8} set to level 10

Step 9: Assigning and Writing UID to RFID Tag

Due to the small footprint of Arduino Pro Mini, receiving commands requires an USB-TTL converter (CP2102 chipset) via the USB port to a PC . In order for the PC to recognize the converter, a software driver has to be downloaded at Silicon Labs. Alternatively, you may use another converter with CH340G chipset. For suggestions on the type of adapter to be used with Arduino Pro Mini, please read the guide on Arduino.cc. We are using a 3.3v Arduino Pro Mini, so we don't need to connect the pin for 5V. Also please make sure the RX pin of this module goes to the TX of the Arduino and vice versa.

First of all, I would like to introduce about the logical structure of the main loop in the sketch.

void loop() {  // This part only activates when serial communication with PC is available
  if (Serial.available()>0) { // USB adapter connected and user input received
     1) TODO...  }
  // Look for RFID tag
  if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial()) {
      2) TODO...
  }
  // check if the pushbutton is pressed. if it is, the buttonState is LOW:
  if (buttonState == HIGH) {
      3) TODO...
  }
  // check if battery is low
  if(vcc.Read_Volts()<3.9) { 
      // it is found that battery level below 3.8v hampers performance; however,
      // due to detection inaccuracy, we set it to below 4v for recharge request
      4) TODO...
  }
  //check if idle for more than 5 mins 
  if(millis()-lapsTime>300000.0) {
      5) TODO...
  }
}

The first section of codes deals with the procedure of assigning new UID to RFID tag.

The user will be prompted to press 'S' or 's' to start the writing session. So, the logic in 1) will be as follows.

if (tmp[0] =='s' || tmp[0] == 'S') { // start writing session
    Serial.println("Press ordinal number of Pokemon monster you want to write or -1 to end writing session.");
  }
     while (wcommand==0) { 
         if (Serial.available()>0) { // received user input
               if (ans == -1) {
                   wcommand = -1;  //end of writing session
              }else if (ans >0 && ans <256) { 
  		   // valid ordinal number for MP3 files
                   assignID();
               } else {      
		  // Invalid number; valid numbers usually from 11 to 255     }
               }
    }
 }

The variable tmp is a String holding the user input. We only check whether the 1st character is 's' or 'S'. If an 'S' is received, then wcommand will be assigned as 0 signifying the start of writing session and is used to decide whether the user wants to continue writing new UIDs; i.e. remaining in the while loop. The subroutine for assigning new ID is assignID().

void assignID() {    // assign new monsterID to newBlk[3]
    newBlk[3] = monsterID;
    int temp = 0; // for holding checksum
    for (int i=0; i<4; i++){ // calculate checksum by XOR the first 4 bytes
      temp = temp ^ newBlk[i];
    }
    newBlk[4]= temp;    
    if ( mfrc522.MIFARE_UnbrickUidSector(false, newBlk) ) { //unbrick tag and write new UID
      Serial.println(F("Cleared sector 0, new UID set."));
    }else {
      Serial.println("Card not rewritable?");
    }
    //delay(1000);
    monsterID= 0x01; // reset to default
}

Here, I made use of the library created by Miguelbalboa which can be downloaded at Miguelbalboa/rfid. During the testing phase, I came across some RFID tags not responding to the normal write UID command. So, I tried the newer command MIFARE_UnbrickUidSector and reactivated them successfully. Therefore, I added a second parameter to the function call so that end-user program can pass a new ID and do the unbricking and assigning in one pass. The modified version of MFRC522.cpp and MFRC522.h are included here. Simply download and copy them into the libraries folder of your Arduino directory. (Delete or remove any existing MFRC522.cpp and MFRC522.h.)

Obviously, for a simple usage like this one, a 4-byte UID is more than enough. I use the 4th byte to hold the ordinal number representing the corresponding MP3 file in the JQ8400FL. The value of the first two bytes (0xAA, 0xBB) are arbitrary and are used for labeling all my Pokemon Monsters. BTW, the newBlk[] is a 16-byte array initialized as a global variable at the beginning of the sketch.

Step 10: The Sections for Detection of RFID Tag and Playback of Audio

The getID() function is used for reading the UID of the available RFID tag.

void getID(){<br>  if (mfrc522.uid.uidByte[0]==0xAA && mfrc522.uid.uidByte[1]==0xBB) {
      // it is a Pokemon monster tag
      monsterID = mfrc522.uid.uidByte[3];
  }else {
      // it is NOT a Pokemon monster tag
      monsterID = 0x01; // default for unknown monster
  }
}

At the beginning of the sketch, I have already defined some useful UART commands for JQ8400.

// UART commands to JQ8400FL<br>byte Cmd07[6]= {0xAA, 0x07, 0x02, 0x00, 0x04, 0xB7}; //play 1st MP3; filename : 01.mp3
// Cmd07[4]= 0x02; Cmd07[5]= 0xB5;  2nd MP3; filename: 02.mp3
byte Cmd13[5]= {0xAA, 0x13, 0x01, 0x14, 0xD2}; // set volume to level 20
// level 0 to 30; default= level 20; {0xAA, 0x13, 0x01, 0x0A, 0xC8} set to level 10
//{0xAA, 0x13, 0x01, 0x14, 0xD2}; // set volume to level 20

Our main concern is the command no. 7 - playback of specified MP3. The fifth byte is used to hold the ordinal file number. The last byte is the checksum byte which is handled by my code in the second section as follows.

// Look for new cards, and select one if present

  if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial()) {  
      // Now a card is selected. The UID and SAK is in mfrc522.uid.
      getID(); //read tag UID
      // assign Cmd07[4] to monsterID
      if(Cmd07[4]==monsterID){
        // existing monster: not new; do nothing
      }else {
        // new monster detected
        Cmd07[4]= monsterID;
        unsigned int tmpChksum = 0;
        for (int i=0; i<5; i++) { // calculate checksum for JQ8400 command07
            tmpChksum += Cmd07[i];
        }
        Cmd07[5]= lowByte(tmpChksum);
        lapsTime = millis();        
      }
  }

At this point of time when a RFID tag is available, we only read and prepare the playback command. The actual playback operation will be triggered by the button on the Pokemon Ball. So, the code is in the section three.

// check if the pushbutton is pressed. if it is, the buttonState is LOW:

  if (buttonState == HIGH) {
      // turn LED off:
      digitalWrite(ledPin, LOW);
  } else {
      detachInterrupt(digitalPinToInterrupt(buttonPin)); // avoid interruption to audio playback
      // turn LED on:
      digitalWrite(ledPin, HIGH);
      Serial.print("playing ... ");
      playAudio();
      pinMode(buttonPin, INPUT_PULLUP);
      lapsTime = millis();
      attachInterrupt(digitalPinToInterrupt(buttonPin),showTime, LOW); 
      buttonState= HIGH;
  }// end if buttonState == HIGH

The funciton playAudio() is as follows.

void playAudio(){

    Serial.print("playing ... ");
    mySerial.write(Cmd07,6);  // play MP3
    if (mySerial.available()>0) { //print return value if any
          String tmp = mySerial.readString();
          Serial.print(tmp);
    }
    delay(9000);
    Serial.println("MP3 playback ended");                                  
}

There is a delay for 9 seconds so as to allow the audio to complete. You can adjust the duration if your audio is in different length.

Step 11: Energy Concerns I

Although the power requirement of JQ8400-FL accepts voltage ranges from 3.3v to 5.5v and optimally at 4.2v, there is obvious degradation of performance when the voltage drops below 3.9v. In addition, avoidance of complete discharge to the lithium-ion battery ensures its longer lifespan. Therefore, there is a block of codes that detects the battery voltage and plays a request for recharge in section 4.

// check if battery if low  

if(vcc.Read_Volts()<4.0) { 
      // it is found that battery level below 3.9v hampers performance; however,
      // due to detection inaccuracy, we set it to below 4v for recharge request
      detachInterrupt(digitalPinToInterrupt(buttonPin));
      Cmd07[4]= 0x03; //3rd mp3 :request for recharge 
      Cmd07[5]= 0xB6;
      Serial.print("playing recharge request! ");
      playAudio();
      // unmask for going to sleep mode right afterwards
      //lapsTime -= 300000.0;        
      // mask the attachInterrupt command to enforce users to recharge battery
      //attachInterrupt(digitalPinToInterrupt(buttonPin),showTime, LOW); 
  }

I adopted the Arduino_VCC written by Yveaux for detection of battery voltage. The best part of it is that it requires no external component. Although it's reading has certain deviation, but it is good enough for our purpose.

The need of the fifth section is due to the 'hefty' power consumption even in idle (more than 40mA). The very first thing I thought of is to tune down the Arduino to sleep mode. The LowPower library of RocketScream was compact and powerful. It serves this purpose well. Then, I realised that the power required by the MFRC522 module is more than 20mA, which is way higher than the Arduino. So, The deepSleep function should set the MFRC522 to sleep mode too. This is done by setting the RST pin of MFRC522 to LOW. The net effect is to slash the sleep time consumption below 20mA so that a small lithium-ion battery of 600mAH can last for more than a day. If further reduction is required, I suggested to remove the LEDs on the module and Arduino to cut down their power consumption. Consider this a radical measure for those of you who are bold enough. There is a valuable piece of information about further cutting down power requirement of Arduino Pro Mini by MadCoffee for your reference. This way make sure the power requirement drops below 15mA in sleep mode. (Regrettabbly, the manufacturer of JQ8400 is not helpful. I can't find any UART command to send the module into standby mode, otherwise, the idle current would just be a low single digit.)

A global variable lapsTime is used to keep track of the time of operations.

unsigned long lapsTime=0.0;

Then,

lapsTime = millis();

is added into the first three sections to record the time stamp so that if the Pokemon Ball idle for more than 5 minutes, section 5 will call deepSleep().

if(millis()-lapsTime>300000.0) {    // turn LED off:
    digitalWrite(ledPin, LOW);
    // idle time > 5 mins go to sleep mode 
    deepSleep();
    lapsTime = millis();
    mfrc522.PCD_Init(); // Init MFRC522 card
  }</p>

The function requires only one line of code calling the idle function of the LowPower library.

void deepSleep(){
    Serial.println("Go to sleep now."); 
    digitalWrite(RST_PIN,LOW); // turn on sleep mode of MFRC522
    LowPower.idle(SLEEP_FOREVER, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, 
                SPI_OFF, USART0_OFF, TWI_OFF);
}

After the system falls asleep, it requires something to wake it up again. Therefore, an external interrupt was set using the digital pin 2 hooking with INT0 (interrupt 0). This statement is added in the setup():

attachInterrupt(digitalPinToInterrupt(buttonPin), showTime, LOW);

Whenever the mini touch switch is pressed, the interrupt will trigger the showTime() function as follows.

void showTime(){ // change the buttonState for playback MP3
  buttonState = LOW;
  digitalWrite(RST_PIN,HIGH); // enable MFRC522
}

Step 12: Energy Concerns II (Optional)

In case your Lithium battery does not have circuit for prevention of over discharge, the measures I've just introduced may not help much as the battery may still be gradually depleted even when the Arduino and MFRC522 are in sleep mode. (The battery I included in the BOM list does come with such a circuit.) So, there is a better solution as follows. The only downside is that you need to get your hands a little bit dirtier with some more soldering work and extra components. You may consider it a slightly advanced option

The first change we need to have is a more precise monitoring of battery voltage. The second feature we need to add is the ability to cut off the power when needed.Similar to the library of Yveaux, many voltage detection methods rely on the internal voltage reference of the ATMEGA chip itself. Unluckily, the percentage of error is as high as 10%. In addition, what we need to measure is the same voltage supplied to the Arduino; that is the gradually decreasing voltage of the battery. So, in theory, it cannot be accurate unless we introduce an external voltage reference. There are a number of voltage regulating diodes available in the market.The one I chose was LM4040AIM3-2.5, which provides a stable 2.5v output when coupled with a 3.6K ohm resistor. [Resistance is calculated by minimum voltage level of Li-Ion battery assumed at 3V minus 2.5v output and divided by 0.138mA (mini. diode current)] For a more detailed explanation, please read the article of John Errington.

An extra problem is the Arduino Pro Mini itself. The VREF pin (pin 20 of the ATMEGA 328) does not have any external pin connection. There was a suggestion on the web to extend the VREF to one of the RST pin on the Arduino Pro Mini, but I found it impossible for the new Chinese-made version I had on hand. Therefore, I resorted to sacrifice the A7 instead. First, use a sharp cutter to cut the connection between A7 and the pin 22 of ATMEGA 328. Verify the open state with a multimeter. Second, solder a small cable between A7 and the pin 20. It is easier to solder the cable at the point of contact with the capacitor as shown in my photo. Now, you can read external voltage reference.

In order to test the actual voltage level of the battery instead of the VCC of the Arduino, a simple voltage divider composed of two resistors (roughly in 9 to 1 resistance ratio) generates a one-tenth voltage to analog pin 3 for comparison with the external VREF. You may forget the daunting number with 11 significant figures in my code below. It is the 2.44mV calculated by dividing 2.5V by 1024. (The 10 bit resolution of Arduino ADC offers 1024 levels.) The 10.46% reflects the voltage at A3 is only about one-tenth of the original voltage after the voltage divider. In addition, we need to iterate several times so as to get a more reliable reading.

void vccCheck() {
  analogReference(EXTERNAL); // reference to VREF (at 2.5v)
  for(int i=0; i<3; i++){
    battLevel = analogRead(battIn); // read A3
    battVolt = battLevel * 0.00244238281 / 0.1046;
    }
}

Next, we need to deal with the ability to cut the power supply when the voltage drops to a critical level. I set it to a much higher voltage because I found that the JQ8400 begins to produce coarse audio below 3.9V. The key component is a P channel MOSFET IRF9540N that turns on when its gate is having negative or zero volt. A NPN transistor is used to sink the voltage of the gate upon receiving output from pin 7 of the Arduino. A 6-pin push button, which replaces the original 2-pin push button, will then be needed to kick start the power supply for all the circuits at the very beginning. You need to press and hold on for about one second in order for the loop routine to start.

We need to change the fourth section as follows.

// check if battery is low
  vccCheck();  //<<<<- new
  if(battVolt<=3.9) { 
      // it is found that battery level below 3.9v hampers performance
      detachInterrupt(digitalPinToInterrupt(buttonPin));
      Cmd07[4]= 0x03; //3rd mp3 :request for recharge 
      Cmd07[5]= 0xB6;
      Serial.print("playing recharge request! ");
      playAudio();
      // unmask for going to sleep mode right afterwards
      //lapsTime -= 300000.0;        
      // mask the attachInterrupt command to enforce users to recharge battery
      //attachInterrupt(digitalPinToInterrupt(buttonPin),showTime, LOW); 
      // Cut the power
      digitalWrite(pwrPin, LOW);  //<<<<- new
  }

BTW, I found the free-of-charge browser-based EasyEDA software very easy to use. It has schematics of a lot of components including arduino boards. You can design your schematics, layout the PCB, and even share them with others. I highly recommend you guys to try.

Step 13: Placement of Electronic Modules in the Pokemon Ball

A round plastic plate of 9cm diameter has to be placed at the level of the latch receiver in the bottom half of the sphere. The RFID module has to be placed at the middle of the plate. In order to minimize magnetic interference, Arduino Pro Mini and JQ8400-FL-10P are perpendicular to the plate. Holes have to be drilled on the plate for two micro USB sockets (one for battery recharge; another one for saving MP3 files in the JQ8400-FL-10P), 5 female Dupont pins (for connection with USB to TTL converter for uploading program), main power switch (DPDT), and two flashing RGB LEDs. I found it a lot tidier to use flat ATA100 IDE cables for connecting components. You may salvage an old one or buy it at about USD0.8.

Due to the orientation of the JQ8400, an extension of its micro USB adaptor is needed for connection with a PC. So, I used a string of 5-pin cable cut from a ATA100 IDE flat cable to connect a male micro USB adaptor with a female micro USB adaptor, which is mounted on the plastic plate.

Step 1: I assembled the plastic plate with the touch button in place and put it into the bottom half of the ball to make sure the level of correct. Also, the thickness of the keeper or hook part is about 3mm, so the gap should be about 4mm.

Step 2: install the two LEDs, two micro USB female socket, 5 female Dupont pins by hot glue. I soldered the DPDT switch on a small piece of Perfboard before sticking it on the plate.

Step 3: hot glue the loudspeaker to the top half of the ball. Make sure it has a pair of wire with male connectors.

Step 4: place the MFRC522 module at about the center position. The MCU on one side and the JQ8400 on the other sider.

Step 5: Hot glue the Li-Ion battery to the bottom the ball.

Step 6: After connecting all the wires of the circuit, hot glue the 'floor' to the bottom half of the ball. And connect the cables for the loudspeaker.

Step 7: decorate the 'floor' with a shiny paper.

Step 14: What's Next?

As my intention of making this 'toy' for kids was to let them have hands-on experience in making their dream comes true. The completion of the Pokemon Ball itself is not the end of the game. This can serve as a platform for further development. Don't forget there are 1024 bytes of memory of a RFID tag. It can be used for storage of other information such combat value of monsters. Additional component can be added to make way for new capabilities and new way of playing. Try to encourage your kids to imagine new improvement and have fun!