Windows 7 Sins

Calendario

November 2009
M T W T F S S
« Oct    
 1
2345678
9101112131415
16171819202122
23242526272829
30  

Archivos

Encuesta

¿Qué te impide usar solo software libre en ingeniería?

View Results

Loading ... Loading ...

Visitas



Free web hostingWeb hosting

A Robust Inexpensive Multi-Purpose Robotic Arm

InexpensiveMulti-PurposeRoboticArm

Alana Lafferty
UAP Report
UAP Advisor: Professor Rodney Brooks and Dr. Una May O’Reilly
May 20, 2005

OGRE, Object-Oriented Graphics Rendering Engine

http://www.ogre3d.org/wp-content/uploads/2009/01/ogre_16_logo.gif

OGRE (Object-Oriented Graphics Rendering Engine) is a scene-oriented, flexible 3D engine written in C++ designed to make it easier and more intuitive for developers to produce applications utilising hardware-accelerated 3D graphics. The class library abstracts all the details of using the underlying system libraries like Direct3D and OpenGL and provides an interface based on world objects and other intuitive classes.

Features

Features Productivity features

  • Simple, easy to use OO interface designed to minimise the effort required to render 3D scenes, and to be independent of 3D implementation i.e. Direct3D/OpenGL.
  • Extensible example framework makes getting your application running is quick and simple
  • Common requirements like render state management, spatial culling, dealing with transparency are done for you automatically saving you valuable time
  • Clean, uncluttered design and full documentation of all engine classes
  • Proven, stable engine used in several commercial products

Platform & 3D API support

  • Direct3D and OpenGL support
  • Windows (all major versions), Linux and Mac OSX support
  • Builds on Visual C++ and Code::Blocks on Windows
  • Builds on gcc 3+ on Linux / Mac OSX (using XCode)

Material / Shader support

  • Powerful material declaration language allows you to maintain material assets outside of your code
  • Supports vertex and fragment programs (shaders), both low-level programs written in assembler, and high-level programs written in Cg, DirectX9 HLSL, or GLSL and provides automatic support for many commonly bound constant parameters like worldview matrices, light state information, object space eye position etc
  • Supports the complete range of fixed function operations such as multitexture and multipass blending, texture coordinate generation and modification, independent colour and alpha operations for non-programmable hardware or for lower cost materials
  • Multiple pass effects, with pass iteration if required for the closest ‘n’ lights
  • Support for multiple material techniques means you can design in alternative effects for a wide range of cards and OGRE automatically uses the best one supported
  • Material LOD support; your materials can reduce in cost as the objects using them get further away
  • Load textures from PNG, JPEG, TGA, BMP or DDS files, including unusual formats like 1D textures, volumetric textures, cubemaps and compressed textures (DXT/S3TC)
  • Textures can be provided and updated in realtime by plugins, for example a video feed
  • Easy to use projective texturing support

Meshes

  • Flexible mesh data formats accepted, separation of the concepts of vertex buffers, index buffers, vertex declarations and buffer mappings
  • Biquadric Bezier patches for curved surfaces
  • Progressive meshes (LOD), manual or automatically generated
  • Static geometry batcher

Animation

  • Sophisticated skeletal animation support
    • blending of multiple animations with variable weights
    • variable/multiple bone weight skinning
    • software and hardware-accelerated skinning pipelines with intelligent buffer sharing
    • manual bone control
    • Configurable interpolation modes, accuracy vs speed tradeoffs
  • Flexible shape animation support
    • Morph animation for legacy applications where you wish to perform simple linear blends between shape snapshots
    • Pose animation for modern shape animation, allowing you to blend many poses at variable weights along a timeline, for example expression / mouth shapes to perform facial animation
    • Both techniques can be implemented in hardware and software depending on hardware support
  • Animation of SceneNodes for camera paths and similar techniques, using spline interpolation where needed
  • Generic animation tracks can accept pluggable object adaptors to enable you to animate any parameter of any object over time

Scene Features

  • Highly customisable, flexible scene management, not tied to any single scene type. Use predefined classes for scene organisation if they suit or plug in your own subclass to gain full control over the scene organisation
  • Several example plugins demonstrate various ways of handling the scene specific to a particular type of layout (e.g. BSP, Octree)
  • Hierarchical scene graph; nodes allow objects to be attached to each other and follow each others movements, articulated structures etc
  • Multiple shadow rendering techniques, both modulative and additive techniques, stencil and texture based, each highly configurable and taking full advantage of any hardware acceleration available.
  • Scene querying features

