Class - Shield Lancer Download For Mac

admin



2013-01-03T08:55:23Z

Posted by Miguel Grinberg under Robotics, Arduino, C++, Programming.

Welcome to the second article in the tutorial series in which I'm building a remote controlled Arduino based vehicle robot.

Here is the list of articles I have published:

  • Part II: Programming the Arduino (this article)

In the previous article I introduced you to my project. I showed you the parts I bought and what features I wanted to implement in my little remote controlled robot vehicle.

Today I will introduce you to the programming side of my project. This is a pretty long article that is heavy in information that can be applied to most Arduino projects. By the end of it you will know the basics of programming sensors, motors and other devices connected to the Arduino, and will also have an understanding of how a wireless remote controller can communicate with the Arduino board over Bluetooth. I encourage you to get the parts I listed in the previous article and try these tests along with me.

The Arduino Pins

Follow these simple four steps to easily download a VPN for Mac in seconds. Download Hotspot Shield VPN on your Mac. Select location. Select the VPN server location you wish to connect to. Open up the Hotspot Shield app and click “Connect” Step 4. Enjoy your favorite content with. Hero Siege - Shield Lancer (Class) available on Steam. 53% positive of 15 user reviews. 0 users have this game to trade, and 13 want it. Establish instantly comprehensive, permanent, real-time remote access, control, and support through secure global network.

The Arduino board communicates with connected devices via its input and output pins, so I'll quickly go over what these pins are.

Here is a diagram of a typical Arduino board.

On the left side you have the USB port (grey box) and the power input jack (black box). During testing I will be powering my Arduino with a USB cable, but the final robot will receive power from a battery box connected to the power input jack.

On the top, from right to left there are 14 pins labeled 0 to 13. These are the digital pins. These pins can be individually configured as inputs or outputs, meaning that digital data can be read or written from connected devices on these pins. Since these pins are digital, they have only two possible states, HIGH and LOW.

Some of the digital pins have preassigned functions. Pins 0 and 1 are also labeld RX and TX respectively. These are used by the serial communication hardware to send and receive data. Pin 13 has a LED attached to it on most Arduino boards, so it is a convenient pin to send simple visual information out to the real world. The pin 13 LED is located below the pin 13 itself, labeled with the letter L in the diagram above. Pins 3, 5, 6, 9, 10 and 11 are marked with a ~ or a PWM label, short for pulse width modulation. These pins are capable of producing simulated analog output over a digital line. These can be used, for example, to light a LED at different levels of intensity.

The next pin on the top from right to left is GND, short for ground. The ground is what closes a circuit and allows the electric current to flow uninterrupted. Connected devices can connect their own GND pin here.

The next pin on the top left is labeled AREF, short for analog reference. This pin is rarely used, it tells the Arduino how to configure the voltage range of the analog pins.

Some Arduino boards have more pins to the left of AREF. Since these are not in all boards I will not discuss them here.

On the bottom right we have six pins labeled 0 to 5. These are the analog input pins. Unlike the digital pins which have only two possible states, an analog pin can have 1024 possible states, according to the voltage applied to it. Typically the voltage range goes up to 5V, but the range can be changed by applying the desired maximum voltage to the AREF pin. Also unlike the digital pins which can be configured as inputs or outputs, the analog pins can only be inputs.

An interesting property of the analog pins is that they can be used as digital pins as well, with pin numbers 14 to 19. You will see later that an important part of any project is allocating pins to components. If you are running short of digital pins keep in mind that you have six more available to you.

Continuing on the bottom from right to left we find a pin labeled VIN. This pin provides direct access to the voltage provided by the power supply. So for example, if you power your Arduino with a 9V power supply through the power jack, then this pin gives you 9V.

The next two pins are labeled GND and are two more ground pins, exactly like the one in the top row. They are here just for convenience.

The next two pins are labeled 5V and 3.3V and just return those voltages, regardless of what the voltage of the power supply is.

Next we have the RESET pin. When this pin is connected to GND the board will reset. So this is a handy pin to build an external reset button.

As with the top row of pins, some boards have a more pins on the bottom left that I will not cover here. If you are interested in finding out what extra pins in your board do you should consult the documentation for your board.

Programming the Arduino with Sketches

By now you are probably wondering how can you make the Arduino do things.

The easiest way to program the board is with the Arduino software, which is free and open source, and available for Windows, Mac OS X and Linux users.

