Mechanical engineering final year project pdf

  1. Mechanical Mini Projects
  2. mechanical projects with pdf
  3. 650+ Mechanical Engineering projects New Updated
  4. Mechanical Engineering Projects

Mechanical Engineering Projects For Final Year College Students . mini project for mechanical engineering in pdf, mechanical engineering. Final Year Project Report- BE Mechanical Engineering - Read online. Project: Autonomous Robotic Wheelchair Project Goal: The project's goal is to enhance an ordinary PROJECT IDEAS «AERO AND MECHANICAL PDF | The purpose of writing this book entitled “INNOVATIVE ENGINEERING Mechanical Engineering Design of a Compressed Air Car.

Language:English, Spanish, Japanese
Genre:Science & Research
Published (Last):26.10.2015
Distribution:Free* [*Registration needed]
Uploaded by: PEARL

69994 downloads 100842 Views 12.67MB PDF Size Report

Mechanical Engineering Final Year Project Pdf

Explore Mechanical Projects Pdf| Mechanical Projects Topics, 's of Mechanical Engineering Projects, Mini Final Year Automobile Projects. A Final Year Project Submitted in Partial Fulfilment of the Requirement for the. Award of the Degree of Bachelor of Science in Mechanical Engineering. Projects with Reports,Mechanical Engineering Final Year Projects. Engineering Major & Minor projects with complete reports in PDF, DOC, PPS, PPT or ZIP.

A production engineer typically has a wide knowledge of engineering practices and is aware of the management challenges related to production. The goal is to accomplish the production process in the smoothest, most-judicious and most-economic way. Production engineering also overlaps substantially with manufacturing engineering and industrial engineering. The names are often interchangeable. It is concerned with the understanding and application of Engineering Procedures in Manufacturing Processes and Production Methods. Taylor, etc. After the s. So B tech M tech final year students can apply for Automobile and Mechanical proejcts here in bangalore. Here the following mechanical project titles are latest project titles for final year mechnical students. If you are giving your own mechanical engineering project idea,we willl implement and give you. Reuleaux called the ideal connections between links kinematic pairs.

The sensor models provided include sonar, LRF, webcam and odometery. But Players modular architecture makes it easy to add support for new hardware and commonly the control programs written for Stages simulated robots work just as well on real hardware as well. The following is a look at the Player User Interface. The NetBeans platform allows applications to be developed from a set of modular software components called modules.

Its programming language G is a dataflow programming language using which we can develop programs or subroutines called virtual instruments or VIs. LabVIEW has three main components: Controls are knobs or dials etc. After we have built the user interface, we can insert our code into the block diagram using VIs and structures to control our front panel objects. Furthermore, LabVIEW communicates with hardware for data acquisition, vision and motion control using devices 8.

We feed in our laptops IP address to enable a Windows-based computer and Ubuntubased computer to network.

We use NetBeans and TCP broadcasting to repeatedly update our forward and angular velocity values for the wheelchair. Furthermore we were also required to design a laptop table in front of the wheelchair user which could simultaneously serve as a mounting for sonar sensors or webcams as well.

This table also was also meant to have a shelf where different electronic circuitry could be placed. So we designed the following new features in our wheelchair: We designed our proposed wheelchair model in Pro-E software. In the picture above, the dotted region shows the newly designed portion of the wheelchair. The above drawn model has exactly the same dimensions as of the original wheelchair. During modeling different complex joints were simplified. This modeling gave us a rough idea about how it will look after fabrication and this also helped us in reviewing our design again and again to make it more accurate.

After this all our detailed diagrams, we used for the next stage i. The person sitting on the wheelchair has a joy stick on his right side. For example if person pushes joy stick forward then wheelchair will move in the forward direction. Similarly if person pushes joy stick backward then wheelchair will move in the backward direction. Joy stick can be move at any angle. The amount by which the joy stick is moved is proportional to the amount of voltage signal send to the internal circuitry and then that specified voltage signal is translated into a specific speed.

