ELECTRONICS IDEA: Quadruped Robot using Arduino

Saturday, 3 August 2019

Quadruped Robot using Arduino | Spider Robot

Quadruped Robot – It is a four-legged walking robot which is a bionic replica of spider (Arachnid species) that uses their legs for movement and can perform some tasks either by human interaction or by its own.

Introduction

The main purpose of moving to legged robots is that they can handle irregular terrain with ease when compared with wheeled robots. It can be done by implementing crawl gait (pattern of movement) in which one leg will be in air and remaining three legs should be in contact with the ground while moving.

The crawl gait (which is also known as quadruped gait) can be converted into a program and embedded into microcontroller which instructs servo motor to move in desired positions.

Components for Quadruped Robot

Arduino Uno microcontroller
Arduino Sensor Shield V5.0
mePed Robot V2 – Base Kit
- Wood kit containing all of the pieces that make up the main structure
- MG90S Metal gear servo motor – 8 pcs
- SG90 plastic gear servo motor – 1 piece
- Screws, nuts, spacers
Sensors and modules
- IR sensor -2
- Ultrasonic sensor with Holder
- HC-05 Bluetooth Module
Power supply
- 2000 mAh power bank for Arduino
- 1.2V 4*AA 1300 mAh rechargeable battery & 4*AA battery holder for sensor shield
Connectors and cables
- Mini breadboard
- Jumper wires
- USB cable

Assembly

The body of the quadruped can be assembled with the help of mePed v2 Assembly Manual. Link to the manual –> “mePedAssemblyManual“.
This manual involves legs assembly by fitting servo motors to it, body assembly and finally all four legs are attached to the body of the quadruped.

Sensor Shield

Once it is done, Arduino microcontroller can be mounted on it and the sensor shield is plugged into Arduino.

Without the sensor shield, the connection looks messy and it will be difficult to debug when something is not working.

Sensor shield simplifies the wire connection and thus all the sensors, servo motors and modules can be connected to it.

A single servo motor with ultrasonic sensor is mounted at the front and IR sensors are attached facing downwards.
Then the Bluetooth module is connected to sensor shield.
Jumper wires are used to connect the sensors to the Arduino shield.
Battery holder is placed at the bottom of the body.

Sensor Shield Connections

8 servos which are used as legs are connected to digital IO ports D0 to D7(D0 –D3 x-axis servos, D4-D7 y-axis servos)
Single servo which is used to turn ultrasonic sensor is connected to D11
Infrared sensors are attached to D9 and D12
Ultrasonic trigPin is connected to D8 and echoPin is connected to D10.
Hc-05 is connected to Bluetooth interface (Tx is connected to D0 & Rx is connected to D1)
Battery holder is connected to the sensor shield power (GND, 5V)
Power bank is connected to Arduino.

Fully Assembled Quadruped Robot with all the Sensors and motors.

Working and its Functions

Architecture

Sample scenario: User requests bot to turn left and walk

User inputs “Can you turn and walk? ” in Android application
API request is made to dialogflow agent with the help of API.ai Android SDK
Agent will check whether input text matches with any of the training phrases (intents) and then extracts the required parameters (@directions:left,right) and prompts the user to provide those if it is missing in the input text.(direction is missing in the input, complete input : “Can you turn left and walk? ”)
Then the extracted parameter(left) is sent as a response to app which in turn passes that parameter to Arduino microcontroller via Bluetooth
Based on the received parameter, the corresponding function is invoked by microcontroller to check whether it can make a left turn with the help of ultrasonic sensor.
Then the result (distance = 6 cm) is passed as response to android app which decides that it is not possible to make a turn, since there is an object nearby and informs the same to user.

Building the Chatbot

A Chabot is a computer program which is used to make conversation with humans in order to assist them to perform some functionalities.
NLP (natural language processing) algorithms are used in chatbots to derive a useful meaning from the natural languages.

Dialogflow – It is a natural language processing engine owned by google which is used to create a conversational bot that parses the user query and extract the relevant parameters.

Agents

Agents are natural language understanding modules that transform user requests into actionable data with the help of intents and entities
Agent ‘NewAgent-1’ is created.

Intents

Agent contains intents which are responsible for mapping user queries with appropriate responses. It is achieved with the help of Training phrases, Action and parameters.
New intent ‘Navigation’ is created.

Training phrases

Training phrases act as sample user inputs.
Multiple training phrases are created in order to increase the efficiency of the agent.

Entities

Every training phrases may contain entity. Entities are the useful parameters which are extracted from the user input.

Entities – User defined & system defined

System entities

Dialogflow contains some predefined entities which can be used in training phrases.

Eg: @sys.date –today, tomorrow, Monday, etc

User/developer defined entities

It allows us to create our own entities which are not covered under Dialogflow’s system entities.

Eg: Can you turn right and walk?

User requests quadruped to turn and walk and it needs to know in which direction it should turn either right or left, which act as an entity in the input.

@direction: direction – left, right

User defined entity ‘direction’ is created.

Action and parameters

Prompts & responses

Prompts

Prompts are used to make sure that complete information is obtained from the user.

Eg: Can you turn and walk?

Missing information: direction(left, right)

Bot response: left or right?

Responses

Then the corresponding responses are defined for the user query which will be displayed to them.

Similarly other intents fly, maze are created.