Here is a screenshot of the Arduino software:

The white area is where the program is written. The programming language that the Arduino platform uses is called C++ (pronounced see plus plus), a language that is regarded as very powerful but difficult to learn. I will try to explain the basics of C++ in this and the following articles, but I will not cover C++ programming in detail. If you have any specific C++ programming questions I'll be happy to address them in the comments at the bottom.

C++ programs are written as regular text. Arduino calls these programs Sketches. Then a utility called compiler reads the sketch and converts it to machine instructions that the Arduino understands.

The black area at the bottom of the Arduino software window is where status information appears. For example, if your C++ code has an error this is where you will see the details.

The Arduino software also has a toolbar, with the following buttons (in order, from left to right):

  • Verify: Runs the C++ compiler on your program. If there are any errors you will see them in the black status area.
  • Upload: Compiles your C++ program like the Verify button does, and if compilation is successful it uploads the resulting program to the Arduino board, which must be connected to the computer through the USB port.
  • New: Clears the program currently loaded.
  • Open: Shows a dropdown with a long list of example programs to load or the option to load a sketch from disk.
  • Save: Saves the current program to a file on disk.
  • Serial Monitor: Opens the serial monitor console. This is used mostly for debugging, as I will show in a little bit.

'Hello, world!', Arduino style

To begin, let's write a very simple program that writes a message to the serial port. We will see this message in the Serial Monitor.

I assume you will be doing this with me, so please follow along.

First install the Arduino software. Installation instructions are very simple, you should not have any trouble with this step.

Start the Arduino software making sure the Arduino board is not connected to your computer. Open the Tools menu, then the Port submenu. Take note of the options that appear here and then close the Arduino software.

Next connect your Arduino board to your computer using the USB cable. If you are doing this on Windows, then see this page for instructions on how to install the Arduino board drivers. If you are on Windows 8, also see this page for information on how to bypass the requirement for signed drivers. Mac and Linux users are lucky and do not need to install any drivers.

With the Arduino board connected, launch the Arduino software again. In the Tools menu open the Board submenu and make sure the correct model of Arduino board is selected. Then in the Port submenu find the serial port entry that did not appear in the list when you had the Arduino board disconnected. That's the serial port that is assigned to the Arduino connection, so select that one.

Then in the white area type (or copy/paste) the following C++ program:

Press the Upload button to compile and upload the sketch to the board. If you made any mistakes they will be indicated in the black status area. At this point the errors will look very cryptic if you are not used to programming in C++, so the best you can do is compare what you typed against the above and fix any differences you find until the upload operation succeeds.

If the Upload is successful the status area will show a message similar to the following:

Binary sketch size: 1,978 bytes (of a 32,256 byte maximum)

At this point the program is running inside the Arduino. You will notice that the LED labeled TX blinks every once in a while, indicating the Arduino board is transmitting data through the serial port.

To see the data click on the Serial Monitor button in the toolbar. At the bottom right of the serial monitor window make sure the drop-down is set to 9600 baud. You should now see the message Hello, world! printing in the window every second.

Congratulations, you've completed your first Arduino sketch!

I'm sure you want to understand a little bit how this sketch works, so let me give you some information.

Arduino sketches have two main functions, called setup and loop. When the program starts it will execute the setup function. This function is supposed to initialize the hardware and get it ready for operation. Then the loop function will be called repeatedly until the Arduino is reset or powered off. If you look at the code above you will see these two functions, each starting with the word void followed by the function name, and ending with a closing curly bracket.

What goes before the opening curly bracket is called the declaration of the function. What goes in between the opening and closing curly brackets is the actual code of the function, or in other words, the instructions that the Arduino executes when the function is invoked.

In this small example the setup function initializes the serial interface by calling the Serial.begin function. What goes in between the parenthesis are called arguments, and each function defines what arguments it needs, if any. The Serial.begin function requires the speed of the serial communication to be given as an argument, in baud units. I selected 9600 bauds in this example. The statement ends with a semicolon, this acts as a statement separator.

Now how do you know what functions you can use in your sketches?

That's what the Arduino reference is for. This page has a quick reference for C++ and the list of all the functions that are provided by the Arduino development environment.