This wheelchair is rare wheel driven and it has differential drive. Fig In order to make wheelchair autonomous, we shiftedits control from joystick to LabView.

You might also like: INTO THE WILD BOOK EPUB

In this case hardware is our wheelchair and software is LabView. This LabView program was made to control wheelchair motion. Previously this was controlled by joystick.

Mechanical Mini Projects

A continuous while loop is implemented so that a required value is being sent to wheelchair at all times. There is a stop button in the program by which code can be terminated at any time. Actually an angular velocity and a forward velocity values are given to the program This conversion is done by two functions; one made for forward speed and another for angular speed.

This function is made by using straight line equation i. Constant voltages of 1. RPM of the rare wheels were measured by the tachometer. Then velocity was calculated on the basis of rpm. The graph above shows the trend of voltage vs. We gave wheelchair different sets of voltages through LabView and then measured the resultant speed of wheelchair by measuring rpm of its rare wheels.

Following conclusions can be drawn from the above graph:. There is a voltage window where wheelchair does not move due to inertia and that is 1. The main purpose of drawing this graph was to know exactly about the speed output when a specified voltage is provided. This knowledge helped during the developing of obstacle avoidance and navigation codes and it also helped us during real-time wheelchair testing phase. Obstacle Avoidance is a means of a robot being able to move around in an unknown environment without unknown obstacles coming in its path.

It is one of the most important aspects of mobile robotics. According to Seigwart et al, local obstacle avoidance focuses on changing the robots trajectory as informed by its sensors during realtime robot motion.

mechanical projects with pdf

The resulting function is both a function of robots current or recent sensor readings and its goal position and relative location to the goal position. In developing our obstacle avoidance algorithms for the Autonomous Robotic Wheelchair, we were able to benefit significantly from the work completed in lieu of our MRDS semester project for our Intro to Mechatronics and Robotics class taught last semester by Dr.

Yasar Ayaz and Dr. Umar Gillani. We studied and practiced coding for primarily the obstacle avoidance algorithms presented in the Introduction to Autonomous Mobile Robotics by Seigwart et al.

For example:. The Bug Algorithm is the simplest most intuitive obstacle avoidance algorithm. The basic idea is to follow the contour of the obstacle in order to circumnavigate around it. It has two different forms Bug1 and Bug2.

In Bug1 algorithm, the robot fully circles around the obstacle and then moves along the line of shortest path towards the endpoint. This is the obstacle avoidance technique we have been able to implement in our code. With Bug2 algorithm, the robot starts to follow the objects contour but departs immediately when it able to move directly towards the object. This would have been more efficient and future coding on the Autonomous Wheelchair could attempt to develop this. The VFH algorithm generates a polar histogram, in which the X-axis represents the angle alpha at which the obstacle was found, and the Y-axis represents the probability grid that there is an obstacle in that direction based on the occupancy grids cell values.

However, we did not pursue it further due to its redundancy with the potential field path-planning algorithm which we were working on implementing at the time. There are a handful of other promising obstacle avoidance algorithms presented in Seigwart et al, however we were able to investigate and understand only the ones discussed.

Our obstacle avoidance functions attempt to update motor speeds if there is an obstacle to be avoided. We update the function just before sending data to the motors.

Thus, obstacle avoidance overwrites onto our navigation behavior for the robot. Once the obstacle is no longer in its way, the robot moves along as it was.

This allows us to transition from any navigation behavior into obstacle avoidance and then back again, as per the requirements of our control structure. We wrote three distinct obstacle avoidance codes for the Autonomous Robotic Wheelchair. These are discussed as follows:. This was the first obstacle avoidance code that we developed. It created and initialized two variables newspeed and newturnrate within a continuous for loop. GetMinRight and GetMinLeft in order to see to the left and right of the robot for obstacles.