Intent: FLY

Training phrases: Can you fly?

Response : haha. No, it is not possible.

Building an Android Application

Designing the Bluetooth layout

This layout uses ListView to list paired Bluetooth devices when @+id/button is clicked

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"

android:layout_height="match_parent" >

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Paired Devices"

android:id="@+id/textView"

android:layout_alignParentTop="true"

android:layout_alignParentLeft="true"

android:layout_alignParentStart="true" />

<Button

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Paired Devices"

android:id="@+id/button"

android:layout_alignParentBottom="true"

android:layout_alignParentLeft="true"

android:layout_alignParentStart="true"

android:layout_alignParentRight="true"

android:layout_alignParentEnd="true" />

<ListView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:id="@+id/listView"

android:layout_centerHorizontal="true"

android:layout_above="@+id/button"

android:layout_below="@+id/textView" />

</RelativeLayout>

view raw Quadruped_Robot_BT_Layout.xml hosted with ❤ by GitHub

Connecting with paired devices

Android platform includes support for the Bluetooth framework that helps to transfer data wirelessly between android device and Arduino.
Android provides Bluetooth Adapter class to communicate with Bluetooth
List of paired Bluetooth devices are retrieved and shown in listview and the device with which communication needs to be done is selected.
Once the connection is successful, it will open chat layout where conversation between user & bot happens.
Add the below permissions into the AndroidManifest.xml in order to allow app to access Bluetooth and internet.

<uses-permission android:name=”android.permission.BLUETOOTH” />

<uses-permission android:name=”android.permission.BLUETOOTH_ADMIN” />

<uses-permission android:name=”android.permission.INTERNET” />

	import android.support.v7.app.AppCompatActivity;
	import android.os.Bundle;
	import android.content.Intent;
	import android.support.v7.app.AppCompatActivity;
	import android.view.Menu;
	import android.view.MenuItem;
	import android.view.View;
	import android.widget.AdapterView;
	import android.widget.ArrayAdapter;
	import android.widget.Button;
	import android.widget.ListView;
	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.widget.TextView;
	import android.widget.Toast;
	import java.util.ArrayList;
	import java.util.Set;

	public class bluetoothActivity extends AppCompatActivity {
	Button btnPaired;
	ListView devicelist;
	private BluetoothAdapter myBluetooth = null;
	private Set<BluetoothDevice> pairedDevices;
	public static String EXTRA_ADDRESS = "device_address";
	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_bluetooth);
	btnPaired = (Button)findViewById(R.id.button);
	devicelist = (ListView)findViewById(R.id.listView);
	myBluetooth = BluetoothAdapter.getDefaultAdapter();
	//checking whether device has bluetooth
	if(myBluetooth == null)
	{
	Toast.makeText(getApplicationContext(), "Bluetooth not Available", Toast.LENGTH_LONG).show();
	finish();
	}
	// Bluetooth not enabled in device
	else if(!myBluetooth.isEnabled())
	{
	//Ask the user to turn on bluetooth
	Intent turnBTon = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
	startActivityForResult(turnBTon,1);
	}

	btnPaired.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View v)
	{
	pairedDevicesList();
	}
	});
	}
	// function to display paired device list
	private void pairedDevicesList()
	{
	pairedDevices = myBluetooth.getBondedDevices();
	//list to store multiple names
	ArrayList list = new ArrayList();

	if (pairedDevices.size()>0)
	{
	for(BluetoothDevice bt : pairedDevices)
	{
	list.add(bt.getName() + "\n" + bt.getAddress()); //Get the device's name and the address
	}
	}
	else
	{
	Toast.makeText(getApplicationContext(), "No Paired Bluetooth Devices Found.", Toast.LENGTH_LONG).show();
	}

	final ArrayAdapter adapter = new ArrayAdapter(this,android.R.layout.simple_list_item_1, list);
	devicelist.setAdapter(adapter);
	devicelist.setOnItemClickListener(myListClickListener); //Method called when the device from the list is clicked

	}

	private AdapterView.OnItemClickListener myListClickListener = new AdapterView.OnItemClickListener()
	{
	public void onItemClick (AdapterView<?> av, View v, int arg2, long arg3)
	{
	// Get the device MAC address, the last 17 chars in the View
	String info = ((TextView) v).getText().toString();
	String address = info.substring(info.length() - 17);

	// Make an intent to start next activity.
	Intent i = new Intent(bluetoothActivity.this, Main2chatActivity.class);

	//Change the activity.
	i.putExtra(EXTRA_ADDRESS, address); //this will be received at Main2chatActivity Activity(Bluetooth address is passed)
	startActivity(i);
	}
	};
	}

view raw Quadruped_robot_bluetoothActivity.java hosted with ❤ by GitHub

Designing the Chat layout