For example, let's say you want to know all the functions related to serial port communications. Then you can open the Serial link under the Communications section. You will find the begin function I used above listed there. Note that outside of any context the function is called Serial.begin, but when the context is clearly in the Serial class, then it is enough to call the function begin. If you now wanted to see information about the arguments required by the Serial.begin function you just click on it to go to the Serial.begin documentation.

The Arduino reference documentation is very good so I recommend you keep it open in a browser window at all times when you are writing sketches.

Let's go back to our example. The second function is the loop function. This function makes two function calls. First it calls Serial.println, passing the message 'Hello, World!' as an argument. As you can guess, the Serial.println function prints a message to the serial port. The message is given as a character string, within double quotes. The function is called println and not print because in addition to printing our message it ends the line, meaning that the next print will start at the beginning of the next line. There is, in fact, a print function that prints the message and does not move to the next line.

The second and last instruction in the loop function is a call to a function called delay. This function pauses the program for the amount of time specified as an argument. The units of time are given as milliseconds, so I'm passing the value 1000 to pause the program for one second.

Since the loop function is invoked repeatedly, the result of this program is that the text Hello, world! is printed to the Serial Monitor every second.

Working with LEDs

Let's look at an improved version of the previous sketch:

Enter the code above in the code window of the Arduino software replacing the old sketch and upload it to your board to test it.

If you understood the first sketch then you can probably figure out what this version does easily.

In the setup function in addition to initializing the serial port like before I'm also initializing pin 13 as an output pin. Recall that digital pins can be used as inputs or outputs, so whenever you need to use a pin you have to configure it for the intended use. In this case I'm making it an output pin, which means that I can write a value to this pin, and the value I write will affect the electrical current coming out it. See the pinMode documentation for details on this.

The loop function prints the message to the serial port like before, but then sets pin 13 to a HIGH state with the digitalWrite function. In most Arduino boards this lights the on-board LED. Then the program pauses for 500 milliseconds, or half a second. Then the state of pin 13 is changed to LOW to turn the LED off. Then the program sleeps for another half a second.

Download

The loop function is called over and over again, so what the above code does is make the LED blink! It blinks at a rate of one blink per second, staying on for the first half second, then off for the other half.

Programming the Distance Sensor

Now you know how to do the basic stuff that appears in every Arduino introductory tutorial. Are you ready to do something real with your Arduino? I hope you are!

I'm going to show you how to program the HC-SR04 distance sensor. Recall that I will be using this sensor to help my robot 'see' and avoid walls and obstacles.

For most devices that connect to the Arduino board there are already appropriate libraries of functions incorporated into the Arduino software. You can see what libraries are included by going to the Sketch menu, 'Import Library...' submenu. You will see libraries there for motors, LCDs and a variety of other devices.

Unfortunately there is nothing for distance sensors. So how can one control such a device?

In most cases manufacturers of Arduino compatible devices provide the required libraries to control their products. Other times developers write their own libraries and make them available as open source. The documentation of the device is the first place to go, but as always in cases like this, Google is your best friend.

Searching around I've found not one but three open source Arduino libraries for my distance sensor, here, here and here. I quickly reviewed them and out of the three the arduino-new-ping library appeared to be the most complete, so I decided to give that one a try first. If that one does not work I can always go get one of the other two.

The library comes in a zip file, available as a download link in the page linked above. To install it and make it available in the Arduino software you just need to unzip it and copy the top folder (called NewPing) inside the libraries folder in your Arduino sketches folder. The Arduino sketches folder is in your home directory, see the documentation for details.

After you install the NewPing library close and reopen the Arduino software so that it can recognize it.

Now start a new sketch, go to the Sketch menu and select 'Import Library...'. You should now see NewPing in the list. If you select this library the following line will be added to your sketch:

This is telling the C++ compiler that you will be using the functions from the NewPing third party library. Note that you don't have to go through the menus to get this text written for you, if you prefer you can write it yourself.

Before I show you the sketch that controls the distance sensor take a look at the following wiring diagram:

As you see in the diagram I'm using the breadboard and some jumper cables to make all the connections.

First I connected the 5V output from the Arduino to the 'red' side of the top section of the breadboard, and the GND line to the 'blue' side. The top and bottom sections of the breadboard have 'red' and 'blue' sides, and these are typically used to distribute power and ground lines to the whole breadboard. Plugging the 5V output to one of the red pins makes the 5V available to all the red pins in that row, and likewise, connecting GND to a blue pin makes GND available in all the blue pins in the row.