Special Effects

  • Compositor system, allowing for full-screen postprocessing effects to be defined easily, via scripts if desired
  • Particle Systems, including easily extensible emitters, affectors and renderers (customisable through plugins). Systems can be defined in text scripts for easy tweaking. Automatic use of particle pooling for maximum performance
  • Support for skyboxes, skyplanes and skydomes, very easy to use
  • Billboarding for sprite graphics
  • Ribbon trails
  • Transparent objects automatically managed (rendering order & depth buffer settings all set up for you)

Misc features

  • Common resource infrastructure for memory management and loading from archives (ZIP, PK3)
  • Flexible plugin architecture allows engine to be extended without recompilation
  • ‘Controllers’ allow you to easily organise derived values between objects e.g. changing the colour of a ship based on shields left
  • Debugging memory manager for identifying memory leaks
  • ReferenceAppLayer provides an example of how to combine OGRE with other libraries, for example ODE for collision & physics
  • XMLConverter to convert efficient runtime binary formats to/from XML for interchange or editing

http://www.ogre3d.org/wiki/images/d/df/Week10.jpg

Orocos, a general-purpose, free software, and modular framework for robot and machine control

http://www.orocos.org/files/logo-t.png

The Orocos Project

Smarter control in robotics & automation!
Orocos” is the acronym of the Open Robot Control Software project. The project’s aim is to develop a general-purpose, free software, and modular framework for robot and machine control. The Orocos project supports 4 C++ libraries: the Real-Time Toolkit, the Kinematics and Dynamics Library, the Bayesian Filtering Library and the Orocos Component Library.
http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.4.x/doc-xml/images/RTT_KDL_BFL_400.png
  • The Orocos Real-Time Toolkit (RTT) is not an application in itself, but it provides the infrastructure and the functionalities to build robotics applications in C++. The emphasis is on real-time, on-line interactive and component based applications.
  • The Orocos Components Library (OCL) provides some ready to use control components. Both Component management and Components for control and hardware access are available.
  • The Orocos Kinematics and Dynamics Library (KDL) is a C++ library which allows to calculate kinematic chains in real-time.
  • The Orocos Bayesian Filtering Library (BFL) provides an application independent framework for inference in Dynamic Bayesian Networks, i.e., recursive information processing and estimation algorithms based on Bayes’ rule, such as (Extended) Kalman Filters, Particle Filters (Sequential Monte methods), etc.

Orocos is a free software project, hence its code and documentation are released under Free Software licenses.

Physical Rigging, library for complex dynamics simulation and visualization.

Physics libraries such as ODE provide excellent real-time simulation, embedding them in a 3D application to create a virtual reality is far from trivial. It is often prohibitively difficult to create a simulated reality that incorporates complex dynamic objects that interact with each other and the environment under physics’ constraints.
One of the major obstacles is mapping between meshes and objects supported by the physics engine.—This is what EZPhysics aims to solve.

EZPhysics API is licensed under the GNU Lesser Public License (LGPL).

The system is composed of two parts:

  • Editor & Simulator—Lets you interactively embed objects supported by the physics engine into 3D meshes, attach joints and constraints to the physics objects, save the “physically rigged” scenes into files, and run simulations.
  • API—Lets you embed the “physically rigged” meshes into your application. This involves using classes and methods for reading the editor files and manipulating the physical aspects of the objects, such as applying torques and forces to joints.

http://ezphysics.org/index_files/image3781.jpghttp://ezphysics.org/index_files/image10531.jpg

CarWorld, a small driving simulator/demo

CarWorld is a small driving simulator/demo I use to test various things of interest. It was mostly developed when I was a student. It is released with the full source code under the GNU General Public License.

The rendering

The two top pictures represent an slightly older version (v0.072) but graphically similar of CarWorld as it was presented for my project. v0.072 includes an OpenGL based renderer allowing

  • file input and displaying of texture mapped models with interpolated surface normals, real time projected shadows (as seen in the dino lights example).
  • background object
  • on screen command line to modify visual and simulation parameters