This layout contains listview to display the conversation between user and bot and edit text at bottom where user makes the conversation.

	<?xml version="1.0" encoding="utf-8"?>
	<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	xmlns:tools="http://schemas.android.com/tools"
	android:layout_width="match_parent"
	android:layout_height="match_parent"
	android:orientation="vertical"
	android:clipToPadding="false"
	android:focusableInTouchMode="true"
	tools:context="com.example.scaledrone.chat.MainActivity">

	<ListView
	android:layout_width="match_parent"
	android:id="@+id/messages_view"
	android:layout_weight="2"
	android:divider="#fff"
	android:layout_height="wrap_content"
	/>

	<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent"
	android:layout_height="wrap_content"
	android:background="#fff"
	android:orientation="horizontal">

	<EditText
	android:id="@+id/editText"
	android:layout_width="match_parent"
	android:layout_height="wrap_content"
	android:layout_weight="2"
	android:ems="10"
	android:hint="Write a message"
	android:inputType="text"
	android:paddingHorizontal="10dp"
	android:text="" />

	<ImageButton
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:layout_gravity="center"
	android:scaleType="fitCenter"
	android:padding="20dp"
	android:layout_marginHorizontal="10dp"
	android:background="@drawable/ic_send_black_24dp"
	android:onClick="sendMessage"/>
	</LinearLayout>
	</LinearLayout>

view raw Quadruped_Robot_Chat_Layout.xml hosted with ❤ by GitHub

Two separate layouts are created, one for user and another for bot and then the corresponding layout is binded to the conversation list accordingly with the help of adapter class.

UserMessage Layout

User message appears at the right side of the screen.

	<?xml version="1.0" encoding="utf-8"?>
	<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent"
	android:layout_height="wrap_content"
	android:paddingVertical="10dp"
	android:paddingRight="15dp"
	android:paddingLeft="60dp"
	android:clipToPadding="false">

	<TextView
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:id="@+id/message_body"
	android:background="@drawable/my_message"
	android:textColor="#fff"
	android:padding="10dp"
	android:elevation="2dp"
	android:textSize="18dp"
	android:layout_alignParentRight="true"
	android:text="Placeholder message"
	/>

	</RelativeLayout>

view raw Quadruped_Robot_UserMessageLayout.xml hosted with ❤ by GitHub

BotMessage Layout

Bot message appears at the left side of the screen.

	<?xml version="1.0" encoding="utf-8"?>
	<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent"
	android:layout_height="wrap_content"
	android:paddingVertical="10dp"
	android:paddingLeft="15dp"
	android:paddingRight="60dp"
	android:clipToPadding="false">

	<View
	android:id="@+id/avatar"
	android:layout_alignParentLeft="true"
	android:scaleType="centerInside"
	android:background="@drawable/circle"
	android:layout_width="34dp"
	android:layout_height="34dp" />

	<TextView
	android:id="@+id/name"
	android:layout_marginLeft="15dp"
	android:layout_toRightOf="@+id/avatar"
	android:layout_alignTop="@+id/avatar"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:paddingBottom="4dp"
	android:text="Quadruped"/>

	<TextView
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:id="@+id/message_body"
	android:layout_below="@+id/name"
	android:layout_alignLeft="@+id/name"
	android:background="@drawable/their_message"
	android:paddingVertical="12dp"
	android:paddingHorizontal="16dp"
	android:elevation="2dp"
	android:textSize="18dp"
	android:text=" This is a sample bot response."
	/>
	</RelativeLayout>

view raw Quadruped_Robot_BotMessageLayout.xml hosted with ❤ by GitHub

Sending and Receiving Messages

In order to implement natural language processing features in our app, we must add the API.AI SDK library to our project.
Dependency needs to be added in build.gradle file. (OurApplication/build.gradle)

compile ‘ai.api:sdk:2.0.7@aar’

