Robotics Technology

Takara Tomy I-SODOG

noreply@blogger.com (Unknown) — Sun, 15 Jul 2012 11:20:00 +0700

Takara Tomy has unveiled the latest in their line of Omnibot toy robots at Tokyo Toy Show 2012. The I-SODOG is small enough to fit in the palm of your hand, but boasts 15 servo motors that can reproduce realistic movement.

When activated, its eyes light up and users can interact with it through more than 50 voice commands or with a smartphone thanks to a Bluetooth connection. Using a custom app, it will perform tricks on command such as shake a paw, dance to songs you’ve downloaded, or move intuitively by simply tilting the phone. There’s also a Tamagotchi-style artificial life component, allowing you to scold bad behavior or reward it with digital doggy treats, which will foster different “personalities” over time.

The robot pup comes equipped with touch sensors, microphones, and a 3D accelerometer to prevent it from falling over. If its younger owners don’t have access to a smartphone, they can command it with the included remote controller. It also includes some practical features, such as a voice mail system and an alarm function. And if two I-SODOGs are brought together, they will exchange data with one another.

At just 15 cm (6″) in height and length, and weighing 400 grams (0.8 lbs), the I-SODOG is considerably smaller than SONY’s ill-fated AIBO. But thanks to its smartphone connectivity, it has the potential to outsmart all of the older robot dogs in the kennel. According to Takara Tomy, it will have some autonomy similar to the AIBO, and operate for between 1~2 hours on AA batteries. The I-SODOG is expected to retail for around 30,000 JPY ($380 USD) in spring 2013.

In 2007, the company released a miniature humanoid robot toy called the I-SOBOT, which revived its brand of home robots that were popular in the 1980s.

[source: Gigazine (JP), Plasticpals]

Self Balancing Robot

noreply@blogger.com (Unknown) — Sun, 15 Jul 2012 10:37:00 +0700

This self balancing robot still uses just two wheels, but it’s balancing very differently than we’re used to seeing. Where most of the projects use a form factor that’s similar to a Segway, this works just like a bicycle. But it doesn’t need to keep the front and rear wheels spinning to stay upright. This Self balancing robot isn’t stuck in one place, with distance sensors on the front and back which are used to move the bike as if by repulsion.

The large wheel where the rider would be is what makes sure the vehicle doesn’t topple over. It acts as an inverted pendulum, pushing against the large wheel’s inertia by rotating the motor to which it is attached. The same concept was seen back in march on a full-sized bike. But why use two wheels when you only need one? His unicycle version can also be seen embedded after the break.

TELESAR V Avatar Transfers Touch, Vibration, Temperature

noreply@blogger.com (Unknown) — Sat, 14 Jul 2012 22:44:00 +0700

The Japanese Science and Technology Agency (JST) and Keio University’s Tachi Lab presented their newest telexistence system, the TELESAR V, at SIGGRAPH 2012 Emerging Technologies. The avatar system’s ability to relay tactile sensation has improved since its original reveal in November 2011. In a world first, a human operator can now distinguish if the robot is handling cloth or paper by touch alone.

Of course, the operator gets much more than just tactile feedback as part of the experience, as a head-mounted display provides a high-definition wide-angle view from the robot’s perspective, along with stereo sound. The robot avatar’s body has a total of 54 degrees of freedom (head x3, trunk x5, two arms x7, two hands (and fingers) x16) which allow it to accurately mimic the operator’s movements (using a motion-capture system).

The TELESAR V’s hands and fingers are equipped with a number of sensors to capture and relay tactile information to its operator through special gloves. The primary sensor inside each fingertip is a vision-based force sensor which is comprised of a wide-angle camera that looks through a gel-layer mixed with thermochromic ink. When the gel compresses, the thermochromic ink becomes denser, which the camera interprets as force information.

Microphones underneath the robot’s fingertips convert low to mid level vibrations; when pouring marbles from one cup to another (as the robot), the operator feels the tactile sensation from doing so. Furthermore, the operator is able to sense changes in temperature at the robot’s fingertips, thanks to thermoelectric peltier devices which reproduce warm and cold temperature inside the operator’s gloves. Now even an object’s texture can be relayed to the operator.

The TELESAR V system overview

Ideally, the robot’s hands and fingers would be as sensitive as the real thing, and recent breakthroughs suggest we may not be that far off. Normally, just cramming all the sensors and feedback devices into a volume the size of a human fingertip has been a major problem. But the TELESAR V’s haptic controls provide enough precision and feedback to accurately pick and place small objects.

Operators extracted straws from a jumble, moved Shogi (Japanese chess) pieces on a cluttered game board, and felt the brushing sensation of a Lego block as it moved across the robot’s fingertips. In addition to earlier systems, the operator’s freedom has been expanded to allow them to bend and lean their upper body and have those movements mirrored by the robot.

When you add it all up, the TELESAR V system is probably the most sophisticated of its kind in the world today and has the potential for many practical applications. It is exactly this kind of system that will enable humanoid robots to perform complex tasks in hazardous environments, though it will take a second operator to control a robot’s lower body.

Teams competing in DARPA’s Robotics Challenge are likely salivating over such a system as they try to devise their own. In fact, it was Prof. Susumu Tachi (the director of Tachi Lab and this project) that worked on the teleoperation system of the Centaur robot designed for use in nuclear plants back in the ’80s. As the world’s leading scientist in telexistence and telepresence robots, we have covered some of his lab’s earlier telexistence robots before (see TELESAR, TELESAR 2, TELESAR 4).

Another video and more photos can be found after the break.

[source: Tachi Lab (EN)] & [TachiLab @ YouTube] via [MyNavi News (JP), Plasticpals]

Robonaut 2 ( R2 ), The First Humanoid Robot Go to Space

noreply@blogger.com (Unknown) — Sat, 26 Mar 2011 10:26:00 +0700

Robonaut 2

Robonaut 2 ( R2 ) is the first humanoid robot in space. Robonaut 2 is developed by collabaration of Nasa and GM. Robonaut target is to help humans perform their jobs on earth or on Space ( ISS - International Space Station ).

Robonaut 2 delivered to space through Mission STS-133 was launched into space on february 24th, 2011.

Finally, Robonaut 2 is out of his Box!

After arrive at ISS, finally Robonaut out of his box. Two human astronauts has big surprise when opened the R2 box.

The two human astronauts make funny video for Robonaut 2, :D it's seems robonauts 2 is naughty robot and got out of the box by it self.. lol.

Robonaut 2 Jobs in Space.
The main job of robonaut 2 is teaching engineers how dexterous robots behave in space, the hope is that through upgrades and advancements, it could one day venture outside the station to help spacewalkers make repairs or additions to the station or perform scientific work.
Robonaut 2 launched inside the Leonardo Permanent Multipurpose Module, which was packed with supplies and equipment for the station and then installed permanently on the Unity node. R2 will initially be operated inside the Destiny laboratory for operational testing, but over time both its territory and its applications could expand. There are no plans to return R2 to Earth. Pity R2 :D

Adaptive Gripper

noreply@blogger.com (Unknown) — Thu, 24 Mar 2011 09:06:00 +0700

The robotic gripper that adapts to all parts, simply.

Robotiq is developed by Quebec company. Robotiq is very interesting robotic gripper that can adapt to various types of objects.

How it works

3 articulated fingers and 4 grasping modes to pick a wide variety of sizes and shapes.

Send simple open-close commands and let the gripper adapts to any geometry.

Control the closing speed, force, do partial closing / opening.

Receive grip detection feedback from the gripper.

Embedded gripper controller communicating with the robot controller over Ethernet/IP, Modbus RTU, DeviceNet or EtherCAT. Program from the teach pendant.

Electric gripper, comes with the mechanical mount for your robot. Has two connectors on the side for 24V power supply and communication.

Adaptive Gripper can use for many type application:

Manufacturing Applications: Work with a single tool to pick, hold and place parts of different sizes and shapes.
Teleoperation: The gripper for dexterous manipulation and intuitive teleoperation.
Research Operations: Expand the research opportunities of your robot.

Even more impressive, when the Adaptive Gripper is combined with the Motoman SDA10D dual-arm robotic system by Yaskawa, the result is a very powerful robot capable of manipulating a large variety of objects very precisely. The kitting example below illustrates the system capabilities very well.

Source: Robotiq

Humanoid Robot SILF H2

noreply@blogger.com (Unknown) — Sun, 13 Mar 2011 10:43:00 +0700

Robo Cup 2004

Robo Cup 2003

Katsuhisa Ito is a hobbyist who has been creating small robots since 1992. Roughly 10 years later, he got around to building his dream project – his own humanoid – whenever he had the time and money to work on it. Before building SILF H2, Katsuhisa Ito has been creating many small robots, SILF H1 and then SILF H2.

SILF H1

Silf-H1 (the first version) was completed over the course of a year starting in 1998, with Ito working on it in his dining room at home. It stood 22.5cm tall and weighed 430g with its battery. He gave up adding arms (for lack of funds), so it had 14 DOF (2 legs x6, head x2). The head is a CMOS camera.One year after beginning development, the Silf-H1 was completed (November 10th, 1999) and soon it was walking (November 17th).
Three days later it qualified for the expert league at the 20th All-Japan micro-mouse tournament, and the following day won the humanoid leg of the competition. In June, 2000 it won the Robotics Society Award at RoboCup Japan.

SILF H2

After Winnning Award for SILF H1, Katsuhisa Ito began working on a newer model. He named it SILF H2.The SILF H2 is 25.2cm (10 inches) tall, weighs 730g (1.5 lbs), and has 21 DOFs (DC motors). Originally designed to compete in micro-mouse style maze competitions, the H2 has a CCD camera for a head that was ingeniously re-purposed from a mobile phone, which allows it to navigate simple environments.

An undeniable part of the Silf-H2′s charm (besides its agility) is its professional, custom-machined body parts, which put it a cut above the majority of custom-built hobby robots. Ito-san even engineered the camera’s microchip himself, so that it would fit inside the slender head case (which is a modified USB cable dongle).