Next I transferred the 5V and GND lines to the bottom part of the breadboard with two more jumper cables. This is always a good practice when prototyping, setting up the breadboard like this ensures that you can always grab your power and ground lines from the side that is most convenient.

The distance sensor plugs nicely into four consecutive pins in the middle of the breadboard. The two middle sections of the breadboard connect groups of five vertically aligned pins together, so to make a connection to one of the sensor pins I just plug one end of the jumper cable into any of the remaining four pins in the same group.

The leftmost pin is labeled VCC, this is the pin that should be connected to the 5V line. So to do that I connect a jumper cable to this pin from the sensor to one of the red pins in the breadboard bottom. The next two pins are labeled Trig and Echo. These connect to any two available pins in the Arduino board. Since any pins will do, I will be using analog pins 0 and 1, which as I said before can double up as digital pins 14 and 15. The rightmost pin is labeled GND, so the connection can go to any of the blue pins at the top or bottom of the breadboard.

Here is an actual picture of how this circuit looks in real life:

So far it's been pretty easy, right?

Let's see what the sketch looks like:

There are a couple new things in this sketch that I haven't used in the previous ones, but overall things are largely similar.

The #include statement at the top tells the C++ compiler that I will be using a third party library. The NewPing.h between the angle brackets refers to a header file that is inside this library. This file contains the definitions for all the functions provided by the library. If a library does not have documentation, chances are there is information at the top of this file.

Next there are a few #define lines. If you recall the LED blinking sketch from above, I have written the pin number 13 in a couple of places there. Instead of using the number directly I could have defined a constant. That's what #define does. You use it to give a value a meaningful name, then in the rest of the sketch you can write the name instead of the value. This is useful to make the code more readable, but also makes it very easy to change the pin assignments, because then you just go to the top of the sketch and update the numbers in just one place.

In this sketch we have three #define statements. The first two create constants for the Trig and Echo pins of the distance sensor which I connected to pins 14 and 15 respectively (analog pins 0 and 1). The third #define is to set a constant for the maximum distance that I want the sensor to recognize, which I set to 2 meters, using centimeter units.

Next we have the following statement:

This statement creates an object that represents the distance sensor. The syntax for object creation requires the class of the object first (NewPing in this case), then the name I want to give the object (DistanceSensor) and then any arguments enclosed in parenthesis. The arguments that the NewPing object requires are the trigger pin, the echo pin and the maximum distance to consider, all in that order and separated with commas. These happen to be the three constants defined above, so I can write the names instead of the values.

Note that the object is created outside of any functions. Objects can exist only at the level they are created, so creating the object inside the loop function would make it disappear when that function ends. The next time loop is called a new object would be created and initialized, which would be a waste of time and effort. Putting the object creation outside of any functions makes it a global object that persists across function calls.

The setup function is exactly like the one I used before, it just sets up the serial communication so that we can see output from the Arduino board in the Serial Monitor.

The loop function starts with a type of instruction that I haven't used before:

Let's analyze this statement one piece at a time. To the right of the = sign I am invoking a function called ping_cm provided by the DistanceSensor object created above. This function is slightly different than functions I used before, because in addition to doing something it returns a result, which in this case is the distance to the closest object measured in centimeters.

Since I intend to use this distance result later in the sketch I have to store it somewhere, so to the left of the = sign I have created a variable, which is basically a space in memory where a value can be stored. The C++ syntax for variable creation requires me to provide the type of values this variable will store first (unsigned int in this case, a positive integer) and then the variable name, which is any name of my choosing that I will use later to refer to the value stored in the variable.

As a side note, the distance sensor library documentation indicates that there is also a ping_in function that is equivalent to ping_cm but returns the distance result in inches. Another option provided by the library is a function ping, which just returns the time it took the ultrasonic signal to make a round trip back to the sensor in microseconds. You can then divide this time by the time it takes sound to travel twice the distance units of your choice to get the distance in those units. For my purposes having the distance in centimeters is accurate enough.

Next in the loop function I have three consecutive prints to the serial port. The first two prints use the Serial.print function and the last uses Serial.println. That means that the second and third prints will go to the same line as the first, and after the third message is printed the cursor will move to the next line.

The first and last print statements print text messages like in the previous sketches. The middle print, however, prints the cm variable, in which I have the result of the distance sensor ping_cm function.