Once user makes the conversation, the input text is sent as request to dialogflow engine where processing takes place and the response is sent back to app. Based on the response received, it will either asks quadruped to perform tasks(waveHello) or it will request to provide some data(checkDistance).
The dialogflow request is an asynctask which will be executed in background.

	import android.app.ProgressDialog;
	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothSocket;
	import android.content.Intent;
	import android.os.AsyncTask;
	import android.os.Handler;
	import android.support.v7.app.AppCompatActivity;
	import android.os.Bundle;
	import android.util.Log;
	import android.view.View;
	import android.widget.EditText;
	import android.widget.ListView;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.UUID;
	import ai.api.AIServiceContext;
	import ai.api.AIServiceContextBuilder;
	import ai.api.android.AIConfiguration;
	import ai.api.android.AIDataService;
	import ai.api.model.AIRequest;
	import ai.api.model.AIResponse;

	public class Main2chatActivity extends AppCompatActivity {
	private EditText editText;
	private MessageAdapter messageAdapter;
	private static final String TAG = Main2chatActivity.class.getSimpleName();
	private ProgressDialog progress;
	private ListView messagesView;
	private AIRequest aiRequest;
	private AIDataService aiDataService;
	private AIServiceContext customAIServiceContext;
	OutputStream mmOutputStream;
	InputStream mmInputStream;
	private String uuid = UUID.randomUUID().toString();
	String address = null;
	BluetoothAdapter myBluetooth = null;
	BluetoothDevice mmDevice;
	BluetoothSocket btSocket = null;
	BluetoothSocket mmSocket = null;
	private boolean isBtConnected = false;
	int readBufferPosition;
	int counter;
	Thread workerThread;
	byte[] readBuffer;
	volatile boolean stopWorker;
	//SPP UUID Look for it
	static final UUID myUUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_main2chat);
	editText = (EditText) findViewById(R.id.editText);
	Intent newint = getIntent();
	address = newint.getStringExtra(bluetoothActivity.EXTRA_ADDRESS); //receive the address of the bluetooth device
	new ConnectBT().execute();
	messageAdapter = new MessageAdapter(this);
	messagesView = (ListView) findViewById(R.id.messages_view);
	messagesView.setAdapter(messageAdapter);
	}
	public void sendMessage(View view) {
	String message = editText.getText().toString();
	if (message.length() > 0) {
	final Message message1 = new Message(message,true);
	messageAdapter.add(message1);
	editText.getText().clear();
	//Dialogflow configuration
	// Unique key is obtained from dialogflow settings
	final AIConfiguration config = new AIConfiguration("<<key>>",
	AIConfiguration.SupportedLanguages.English,
	AIConfiguration.RecognitionEngine.System);
	aiDataService = new AIDataService(this, config);
	customAIServiceContext = AIServiceContextBuilder.buildFromSessionId(uuid);// helps to create new session whenever app restarts
	aiRequest = new AIRequest();
	aiRequest.setQuery(message);
	// Dialogflow request
	RequestTask requestTask = new RequestTask(Main2chatActivity.this, aiDataService, customAIServiceContext);
	requestTask.execute(aiRequest);// background task
	}
	}
	// Dialogflow response
	public void callback(AIResponse aiResponse) {
	if (aiResponse != null) {
	// process aiResponse here
	String botReply = aiResponse.getResult().getFulfillment().getSpeech();
	Log.d(TAG, "Bot Reply: " + botReply.contains("Hello!"));
	char first='z';
	//response: Hello
	if(botReply.contains("Hello!"))// wave hello
	{
	first='h';
	}
	//response: Hm. I will check and tell you
	else if(botReply.contains("check")) //navigation check
	{
	first='c';
	}
	//response: haha. No, it is not possible.
	else if(botReply.contains("possible")) //fly
	{
	first='p';
	}
	if (btSocket!=null && first!='z')
	{
	try
	{
	btSocket.getOutputStream().write(String.valueOf(first).getBytes());
	if(first=='c')
	openBT();// receive message from arduino
	}
	catch (IOException e)
	{
	Log.d("","Error");
	}
	}
	final Message message1 = new Message(botReply,false);
	messageAdapter.add(message1);

	} else {
	Log.d(TAG, "Bot Reply: Null");

	}
	}
	private class ConnectBT extends AsyncTask<Void, Void, Void> // UI thread
	{
	private boolean ConnectSuccess = true;

	@Override
	protected void onPreExecute()
	{
	progress = ProgressDialog.show(Main2chatActivity.this, "Connecting...", "Please wait!!!"); //show a progress dialog
	}

	@Override
	protected Void doInBackground(Void... devices) //while the progress dialog is shown, the connection is done in background
	{
	try
	{
	if (btSocket == null \|\| !isBtConnected)
	{
	myBluetooth = BluetoothAdapter.getDefaultAdapter();//get the mobile bluetooth device
	BluetoothDevice dispositivo = myBluetooth.getRemoteDevice(address);//connects to the device's address and checks if it's available
	btSocket = dispositivo.createInsecureRfcommSocketToServiceRecord(myUUID);//create a RFCOMM (SPP) connection
	BluetoothAdapter.getDefaultAdapter().cancelDiscovery();
	btSocket.connect();//start connection
	}
	}
	catch (IOException e)
	{
	ConnectSuccess = false;//if the try failed, you can check the exception here
	}
	return null;
	}
	@Override
	protected void onPostExecute(Void result) //after the doInBackground, it checks if everything went fine
	{
	super.onPostExecute(result);

	if (!ConnectSuccess)
	{
	Log.d("error","Connection Failed. Is it a SPP Bluetooth? Try again");
	finish();
	}
	else
	{
	Log.d("Success","Connected.");
	isBtConnected = true;
	}
	progress.dismiss();
	}
	}

	//function to listen data
	void openBT() throws IOException
	{
	/* UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); //Standard SerialPortService ID
	mmSocket = mmDevice.createRfcommSocketToServiceRecord(uuid);
	mmSocket.connect();*/
	mmOutputStream = btSocket.getOutputStream();
	mmInputStream = btSocket.getInputStream();
	beginListenForData();
	}
	//function to read input from arduino
	void beginListenForData()
	{
	final Handler handler = new Handler();
	final byte delimiter = 10; //This is the ASCII code for a newline character

	stopWorker = false;
	readBufferPosition = 0;
	readBuffer = new byte[1024];
	workerThread = new Thread(new Runnable()
	{
	public void run()
	{
	while(!Thread.currentThread().isInterrupted() && !stopWorker)
	{
	try
	{
	int bytesAvailable = mmInputStream.available();
	if(bytesAvailable > 0)
	{
	byte[] packetBytes = new byte[bytesAvailable];
	mmInputStream.read(packetBytes);
	for(int i=0;i<bytesAvailable;i++)
	{
	byte b = packetBytes[i];
	if(b == delimiter)
	{
	byte[] encodedBytes = new byte[readBufferPosition];
	System.arraycopy(readBuffer, 0, encodedBytes, 0, encodedBytes.length);
	final String data = new String(encodedBytes, "US-ASCII");
	readBufferPosition = 0;

	handler.post(new Runnable()
	{
	public void run()
	{
	final Message message1 = new Message("Some object is there at a distance of "+data.toString()+" cms from my point. So i can't move\uD83D\uDE1F",false);
	messageAdapter.add(message1);
	Log.d("Value",data);
	}
	});
	}
	else
	{
	readBuffer[readBufferPosition++] = b;
	}
	}
	}
	}
	catch (IOException ex)
	{
	stopWorker = true;
	}
	}
	}
	});

	workerThread.start();
	}
	}