The Silf-H2 was featured on the cover of Industrial Automation (September 2004 issue) accompanied by two of the most prominent robots; QRIO and Asimo, and won various awards at RoboCup tournaments for its fast walking and jumping capabilities. Katsuhisa Ito has also contributed an article that was included in Handy Book Mechatronics, published in November 2005.

Source: Here

Robot Arm Torque Tutorial

noreply@blogger.com (Unknown) — Sat, 12 Mar 2011 15:16:00 +0700

The equations used in the calculator to determine the torque required at any given lifting joint (raising the arm vertically) in a robotic arm are presented here. Note that the term "actuator" is used rather than motor because not all robotic arms necessarily use servo motors (some may use pneumatics, hydraulics, etc.).

Torque (T) is defined as a turning or twisting “force” and is calculated using the following relation:

The force (F) acts at a length (L) from a pivot point. In a vertical plane, the force acting on an object (causing it to fall) is the acceleration due to gravity (g = 9.81m/s²) multiplied by its mass:

The force above is also considered the object's weight (W).

The torque required to hold a mass at a given distance from a pivot is therefore:

This can be found similarly by doing a torque balance about a point. Note that the length L is the PERPENDICULAR length from the pivot to the force.

Therefore, replacing F with m*g, we find the same equation above. This method is the more accurate way to find torque (using a torque balance).

In order to estimate the torque required at each joint, we must choose the worst case scenario.

In the above image, a link of length L is rotated clockwise. Only the perpendicular component of length between the pivot and the force is taken into account. We observe that this distance decreases from L3 to L1 (L1 being zero). Since the equation for torque is length (or distance) multiplied by the force, the greatest value will be obtained using L3, since F does not change. You can similarly rotate the link counterclockwise and observe the same effect.

It can be safe to assume that the actuators in the arm will be subjected to the highest torque when the arm is stretched horizontally. Although your robot may never be designed to encounter this scenario, it should not fail under its own weight if stretched horizontally without a load.

The weight of the object (the "load") being held (A1 in the diagram), multiplied by the distance between its center of mass and the pivot gives the torque required at the pivot. The tool takes into consideration that the links may have a significant weight (W1,W2..) and assumes its center of mass is located at roughly the center of its length. The torques caused by these different masses must be added:

Note: do not confuse 'A' (the weight of the actuator or load) with 'a' (acceleration).

You may note that the actuator weight A2 as shown in the diagram below is not included when calculating the torque at that point. This is because the length between its center of mass and the pivot point is zero. Similarly, when calculating the torque required by the actuator A3, its own mass is not considered. The torque required at the second joint must be re-calculated with new lengths, as shown below (applied torque shown in pink):

Knowing that the link weight (W1, W2) are located in the center (middle) of the lengths, and the distance between actuators (L1and L3 as in the diagram above) we re-write the equation as:

The tool only requires that the user enter the lengths of each link, which would be L1 and L3 above so the equation is shown accordingly. The torques at each subsequent joint can be found similarly, by re-calculating the lengths between each weight and each new pivot point.

Note: if any of the joints have two or more motors, they share the torque required evenly. Because the base of the arm is subjected to the highest torque, often two actuators are used instead of one.

More Advanced:

The above equations only deal with the case where the robot arm is being held horizontally (not in motion). This is not necessarily the "worst case" scenario. For the arm to move from a rest position, an acceleration is required. To solve for this added torque, it is known that the sum of torques acting at a pivot point is equal to the moment of inertia (I) multiplied by the angular acceleration (alpha):

To calculate the extra torque required to move (i.e. create an angular acceleration) you would calculate the moment of inertia of the part from the end to the pivot using the equation (or an equation similar to):

Note this equation calculates the moment of inertia about the center of mass. In the case of a robotic arm, the moment of inertia must take into consideration that the part is being rotated about a pivot point located a distance away from the center of mass and a second term ( +MR² ) needs to be added. For each joint, the moment of inertia is calculated by adding the products of each individual mass (m_i) by the square of its respective length from the pivot (r_i). Note that the equation for calculating the moment of inertia to consider for actuator N omits the mass of the actuator at the pivot point (N-1):

Note: The equation used to calculate the moment of inertia above (in this case multiplied by a constant value of 1/2) is not universal but rather varies from part to part (hollow vs. solid bar, cylindrical vs. rectangular cross-section etc.). The moment of inertia also differs depending on which axis is considered (Ixx, Iyy, Izz can all be different). More information about moment of inertia can be found by doing a search on the internet.

In all cases considered here, ‘r’ represents the distance from the center of mass to the pivot. Since the moment of inertia varies tremendously from part to part, angular acceleration is not taken into consideration with the Robot Arm Torque Calculator. Instead, to correct for possible angular acceleration, a “safety factor” is used and set to 2 by default. As with all dynamic tools, inefficiencies in the actuators and joints themselves must also be taken into consideration. This way, the motor at each joint will be able to provide more than the required torque to keep the arm stationary. The required torque to accelerate the weight being support by an actuator from a static position can be calculated using the following relation:

Above tutorial is for you if you good in mathematic but how about if you don't understand about that formulas? Don't worry, at below you'll find Torque Calculator. Very simple, you just need insert the value and you'll get the result.

Robot Arm Torque Calculator

The Robot Torque Arm Calculator is intended to help you choose the right motor for each joint of your robotic arm. The torque (T) required at each joint is calculated as a worst case scenario (lifting weight at 90 degrees). Ensure your units are consistent. Most common units are kg-cm and oz-in. T

L: length from pivot to pivot.
M: link mass
A: Actuator (servo or other) mass. Note: same units as for link masses.
A1 can represent the load being lifted.

Use the image above to help you determine which torque corresponds to which joint. Note the numbering starts with the extremity of the arm, so the final torque is the one lifting the entire arm (start from A1 being the load you wish to carry at full reach.). The torque shown is the STALL TORQUE you can use for your search.

The Torque Calculator

L:	[cm]	M:	[Kg]	A:	[Kg]	T:	[Kg-cm]
L1:		M1:		A1:		T1:
L2:		M2:		A2:		T2:
L3:		M3:		A3:		T3:
L4:		M4:		A4:		T4:
L5:		M5:		A5:		T5:
L6:		M6:		A6:		T6:

Source: Here

Arduino Tutorial for Beginner

noreply@blogger.com (Unknown) — Sat, 12 Mar 2011 13:11:00 +0700

The Arduino website offers free resources and tutorials as well as a language reference to help you understand the code and syntax. In order to get started, you will at the very minimum need an Arduino board. Note that all the Arduino (and most of the clone boards) can use the Arduino software. If you are unsure what hardware to get, the Arduino USB is currently the most popular model

Windows Connection and Setup

Hardware: none