The final line in the loop function does a delay of one second, exactly like before.

When you run this sketch on your board and move your hand or some other object closer and farther away from the sensor you will see something like this in the serial monitor:

Fun with motors

Let's move on to something else. The vehicle kit that I'm using for my project comes with two wheels, each with an attached motor.

The motor driver board that I have is the Adafruit Motor Shield, which comes with its own library, called AF_Motor. If you are using the same motor controller then go ahead and install this library in your Arduino environment. If you are using a different motor controller then you'll have to find the library that works for your hardware.

Most motor controllers come as a shield, which means that the motor board plugs right on top of the Arduino board, connecting to both rows of pins, even though many of the pins are not used to control motors. The nicer motor shields provide pass-thru headers with access to all the Arduino pins. Unfortunately the Adafruit shield does not give access to the pins, so connecting additional components becomes difficult. This is a problem I'll have to work around.

The Adafruit motor controller can drive up to four DC motors, labeled M1 through M4 in the board. I need just two, so for convenience I'm going to connect my two motors one on each side of the board, using the M1 and M3 connectors.

To test the motors on the assembled kit I turned it upside down, so that I can see the wheels turn without the vehicle moving while the Arduino is connected to the USB power. The motor connections are extremely simple, each motor has just two connections:

The Arduino board is hidden underneath the motor shield in this picture.

Here is the sketch that I used to test the motors:

I don't think I need to explain every line in this sketch, since it does not have any new C++ constructs. Like the distance sensor, each motor requires an object to be created, this time one of class AF_DCMotor. The only argument is the motor number, from 1 to 4. I created two motors, numbers 1 and 3 to match the motors connected to ports M1 and M3 of the controller.

The motors are controlled with two functions, setSpeed and run. The setSpeed function takes a numeric argument with range 0 to 255, indicating the speed the motor should turn. The run function configures the mode in which the motor runs, which can be FORWARD, BACKWARD, BRAKE or RELEASE.

The sketch above makes the wheels do a few tricks: one second of both wheels going forward, then one second of both wheels going backwards, then one wheel forward and the other backwards, then each wheel reverses direction, then the wheels stop for a second. Then the cycle repeats with the next invocation of the loop function.

Remote Control over Bluetooth

The final piece of hardware that I intend to use in my Android robot vehicle is the Bluetooth slave, which connects to my smartphone to receive remote control commands.

I expected bluetooth communication would be the most complex aspect of my project, but after reading the one page documentation that came with my device I was proved wrong. Turns out the bluetooth slave works over the standard serial communication protocols in the Arduino board, which means you use the functions in the Serial class like I used in all the previous sketches. When the Arduino board with Bluetooth is paired with a smartphone a Serial.print command will send the data not to the PC but to the phone! The Serial class also has functions to read data from the other end, so I will use these functions to receive commands from the smartphone.

The wiring of the bluetooth slave is pretty simple:

Note how the RX and TX pins in the Bluetooth slave go to digital pins 0 and 1 respectively, the pins that are dedicated to serial communications.

This is how my actual circuit looks like with everything connected, noting that in the picture below the Bluetooth dongle is facing the other side, so the connections appear reversed from the diagram above:

An example sketch that allows remote communication is below:

The setup function does not have anything I haven't done before. From reading it you can guess that I'm going to be playing with the pin 13 LED again.

In the loop function I'm introducing a new type of C++ statement, the if statement, sometimes also called conditional. A conditional is useful when you want the program to do something only when a condition is true.

What follows after the if keyword is the condition, enclosed in parenthesis. In my sketch the condition that I'm checking is Serial.available() > 0. To know if this condition is true or not the Arduino will invoke the function Serial.available, which returns the number of data bytes that have been received in the serial port, and compare that number against 0. If the number of available bytes is greater than 0 then the condition is true, so the instructions that are between the opening and closing curly brackets will be executed. If the condition is not true, then the whole group of instructions inside the curly brackets will be skipped.

Do you understand why a conditional makes sense in this case? The Serial.available function will return a positive number only when the master on the other end of the serial communication has sent data. Saying if Serial.available() > 0 in C++ is the same as saying 'if there is data available' in English. If the condition is not true (which is the same as saying it is false), then it means that at that moment the remote controller has not sent any data, so in that case I have nothing to do and skip the whole thing.

So what happens when the condition is true?