view raw Quadruped_Robot_Main2chatActivity.java hosted with ❤ by GitHub

Model Class

This class is the bridge between the controller and the view.
So when user ask for an information though View(UI), view goes to controller and controller notify the model. Then model give that information to controller and controller notify View about that information so the user can see that information.
Message.java act as model class which holds conversation text and belongsToCurrentUser(either it belongs to user or bot) properties

	public class Message {
	private String text;
	private boolean belongsToCurrentUser;
	public Message(String text, boolean belongsToCurrentUser) {
	this.text = text;
	this.belongsToCurrentUser = belongsToCurrentUser;
	}
	public String getText() {
	return text;
	}
	public boolean isBelongsToCurrentUser() {
	return belongsToCurrentUser;
	}
	}

view raw Quadruped_Robot_Message.java hosted with ❤ by GitHub

Binding the Messages to listview

In Android, Adapter is a bridge between UI component and data source that helps us to fill data in UI component.

UI component represents the listview which is used to list the conversation
Data source represents the arraylist messages from which data is populated into listview

	import android.app.Activity;
	import android.content.Context;
	import android.graphics.Color;
	import android.graphics.drawable.GradientDrawable;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.BaseAdapter;
	import android.widget.TextView;
	import java.util.ArrayList;
	import java.util.List;
	public class MessageAdapter extends BaseAdapter {
	List<Message> messages = new ArrayList<Message>();//stores the conversation between user & bot
	Context context;
	public MessageAdapter(Context context) {
	this.context = context;
	}
	//add the new message coversation
	public void add(Message message) {
	this.messages.add(message);
	notifyDataSetChanged(); whenever there is a change in listview, this method is called to refresh
	}
	@Override
	public int getCount() {
	return messages.size(); // get the count of messages
	}
	@Override
	public Object getItem(int i) {
	return messages.get(i);
	}
	@Override
	public long getItemId(int i) {
	return i;
	}

	@Override
	public View getView(int i, View convertView, ViewGroup viewGroup) {
	MessageViewHolder holder = new MessageViewHolder();
	LayoutInflater messageInflater = (LayoutInflater) context.getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
	Message message = messages.get(i);

	if (message.isBelongsToCurrentUser()) { // User message
	convertView = messageInflater.inflate(R.layout.my_message, null);
	holder.messageBody = (TextView) convertView.findViewById(R.id.message_body);
	convertView.setTag(holder);
	holder.messageBody.setText(message.getText());
	} else {
	// Bot message
	convertView = messageInflater.inflate(R.layout.their_message, null);
	holder.avatar = (View) convertView.findViewById(R.id.avatar);
	holder.name = (TextView) convertView.findViewById(R.id.name);
	holder.messageBody = (TextView) convertView.findViewById(R.id.message_body);
	convertView.setTag(holder);

	holder.name.setText("Quadruped");
	holder.messageBody.setText(message.getText());
	GradientDrawable drawable = (GradientDrawable) holder.avatar.getBackground();

	}

	return convertView;
	}

	}

	class MessageViewHolder {
	public View avatar;
	public TextView name;
	public TextView messageBody;
	}

view raw Quadruped_Robot_messageAdapter.java hosted with ❤ by GitHub

Android AsyncTask

Android AsyncTask is an abstract class provided by Android which is used to perform heavy tasks in the background and keep the UI thread light thus making the application more responsive.

	import android.app.Activity;
	import android.os.AsyncTask;
	import ai.api.AIServiceContext;
	import ai.api.AIServiceException;
	import ai.api.android.AIDataService;
	import ai.api.model.AIRequest;
	import ai.api.model.AIResponse;

	public class RequestTask extends AsyncTask<AIRequest, Void, AIResponse> {
	Activity activity;
	private AIDataService aiDataService;
	private AIServiceContext customAIServiceContext;

	RequestTask(Activity activity, AIDataService aiDataService, AIServiceContext customAIServiceContext){
	this.activity = activity;
	this.aiDataService = aiDataService;
	this.customAIServiceContext = customAIServiceContext;
	}

	@Override
	protected AIResponse doInBackground(AIRequest... aiRequests) {
	final AIRequest request = aiRequests[0];
	try {
	return aiDataService.request(request, customAIServiceContext); // dialogflow request is made
	} catch (AIServiceException e) {
	e.printStackTrace();
	}
	return null;
	}

	@Override
	protected void onPostExecute(AIResponse aiResponse) {
	((Main2chatActivity)activity).callback(aiResponse);
	}
	}

view raw Quadruped_Robot_requestTask.java hosted with ❤ by GitHub

Arduino Code for Chat Interaction