The readings obtained are processed and we check to see if either the left or the right distances to the obstacle are greater than And use the SetSpeed command to set these motor speeds. Pseudocode for Left-Right Obstacle Avoidance: It was not tested in real-time on the wheelchair because we were providing the wheelchair with the path beforehand from our navigation algorithm and we wanted primarily that the wheelchair should be able to detect and avoid the obstacles in its path rather than the obstacles coming to the left and right close to its path.

A snapshot of the Left-Right Obstacle avoidance simulation has been provided in the Section 4. This was the second Obstacle Avoidance code we developed. However, we could not implement this one in the actual lab trials as well. Then inside a continuous for loop, we gave forward speed an initial value of 0. The Robot. GetRange command. Doing so checks to see if there is an obstacle directly in front of the robot which if the robot was to continue moving along its given path it would collide with.

If the obstacle is in front of the robot and the lp. GetRange value of distance in front of the obstacle comes out as less than 1.

So, if there is an obstacle closer than 1. It would detect its X and Y coordinates at that point using the robot. GetXPos and robot. GetYPos commands. Thereafter, it would use those x and y position values to navigate around the obstacle using a sequence of GoTo commands that take the robot out of its path, enable it to cross the obstacle from its left and makes it come back directly in the position it would have been moved along to had there been no obstacle in its path. Lastly it checks to see if the endpoint has been reached, at which point it would stop immediately.

Pseudocode for GoTo-based Obstacle Avoidance: Enable Motors Initialize robotSpeed. ForwardSpeed to some initial value Initialize robotSpeed.

TurningSpeed to zero Use Robot. Use GetRange to look in front of the robot Check to see if obstacle in front close than set distance 1. If Yes, read robot coordinates at current position Use GoTo commands with current position coordinates to move around obstacle Else Continue moving along original path Check to see if EndPoint has been reached? If Yes, Stop. This was the Obstacle Avoidance code which we eventually used for trial runs in the lab. Logically it follows the same sequence of instructions as out GoTo-based Obstacle Avoidance code except that it uses a set of SetSpeed commands in conjunction with various sleep calls in order to navigate around the obstacle instead of the GoTo commands.

It was important to develop this code because ultimately we needed that the forward speed and turning speed values for the robot should change against different time calls and we should be able to pass these changing forward and turning speed values to drive our wheelchair.

For this code, we again declare our data variables robotSpeed. This is an important first step because not setting these speed values to zero initially causes the wheelchairs automatic safety system to activate causing the wheelchair to lock itself and give a beep sound. Once weve passed zero values to the motors for some time, we give the wheelchair an initial forward speed of 0.

This is the minimum. For power values below this velocity level, the wheelchair does not move. Thereafter, inside a continuous for loop we use Robot. As before, we read in LRF readings of minimum distances at angles 88 to 91 using the lp.

And we check to see if at some point all of these GetRange values would be less than 1. If the obstacle is present, the robot halts and reads its X and Y coordinates using the robot. Thereafter, it uses those x and y positions to navigate around the obstacle using a sequence of SetSpeed commands that take the robot out of its path, make it cross the obstacle and makes it come back to its path after having crossed the obstacle. Lastly, it checks to see if the endpoint has been reached at which point the robot stops.

Pseudocode for SetSpeeds-based Obstacle Avoidance:. Read Use GetRange to look in front of the robot Check to see if obstacle in front close than set distance 1. If Yes, read robot coordinates at current position Use SetSpeed commands with current position coordinates to move around obstacle Else Continue moving along original path. Check to see if EndPoint has been reached? In this Obstacle Avoidance code, the wheelchair takes 90 turns around the obstacle.

We have also written and tested a modified form of the SetSpeeds based obstacle avoidance code. In this version, instead of using 90 turns, the wheelchair moves around the obstacle at some angle. We are using different values for sleep to give different values for the angle at which the wheelchair moves out of its path. The advantage of this variation is that the wheelchair has to cover less overall distance while it is avoiding the obstacle. But the problem with this technique is that the wheelchair is frequently unable to properly swerve around the obstacle.