The mechanics

  • based on classical mechanics
  • uses standard metrics (Newtons, meters, seconds…)
  • there are no constraints on the environment surface
  • variable length time increments and variable increment number means “CarWorld time” is not dependent on frame rate.
  • adjustable simulation specs include: metrics, mass, moment of inertia around rotation axis, suspension pre load, compression dampin

Where I am now

I am now working at OKTAL where I work on Callas/Prosper a vehicle dynamics evaluation tool and  full scale driving simulator.

The rendering

The two top pictures represent an slightly older version (v0.072) but graphically similar of CarWorld as it was presented for my project. v0.072 includes an OpenGL based renderer allowing

  • file input and displaying of texture mapped models with interpolated surface normals, real time projected shadows (as seen in the dino lights example).
  • background object
  • on screen command line to modify visual and simulation parameters

The mechanics

  • based on classical mechanics
  • uses standard metrics (Newtons, meters, seconds…)
  • there are no constraints on the environment surface
  • variable length time increments and variable increment number means “CarWorld time” is not dependent on frame rate.
  • adjustable simulation specs include: metrics, mass, moment of inertia around rotation axis, suspension pre load, compression damping, rebound damping, engine torque output, air friction, surface friction.

cwscreen3smallthumbnailcwscreen4small

UbuntuScience, application for Scientists and Engineers with Ubuntu or GNU/Linux

Soruce: here

The aim of the page is to become a useful resource for scientists, engineers and students using Ubuntu (or any other) Linux.

Open Source Robotic Arm

Open Source Robotic Arm

A five degrees of freedom robotic arm.

Why this isn’t quite ready for sale:
-We lack any inverse kinematics program which makes moving the arm intelligently nearly impossible.
-Without software limits on the servos it is capable of stripping the low cost hobby servo motors (this is alright for testing as they are only five dollars) (we have stripped two in the life of our arm and both happened when we were asking it to do silly things) (this can be fixed by upgrading the servos)
-We haven’t completed the 3d model or assembly instructions just yet, but by studying the photos it is possible to assemble. (think more jigsaw puzzle than lego set)
-The gripper, lets just say the gripper needs a little work.

That said it is an amazingly fun toy to play around with, and a good starting point if anyone has ever had a desire to make the perfect robotic arm (it is open source so you’d be free to make and sell your own)