The response obtained by app from dialogflow is processed and serial communication is done with arduino via bluetooth which instructs quadruped to perform tasks(waveHello(), tellNo()).
And also if any additional data is required by app in order to make a decision, then it will request arduino to help (checkDistace() – quadruped needs to check whether any object is located nearby)
Ultrasonic sensor is used to calculate distance of an object which is present in front of it.

	// Include the Servo library
	#include <Servo.h>
	// Declare ultrasonic sensor pins
	const int trigPin = 8;
	const int echoPin = 10;
	// Declare the Servo pin

	int servoPin1 = 0;
	int servoPin2 = 1;
	int servoPin3 = 2;
	int servoPin4 = 3;
	int servoPin5 = 4;
	int servoPin6 = 5;
	int servoPin7 = 6;
	int servoPin8 = 7;
	int servoPinu = 11;
	// servo objects
	Servo Servo1,Servo2,Servo3,Servo4,Servo5,Servo6,Servo7,Servo8,Servou;
	char Incoming_value ; //Variable for storing Incoming_value
	void setup()
	{
	Serial.begin(9600); //Sets the data rate in bits per second (baud) for serial data transmission
	pinMode(trigPin, OUTPUT);
	pinMode(echoPin, INPUT);
	//Servo1.attach(servoPin1);
	Servo2.attach(servoPin3);
	// Servo3.attach(servoPin5);
	Servo4.attach(servoPin7);
	Servo5.attach(servoPin2);
	Servo6.attach(servoPin4);
	Servo7.attach(servoPin6);
	Servo8.attach(servoPin8);
	Servou.attach(servoPinu);
	}
	void loop()
	{
	Serial.flush();
	//Serial.println("i am talking");
	if(Serial.available() > 0)
	{
	Incoming_value = Serial.read(); //Read the incoming data and store it into variable Incoming_value
	//Serial.print(Incoming_value);
	if(Incoming_value == 'h') //Checks whether value of Incoming_value
	{
	//Serial.print("connected");
	waveHello();
	}
	else if(Incoming_value == 'c')// navigation
	{
	checkDistance();
	}
	else if(Incoming_value == 'p') ///fly
	{
	tellNo();
	}
	}
	delay(1000);

	}

	//code to nod the head
	void tellNo()
	{
	int cc=5;
	while(cc>0)
	{
	Servou.write(20);
	delay(350);
	Servou.write(160);
	delay(350);
	cc--;
	}
	Servou.write(90);
	delay(200);
	}
	//checks the distance of an object with the help of ultrasonic sensor
	void checkDistance()
	{
	Servou.write(170);
	delay(200);
	long duration, inches, cm;
	pinMode(trigPin, OUTPUT);
	digitalWrite(trigPin, LOW);
	delayMicroseconds(10000);
	digitalWrite(trigPin, HIGH);
	delayMicroseconds(10000);
	digitalWrite(trigPin, LOW);
	// Read the signal from the sensor: a HIGH pulse whose
	// duration is the time (in microseconds) from the sending
	// of the ping to the reception of its echo off of an object.
	pinMode(echoPin, INPUT);
	duration = pulseIn(echoPin, HIGH);
	// convert the time into a distance
	inches = microsecondsToInches(duration);
	cm = microsecondsToCentimeters(duration);
	Serial.println(cm);
	Servou.write(90);
	delay(200);
	}
	//code to wave hello
	void waveHello()
	{
	int i=2;
	while(i>0)
	{
	i--;

	Servo8.write(50);
	Servo7.write(50);
	delay(1000);
	Servo8.write(150);
	Servo7.write(150);
	delay(1000);
	Servo8.write(30);
	Servo4.write(30);
	delay(200);
	Servo4.write(120);
	delay(200);
	Servo4.write(30);
	delay(200);
	Servo4.write(120);

	Servo4.write(30);
	delay(200);
	Servo4.write(120);
	delay(200);
	Servo4.write(30);
	delay(200);
	Servo4.write(90);
	Servo8.write(150);
	delay(1000);
	Servo8.write(90);
	Servo7.write(90);

	delay(1000);

	}

	}
	long microsecondsToInches(long microseconds)
	{
	// According to Parallax's datasheet for the PING))), there are
	// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
	// second). This gives the distance travelled by the ping, outbound
	// and return, so we divide by 2 to get the distance of the obstacle.
	// See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
	return microseconds / 74 / 2;
	}

	long microsecondsToCentimeters(long microseconds)
	{
	// The speed of sound is 340 m/s or 29 microseconds per centimeter.
	// The ping travels out and back, so to find the distance of the
	// object we take half of the distance travelled.
	return microseconds / 29 / 2;
	}

view raw Quadruped_Robot_ArduinoCodeforChat.ino hosted with ❤ by GitHub

Building the Maze Solver

It is done with the help of Line following & obstacle avoidance techniques

Line follower

Quadruped uses IR sensors which has the ability to detect black lines and guides the robot to follow a certain path.

Working Principle

Uses IR sensors (transmitter & receiver) to sense the line by emitting infrared radiations
Output of sensor is an analog signal which depends on the amount of light reflected back from the surface.
It returns 0 when the amount of light reflected from the surface is less (since black colour absorbs infrared radiations) and returns 1 when the amount of light reflected is more.

Obstacle Avoider

Quadruped uses ultrasonic sensors to detect obstacles in front of it

Working Principle

Consists transmitter & receiver in which transmitter emits sound waves and receiver waits for the echo signal.
Calculates time interval between signal transmission and reception of echo and determines the distance of the object from the sensor