The very first thing I do inside the if block is read a byte from the serial port, using the Serial.read function. Note that I use a variable to store the result, but this time I declared the variable with the type char, which in C++ is the type that represents one byte of data.

Once I have my byte of data I print it, using our old friends the print and println functions.

After I print the data received I have another conditional (note how I indent my sketch to make it very clear that I have one if statement inside another). This time my condition is ch 'a', which as I'm sure you guessed, will be true only when the lower case letter a is the data received. In that case I set pin 13 to HIGH, which turns the LED on.

The else statement that follows is an extension to the if. I said before that when the if condition is false the instructions inside the curly brackets are skipped. When a conditional has both if and else blocks the condition determines which of the two blocks executes. If the condition is true the block that follows the if executes and the block that follows the else is skipped. If the condition is false the block that follows the if is skipped and the block that follows the else executes.

Do you see what this conditional does, then? When the Arduino receives an a it will turn on the pin 13 LED. Any other data received will turn it off. With this simple sketch I built a remote control for the LED in the Arduino board!

When trying to upload this sketch to my Arduino I've found that often the upload failed. I believe this is a result of a collision between the serial communication established by the computer and the one from the Bluetooth slave. It appears that the Bluetooth slave wins and prevents the computer from talking to the Arduino. I have found that disconnecting the RX and TX pins from the Bluetooth slave when I need to upload a new sketch solves the issue.

Are you ready to try this?

Go ahead and install BlueTerm in your Android device. This app works exactly like the Serial Monitor from the Arduino software. I suppose there is an equivalent app for iOS, if you have found one that works please let me know in the comments below.

Update: It appears that nBlueTerm is an equivalent application for iOS devices, though I haven't had a chance to test it yet.

If you don't have a smartphone or the Bluetooth slave you can try this sketch using the serial communication to the computer and the Serial Monitor.

Once you have the app in your Android device and the sketch uploaded to the Arduino you are ready to go. Start by powering up the Arduino (via USB cable or power supply). The red LED in the Bluetooth slave will blink rapidly, indicating it is ready to pair with another device. Start BlueTerm in your smartphone and select 'Connect Device' from the menu. The Bluetooth pairing window should appear and should show a device with name linvor. Select this device to establish a connection. Use 1234 as pairing code.

Once the connection is established the LED in the Bluetooth slave goes steady, and on the smartphone you have a terminal like the one in the Serial Monitor. Any letters that you type are sent over to the Arduino, and the Arduino responds back with a message that confirms that it has received the same letter. When you type the lower case letter a in addition to the above the LED in the Arduino board lights up. When you press any other key the LED goes off. Pretty cool, right?

Final words

I hope you found the information in this article useful. Please let me know if you have any questions below in the comments.

In the next article I'll be discussing a much lighter topic. I will show you how I mounted and connected all the hardware into the vehicle kit platform. Then after that I 'll show you how I developed the firmware for my robot from scratch!

As always, I thank you for being a loyal reader. I hope to see you next time!

Miguel

Hello, and thank you for visiting my blog! If you enjoyed this article, please consider supporting my work on this blog on Patreon!

124 comments

  • #1F.Javier Fernandez said 2013-01-03T17:35:48Z

  • #2Miguel Grinberg said 2013-01-03T22:39:03Z

  • #3Markus said 2013-01-06T12:41:04Z

  • #4Dimitri said 2013-01-23T14:29:59Z

  • #5salem said 2013-03-23T04:47:41Z

  • #6Bas15 said 2013-05-05T11:23:33Z

  • #7Chaminda Amarasinghe said 2013-05-22T21:14:53Z

  • #8Kevin said 2013-06-19T20:50:23Z

  • #9Miguel Grinberg said 2013-06-20T04:28:50Z

  • #10sid said 2013-07-07T18:30:56Z

  • #11Miguel Grinberg said 2013-07-07T18:49:08Z

  • #12Marcos Montelpare said 2013-07-09T17:18:18Z

  • #13Nilesh said 2013-07-28T08:45:05Z

  • #14Miguel Grinberg said 2013-07-28T16:41:16Z

  • #15Gabriel said 2013-08-16T01:10:28Z

  • #16Miguel Grinberg said 2013-08-16T04:27:31Z

  • #17Mick said 2013-08-24T16:59:11Z

  • #18Miguel Grinberg said 2013-08-25T04:55:27Z

  • #19Chip said 2013-08-26T18:46:44Z

  • #20Marcel said 2013-09-02T04:51:32Z

  • #21Miguel Grinberg said 2013-09-02T05:30:43Z

  • #22Marcel said 2013-09-02T20:23:07Z

  • #23Nilesh said 2013-09-20T16:08:39Z

  • #24Subhash Jadhav` said 2013-09-23T16:50:55Z

  • #25Miguel Grinberg said 2013-09-24T01:54:50Z