Go to www.arduino.cc to download the latest version of the Arduino software (Direct link:http://arduino.cc/en/Main/Software and select your operating system; in this case we are using Windows)
Save the ZIP file to your desktop (you can move or delete it later)
Create a new folder called “Arduino” under “Program Files”. To do this, go to “My computer” -> “C:” (or the drive where the operating system is installed) -> “Program Files”, then left click once on “program Files” folder, then select “New”->”Folder” from the main Explorer menu.
Extract the entire ZIP folder to this new “Arduino” folder
To run the Arduino software, open Windows Explorer by pressing the windows key (usually between the Ctrl and Alt keys on your keyboard) and the ‘E’ character at the same time (there are other ways to access explorer as well).
Go to “My computer” -> “C:” (or the drive where the operating system is installed) -> “Program Files” -> “Arduino” In this folder you will see an executable file (Blue colored icon), you can left click (once) and then right click and select “send to” -> Desktop (create shortcut) to have Arduino more easily accessible.
Double click the icon to start the software. The Arduino Software is ready to use.

Arduino Software Interface

Hardware: Arduino USB Microcontroller or Arduino Microcontroller with USB

The Arduino interface is “bare-bones”. When you load the software, the first screen you will see is a white window with several different shades of blue and blue-green as border. There are the main headings “File” “Edit” “Sketch” “Tools” “Help” and several shortcut icons beneath “Verify”, “Stop”, “New”, “Open”, “Save”, “Upload” and “Serial Monitor”. Note that all these icons are also available from the main menus. Arduino projects are called “sketches” and when you start a new sketch, several files are also created. To connect to your board,

1. Start the Arduino software by double-clicking the Arduino icon (see S1 for details)

2. Plug one end of the USB into the Arduino and the other end into your computer.

3. In the software, select “Tools” -> “Board” -> “Arduino Duemilanove w/ATMEGA328” (if you have a different board, select it from the drop-down list; if you have purchased a compatible board, that manufacturer should indicate which board to choose).

4. In the software, select “Tools” -> “Serial Port” -> COM X (note that if you have several COM ports, you will need to go to Control Panel to see which is assigned to your board.

The computer may ask you to install the USB to Serial interface; let the system find and install the drivers automatically.

Basic Program Structure
Hardware: Arduino Microcontroller with USB

The Arduino language is CASE SENSITIVE: a capital letter is not the same as a lower case letter. Arduino software requires the following code in order to compile:

The “setup” section is widely used to initialize variables, pin modes, set the serial baud rate and related. The software only goes though the section once. The “loop” section is the part of the code that loops back onto itself and is the main part of the code. Note that you are free to add subroutines using the same syntax:

void subroutinename() {}

Almost every line of code needs to end with a semicolon ‘;’ (there are a few exceptions which we will see later). To write single line comments in the code, type two back slashes followed by the text:

//comments are overlooked when compiling your program and are used used to explain the code textually

To write multi-line comments, start the comment with /* and end with */

/* This is a multi-line comment and saves you having to always use double slashes */

Serial Communication

Hardware: Arduino Microcontroller with USB

The Arduino board can communicate at various baud ("baud rates"). A baud is a measure of how many times the hardware can send 0s and 1s in a second. The baud rate must be set properly for the board to convert incoming and outgoing information to useful data. If your receiver is expecting 2400 changes per second your transmitter is transmitter at a different rate, the data you get will not make sense. To set the baud rate, use the following syntax in

void setup()
{
Serial.begin(9600);
}

Other standard baud rates available on most Arduino modules include: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200 and you are free to specify other baud rates. To output a value in the Arduino window, consider the following program:

Verify the program by pressing the “verify” button (looks like a “play” button); you should not get any errors at the bottom of the screen. If you get errors, check that only the two numbers in the code are black, the rest of the text should have been automatically recognized and assigned a color. If part of the text is black, check the syntax (often copy/pasting text from another program can include unwanted formatting). If this does nto correct the error, you may need to re-do S1 and S2 in this tutorial.

Next, upload the sketch to the board using the “Upload to I/O Board” button (arrow pointing right). Wait until the sketch has finished uploading. You will not see anything unless you then select the “Serial Monitor” button (rectangle with a circle that looks like a TV). Make sure the baud rate selected is the same you wrote in your program. Try using

Serial.print("Hello World");

If you want to save all your programs, we suggest creating a new folder called “reference” and save this program as Hello World.

Arduino and LED
Hardware: Arduino Microcontroller

Making an LED light up is very straightforward. Many Arduino boards such as the Uno come with an LED soldered to the board and connected to digital pin13.

Note that the ‘W’ is capitalized. The line digitalWrite(pin, HIGH); puts a specified pin high to +5V. In this case we chose pin 13 since on the Uno, the LED is connected to pin 13. Replacing HIGH with LOW, the pin is set to 0V. You can attach your own LED using a digital output and the GND pin. The delay(1000); line causes the program to wait for 1000 milliseconds before proceeding (where 1000 is just a convenient example to get a 1 second delay). Compare this to a program that uses variables and comments.

Arduino and Potentiometers
Potentiometers (also known as “pots”) are great little electromechanical devices used to get angular or linear position feedback. Potentiometers are used to set volume level, or as feedback devices in servo motors. Pots can vary in quality, size, feedback type and most are linear or rotary (some have additional features incorporated inside). Almost all potentiometers have three outputs: one for ground, another for voltage input and a third for analog signal output (almost always the middle pin). A good pot to start with is a 10k (which is 10 kilo ohms) linear rotary potentiometer.

Cut three lengths of wire and remove the shielding from either end.
Solder one end of each wire to the three terminals on the pot.
Connect the middle wire to one of the Analog pins on the Arduino (in this case pin #2)
Connect one of the other wires to the Gnd on the Arduino
Connect the last wire to the +5V output pin on the Arduino.

Upload this program to the board and change to the Serial monitor. As you rotate the knob (or slide the slider), the values should change between 0 to 1023. You can now read values and use them within your code. The new function used here is “analogRead();” where the pin selected is pin #2 (if you used analog pin #5, you would change the code to
x = analogRead(5);

Troubleshooting:

If you bought a very cheap or old potentiometer, there is a chance it may be mechanically defective. You can test this using a multimeter and connect the ends to the middle pin and an outer pin. Set the multimeter to read resistance and rotate the knob; if the resistance changes slowly, the pot is working, and your connections or code may be at fault. If the resistance is erratic, you need a new potentiometer.

Arduino and Infrared Distance Sensors
Hardware: Arduino Microcontroller with USB, Infrared Distance Sensor and cables

Infrared distance sensors are useful for measuring distances without actually contacting a surface. The three wires protruding from a distance sensor represent +5V (in most cases), Gnd (Ground) and signal. These are almost always color coded with black as ground, red as +V and white or yellow as the signal. If your infrared distance sensor did not come with any wires, you will either need to find the appropriate connector, or solder wires directly to the leads (ensure the pins and solder do not contact one another).

Connect the red wire to +5V on the Arduino
Connect the black wire to Gnd on the Arduino
Connect the yellow wire to an analog pin on the Arduino

Since the sensor is connected to the analog input of the Arduino, the code is identical to that of the potentiometer:

Upload this program to the board and change to the Serial Monitor. As you move the front of the distance sensor closer to and away from an object, the values should change between 0 to 1023. You can now read values and use them within your code. Check the range for your sensor (not all sensors can read up close). Note that some sensors have a minimum distance - although it is always listed in the specifications, try to find it by experimentation.

Arduino and Push Buttons
Hardware: Arduino Microcontroller with USB and push button

Connecting toggle switches, push buttons and momentary contact switches to the Arduino is straightforward. A push button is a simple device that completes a circuit. One end of the button is connected to source, usually a low voltage (5V on the Arduino is ideal) and the other connected to the digital pin. When the switch is flipped, pressed or toggled, the circuit is either opened or closed. The digital pin simply returns if there is 5V or 0V. The code associated with this is:

digitalRead(pin);

In the following simple program, a pushbutton is used to turn on the LED connected to pin 13:

Arduino and Servo Motors
Hardware: Arduino Microcontroller and USB, a low power servo motor and additional wires

Controlling a servo motor directly from the Arduino is quite easy. Note however that a servo motor may require significantly more current than the Arduino can provide. The following example uses a standard sized servo (without any load) powered directly from the Arduino via USB. If you want to use a more powerful servo, or if you want to connect it to a load, you’ll need to use an external power supply connected to the red and black wires (ensure you also connect the black (ground) wire to the Gnd pin on the Arduino (common ground).

Connect the black wire from the servo to the Gnd pin on the Arduino
Connect the red wire from the servo to the +5V pin on the Arduino
Connect the yellow or white wire from the servo to a digital pin on the Arduino

Note that it is often unwise to connect a motor of any kind directly to the Arduino as it often requires more power than the board can provide. In this case, the servo is being used to demonstrate code and is not encountering any resistance. Note that you should use a standard or small size servo motor, if you are uncertain, check the servo's no load current rating (it should ideall be under 150mA).

Two new functions were used in this code, pinMode(pin number, OUTPUT); sets a pin number as dedicated input or output. In this case, we called the pin “servopin” and assigned a value of 4. The term “pulse” is in black as it is not a reserved word and can be changed by the user. It is best to use descriptive variables when coding to understand what each does, or the information it will contain. Servos operate by sending a timed +5V pulse to the onboard electronics every 20ms. This pulse corresponds to a servo position, usually from 0 to 180 degrees.

5V for 500 microseconds = 0.5 milliseconds corresponds to 0 degrees
5V for 1500 microseconds = 1.5 milliseconds corresponds to ~90 degrees
5V for 2500 microseconds = 2.5 milliseconds corresponds to ~180 degrees
The relationship is linear, so use mathematics to determine the values between. Note that if you send a signal that is greater or lower than the servo can accept (for example, Firgelli linear actuators acecpt 1 to 2 ms), you might dammage the actuator.
Arduino has the option of including a "servo library" (currently separate from the basic Arduino software) that manages much of the overhead and includes new, custom commands. If you want to control multiple servo motors, you should use a servo motor controller and a separate power supply between 4.8V to 6V.

Arduino and Force Sensors, Bend Sensors and Stretch Sensors
Hardware: Arduino Microcontroller, voltage divider circuit, flex or bend sensor

Force “sensors” are actually “force sensing resistors” (FSRs). Similarly, bend “sensors” are actually products whose resistance changes with flexing. These can all be categorized as “variable resistors”. To interface a product whose resistance changes with a microcontroller, you need a voltage divider circuit. This “circuit” is nothing complex – aside from wires, the only part you are missing is a resistor. To create the circuit, add the variable resistor in series with a similar (standard) resistor of roughly the same resistance (in ohms). Connect a wire between the two - this wire goes to the analog input of the board. There should only be two wires left - one end of the standard resistor, and one end from the variable resistor - these ends are connected to +5V and GND respectively. You can now use it as a regular sensor with analog output.

If you want a pre-made circuit, consider the Phidgets voltage divider:

The output of this “mini circuit” is a signal between 0 to 5V (this is referred to as an analog signal), which is connected to an analog pin of the microcontroller. The microcontroller's onboard analog to digital converter (ADC) interprets this voltage and assigns it a number which you can use in your code. For 10 bit ADC, you will get a number between 0 and 1024 representing 0V to 5V. You would need an equation in your code to use this number to send the appropriate signal to a motor controller. As you might have suspected, the code is now identical to that used to get an analog input.

Arduino and Accelerometers, gyroscopes and IMUs.
Hardware: Arduino microcontroller with USB and an accelerometer, gyroscope or IMU and wires (mini breadboard is optional)

When using accelerometers, gyroscopes or inertial measurement units to obtain positions in space, it is important to note that there are several additional factors that will affect the readings. The first and largest obstacle is the sampling rate. Microcontrollers requires a certain amount of time to read values being given to them by the sensor and because of this, the values between these readings are lost. There are several mathematical methods (Kalman being a popular choice) that attempt to compensate for this. A second source of error is that readings are often affected by fluctuations in temperature. Most datasheets associated with MEMS devices attempt to describe how temperature affects the output.

When choosing an accelerometer, gyroscope or IMU, it is also important to note the type of output; depending on the type of sensor, readings can be output as serial data, I2C, analog, TTL or a variety of others. The low cost ADXL3xx series output as analog voltage and can be directly connected to the Arduino’s pins with no need for additional electronics. The code shown below includes the output for a single axis sensor and factors in the rest value.

Source: Here

Miraikan, The National Science Museum, The real biped robot Exhibition

noreply@blogger.com (Unknown) — Fri, 11 Mar 2011 09:21:00 +0700

Here in Odaiba Miraikan.
The National Science Museum, tells us clearly the results of research
in a variety of attractions and the latest scientific knowledge, From
young children to the elderly, anyone who is a popular spot to enjoy.

Speaking of the permanent exhibition of this popular event, so
The real biped robot by Honda's Asimo,
The robotic stage.

Stage twice a day, the attraction of the short period of 10 minutes,
Despite an unstable two-legged and dancing and running and kicking
a ball, a miracle of skill to balance on one foot momentarily,
Would appeal to visitors through a demonstration of Asimo.

However, it requires advanced machine control technology "or running"
"dancing" and works well, And they were beaten in front of you
actually look like that because it is natural that the great work,
Because of the appearance of high technology obsolescence.
And to rely on a combination of operation for a limited repertoire of
rigidity. Further structural deficit Miraikan (2 years - for a Fee
income 300 million yen, 28 billion yen maintenance costs - cost).
The problem also now be reviewed in June, full content of the last
stage of this robot.

ASIMO day lit:
Left: the right to kick the ball Asimo: Asimo Dancing

The contents of the current stage of the robot in July, which will
happen next.

The National Museum of Emerging Science, I have been engaged in a
number of volunteer work exhibition,
Asimo this month on behalf of a whopping Sereburobotto the famous
lady Drossel. It is a volunteer O勤Me the stage.

Following that, is what stage the mistress Drossel.

Walking out on center stage and captivating hips smooth gait, lady
Drossel. Wrong and the names of the staff of Miraikan host, do not
forget service is gracious promise.

The image above, the staff tries to correct the wrong name is called
"You do not stay out of" I pronouncing this.

Keep the applause from the audience.

Drossel's daughter showed an interest in your child audience

Mistress, seeing visitors with images of dolphins and reflected in the
screen behind Creative thoughts and prettiness ("Good to love,
Well I eat") or to describe a Kudasaimasu very friendly touches.

In addition to time and at your pleasure to see a demonstration of
karate. Kuretari so capriciously change the contents of the stage.
Seen many times that it does not get tired. The lady herself, seems
to enjoy the stage.

Such fun on stage, who appeared suddenly forced entry? !

"Mogitatefuresshu The Cure (snip)"
The stage has been stormed, was that we Asimo restructuring last
month!

"Dorosserusan, Kyouha, Chikaradzukude, Shuyakunozawo,
Torikaeshinikimashita"
"Kudoukei, Limiter, Kaijo"
"Sentoupuroguramuwo, Rodoshimashita. Kakugowo, Shitekudasai"

ASIMO is a robot voice their 棒読Mi polite as ever, are saying that
tyranny easily. Drossel lady is surprised.

"Chikarakosoga, Seiginanoda!"
"Taa!"

Drossel the princess, who took three people in attacks suddenly Asimo.
Gyun! Actuator with a sound that will show you a terrible leap.
What talent that it has canceled the limiter which Asimo.

Lady, away!

"Galaxy of the Rising Dragon type!"
3 to ASIMO's body ~~Fist Space~~ Technology, intercepting karate
princess.
ASIMO We are still blown away the momentum jumps are put on the
ground beating. Died out evil.

"... You play it (attraction) was" "Chan Chan"
Good friend in that appeal.
Also the hair lady, "Belinda" and was changed to karate kicking the show
off with us Asimo. The next time, what would be a totally different stage,
Drossel prettiness of the young lady does not change.
Now, in Odaiba Miraikan everyone, go to see Drossel princess!

Disclaimer

- But to say, this story is a lie Do not be serious, almost all of it.
Asimo robot - is being staged stage still popular. (Start time because
there is only performed twice a Note) Miraikan - a large deficit, so true,
but the occasion of watching Gundam, please click here.
* Do not report

So, that was introduced at 9 Wanhobi figma Kano Masa, demand
The princess Drossel.

If you know this is out, yujin Drossel and a set of daughter
The book ... I did not ー
(And this is not for sale yet)

Drossel lady is good to love anyway, and good to play with,
The figure of fun.

Yamaguchi expression movable action figure, with many moving
There was a fun look tasteful pose determined Keren,
Drossel figma lady also, and decided 彼女Rashii pose,
And prettiness, and the discovery and reproduction and also
I think it's particularly strong figure of fun pose envisioned.

This property is determined to pose in a string of video
May owe much of the character of the princess.

The monotone color scheme, a completely expressionless.
Drossel daughter has yet to show significant portion of the design
portion of inorganic, This would be pretty up for?
Lie on the article, but Honda's two-legged "real princess moving
Drossel".

Combat unit, "Belinda" is
installed.
I do not know what kind of
special features that combat
units, This young lady was
wearing was mainly like capoeira
judo foot technique Extends as
the brilliant technique of karate.

Flight unit was decorated very stylish Beautiful "Obruchev."
Together with three times the heel tips diligently, you can fly to the
flight form transformation. (Also a gesture that is very cute)

Type galaxies of the Rising Dragon

If Gugure former material is not just a thought you'll find,
Pointed out that we often do not hit at all and even search. ※
We must explain this.

In the past, that flesh and blood and the mechanisms of love and justice
SF Violence full of Pharaoh Please note there are special effects comic
fighting. Its hero, a good girl most powerful cosmic cloud "Li Yan" is
the name of the mortal draw, That "type of the Rising Dragon Galaxy"
is. It seems really left fingers and stretch the right pin.
That was good knowledge to know.

It typos, "raising the galaxy dragon type "to search for
"Fist" space in relation to the number of hits

Lies in the article above appeared in a pose when the body's Asimo is
3 Fresh, mistress Drossel images have appeared on the screen.

This image as well, but so too is the image of the article lies
Neon lights and that is reflected in the body of an innocent young lady
is almost a composite. This image was so small and the screen will just
seem, is not just a good finish even more suitable, 've Been stuck into
a variety of materials suddenly realized.

This time, the body of these reflections, reflections on the floor of the
synthesis of the shadow refers to the floor, and Affected by ambient
and was there when the real work around the effects of impact, I have
taken more time.

Miraikan purchased this was the scene of the skit,
Asimo action figure.

Honda ASIMO's appearance as well, even a reproduction of moving
This is a pretty good figure.

Also joint stiffness, 硬Karazu, Yurukarazu.
Has moved considerably, there is no sign that the joints calyx.
It seems to do the mold design products fairly yelling.

The size of the figure,
Than as a mistress around Kii Hiroshi Drossel.

In the composite image above, there are depicted as if the light is
around the chest and waist, The processing by the image is not
illuminated in Ashimofigyua.

Hand, comes with two types of hand grip and Hirate.
Possession of a gun but unfortunately no, it can be managed to have
flat hand. Inherent in, I'd just had a picture of a robot figures have
a gun, That it is a real robot, it will be mighty ugly face painting ...

When the lower body, such as ASIMO robot anime, but has become
quite innovative joint system, It is truly industrial design, has a fairly
wide range of movement than it looks like this. I'm so bent ankle.

More arms, including the shape of the shoulder is the same joint design
and much Gundam.

Mono-cropping

Actually this next Wanhobi 10 Photo of you who entered it.
At times, "Wanhobi live until morning," but I was in the winners are
announced live at Naka Naka is heating up in the fun with this, a little
Narimashi I want to join.

I made the announcement two days ago about the Wonder Festival Prize,
The goal is to enter into it anyway.

Let's make an attempt this time is a combination of background material.
Also, instead of to the body by synthesizing reflection, even an attempt
to try to shoot them reflected the actual figure Koma.

Reflection as a way to top, but I also get to shoot with the young lady
went Drossel Kawasaki industrial zone,
Serious effort on the "I no longer need to synthesize it?" So likely to
be called a little Itadakemasen.

So that is the image, the image will be displayed in the LCD TV of this
background, reflected on the top was placed before the figures,
Is what you take. (Then composited into the background material
to it again) When shooting, such as using a mirror to the left and right
as well as Komu after reflection from the image, I tried out a
three-dimensional image of reflection Komu.

The result is not too sluggish.

There is not a reflection of how not to become a painting, you can
control it again, I guess only take pains over the paste crowded
I thought.

Behind the church ceiling and Motomachi floor and telecom centers,
smoke is a combination of different materials.

At times, a Valkyrie, and Ranka synthesis, combining two images taken
with different light source directions, Were combined to make light
of such images from two directions simultaneously,
This combined light of three separate images from three directions,
I made a picture of one daughter Drossel. Immediately after completing
the left light pink, with light blue colored, synthetic right.
Result, under the influence of light pink and light blue, somewhat like
a pearl coating.

More like this, but I think a synthesized feel chaotic blend of three
colors of light,
Such a gorgeous image became unintentionally.

Like this, pearl paint coated Repaint Ver. And
Original CG animated images such as coating Howaitometarikku Ver.
Also things like a lady, I'm glad for you when released. Lady embarrass
even the body is nothing.

Arduino Servo Control

noreply@blogger.com (Unknown) — Thu, 24 Feb 2011 14:25:00 +0700

In this Project, we want to control servo motor potitions from analog sensor ( potentiometer or flex sensor ).

The Hardware

As shown at picture, connect analog input to Arduino analog pin 0. don't forget about 10K resistor. Connect an Servo motor ( yellow wire ) to Arduino Digital pin 2 and then connect the red and black wires go to +5V and ground, respectively. Refer to the picture and scheme to do this.

The Program

Here we will use 2 method to control an servo motor.

1. Pulse Method

This method is more complex and exposes the math and timing required to control a servo with a microcontroller.

/*
  Servo control from an analog input

 The minimum (minPulse) and maxiumum (maxPulse) values
 will be different depending on your specific servo motor.
 Ideally, it should be between 1 and 2 milliseconds, but in practice,
 0.5 - 2.5 milliseconds works well for me.
 Try different values to see what numbers are best for you.

 This program uses the millis() function to keep track of when the servo was
 last pulsed.  millis() produces an overflow error (i.e. generates a number
 that's too big to fit in a long variable) after about 5 days. if you're
 making a program that has to run for more than 5 days, you may need to
 account for this.

 by Tom Igoe
 additions by Carlyn Maw & Rob Faludi
 Created 28 Jan. 2006
 Updated 10 Jun. 2008
 */

 int servoPin = 2;     // Control pin for servo motor
 int minPulse = 500;   // Minimum servo position
 int maxPulse = 2500;  // Maximum servo position
 int pulse = 0;        // Amount to pulse the servo

 long lastPulse = 0;    // the time in milliseconds of the last pulse
 int refreshTime = 20; // the time needed in between pulses

 int analogValue = 0;  // the value returned from the analog sensor
 int analogPin = 0;    // the analog pin that the sensor's on

 void setup() {
  pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
  pulse = minPulse;           // Set the motor position value to the minimum
  Serial.begin(9600);
 }

 void loop() {
  analogValue = analogRead(analogPin);      // read the analog input
  pulse = map(analogValue,0,1023,minPulse,maxPulse);// convert the analog value
                                                    // to a range between minPulse
                                                    // and maxPulse.
  // pulse the servo again if rhe refresh time (20 ms) have passed:
  if (millis() - lastPulse >= refreshTime) {
    digitalWrite(servoPin, HIGH);   // Turn the motor on
    delayMicroseconds(pulse);       // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse
  }
 }

This code was written with a potentiometer in mind, so it assumes you're going to get values from 0 to 1023 from the sensor. If you don't, the servo won't move through its whole range. Determine the range of numbers the sensor is giving you and adjust the servo formula to fit. To fix this, use the map() function. You know the input range is the range of the sensor, 0 to 1023. And you know the output range is from minPulse to maxPulse. So do this:
 pulseWidth = map(analogValue, 0, 1023, minPulse, maxPulse);

   2.  Using the Arduino Servo Library

The second example shows you how to control a servo motor using the Arduino Servo library. This library is very easy to use and is much easier to follow. However, it obscures all the calculations and handles the dirty work for you. This is useful once you've attempted the pulse method and understand it completely.

/*
 Servo control from an analog input using the Arduino Servo library
 This example code uses the Arduino Servo library which comes packaged with the Ar duino software.
 In order to make this work, you must include the Servo.h library file, create an  instance of the Servo object. 
 attach a pin to the Servo object, and then write an analog value to the Servo obj ect to set its position.
 The difference between using the Servo library and the older method of pulsing a  digital pin is that the library
 handles a lot of the work for you. You no longer need to figure out the translati on between pulse length and position. 
 You now can simply specify the angle you'd like your servo to be at and it will t urn to that position.

 Updated 08 Sep 2009
 by Rory Nugent
 Created 20 Jan 2009
 by Tom Igoe
 */

 #include <Servo.h>      // include the servo library
 Servo servoMotor;       // creates an instance of the servo object to control a servo
 int analogPin = 0;      // the analog pin that the sensor is on
 int analogValue = 0;    // the value returned from the analog sensor
 int servoPin = 2;       // Control pin for servo motor. As of Arduino 0017, can be any pin
 void setup() { 
   servoMotor.attach(servoPin);  // attaches the servo on pin 2 to the servo object
 } 
 void loop() 
 { 
   analogValue = analogRead(analogPin);             // read the analog input (value between 0 and 1023)
   analogValue = map(analogValue, 0, 1023, 0, 179); // map the analog value (0 - 1023) to the angle of the servo (0 - 179)
   servoMotor.write(analogValue);                   // write the new mapped analog value to set the position of the servo
   delay(15);                                       // waits for the servo to get there 
 }

Source: http://itp.nyu.edu/physcomp/Labs/Servo

Write from Arduino to LCD

noreply@blogger.com (Unknown) — Thu, 24 Feb 2011 10:39:00 +0700

Scheme Description:

Connect the LCD RS pin to the Arduino pin 12
Connect the LCD enable pin to the Arduino pin 11
Connect the LCD D4 to D7 pins into pin 5 to 2 Arduino
Connect the LCD +5 and ground to pin +5 V and ground Arduino
Connect the pin to a potentiometer LCD Vo. Use of this potentiometer is to adjust the LCD contrast

In this Project, we will write " Hello World " from arduino to LCD

Program Arduino:

// LCD Demo Program 
// Use LCD library
#include "LiquidCrystal.h";
// LCD initialization & use pin
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
  // Set the numbers of LCD columns and rows
  lcd.begin(16, 2);
  // Make the writing on the LCD
  lcd.print("hello, world!");
}
void loop() {
  // Set cursor to Column 0 & Row 1
  // Note: Column & Row starting with 0
  lcd.setCursor(0, 1);
  // Print the number of seconds since last reset
  lcd.print(millis()/1000);
}

Temperature Sensor Using Arduino and LM35

noreply@blogger.com (Unknown) — Thu, 24 Feb 2011 09:38:00 +0700

LM35 is a temperature sensor from National Semiconductor that have a high accuracy. The output of analog voltage and has a measurement range of -55 º C to +150 º C with an accuracy of ± 0.5 º C. Output voltage is 10mV / º C. Output ports can be directly connected to Arduino, because Arduino has 6 ADC ports (analog input).

Analog inputs on the Arduino has a 10-bit resolution, which can provide output 2 ^ 10 = 1024 discrete values. When used 5V supply, the resulting resolution is 5000mV/1024 = 4.8mV. Because the LM35 has a resolution output of 10mV / º C, then the resolution of the thermometer are made with Arduino is 10mV/4.8mV ~ 0.5 º C.

So, let make a simple temperature sensor with Arduino and LM35. After we connect the LM35 with the Arduino as in the picture above, we can start write the program.

// variable declare
float tempC;
int tempPin = 0;
void setup()
{
    Serial.begin(9600); // Open serial port, set baud rate 9600 bps
}
void loop()
{
    tempC = analogRead(tempPin);           // Read data from sensor
    tempC = (5.0 * tempC * 100.0)/1024.0;  // convert from analog to temperature
    Serial.println((int)tempC,DEC);        // send data via serial
    delay(1000);                           // delay
}

This program will read temperature data from LM35 and conversion the analog data to digital and write it to PC in celcius through Serial port.

Interfacing Arduino and PC using VB 6

noreply@blogger.com (Unknown) — Wed, 23 Feb 2011 11:25:00 +0700

One of the conveniences that exist on the Arduino is a serial communication function that has been bundled in the Arduino software. With the serial function, then the Arduino can communicate two ways with PC using a program created with Visual Basic 6.

In this project, we will combining the Digital Data and Analog Data. How to receive and transmit Digital and Analog Data from Arduino to PC and vice versa.

Arduino Conditions:

Digital Input Signal from Push Button
Analog Digital Input Signal from LDR
Digital Output Signal at LED (on-off)
Analog Outpuy Signal at LED (brightness).

PC Conditions with VB 6:

Digital Input Data showing by Command Button Object

Analog Input Data showing by Slider Object

Digital Output Data showing by Shape Object

Analog Output Data showing by Picture Box Object

Procedures:

Connect Arduino to the computer through a USB port.

Check the COM channel used (open Device Manager to find out).

Arrange a series of Input Output Arduino using buttons, LDR and 2 pieces LEDs, where the key to connect with feet D2, A0 LDR connect with your legs, and first and second LEDs in succession to connect with feet D9 and D10.

Perform programming on the Arduino, then Compile and upload the program.

Perform Visual Basic, run the program and complete.

Arduino Source Code:

int kakitombol=2;

int kakiled=9;

int pinled=10;

void setup() {

Serial.begin(9600);

pinMode(kakitombol,INPUT);

pinMode(kakiled,OUTPUT);

pinMode(pinled,OUTPUT);

}

void loop() {

if(Serial.available())

{

int terimadata=Serial.read();

if (terimadata=='a')

{digitalWrite(kakiled,HIGH);}

else if (terimadata=='b')

{digitalWrite(kakiled,LOW);}

else

{analogWrite(pinled,terimadata);}

}

int statustombol=digitalRead(kakitombol);

if(statustombol==HIGH)

{Serial.print('a');}

else

{Serial.print('b');}

int analogValue = analogRead(0);

int datamsb=highByte(analogValue);

int datalsb=lowByte(analogValue);

Serial.print(datamsb,BYTE);

Serial.print(datalsb,BYTE);

delay(100);

}

Visual Basic 6 Source Code:

Private Sub drawscale(var As Long)

Picture1.Cls

Picture1.Line (0, 0)-(var, Picture1.ScaleHeight), vb3shadow, BF

End Sub

Private Sub Command1_Click()

Dim statusled As String

If Option1 = True Then

statusled = "b"

Else

statusled = "a"

End If

MSComm1.Output = statusled

End Sub

Private Sub Form_Load()

Slider1.Max = 255

Slider1.Min = 0

Slider1.TickFrequency = 10

Slider1.LargeChange = 10

MSComm1.RThreshold = 3

MSComm1.InputLen = 3

MSComm1.Settings = "9600,n,8,1"

MSComm1.CommPort = 6

MSComm1.PortOpen = True

MSComm1.DTREnable = False

Picture1.ScaleWidth = 1000

Picture1.AutoRedraw = True

End Sub

Private Sub Form_Unload(Cancel As Integer)

MSComm1.PortOpen = False

End Sub

Private Sub Slider1_Change()

MSComm1.Output = Chr$(Slider1.Value)

Label3.Caption = Slider1.Value

End Sub

Private Sub MSComm1_OnComm()

Dim sData As String

Dim highbyte As Long

Dim lowbyte As Long

Dim word As Long

Dim tombol As String

If MSComm1.CommEvent = comEvReceive Then

sData = MSComm1.Input

tombol = Mid$(sData, 1, 1)

highbyte = Asc(Mid$(sData, 2, 1))

lowbyte = Asc(Mid$(sData, 3, 1))

word = (highbyte * &H100) Or lowbyte

Label1.Caption = CStr(word)

drawscale word

Label2.Caption = tombol

If tombol = "a" Then

Shape1.FillColor = vbYellow

Else

Shape1.FillColor = vbRed

End If

End Sub

Using Objects Informations:

1 Form
1 Mscomm (diperoleh dari Project / Components / Controls / Microsoft Comm Control 6.0)
1 Shape
3 Label
1 Picture Box
1 Slider (diperoleh dari Project / Components / Controls / Microsoft Windows Common Controls 6.0)
2 Option Button
1 Command Button

Source: http://arduinodanvb.blogspot.com/2010/10/interface-3-menggabungkan-digital-dan.html

Arduino Uno

noreply@blogger.com (Unknown) — Wed, 23 Feb 2011 10:24:00 +0700

The Arduino Uno is a microcontroller board based on the ATmega328 replaced old version Arduino called Arduino Duemilanove. Arduino Uno will initially be named Arduino Uno Punto Zero (Italian) which means Arduino 1.0. However, that name is to long, so to be short and easily remembered by the world, finally selected the name Arduino Uno, orArduino version 1.0

Arduino Uno has significant changes compared with the change of board Diecimila to Duemilanove (2009).

Changes are on the Arduino Uno can be summarized as follows:

Not using FT232RL FTDI chip USB converter, but uses a specially programmed ATMega8U2 so that the upload process and faster serial communication.
Using LUFA project as a framework for AVR USB is relatively small and fast.
Bootloader size is smaller, only a quarter of the old bootloader for using Optiboot. The result will leave more space to store the program.
Arduino board can be recognized as a keyboard, mouse, joystick, etc.. with how to program the chip Atmega8U2,
Already have own logo (trade mark).
The size of the Arduino Uno remain compatible with arduino shields before it. Formation spacing header pins is same so that the shields we have can still be used.

Arduino Uno Specifications:

Microcontroller	ATmega328
Operating Voltage	5V
Input Voltage (recommended)	7-12V
Input Voltage (limits)	6-20V
Digital I/O Pins	14 (of which 6 provide PWM output)
Analog Input Pins	6
DC Current per I/O Pin	40 mA
DC Current for 3.3V Pin	50 mA
Flash Memory	32 KB (ATmega328) of which 0.5 KB used by bootloader
SRAM	2 KB (ATmega328)
EEPROM	1 KB (ATmega328)
Clock Speed	16 MHz

If you need to know about Arduino Uno Schematics and Reference design, You can download it at below link.
EAGLE files: Arduino Uno Reference Design.Zip
Schematic: Arduino Uno Schematic.pdf

Arduino Power
The Arduino Uno can be powered via the USB connection or with an external power supply. Other power source is come from AC to DC Adaptor and Battery. The power source is selected automatically.
The board can operate on external supply from 6 to 20 volts. If power less than 7V, however, the 5V pin may supply less than five volts and the board may be unstable. If using more than 12V, the voltage regulator may overheat and damage the board. So, the recommended range is 7 to 12 volts.

Input and Output
Each of the 14 digital pins on the Uno can be used as an input or output, using pinMode(), digitalWrite(), and digitalRead() functions. They operate at 5 volts. Each pin can provide or receive a maximum of 40 mA and has an internal pull-up resistor (disconnected by default) of 20-50 kOhms.
Some pins also have specialized functions:

Serial: 0 (RX) and 1 (TX). Used to receive (RX) and transmit (TX) TTL serial data. These pins are connected to the corresponding pins of the ATmega8U2 USB-to-TTL Serial chip.
External Interrupts: 2 and 3. These pins can be configured to trigger an interrupt on a low value, a rising or falling edge, or a change in value.
PWM: 3, 5, 6, 9, 10, and 11. Provide 8-bit PWM output with the analogWrite() function.
SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). These pins support SPI communication using the SPI library.
LED: 13. There is a built-in LED connected to digital pin 13. When the pin is HIGH value, the LED is on, when the pin is LOW, it's off.

Arduino Uno has 6 analog inputs, labeled A0 through A5, each of which provide 10 bits of resolution (i.e. 1024 different values). By default they measure from ground to 5 volts, though is it possible to change the upper end of their range using the AREF pin and the analogReference() function. Other some pins have specialized functionality:

I2C: A4 (SDA) and A5 (SCL): Support I2C (TWI) communication using the Wire library.
AREF: Reference voltage (0 to 5V only) for the analog inputs. Used with analogReference().
Reset: Bring this line LOW to reset the microcontroller. Typically used to add a reset button to shields which block the one on the board.

The ATmega328 also supports I2C (TWI) and SPI communication. The Arduino software includes a Wire library to simplify use of the I2C bus.

Programming

The Arduino Uno can be programmed with the Arduino software. Select "Arduino Uno from the Tools > Board menu (according to the microcontroller on your board).

The ATmega328 on the Arduino Uno comes preburned with a bootloader that allows you to upload new code to it without the use of an external hardware programmer. It communicates using the original STK500 protocol (reference, C header files).

You can also bypass the bootloader and program the microcontroller through the ICSP (In-Circuit Serial Programming) header.

The ATmega8U2 firmware source code is available . The ATmega8U2 is loaded with a DFU bootloader, which can be activated by connecting the solder jumper on the back of the board (near the map of Italy) and then resetting the 8U2. You can then use Atmel's FLIP software (Windows) or the DFU programmer (Mac OS X and Linux) to load a new firmware. Or you can use the ISP header with an external programmer (overwriting the DFU bootloader).

Arduino programming language is the C Language. But this language has been simplified using simple functions so that even beginners can learn it easily enough.

To make Arduino and upload the program into the Arduino board, you need the Arduino software IDE (Integrated Development Environment) that can be downloaded free at here.

Arduino programming language manual along with examples can be read at here.

For more information, please refer to Arduino Uno Hompage

"Ornithopter," The Nano-Hummingbird

noreply@blogger.com (Unknown) — Mon, 21 Feb 2011 14:46:00 +0700

"ornithopter," the Nano-Hummingbird, developed by the company AeroVironment Inc., the miniature spybot looks like a hummingbird complete with flapping wings, and is only slightly larger and heavier than most hummingbirds, but smaller than the largest species.

The ornithopter can fly into buildings under the control of an operator flying the spybot with the help of a feed from its tiny video camera. The prototype is capable of flying at speeds of up to 18 km/h (11 mph) and weighs 19 grams, which is about the same as an AA battery.

Manager of the project, Matt Keennon, said it had been a challenge to design and build the spybot because it “pushes the limitations of aerodynamics.” The specifications given to the firm by the Pentagon included being able to hover in an 8 km/h wind gust and being able to fly in and out of buildings via a normal door.

The spybot was developed for the US military's research arm, the Defense Advanced Research Projects Agency (DARPA). The hummingbird appearance is intended to disguise the bot, although it would look decidedly out of place and would attract attention in most places in the world since hummingbirds are not found outside of the Americas.

DARPA's head of the Nano Air Vehicles (NAV) program. Dr Todd Hylton, said the successful flight tests pave the way for new vehicles that resemble small birds and match their agility. The new drone is a departure from existing NAVs, which in the past have always resembled helicopters or planes.

Super Robust Anthropomorphic Robot Hand

noreply@blogger.com (Unknown) — Mon, 21 Feb 2011 12:04:00 +0700

German researchers may have an anthropomorphic robot handthat a collision with hard objects, and even the strike, without breaking into pieces survive Hammer built.

In designing the new site, a researcher at the Institute of Roboticsand Mechatronics, German Aerospace Center, part of the (DLR),focused on resilience. You may only have built a robot hand of themost difficult yet.

DLR hand has articulated a shape and size of the human hand withfive fingers through a network of 38 tendons each with a singleengine supports the forearm.

The main features of the DLR from the hand of the other robot cancontrol it its rigidity. The engine can strain the tendon, which thehand can to absorb the shock of the violence. In one study, theresearcher's hand collided with a baseball bat the effects of the66th G Good hands.

The video below shows the movement of the fingers and wasbeaten with a hammer and metal bars:

DLR team did not want to build a copy of the correct anatomy of the human hand, like other teams. They want to hand, which can lead asa human hand in terms of both skill and strength.The hand has 19 degrees of freedom, or just one less than the real thing, and your fingers can move independently of each other toidentify different objects. The radius can be up to 30 Newton force of the fingertip, which makes this hand is also one of the most powerfulever built.

Another key element in the design of the DLR is a spring mechanism that is attached to each tendon. This [photo left] springsto yield the tendon, which is made from super strong synthetic fibercalled Dyneema, greater flexibility, allowing fingers to absorb andrelease energy, just as our own hands. This capability is key to achieving sustainability and to mimic the properties of thekinematics, dynamics and force the hand of man.

During normal operation, the finger joints can rotate 500 degrees per second. With the spring tension, then release their energy to produce more torque, speed can reach 2000 degrees per joint second. This means that the robot hand can do something few, if any, are: finger pressure.
Why build a super strong hand?
Mark Grebenstein, lead designer's hand, said that the robot is built by hand the rigid, although they look Terminator-drive, relatively fragile. Even a small collision with the police a few tens of Newton,can move the joints and fingers to tear apart.
"If every time the robot knocked on his hands, arms broken, we will have a big problem distribution service robots in the real world,"said Grebenstein.
To change its stiffness, DLR hand drive using known antagonists.The joints of each [photo below] finger is driven by two tendons,each attached to the motor. When the motors rotate in the same direction, movement joints, as they rotate in the opposite direction,which tightened together.

Before developing a new hand, Grebenstein has designed another advanced robot, Justin humanoid. He said that in the experiment throwing heavy balls and Justin have to try to catch them. "The impact would be a distortion of the joints beyond their borders and kill your fingers," he said. New hand can catch a ball thrown several yards. Mechanisms for implementation and spring can absorb the kinetic energy without structural damage. But hands can not always be stiff. For tasks that require precise handling, better to have a hand with low stiffness. By adjusting the machine tendon, could DLR hand. To operate by hand, researchers used a special sensor gloves or simply send take command. The control system is based on joint angle control. He does not need to control impedance, Grebenstein said, because the hand is compliance in mechanics. To detect if an object is soft and should be treated more gently, the steps to force the hand with a track extension of the spring mechanism. "In terms of grip and agility, we are very close to the human hand, he said, adding that the new hand is" miles ahead "of Justin's hand. About 13 people work on the one hand, and Grebenstein emphasize that it is difficult to estimate the project cost. But he said the cost of the hand between 70,000 and € 100,000. Researchers are trying to build a trunk full of two arms called the DLR Hand Arm System. Their plan is to explore innovative strategies to capture and manipulation, including manipulation with both hands. Grebenstein hope that their new approach to design by hand will help you progress in the field of service robots. He said the robotic equipment is now limiting new development because it is expensive and the researchers were not able to perform experiments that could damage them. "The problem is, he says," you can not learn without experience. "

Japanese researcher unveils 'hummingbird robot'

noreply@blogger.com (Unknown) — Mon, 21 Feb 2011 09:47:00 +0700

Japanese researchers have developed a robotic bird that can movefreely in the air with rapid wing movement. Robot bird has a sizesimilar to a real bird Hummingbird, equipped with micro motors and four wings that can flaps 30 times per second, said HiroshiLiu, a researcher at the University of Chiba east of Tokyo.

Professor Hiroshi Ryu of Japan's Chiba University displays his flying robot, which flaps its wings 30 times per second like a hummingbird, at his laboratory in Chiba city, suburban Tokyo, December 28.

This unique robot has a weight of 2.6 gram, can fly 8 times morestable than a helicopter with propeller. This bird robot is controlled by infrared sensors and can move up, down, right or left.

Hiroshi Liu plans to make it float to rest at one point in the air, andequip it with a micro camera in March 2011.

This robot development cost 200 million yen ($ 2.1 million), can be used to help rescue people trapped in damaged buildings, looking for criminals or even operate as a vehicle probe on Mars.

22mm BX4 Series Brushless DC Servomotor

noreply@blogger.com (Unknown) — Mon, 21 Feb 2011 09:18:00 +0700

The world's smallest brushless DC servomotor, the FAULHABER series 2232/2250 BX4 CSD/CCD from MICROMO, combines the advantages of the BX4 four-pole brushless technology with a single-axis motion controller.

MICROMO introduces an addition to its FAULHABER BX4 range of four-pole brushless DC servomotors with the introduction of the series 2232/2250 BX4 CSD/CCD, the world’s most compact drive with an integrated motion controller. This new series combines all the advantages of the BX4 four-pole brushless technology with a single-axis motion controller. High reliability, high torque, compact slotless design with no cogging torque, and robust construction without the use of adhesives make this new series ideal for complex application areas such as robotics, automation, medical and laboratory technology, specialty machinery, and aerospace/defense.

The drives are based on the flexible and easy-to-use FAULHABER motion control platform. The compact motion controller, which fits within the diameter of the motor, combined with the motor and a full range of gearhead combinations, provides a versatile modular platform for a variety of applications. The drives are available with an RS-232 serial or CAN interface. Configuring the drives is simple using the free FAULHABER Motion Manager 4.4 software.

The drives have a wide operational temperature range from -25°C to 85°C and provide a continuous current up to 0.69 A with a peak of up to 3A. The speed can be precisely controlled from down to 5 rpm and up to 8,000 rpm. Custom firmware and software are available on request. All of the drives have factory-preset current limits to protect the motor and electronics during normal operation. Upon request, the drives can be supplied with separate motor and electronics voltage supply connections.

MICROMO, based in Clearwater, Florida, represents FAULHABER products in the Americas. Contact the MICROMO team today at 1-800-807-9166 for more information and the opportunity to order samples. www.micromo.com

Technical Data Series 2232	BX4 S	BX4
Speed Upto	14100	10400	rpm
Efficiency	61, 7	67, 6	%
Stall Torque	29, 4	59, 9	mNm
Torque Upto	6	12	mNm
Current Upto	0, 85	0, 90	A
Slope of n-M curve	493	120	rpm/mNm

Source:
http://www.micromo.com/bx4-series-2232-brushless-dc-servomotors.aspx
http://www.roboticstrends.com/design_development/article/challenge_complexity_reliability_high_torque_solution_22mm_bx4_series_brush

3D Printer, Let's built it!

noreply@blogger.com (Unknown) — Wed, 23 Jun 2010 12:28:00 +0700

What is 3D Printing?

A 3D printer produces a solid object rather than printing onto a 2D sheet like a conventional printer. A 3D printer produces the object from plastic by taking a plastic filament, melting it and squirting it out - similar to a hot glue gun. The head is driven in the x and y directions to form a layer and at the end of each layer the print bed lowers to allow the next one to be laid down on top.

In order to produce your object you simply draw a 3D model using almost any CAD package and then save it as an stereo lithography file (STL file). This file is then converted to g-code to produce layers which will be printed.

There, so many people built 3D printer, and i found a good one 3D printer opensource Project called Rapman made by Bits From Bytes Ltd, UK.

BFB 3000 a fully assembled 3D printer for less than £2000

Award Winning RapMan
The RapMan has recently won the BETT Award for Best Digital Device at the 2010 BETT show - the world's largest Technology Education event. The judges commented "The RapMan allows for the teaching of many different design principles from initial concept to pre-production prototype, and is a fascinating example of design in its own right.”
Thinking to make one like this?
Now, it's possible for you to built a 3D Printer to produces the object from plastic by taking a plastic filament, melting it and squirting it out - similar to a hot glue gun.

The newest Version is 3.1, Download full Build manual here

Source: This Article take from Rapman Website
http://www.bitsfrombytes.com/index.php?option=com_content&view=frontpage&Itemid=1

RoboBee - Robotic Insect could Pollinate Flowers

noreply@blogger.com (Unknown) — Thu, 7 Jan 2010 09:45:00 +0700

This RoboBees are collaborating investigators at Harvard University School of Engineering and Applied Sciences, the Wyss Institute for Biologically Inspired Engineering and CentEy.

This project integrates approaches at the body, brain and colony level. Inspired by the biology of a bee and the insectÕs hive behavior, we aim to push advances in miniature robotics and the design of compact high-energy power sources; spur innovations in ultra-low-power computing and electronic " smart " sensors; and refine coordination algorithms to manage multiple, independent machines.

Anatomy of the Robobee

- Brain: Simple circuits handle basic functions, including balance and hovering. A microprocessor runs the bee’s high-level functions, such as processing data from sensors.

- Eyes: Ultraviolet sensors scan for natural UV patterns on flowers. Digital cameras track objects below the bee to determine how fast and far it’s flying. Light sensors follow the sun to tell if the bee is flying north or south.

- Wings: An actuator flaps two lightweight carbon-fiber wings.

- Antennae: The antennae beam data between bees and could act like whiskers to prevent the ’bot from bumping into things.

- Feet: In the hive, three pronged feet lock the bee into a docking station to recharge its micro fuel cell and upload sensor data to a computer. The feet could also help grab pollen from flowers. Graham Murdoch

How RoboBees Pollinate an Orchard

STEP 1: Establish Home Base
A farmer sets up a mobile RoboBee “hive.” In the future, an autonomous robot could haul the hive from field to field.
STEP 2: Survey the Landscape
Scout RoboBees leave the hive first and use their ultraviolet sensors to locate the same UV patterns on flower petals that real bees look for. Cameras on the bee’s head record landmarks underneath the bee to give it a sense of where and how far it has traveled.
STEP 3: Make a Map
The scouts return to the hive to recharge and upload flower locations to a central computer, which maps the entire orchard as more scouts report in.
STEP 4: Get Pollinating
Worker bees, outfitted with fewer sensors and bigger batteries for longer trips, head directly for the flowers, picking up pollen from one and delivering it to others.

How to replace ALINCO DJ-195T VHF FM Transceiver

noreply@blogger.com (Unknown) — Thu, 23 Jul 2009 09:39:00 +0700

How to replace Alinco DJ-195T VHF FM Transceiver battery - More DIY How To Projects

Controlling 3 Stepper Motors with the 12 way Interface

noreply@blogger.com (Unknown) — Mon, 20 Jul 2009 15:50:00 +0700

source: http://www.southwest.com.au/~jfuller/

This interface is designed for use with a three axis robot arm based on stepper motors out of 5 1/4" drives. The circuit uses two ULN2803 'drivers' controlled by logic ICs to allow mutliple lines to be controlled at the same time. (Logic circuit design by Ian Threlfo). How it Works: Click here for an explanation of the circuit logic.

This is also the first interface bearing the Educational Computing Association of Western Australia (ECAWA) logo, indicating it has been developed by the ECAWA Robotics Special Interest Group.

Logic Design

PCB

Component Overlay

Parts List

2 x 4081 AND gate
2 x 4030 NOR gate
2 x ULN2803 Driver
1 x 74LS244 buffer
12 x 560 ohm resistor
12 x 100Kohm resistor
1 x 10Kohm resistor
1 x 47 uF electrolytic capacitor
1 x 2.1mm power socket
1 x DB25 PCB mount, right angle socket
1 x serial cable (male to male)
1 x 1 amp bridge rectifier
1 x 7805 voltage regulator
1 x 7812 voltage regulator
12 x 3mm red LEDs
2 x 0.01 uF greencap capacitors
1 x PCB

Low Speed AVR Oscilloscope

noreply@blogger.com (Unknown) — Wed, 15 Jul 2009 21:52:00 +0700

This project by Vassilis Serasidis. You can fing his original page at http://www.serasidis.gr/circuits/AVR_oscilloscope/avr_oscilloscope.htm

Features

Frequency measurement

Voltage input

Power supply

Liquid Display Crystal

Measurement display area

Auto trigger

up to 5 kHz (square wave)

24V AC / 30V DC

12V DC

128x64 pixels

100x64 pixels

The maximum signal speed who can show up this oscilloscope is 5 kHz in square signal. For other signals (sine or triangle) the frequency is lower ( almost 1 kHz) for having clear view of the signal.

Below is the schematic.

Description

The operating voltage of the circuit is 12V DC. By this voltage, the power supply is producing 2 voltages. +8.2V for IC1 and +5V for IC2 and IC3. This circuit can measure from +2.5V to -2.5V or from 0 to +5V dependent by S1 position (AC or DC input). By using probe with 1:10 division you can measure almost 10 times higher voltages. Moreover, with S2 you can make an extra division by 2 the input voltage.

Programming The ATmega32

Burn the ATmega32 with AVR_oscilloscope.hex and select external crystal at the fuses section.

After that, you Must disable the JTAG interface from your ATmega32 microController. If you don't do that, the mega32 will show you the initial screen and when it go to the oscilloscope screen it will restart immediately to the initial screen and it will stay there for ever.

Calibrations

The only 2 things you have to calibrate is the LCD contrast trimmer P2 and the P1, to move the beam at the center of the LCD. To do that, apply only the power supply to the circuit and adjust the P2 up to the point you will see clear the appeared pixels on the screen. Then, adjust the P1 up to the point the beam is moved at the middle of the LCD (at the horizontal line of the cross).

Usage

You can move the beam up or down the screen by pressing the buttons S8 or S4 correspondingly to measure the voltage of the signal. 1 volt is taking up 1 square height. With S7 and S3 you can increase or decrease the measurement speed. This oscilloscope has an automatic trigger. That means, if you have a continuous signal (ex a triagle waveform) the auto trigger will work perfect. If your signal is not stable (ex a serial transmittion) you can freeze the screen by pressing S6 switch. At his case you can get a snapshoot of your measurment signal. By the time you release the S6, the snapshoot will end.

PCB (101x160mm) and components placing

V1.01 Download the source code and the hex file of AVR oscilloscope.

V1.00 Download the source code, hex, schematic and PCB of AVR oscilloscope.

Software to make your own 128x64 pixel logos for graphical LCDs .

So, what do you think guy's? isn't this is great projects? thanks to Mr Vassilis Serasidis for this great projects.

If you have any doubt, please go to http://www.serasidis.gr/circuits/AVR_oscilloscope/avr_oscilloscope.htm

ATmega 32 & DS1307 Digital Clock

noreply@blogger.com (Unknown) — Tue, 14 Jul 2009 13:52:00 +0700

This projects called Digital Clock used ATmega 32 and RTC DS 1307.

FEATURES OF DS1307
1. Real time clock counts seconds,minutes,hours, date of month,moth, day of week and year with leap year compensation valid up to 2100.
2. 56 byte nonvolatile RAM for general data storage
3. 2-wrire interface (I2C)
4. Automatic power fail detect
5. Comsumes less than 500 nA for battery back-up at 25′C
With this features, DS 1307 is great rtc can we use to build a perfect digital clock.

Here is the schematic for DS1307 Connection to ATmega 32:

The clock display used LCD, C Port for LCD, B.0 Port for SCL and B.1 Port for SDA Port 0.

Below is the sourcecode to read RTC DS1307 used CodeVision AVR Evaluation 2.03.9

Source 1 :

**************************************************************

#include

// I2C Bus functions
#asm
.equ __i2c_port=0×18 ;PORTB
.equ __sda_bit=0
.equ __scl_bit=1
#endasm
#include

// Alphanumeric LCD Module functions
#asm
.equ __lcd_port=0×15 ;PORTC
#endasm
#include

// Standard Input/Output functions
#include
#include
#define ADDA_ADDR 0×90
#define EEPROM_ADDR 0xA0
#define RTC_ADDR 0xD0
unsigned char data_rtc[8];
unsigned char kata1[16];
unsigned char kata2[16];
unsigned char kata3[16];
unsigned char kata4[16];
unsigned char kata5[16];
unsigned char kata6[16];

// Declare your global variables here

unsigned char bcd2dec(unsigned char input){
unsigned char tmp_data, tmp1;

tmp_data = input;
tmp1 = tmp_data % 16;
if (tmp_data > 15) tmp_data = tmp_data / 16;
else tmp_data = 0;
tmp_data = (tmp_data * 10)+tmp1;
return tmp_data;
}

void read_rtc(void){
unsigned char i, tmp_data;

i2c_start();
i2c_write(RTC_ADDR);
i2c_write(0);
i2c_stop();
i2c_start();
i2c_write(RTC_ADDR | 1);
for (i=0; i<6; tmp_data =" bcd2dec(i2c_read(1));" tmp_data =" bcd2dec(i2c_read(0));">

unsigned char dec2bcd(unsigned char input){
unsigned char tmp_data;

if (input > 9) tmp_data = ((input / 10)*16) + (input % 10);
else
tmp_data = input;
return tmp_data;
}

void write_rtc(unsigned char alamat, unsigned char data){
i2c_start();
i2c_write(RTC_ADDR);
i2c_write(alamat);
if (alamat <>

unsigned char read_nvram(unsigned char alamat){
unsigned char tmp_data;

i2c_start();
i2c_write(RTC_ADDR);
i2c_write(alamat);
i2c_stop();
i2c_start();
i2c_write(RTC_ADDR | 1);
tmp_data = i2c_read(0);
i2c_stop();
return tmp_data;
}

unsigned char read_EEPROM(unsigned char alamat){
unsigned char data;
i2c_start();
i2c_write(EEPROM_ADDR);
i2c_write(alamat);
i2c_start();
i2c_write(EEPROM_ADDR | 1);
data = i2c_read(0);
i2c_stop();
return data;
}

void write_EEPROM(unsigned char alamat, unsigned char nilai){
i2c_start();
i2c_write(EEPROM_ADDR);
i2c_write(alamat);
i2c_write(nilai);
i2c_stop();

delay_ms(10);}

void main(void)
{
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 9600
UCSRA=0×00;
UCSRB=0×18;
UCSRC=0×86;
UBRRH=0×00;
UBRRL=0×47;

// I2C Bus initialization
i2c_init();

// LCD module initialization
lcd_init(16);
putchar(’p');
while (1)
{
read_rtc();
//0123456789ABCDEF
sprintf(kata1,”%2d:”,data_rtc[2],);
sprintf(kata2,”%2d:”,data_rtc[1],);
sprintf(kata3,”%2d”,data_rtc[0],);
sprintf(kata4,”%2d-”,data_rtc[4],);
sprintf(kata5,”%2d-”,data_rtc[5],);
sprintf(kata6,”%2d”,data_rtc[6],);
lcd_clear();
lcd_gotoxy(3,0);lcd_puts(kata1);
lcd_gotoxy(6,0);lcd_puts(kata2);
lcd_gotoxy(9,0);lcd_puts(kata3);
lcd_gotoxy(3,1);lcd_puts(kata4);
lcd_gotoxy(6,1);lcd_puts(kata5);
lcd_gotoxy(9,1);lcd_puts(kata6);
delay_ms(100);

}
}

Source 2 :

**************************************************************

#include

// I2C Bus functions
#asm
.equ __i2c_port=0×18 ;PORTB
.equ __sda_bit=0
.equ __scl_bit=1
#endasm
#include

// Alphanumeric LCD Module functions
#asm
.equ __lcd_port=0×15 ;PORTC
#endasm
#include

// Standard Input/Output functions
#include
#include
#define ADDA_ADDR 0×90
#define EEPROM_ADDR 0xA0
#define RTC_ADDR 0xD0
unsigned char data_rtc[8];
unsigned char data_t[16];

// Declare your global variables here

unsigned char bcd2dec(unsigned char input){
unsigned char tmp_data, tmp1;

tmp_data = input;
tmp1 = tmp_data % 16;
if (tmp_data > 15) tmp_data = tmp_data / 16;
else tmp_data = 0;
tmp_data = (tmp_data * 10)+tmp1;
return tmp_data;
}

void read_rtc(void){
unsigned char i, tmp_data,y;

i2c_start();
i2c_write(RTC_ADDR);
i2c_write(0);
i2c_stop();
i2c_start();
i2c_write(RTC_ADDR | 1);
for (i=0; i<6; tmp_data =" bcd2dec(i2c_read(1));" tmp_data =" bcd2dec(i2c_read(0));">

unsigned char dec2bcd(unsigned char input){
unsigned char tmp_data;

if (input > 9) tmp_data = ((input / 10)*16) + (input % 10);
else
tmp_data = input;
return tmp_data;
}

void write_rtc(unsigned char alamat, unsigned char data){
i2c_start();
i2c_write(RTC_ADDR);
i2c_write(alamat);
if (alamat <>

unsigned char read_nvram(unsigned char alamat){
unsigned char tmp_data;

i2c_start();
i2c_write(RTC_ADDR);
i2c_write(alamat);
i2c_stop();
i2c_start();
i2c_write(RTC_ADDR | 1);
tmp_data = i2c_read(0);
i2c_stop();
return tmp_data;
}

// I2C Bus initialization
i2c_init();

// LCD module initialization
lcd_init(16);
while (1)
{
read_rtc();
//0123456789ABCDEF
data_t[0]=(data_rtc[2]/10)|0×30;
data_t[1]=(data_rtc[2]%10)|0×30;
data_t[2]=(data_rtc[1]/10)|0×30;
data_t[3]=(data_rtc[1]%10)|0×30;
data_t[4]=(data_rtc[0]/10)|0×30;
data_t[5]=(data_rtc[0]%10)|0×30;

data_t[12]=(data_rtc[3]/10)|0×30;
data_t[13]=(data_rtc[3]%10)|0×30;

lcd_clear();
lcd_gotoxy(3,0);lcd_putchar(data_t[0]);
lcd_gotoxy(4,0);lcd_putchar(data_t[1]);
lcd_gotoxy(5,0);lcd_putchar(’:');
lcd_gotoxy(6,0);lcd_putchar(data_t[2]);
lcd_gotoxy(7,0);lcd_putchar(data_t[3]);
lcd_gotoxy(8,0);lcd_putchar(’:');
lcd_gotoxy(9,0);lcd_putchar(data_t[4]);
lcd_gotoxy(10,0);lcd_putchar(data_t[5]);

lcd_gotoxy(0,1);lcd_putchar(data_t[12]);
lcd_gotoxy(1,1);lcd_putchar(data_t[13]);

lcd_gotoxy(3,1);lcd_putchar(data_t[6]);
lcd_gotoxy(4,1);lcd_putchar(data_t[7]);
lcd_gotoxy(5,1);lcd_putchar(’:');
lcd_gotoxy(6,1);lcd_putchar(data_t[8]);
lcd_gotoxy(7,1);lcd_putchar(data_t[9]);
lcd_gotoxy(8,1);lcd_putchar(’:');
lcd_gotoxy(9,1);lcd_putchar(’2′);
lcd_gotoxy(10,1);lcd_putchar(’0′);
lcd_gotoxy(11,1);lcd_putchar(data_t[10]);
lcd_gotoxy(12,1);lcd_putchar(data_t[11]);

delay_ms(200);

}
}

Humanoid: Albert Hubo

noreply@blogger.com (Unknown) — Tue, 7 Jul 2009 08:40:00 +0700

A robot called Robot Hubo is the creation of professor Jun Ho-Oh. Jun Ho-Oh from South Korea's Institute of Advanced Technology. This robotcan talk, walk and even smile because it have 66 motors, wow this is huge amount of motor for a humanoid. Albert Hubo run on Windows XP Platform with 4 foot 5 inches tall make this robot become a very interesting robot and the way it talk and moving is cool. See the video below, it's cool.

Below is the video from the Development of HUBO (KHR-3)

Great video to learn much about making the humanoid.