Depending on where the LRF will actually detect the obstacle, the angle required for obstacle avoidance will change from one trail run to the next. Our code does not have the capability for calculating a changing obstacle avoidance angle in this way every single time and this is one area which calls for further coding in order to perfect the performance of the Autonomous Robotic Wheelchair.

The commands are as follows: Thereafter, we open a second terminal window and use the following command: This stage window can be kept open and we can use a third terminal window to open a second Stage window in which we can run our robot while were doing obstacle avoidance in real time. In Left-Right Obstacle Avoidance, the robot wanders around in the cave environment and turns right or left based on the position of obstacles.

The following is a snapshot of the Left-Right Obstacle Avoidance code. In the GoTo-based Obstacle Avoidance, the robot moves along its path and if it finds obstacles it navigates around it and returns to keep moving along its original path until endpoint is reached.

The following snapshots show our GoTo-based obstacle avoidance simulations for a straight axis and for an inclined axis. According to Introduction to Autonomous Mobile Robots by Seigwart et al, for a mobile robot, the specific aspect of cognition directly linked to robust mobility is navigation competence.

Given partial knowledge about its environment and a goal position or a series of positions, navigation encompasses the ability of a robot to act based on its knowledge and sensor values so as to reach its goal positions as efficiently and as reliably as possible. Therefore, navigation refers to the robots ability to determine its own position in its frame of reference and then to plan a path towards its goal position.

Thus, for navigation, the robot requires representation i. Navigation can be defined as a combination of three fundamental competencies: Also there are two different types of Navigation: We attempt to find the path with the lowest cost for the journey. Thus, in local path planning we are looking for a planned path with small deviations which bring the robot back to its planned path. In developing our navigation code we studied the various algorithms presented in the Introduction to Autonomous Mobile Robots by Seigwart et al.

The following is a brief discussion of the algorithms that we reviewed:. The Breadth First Search algorithm begins at the start node and explores all of its neighboring nodes. For each of these nodes it explores all of its unexplored neighbors marking its nodes as either visited or open. In this way the algorithm iterates until it reaches it goal where it terminates. The breadth first search always returns the path with the fewest number of edges between the start and end nodes.

If we assume that the cost of all individual edges in the graph is constant than the breadth first search returns the optimal-cost path. In contrast to the Breadth First Search, the Depth First Search Navigation algorithm expands every single node to its deepest level, its branches are removed and the search backtracks by expanding the next neighboring node of the start node until its deepest level.

Depth First Search offers the advantage of space complexity, in that it stores only the single path from the start node to the goal node. For Potential Field navigation we start out by creating a two dimensional discretized configuration space of X and Y coordinates. We can then attach a potential value to each of these grid configurations and denote as a potential function or gradient spread over the entire 2D field within which the robot moves.

The potential field method treats the robot as a point under the influence of an artificial potential field U q. The robot moves by following the field just as a ball were rolling downhill under the action of gravity. The basic idea is that the endpoint is pulling an attractive potential onto the robot and the obstacles within the robots environment are exerting a repulsive potential onto the robot.

Thereafter the potential field of the robot is computed as a sum of the attractive field of the goal and the repulsive fields of the obstacles. At every point in time, the robot will look at the potential field vector at that point and start going in that direction. The attractive and repulsive potentials can be found using any of the linear or quadratic formulae with various scaling factors for the endpoint attraction and the repulsion by obstacles. Some of the problems associated with the potential field algorithm are the Local Minima Problems in which robot is unable to navigate its way to the endpoint of the repulsive potentials due to the obstacles chocking its pathway.

650+ Mechanical Engineering projects New Updated

In order to implement the Potential Field Navigation method for our code, we implemented the BrushFire Navigation scheme. The BrushFire algorithm is a clearance-based path finding algorithm which overlays a grid onto the entire navigational space of the robot. In the BrushFire algorithm weve represented the 2D navigational space of our robot as a grid of pixels. For example, if weve used a X jpg image for our robot environment, we will first break it down into a grid of blocks.