Leave a Comment

In this era of mobile technology, there is hardly any person who has never used any mobile device. Among Android, iOS and other mobile devices, which makes the remarkable position among them are Android devices. When more and more people are using Smartphones as the best affordable solution to meet their needs, Android OS has become most popular around the world because of its amazing functionalities and features to the users.

Whether you want to play games, want to communicate with others, want to learn something, want to prepare documents, want to manage your data or anything related to the technical world, Android users can easily access all such apps on their devices.

No doubt, many of these apps are available for free, but some are paid. It means to access these apps, you need to pay some amount or you can go for their paid versions, once you are fully satisfied with their free trials.

But, do you know that you can use these Android apps on your Windows PC and Mac OS?

These apps are exclusively developed to use on Android devices, so you cannot use them directly on your system. But, it doesn’t mean having to follow some complex or paid procedure to get these apps on PC. We have one free solution with the help of which you can perform this task easily and stress-free.

Using this solution, you can also play mobile-based online games on your PC/Mac and can gain excellent gaming experience on the big screen than your mobile phones.

Yes, it is possible. Only you require is the Android emulator.

Contents

  • 4 How to Install the Android app on PC using BlueStacks?

BlueStacks – Most Popular and Reliable Android Emulator to Meet Gaming needs on PC

Class - Shield Lancer Download For Mac

Now, you may be thinking of how this android emulator can help you to install and run Android apps on your system.

Android emulator is actually third-party software that works great in emulating the Android environment on Windows OS and enables you to get all its apps on Windows PC and Mac systems.

Some of the popular Android emulators are BlueStacks, Nox App Player, Genymotion, MEmu, Andyroid, and many others.

Here, in this guide, we are going to get all the essential information about one of the most popular and trusted emulators – BlueStacks.

You know what? Millions of people around the world have used this emulator for different purposes, where the main reason involves their gaming needs. Yes, no matter what game you want to play on your PC, with the help of BlueStacks, you can get your desired game on your PC/Mac and that too with better performance and quality.

If you are an action game lover, you must use BlueStacks to install Clash Royale, State of Survival, Crystal Borne, Raid Shadow Legends, Clash of Clans or any Android game on your desktop.

Before moving to the installation steps of BlueStacks, it would be good to be more familiar with this emulator through its wonderful features.

Features of BlueStacks – How it Stands Out?

Let’s have a look at some of the amazing features of BlueStacks that makes it stand out from other android emulators out there in the market.

  • This emulator allows you to set the customized keymap based on your needs. BlueStacks also has a default keymap for its users, but you can choose to set your keys, which is quite simple using drag and drop function.
  • Do you want to play various games on PC simultaneously? Yes, BlueStacks supports multiple instances that enable you to play many games using different Google accounts or many games using the same Google account, all at the same time. All these games can be played in separate windows.
  • If we talk about its performance, you will be amazed to know that BlueStacks perform 6 times faster and much better than Android devices. Due to this reason, BlueStacks is widely used to play games on Windows PC.
  • BlueStacks has a simple and user-friendly interface; it means even if you are using this emulator for the time, you will not find any difficulty in accessing apps on this emulator.
  • It is also recommended to use the latest version of BlueStacks. It is so because it performs 8 times faster than its prior versions.
  • Moreover, there is no need to worry about your system’s resource consumption, as this emulator is well-known for its lower memory and CPU consumption.

Let’s learn how to get BlueStacks on your PC and Mac.

Steps to Install BlueStacks on PC/Mac

Installing BlueStacks on Windows and Mac does not hold any kind of long or complex process, nor, you have to take the help of any paid tool. The whole process is quite simple and straightforward.

All you have to do is just use these steps and get this top-rated emulator on your computer/laptop.

  • The first very step is to download BlueStacks using the download link given here.
  • After this emulator is downloaded, you have to double-click this downloaded file to install the BlueStacks.
  • After taking your confirmation, the installation process will get started.
  • Make sure to follow the on-screen instructions attentively.
  • The completion of the installation process may take a few minutes, so wait for it.
  • Once it is installed completely, your system is ready to install and use Android apps on it.