For more details about becoming a Robotic Arm Developer visit our blog
(http://www.oomlout.com/blog)

OpenSource Robotic Arm

http://www.hobbycity.com/hobbycity/store/catalog/hxt12K.jpghttp://www.pololu.com/picture/0J48.200.jpg?1236749329

http://thingiverse_beta.s3.amazonaws.com/renders/df/ff/f4/bd/ad/RARM-Ponoko_display_medium.jpg

The Katana Robotic Arm

The Katana Robotic Arm is typically used for handling, measurement, or testing applications in assembly, production, and laboratory automation, says Neuronics. The robot is billed as an “intelligent” industrial robotic arm with safety features that “allow it to work directly hand-in-hand with human operators without the need for any additional safeguards or fences,” says the company. The Katana is also touted for its ability to run as an an independent stand-alone unit, without requiring an external control host.

Katana linux robot arm
Oh no, Mr. Bill! The Katana in action

The new Linux version of the Katana allows low-level access to the robot’s Linux control board, and comes with system, communication, and motion libraries available as open source packages. This open source access provides application opportunities “that could hitherto only be met by developing highly expensive custom engineered robotics systems,” says the company.

The Katana is based on a single-board computer (SBC) equipped with a PowerPC-based Freescale MPC5200 processor that provides 750 MIPS (millions of instructions per second) of performance, says Neuronics. The robot has six Texas Instruments (TI) TMS320 32bit motor controllers, one for each axis. Built around a CAN bus architecture, the robot also offers Ethernet and USB ports. The Katana is said to operate in three modes: control, standalone direct, and a standalone RPC/Web-services mode that supports technologies such as SOAP and Ajax for web-based control.

The Katana’s control board
Katana robot arm control board

Specifications for the Katana Robotic Arm are said to include:

* Processor — Freescale MPC5200
* Embedded controllers — 6 x TI TMS320 32bit motor controllers
* Memory — 64MB RAM
* Flash — 32MB flash
* CAN bus — 1 x control bus; 1 x sensor bus; external CAN connector
* Networking — 1 x Ethernet hub
* USB — 1 x host; 1 x device
* Other I/O — integrated digital I/O extension board
* Katana software/services:
o Communication server
o Standalone mode
o CAN open (PDO) driver interface
o Control-pad deamon
o Fieldbus server
o Ajax-based web Interface
o Process image server
o Eventhandler as web service
o Configurable debugging modes
o XML-RPC command and control interface
o Linux shell interface via web service
o SOAP server command and control interface
o C++ libraries and Python 2.5 bindings
* Operating system — Linux 2.4.25 (Linux kernel 2.6 optional) with Xenomai hard real-time extensions; driver patches for control board

Denx Linux and Xenomai

The embedded Linux version of Katana runs a 2.4.25 Linux kernel (upgradable to 2.6.22) that is said to be optimized for industrial high availability. The robot has been developed with the Denx Embedded Linux Development Kit (ELDK) software development kit (SDK), an open-source Linux distribution and development tool suite that is especially popular in Europe’s industrial Linux community.

Katana software architecture

The Linux kernel is coupled with the Xenomai pre-emption and scheduling real-time add-on framework for Linux, which is supported by recent versions of ELDK. Xenomai provides “skins” for emulating API requests for different real-time operating systems (RTOSes). In the Katana implementation, Xenomai provides a development framework that cooperates with the Linux kernel to provide pervasive, hard real-time support to Nucleus-, kernel-, and user-space applications, says Neuronics.

Neuronics offers a Katana Native Interface (KNI) C++ library for control application development “at the lowest interface level,” says the company. The KNI interface can be exported as a Python 2.5 binding, enabling Python development of native and external programs. A control interface is also said to be available directly on the robot, with interfaces in C++ and Python.

For non-programmers, the company provides a GUI-based application programming interface (API) called Katana4D, which is targeted at industrial applications, and offers a built-in scripting language. Developers can move the robot arm into the desired position by hand, and Katana4D detects the position, generating the appropriate code, says the company. Katana4D is also said to provide AI algorithms for path optimization and adaptation, and can automatically convert applications to Python for deployment on the Katana in standalone mode.

This month, Neuronics announced a “Katana UniKit” robot axis development board. The UnkiKit is said to offer 1-3 axes (axis controllers and motors), a CAN adapter, and a plug-and-play live CD with a customized Ubuntu Linux distribution. The distribution is said to offer sources, documentation, cross compilers and toolsuites for learning, developing, and modifying robotics applications. Aimed at research, education, and OEM robotics development, the UniKit can be purchased separately from the Katana.

Founded in 2001, Neuronics is a spin-off venture from the Artificial Intelligence Laboratory at the Institute for Informatics of the University Zurich.

Availability

The pricing for the embedded Linux version of the Katana starts at 19,500 Euros, or about $24,900 US, says Neuronics. No pricing or availability information was provided for the new Ubuntu-based Katana UniKit development board. More information on the Katana, including links to detailed information on APIs, patches, hardware, and more, may be found here.

Text taken from: http://www.linuxfordevices.com/c/a/News/Robotic-arm-runs-Linux/

Presentación: PIC con GNU/Linux.

PICconGNUpresentacion

Article: “Case Study: Fedora in an University Engineering Lab”

The standard setup uses a Motorola 68HC908 microcontroller, the Windows operating system on the PC, and Matlab. An alternative setup was chosen, using a PIC18F4520 microcontroller, Fedora 8 Linux on the PC, and GNU Octave. This alternative setup allowed for an easier to implement software design, which outperformed other designs on a variety of levels.

Case Study: Fedora in an University Engineering Lab
Benjamin Kreuter and Robert Greene
May 14, 2008

Purpose
This case study provides details on how Fedora 8 Linux was used and relied on in an academic laboratory project. The motivation for choosing Fedora is outlined, and the advantages afforded by this
choice are discussed. In addition, the ability to use necessary proprietary software in Fedora 8 is discussed. Block diagrams of specific parts of the design are presented, to aid in illustrating how a
Linux system was used to accomplish the goals of the project. Due to concerns over possible plagiarism by future students, the specific results of the project have been omitted, but are available from the authors upon request.

Conclusion
By choosing a free software system, a superior software design was achieved, at no cost, in a university engineering laboratory setting. This design was more flexible than designs based on proprietary software, with a shorter development schedule. This project may serve as an example of how engineering students can use Fedora Linux in their education, especially in a demanding course in engineering design.

The four pages study is available clicking the title.