Each of the block is then checked using nested iterative for loop of pointers, if the pixels are occupied by obstacles we mark them with 1s and if theyre free and the robot can travel to them we mark them as zero.

In order to compute the attractive potential of the endpoint we compute it as a function of the distance of each pixel from the goal. On the other hand, the repulsive potential of the obstacles is generated by traversing the map such that at each pixel visited the 8 neighbors connected to it are updated to a value one greater than the value of the current pixel.

Doing so we have a grid where the occupied pixels are blocked out and the empty pixels close to the obstacles have higher grid values than those adjacent to them and the pixels as they go towards the endpoint have a decreasing grid value. It uses nested for loop to access every grid block and for each occupied grid block marked with 1 provided by the CreateMap grid it updates the cells around those obstacles to show repulsion.

Then it goes around to the cells around those updated blocks and keeps updating values on the grid to show to the rippling effect of the repulsion produced by the obstacles in the navigation space. Once again we make use of nested for loops to iterate to all the grid blocks and the blocks closer to the endpoint are marked with lower and lower values with the endpoint having the value of zero and the starting point having the maximum value on the grid iv.

The PotentialMap program uses the grid output from both to compute a grid showing the net potential function at each point. The potential function is computed as follows: Based on the output of the PotentialMap program, the runBrushFireMap causes the robot to move from its start point to its endpoint. For our simulation we have used a for loop to get the robot moving along its PotentialMap path of shortest cost from the start to end.

At each grid point, it checks to see if endpoint has been reached, if not it keeps moving along its PotentialMap shortest cost path. We were able to obtain successful test trails in some of the BrushFire simularions but not all.

Some of the problems arose to the programming complexity for the algorithm and due to the local minima problems of the BrushFire algorithm.

The following are screen shorts of our BrushFire Simulations which enables the robot to move from start point provided by the cfg file to endpoint specified in the code.

We started out by using simpler jpg images for testing as shown:. Eventually we progressed to more complicated scale model representations of our RISE Lab workspace and more realistic model-type obstacles placed within that workspace. In almost all of these simulations the robot was able to determine the shortest cost path to its end point specified. However, perhaps making the obstacles as models within the cfg file or for some other reason the BrushFire algorithm almost always crashed during more challenging test runs.

There were not only logical problems in implementation of the algorithm but also the test constraints which became a significant hurdle in the way. For example, we need to provide forward and angular velocities in order to physically drive our wheelchair using the NI USB.

However, the BrushFire code does not navigate based on velocity variables, it navigates based the relative grid values from start point to end point. Logically we could not translate the output of the latter into giving velocity values to the power drive of our wheelchair.

Another significant problem was the small test space and the limited scope of obstacle avoidance and navigation we could afford within that test space as well as the front two wheels of the wheelchair being idle and causing significant deviations betweens the expected and actual wheelchair motion. In view of these and other problems, we simplified our navigation scheme for the wheelchair based on a solution proposed by Lab Engineer Ahmed Hussain Qureshi.

Using our cfg file, the robot was given an initial start position and an initial angular heading in order to move the robot along that heading. The robot was thus able to move along the line we wanted it move along, meanwhile our code was used to provide an end point along the length of the line the robot travels along. Once the robot has reached that specified point along the line, the robot motion terminates.

Since most of our testing on the wheelchair required for the chair to move along a straight line while avoiding obstacles in its path, we were able to successfully use this navigation technique in our simplified simulations and trail runs in the lab.

The information shared on networks is accessible to all the computers connected on the network. There are two main types of Computer networks, I. Wired Network We used Wireless Networking for our project as it enabled us to communicate with the.