Now, once BlueStacks is installed on your PC, you can use it to install any Android app or game without any hassle.

Let’s learn how to get the Android app on BlueStacks so that you can use it effortlessly on your PC.

How to Install the Android app on PC using BlueStacks?

Now, it’s time to install and run Android apps on your PC with the help of BlueStacks.

As you have already learned the steps of getting BlueStacks on your system, now learn to get an app/game using BlueStacks.

It can be done in two ways. One is using the APK file of that particular app and another one is using Google Play Store.

In order to make you understand it in a better way, here we are going to install ‘Clash Royale’ with both these methods.

Installing Android app on BlueStacks using APK

  • Download BlueStackson your PC/Mac with the help of the available download link.
  • After this, you have to install by clicking its .exe file.
  • Now, open the BlueStacks.
  • In the next step, you have to download Clash Royale APK using the download link given here.
  • Once it is downloaded, double-click this file.
  • You will get a pop-up window, asking you to confirm the installation of this online game on your PC.
  • After its installation, go to the main page of BlueStacks.
  • You will find an icon of Clash Royale and click on it.
  • Now, your game is ready to play on your system.

Installing Android app on BlueStacks using Google Play Store

  • Download BlueStacks on your PC/Mac with the help of the available download link.
  • After this, you have to install by clicking its .exe file.
  • Now, open the BlueStacks.
  • In the next step, you have to sign-in to the Google account with the aim to access apps available in the Google Play Store.
  • No worries if you have no Google account, you can create the new to move further.
  • Open the Google Play Store and type ‘Clash Royale’ keyword in the search bar.
  • Now, select the topmost result and click its Install button.
  • Once it is installed completely, its icon will be available on the main page of BlueStacks.
  • That’s it, start playing your favorite game on the large screen of your computer.

BlueStacks – Is it safe to use?

No matter which Android app you want to install on your system, BlueStacks makes the entire process easier and smoother by letting you use any kind of Android app effectively on your PC.

Class - Shield Lancer Download For Mac Os

Even though it is the most popular android emulator around the world, many users are still confused about their system’s privacy and security when it comes to getting third-party software on it.

Class - Shield Lancer Download For Mac Catalina

It has been reported that this emulator is completely safe to use and you can blindly rely on it to meet your gaming needs on your PC.

More to this, the latest version of BlueStacks has overcome all downsides or errors which had been reported by some of its users. Some had complained of it as an insecure emulator and also reported some kind of warning message indicating it as an emulator with some viruses.

Moreover, this emulator does not contain any kind of malware. But still, if you are not satisfied with the answer, you are advised to go for its premium version instead of its free version.

Alternatives of BlueStacks

The above information about BlueStacks will surely encourage you to install this emulator on your PC/Mac and enjoy your desired apps on it.

Here are some of the alternatives to BlueStacks, which you can try to have a somewhat similar or better experience than BlueStacks.

  • Genymotion
  • Remix OS Player
  • LDPlayer
  • And many more…

No matter which emulator you will choose to get Android apps on your PC, each one of them will work great and will never disappoint you in terms of their performance.

Class - Shield Lancer Download For Macbook Pro

System Requirements for Installing BlueStacks

It is really good that you have decided to go with BlueStacks on your PC. But, have you checked whether your system is capable enough to install and use BlueStacks without getting any issue?

For this, you must check these minimum system requirements and determine if your system meets these requirements or not.

Operating System – Windows 10, 8.1, 8, 7
Processor – Intel or AMD Processor
RAM – at least 2 GB
HDD – 5 GB of free disk space
Graphics Card – latest Graphics drivers
DX – Version 9.0c

Note:
The system with better PC specifications than these minimum requirements always performs better and incomparable.

Final Words

If you are wondering how to get your favorite mobile-based game on your PC/Mac, this guide will help you to answer all of your queries with a 100% satisfied solution.

Class - Shield Lancer Download For Mac Download

Simply, get BlueStacks on your system and gain fantastic gaming experience on the larger screen than your Android device, and that too with superior performance and speed.

What are you thinking?

Use this guide to install BlueStacks and start playing your favorite game on your computer/laptop and have more fun with your friends.