Servo motors are high torque motors which have a geared output shaft which can be programmatically controlled using Arduino to turn at certain degrees at a time. It is used for robot movement.

Line Follower Principle

Case 1: when both sensors senses black line, then it should move forward (left sensor =0, right sensor=0)

Case 2: when left sensor senses black line and right sensor sensor senses white, then it should turn left

Case 3: when right sensor senses black line and left sensor sensor senses white, then it should turn right

Case 4: when both sensors senses white, then it should stop.

Quadruped Gait for Forward Movement

Gait is defined as a pattern of movement of legs in order to reach a destination. Quadruped gait is one in which the body lifts one leg at a time and other three legs form a supporting tripod.
In order to achieve quadruped gait, all we need to know is that when and at which position we need to move the legs and this is known as inverse kinematics.
Inverse kinematics helps in defining values for servo motors in order to make the leg move to desired position.
The below diagram represents forward quadruped gait.
L(x,y) where L represents leg , x represents x-axis(horizontal) movement and y represents y-axis(vertical) movement.
Stable position is 90 degree.

Maze

Task: Quadruped needs to follow the black line and it needs to avoid the obstacles

Arduino Code for Maze Solver

The quadruped gait is converted to algorithm by combining line follower and obstacle avoider technique in order to build a maze solver.
The forward movement gait is slightly modified to make a turn when either quadruped deviates from the line or any obstacle is detected.

	// Include the Servo library
	#include <Servo.h>
	// IR sensor
	#define LS 9 // left sensor
	#define RS 12 // right sensor
	// Ultrasonic sensor pins
	const int trigPin = 8;
	const int echoPin = 10;
	// Declare the Servo pin
	int servoPin1 = 0;
	int servoPin2 = 1;
	int servoPin3 = 2;
	int servoPin4 = 3;
	int servoPin5 = 4;
	int servoPin6 = 5;
	int servoPin7 = 6;
	int servoPin8 = 7;
	int servoPinu = 11;
	int flag;
	int cnt;
	Servo Servo1,Servo2,Servo3,Servo4,Servo5,Servo6,Servo7,Servo8,Servou;
	void setup() {
	pinMode(LS, INPUT);
	pinMode(RS, INPUT);
	pinMode(trigPin, OUTPUT);
	pinMode(echoPin, INPUT);
	Servo1.attach(servoPin1);
	Servo2.attach(servoPin3);
	Servo3.attach(servoPin5);
	Servo4.attach(servoPin7);
	Servo5.attach(servoPin2);
	Servo6.attach(servoPin4);
	Servo7.attach(servoPin6);
	Servo8.attach(servoPin8);

	flag=0;
	cnt=1;
	}
	void loop(){

	long duration, inches, cm;

	if(flag==0)//moving Leg A backwards for first time alone
	{
	Servo5.write(50);
	delay(50);
	Servo1.write(150);
	delay(100);
	Servo5.write(90);
	delay(50);
	}
	// The sensor is triggered by a HIGH pulse of 10 or more microseconds.
	// Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
	pinMode(trigPin, OUTPUT);
	digitalWrite(trigPin, LOW);
	delayMicroseconds(10000);
	digitalWrite(trigPin, HIGH);
	delayMicroseconds(10000);
	digitalWrite(trigPin, LOW);
	// Read the signal from the sensor: a HIGH pulse whose
	// duration is the time (in microseconds) from the sending
	// of the ping to the reception of its echo off of an object.
	pinMode(echoPin, INPUT);
	duration = pulseIn(echoPin, HIGH);
	// convert the time into a distance
	inches = microsecondsToInches(duration);
	cm = microsecondsToCentimeters(duration);

	if(cm>=26)//when obstacle is not present
	{

	if(!digitalRead(LS) & !digitalRead(RS) ) // Move Forward
	{

	Servo6.write(50);
	delay(50);
	Servo2.write(30);
	delay(100);
	Servo6.write(90);
	delay(50);

	Servo5.write(50);
	delay(50);
	Servo1.write(90);
	delay(100);
	Servo5.write(90);
	delay(50);
	//main
	Servo6.write(120);
	delay(50);
	Servo8.write(120);
	delay(50);
	Servo4.write(60);
	delay(100);
	Servo2.write(60);
	delay(100);
	Servo6.write(90);
	delay(50);
	Servo8.write(90);
	delay(50);



	Servo7.write(50);
	delay(50);
	Servo3.write(150);
	delay(100);
	Servo7.write(90);
	delay(50);


	Servo8.write(50);
	delay(50);
	Servo4.write(90);
	delay(100);
	Servo8.write(90);
	delay(50);

	//main
	Servo7.write(120);
	delay(50);
	Servo5.write(120);
	delay(50);
	Servo1.write(120);//changed
	delay(100);
	Servo3.write(60);
	delay(100);
	Servo7.write(90);
	delay(50);
	Servo5.write(90);
	delay(50);
	flag=1;
	}
	//when quadruped deviates the line in left side, then it should move rightwards
	else if(!digitalRead(LS) & digitalRead(RS))//right
	{


	Servo6.write(50);
	delay(50);
	Servo2.write(30);
	delay(100);
	Servo6.write(90);
	delay(50);

	Servo5.write(50);
	delay(50);
	Servo1.write(90);
	delay(100);
	Servo5.write(90);
	delay(50);
	//main
	Servo6.write(120);
	delay(50);
	Servo8.write(120);
	delay(50);
	Servo4.write(30);
	delay(100);
	Servo2.write(60);
	delay(100);

	Servo6.write(90);
	delay(50);
	Servo8.write(90);
	delay(50);



	Servo7.write(50);
	delay(50);
	Servo3.write(150);
	delay(100);
	Servo7.write(90);
	delay(50);
	Servo8.write(50);
	delay(50);
	Servo4.write(90);
	delay(100);
	Servo8.write(90);
	delay(50);
	//main
	Servo7.write(120);
	delay(50);
	Servo5.write(120);
	delay(50);
	Servo3.write(60);
	delay(100);
	Servo1.write(120);

	delay(100);

	Servo7.write(90);
	delay(50);
	Servo5.write(90);
	delay(50);
	flag=1;
	}
	//when quadruped deviates the line in right side, then it should move leftwards
	else if(digitalRead(LS) & !digitalRead(RS))//left
	{

	Servo6.write(50);
	delay(50);
	Servo2.write(30);
	delay(100);
	Servo6.write(90);
	delay(50);

	Servo5.write(50);
	delay(50);
	Servo1.write(90);
	delay(100);
	Servo5.write(90);
	delay(50);
	//main
	Servo6.write(120);
	delay(50);
	Servo8.write(120);
	delay(50);
	Servo4.write(30);
	delay(100);
	Servo2.write(90);
	delay(100);
	Servo6.write(90);
	delay(50);
	Servo8.write(90);
	delay(50);
	Servo7.write(50);
	delay(50);
	Servo3.write(150);//changed
	delay(100);
	Servo7.write(90);
	delay(50);


	Servo8.write(50);
	delay(50);
	Servo4.write(90);
	delay(100);
	Servo8.write(90);
	delay(50);
	//main
	Servo7.write(120);
	delay(50);
	Servo5.write(120);
	delay(50);
	Servo1.write(120);
	delay(100);
	Servo3.write(60);
	delay(100);
	Servo7.write(90);
	delay(50);
	Servo5.write(90);
	delay(50);
	flag=1;
	}
	}
	//obstacle is detected, so taking complete right turn
	else
	{
	// just turning the head right side and again to usual position
	Servou.write(30);
	delay(100);
	Servou.write(150);
	delay(100);
	Servou.write(90);
	delay(500);

	if(digitalRead(LS) & !digitalRead(RS)) // if left sensor is outside black line, repeat right turn 4 times so that after turning it will be in correct position in line to walk
	{
	makeRight(4);
	}
	else if (!digitalRead(LS) & !digitalRead(RS))
	{
	makeRight(3); // if both sensor are in black line, repeat right turn 3 times
	}

	else
	{
	makeRight(2); // if right sensor is outside black line, repeat right turn 2 times
	}


	}
	}

	void makeRight(int j) //to turn when there is an obstacle
	{

	while(j>=0)
	{
	j--;
	Servo6.write(50);
	delay(100);
	Servo2.write(30);
	delay(100);
	Servo6.write(90);
	delay(100);

	Servo5.write(60);
	delay(100);
	Servo1.write(90);
	delay(100);
	Servo5.write(90);
	delay(100);

	Servo6.write(120);
	delay(100);
	Servo8.write(120);
	delay(100);
	Servo4.write(130);
	delay(100);
	Servo2.write(130);
	delay(200);

	Servo6.write(90);
	delay(100);
	Servo8.write(90);
	delay(100);
	Servo7.write(50);
	delay(100);
	Servo3.write(130);
	delay(100);
	Servo7.write(90);
	delay(100);

	Servo8.write(50);
	delay(100);
	Servo4.write(90);
	delay(100);
	Servo8.write(90);
	delay(100);

	Servo7.write(120);
	delay(100);
	Servo5.write(130);
	delay(100);
	Servo1.write(130);
	delay(100);
	Servo3.write(60);
	delay(200);

	Servo7.write(90);
	delay(100);
	Servo5.write(90);
	delay(100);
	}
	}
	long microsecondsToInches(long microseconds)
	{
	// According to Parallax's datasheet for the PING))), there are
	// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
	// second). This gives the distance travelled by the ping, outbound
	// and return, so we divide by 2 to get the distance of the obstacle.
	// See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
	return microseconds / 74 / 2;
	}

	long microsecondsToCentimeters(long microseconds)
	{
	// The speed of sound is 340 m/s or 29 microseconds per centimeter.
	// The ping travels out and back, so to find the distance of the
	// object we take half of the distance travelled.
	return microseconds / 29 / 2;
	}

view raw Quadruped_Robot_Arduinocodeformazesolver.ino hosted with ❤ by GitHub

Conclusion

Thus, a quadruped robot is designed in such a way that humans can interact with it using android chatbot to perform some tasks. The movement of servos is achieved by Inverse kinematics algorithm.

The Arduino Quadruped robot will be able to move on a guided path sensing the black line with its automatic obstacle avoiding feature makes it efficient to reach any destination as desired.

The post Quadruped Robot using Arduino | Spider Robot appeared first on Electronics Hub.

from Electronics Hub https://ift.tt/333E5hf

ELECTRONICS IDEA

Pages