Such networks are used to replace wired networks and are most commonly used to provide last few stages of connectivity between a mobile user and a wired network. Wireless networks use electromagnetic waves to communicate information from one point to another without relying on any physical connection. Radio waves are often referred to as radio carriers because they simply perform the function of delivering energy to a remote receiver. The data being transmitted is superimposed on the radio carrier so that it can be accurately extracted at the receiving end.

Once data is superimposed modulated onto the radio carrier, the radio signal occupies more than a single frequency, since the frequency or bit rate of the modulating information adds to the carrier.

Multiple radio carriers can exist in the same space at the same time without interfering with each other if the radio waves are transmitted on different radio frequencies. To extract data, a radio receiver tunes in one radio frequency while rejecting all other frequencies. The modulated signal thus received is then demodulated and the data is extracted from the signal. They provide mobile users with access to real-time information so that they can roam around in the network without getting disconnected from the network.

This mobility supports productivity and service opportunities not possible with wired networks. Installation speed and simplicity: Installing a wireless system can be fast and easy and can eliminate the need to pull cable through walls and ceilings.

More Flexibility: Wireless networks offer more flexibility and adapt easily to changes in the configuration of the network. Reduced cost of ownership: While the initial investment required for wireless network hardware can be higher than the cost of wired network hardware, overall installation expenses and life-cycle costs can be significantly lower in dynamic environments.

Wireless systems can be configured in a variety of topologies to meet the needs of specific applications and installations. Configurations can be easily changed and range from peer-to-peer networks suitable for a small number of users to large infrastructure networks that enable roaming over a broad area. In this project we used two computers operating in parallel.

The working algorithm gave the velocity output stored in variable form that was to be transmitted. We used wireless communication to transmit these velocity values from the navigation algorithm to the LabView operated computer.

This LabView code further translated these values into voltage outputs, thereby enabling the accurate movement of the wheelchair. The Networking task required a lot of literature reading as the coding for creating a network and data transfer was a fairly new for us. This involved the study of standard networking tutorials and manuals.

Following are some of the Tutorials that were used for Networking. We used the server to transmit float type data to the client by casting it into a binary value. The Client interpreted this data type in binary and then re-calculated the values in float type data.

There are two types of sockets Stream sockets and Datagram sockets. We used Stream Sockets for our server because Stream sockets are reliable two-way connected communication streams. If we two output items into the socket in the order 1, 2, they will arrive in the order 1, 2 at the opposite end and they will be error free.

It was in the form of IPv4. This IP address was used by the client program to connect with the server on the network and pick up the data. When representing a two byte digit like b34f, this type of byte order will store the sequential bytes 4f followed by b3 in the memory. This storage method is called Little-Endian.

Mechanical Engineering Projects

Lower pair: A lower pair is an ideal joint that has surface contact between the pair of elements, as in the following cases: A revolute pair, or hinged joint, requires a line in the moving body to remain co-linear with a line in the fixed body, and a plane perpendicular to this line in the moving body must maintain contact with a similar perpendicular plane in the fixed body.

This imposes five constraints on the relative movement of the links, which therefore has one degree of freedom. A prismatic joint, or slider, requires that a line in the moving body remain co-linear with a line in the fixed body, and a plane parallel to this line in the moving body must maintain contact with a similar parallel plane in the fixed body.

A cylindrical joint requires that a line in the moving body remain co-linear with a line in the fixed body.

It combines a revolute joint and a sliding joint. This joint has two degrees of freedom. A spherical joint, or ball joint, requires that a point in the moving body maintain contact with a point in the fixed body. This joint has three degrees of freedom. A planar joint requires that a plane in the moving body maintain contact with a plane in fixed body. A screw joint, or helical joint, has only one degree of freedom because the sliding and rotational motions are related by the helix angle of the thread.

Higher pairs: Generally, a higher pair is a constraint that requires a line or point contact between the elemental surfaces. For example, the contact between a cam and its follower is a higher pair called a cam joint.

Similarly, the contact between the involute curves that form the meshing teeth of two gears are cam joints..

Similar posts:

Copyright © 2019