This project does not require much indeed:
* A toothbrush
* A vibrating cell phone
* A button
* A piece of double sided tape
* May be a bit of copper wire that will be welded if the motor of the vibrator does not have one.

As you can see, this simple mini robot using only a toothbrush that cut off the handle with clippers, so we use only the head of the toothbrush ( Don’t forget to choose the right toothbrush as in the figure).
The first thing we will do is put double-sided tape on top of the toothbrush head. The first thing we will do is put double-sided tape on top of the toothbrush head. Then mount the motor in the top of the toothbrush. Then put the battery at in remaining places available. And plug the cable that was attached in motor to the battery. that’s it … Your mini-robot is ready to run.

To see more clearly about how to make a mini robot from toothbrush you can watch the video below:

Robotics Software: Introducing Urbi

Urbi is an open source robotics software platform. The Robotics software is applied to many robotics projects like, for instance, Segway RMP, Lego Mainstorm, Aldebaran Nao, Goztai Jazz, Pioneer 3-DX, etc. Besides, Urbi is utilized as well by simulator program like Webots. The platform is flexible enough and easy to apply. Even though it impressed easy to apply, the platform brings about advantages such as a C++/Java middleware called UObject. It is a kind of library model which is well-matched to a robot standard API to describe motors, sensors, and algorithms. URBI is compatible as well as with ROS (Robot Operating System).

Robotics Software: FIRST and LEGO

The development of robotics technology also tapped children and teenagers. Children and teenagers are some of phases of life who are not lack of creativities. The creativities are accommodated by FIRST (For Inspiration and Recognition of Science and Technology) invented by Dean Kamen the businessman. FIRST introduces younger children to the exciting world of science and technology. This program features a real-world challenge to be solved by research, critical thinking, construction, teamwork, and imagination. The contribution of FIRST in robotics software is the development of first robotics software released on 1 June 2012.

FISRT as a non-profit organization really pays attention to children’s development and achievement in the robotics world. FIRST concerns to children’s interests about robot and is willing to transmit them into positive things which become the significant of robotics software. One of FISRT concerns is the conducted FIRST LEGO League. The league aimed to introduce younger students to real-world engineering challenges by building LEGO-based robots to complete task on a thematic playing surface. FLL teams, guided by their imaginations and adult coaches, discover exciting career possibilities and, through the process, learn to make positive contribution to society. FIRST LEGO League is a place to develop the creativities of children and teenagers, who are in primary and secondary school, enriching with brilliant ideas. Through the league, they can design, build, test and program robots using LEGO robotics software called LEGO MINDSTORMS technology, apply real world math and science concepts, research challenges facing today’s scientist. They can also learn critical thinking, team building and presentation skills. They certainly can participate in tournaments and celebration.

Talking about Lego Mindstorms, it means that it refers to free robotics software which is popular among children, teenagers, and adults. Lego Mindstorms is robotics software which is versatile. It bring you to various Lego brick parts which are fun, moreover it is not costly. It is easy to use by everyone. One of the recommended devices of Lego Mindstorms is LEGO Mindstorms NXT 2.0. It is centered on NXT intelligent brick consisting of 32-bit microprocessor, an LCD display, 4 input ports, 3 output ports, Bluetooth support, and a USB port. Another device consists of two touch sensors, an ultrasonic range sensor, a color sensor, three motor-powered servos are included, and some other devices such as wheel and treads. The device costs about $280.99 from the Lego store, but software for “robot simple” is free.

Robotics Software: Employment Opportunities

The development of robotics software is growing rapidly. If you are interested to join with the team dedicated to the software of robotics, you can go to Bluefin Robotics. It is very good opportunities if you can join with Bluesfin Robotics. The job descriptions of Bluesfin Robotics are, first, designing, implementing and modifying next generation AUV software. Second, being the lead software developer on project requiring software expertise. Third, working with engineers from other department including Electrical, Mechanical, Manufacturing and Operations Engineering on our AUV System.

The qualifications required certainly you must have robotics software engineering with the provisions, first, Bachelor’s degree in computer science or strong practical computer experience. Second, you must have excellent programming skills, particularly in C/C++. Third, you also have to possess ability and desire to work in an energetic, multi-disciplinary environment with top-notch engineer. Fourth, one or more of the following would be a plus: Linux, Windows, hardware experience, EE and/or ME experience. Fifth, no prior experience with AUVs required. Therefore, if you have accomplished the qualifications above, feel free to follow the dynamic development of robotics software.

The ultrasonic range finder is based on measuring the time elapsed between emission and returning the echo. When the ultrasonic wave is emitted it spreads with speed of sound in the surrounding air, to 342 m / sec. Once an obstacle is encountered, the echo returns to the transducer which then calculates the elapsed time between transmission and receiving of the wave. These waves can not be heard by the human ear.

All rangefinders work the same way, regardless of the manufacturer. The differences will be within the frequencies transmitted, and the conical diffraction of the wave. Depending on the model, the ultrasonic sensors will be more or less accurate, and will have a greater or lesser extent. Their prices vary accordingly. Generally, the higher is the connical end, the sensor will be more precise, it will be more expensive. But as we shall see, some manufacturers have things differently

>>Once the data transfer direction for the port is configured, you can set the port value to be stored in the appropriate register PORTx.
PORTx – register the port, where x is the port name.

If the output is configured as an output, then the corresponding bit in the register PORTx forms on output high signal, and zero – low signal.

If the output is configured as an input, the corresponding bit in the register PORTx connects to the output internal pull-up resistor, which provides a high level of input in the absence of an external signal.

Set to “1″ on all the outputs of port D as follows.

PORTD = 0xff;

A set of “0″ on all the outputs of the port D may be the case.

PORTD = 0×00;

For each bit registers can be accessed PORTx and individually as well as in the case of registers DDRx.

For example, the command

PORTD | = 1 <<3;

set to “1″ (high signal) on output PD3.

Command

PORTD & = ~ (1 <<4);

set to “0″ (low signal) on output PD4.

In AVR GCC and the shift can be made using the _BV (), which performs the bitwise shift and inserts the result in the compiled code.

In the case of functions _BV () the previous two commands will look like.

PORTD | = _BV (PD3); / / set to “1″ on line 3 of port D

PORTD & = ~ _BV (PD4); / / set to “0″ on line 4 port D

Now try to write some simple programs to better understand how to work with the ports of the microcontroller.

Our first program will consist of only a few lines, and their task will include lighting LEDs connected to the microcontroller.

Connect the LED to a microcontroller in various ways.

Depending on how you connect the LED will light up any signal from a high level applied to the output of the microcontroller PD1, as in the first figure, or from low-level signal in the case of connection shown The second figure.

/************************************************* ************************
EXAMPLE LED on High-level inputs
Connection example in Figure 1
************************************************** ************************/

# include <avr/io.h>
int main (void) {    / / start the main program
DDRD = 0xff;         / / D port pins are configured as outputs
PORTD | = _BV (PD1); / / set to "1" (high level) on output PD1
}                    / / Closing bracket of the main program

/************************************************* **********************
EXAMPLE LED on low-level signals
Connection example in Figure 2
************************************************** **********************/

# include <avr/io.h>

int main (void) {      / / start the main program
DDRD = 0xff;           / / D port pins are configured as outputs
PORTD & = ~ _BV (PD1); / / set to "0" (low level) on output PD1
}                      / / Closing bracket of the main program

Now try to blink an LED connected as shown in the left figure. For this we use the delay function _delay_ms ().

Function _delay_ms () creates a delay, depending on the argument passed to it, expressed in milliseconds (one second in 1000 milliseconds). The maximum delay can be up to 262.14 milliseconds. If the user submits the function value is greater than 262.14, it will automatically reduce the resolution to 1 / 10 milliseconds, which provides a delay of up to 6.5535 seconds.

Function _delay_ms () is contained in a file delay.h, so we will need to attach this file to the program. In addition to the normal operation of this feature, you must specify the rate at which works a microcontroller, in hertz.

/*************************************
EXAMPLE flashing LED
Connection example in Figure 1
**************************************/

# define F_CPU 1000000UL / / specify the frequency in hertz

# include <avr/io.h>
# include <util/delay.h>

int main (void) {        / / start the main program

DDRD = 0xff;             / / D port pins are configured as outputs

PORTD | = _BV (PD1);     / / set to "1" (high level) on output PD1,
                         / / LED light

_delay_ms (500)          / / wait for 0.5 seconds.

PORTD & = ~ _BV (PD1);   / / set to "0" (low level) on output PD1,
/ / LED to extinguish

_delay_ms (500)          / / wait for 0.5 seconds.

PORTD | = _BV (PD1);     / / set to "1" (high level) on output PD1,
/ / LED light

_delay_ms (500)          / / wait for 0.5 seconds.

PORTD & = ~ _BV (PD1);   / / set to "0" (low level) on output PD1,
                         / / LED to extinguish

}                        / / Closing bracket of the main program

A series of LED flashes, it will be very short. In order to make continuous flashing, you can organize an infinite loop by using an unconditional jump “goto”. The goto statement jumps to the place of the program, the designated mark. Name tags can not contain spaces. After the name tags put a colon. Between the tag name and a colon should be no spaces.

/************************************************* ******
Examples of infinitely flashing LED
Connection example in Figure 1
************************************************** ******/

# define F_CPU 1000000UL / / specify the frequency in hertz

# include <avr/io.h>
# include <util/delay.h>

int main (void) {        / / start the main program

DDRD = 0xff;             / / D port pins are configured as outputs

start:                   / / label for the command goto start

PORTD | = _BV (PD1);     / / set to "1" (high level) on output PD1,
/ / LED light

_delay_ms (250)          / / wait 0.25 seconds.

PORTD & = ~ _BV (PD1);   / / set to "0" (low level) on output PD1,
/ / LED to extinguish

_delay_ms (250)          / / wait 0.25 seconds.

goto start;              / / go to label start

}                        / / Closing bracket of the main program

Algorithms for this robot motion will be as follows: when the sensor on a black field, then one of the motor will be switched on and off the other. Thus, the robot will change until the sensor is not able to pass on a white field. Then the motor running, and off – on. The robot starts rotating in the opposite direction until the sensor back on the black line. The algorithm will repeat again, and robots, slightly swaying from side to side, begin to move along the border of black and white.

A logical element that we add to the circuit of the robot is an element  “NOT” gate, or “inverter”. The inverter has one input and one output. When the input of inverter fed a logical “1″ (logical unit – a high signal), the output we will have a logical “0″ (logical zero – low signal), and when the input will be submitted to a logical “0″, then output will be present a logical “1″.

In addition to the NOT gate, there are also elements of OR and AND, providing a logical addition and logical conjunction, respectively. In addition, is often used combined elements of NAND and NOR. More information about the logical elements can be read here.

Schematic of the robot will look like this :
Resistor R2 is selected in such a way to give the best sensitivity of the sensor.

When connecting the phototransistor used pull-up resistor R2, sincethe TTL chips at the entrance when no signal is present a logic high(logic ”1″). Resistor, pull-up input to the “land”, will provide a low level(logic ”0″) in the absence of a signal from the phototransistor.

The principle of the scheme is based on inversion of the signal from the phototransistor. When the sensor is illuminated (located on a white field), the phototransistor will be opened and the input motor driver L293D INPUT1 a signal is high (logic ”1″). Motor M1 rotates. In addition, the signal from the phototransistor will be served at the input of ”NO”, which will convert a logical ”1″ to logical ”0″ and submit it to the input INPUT4. Motor M2 will stand.

When the robot turns and the sensor is over the white field, the phototransistor will be closed and the input signal INPUT1 be low (logic “0″). M1 motor stops. A logical “0″ is inverted by an element “NOT”, and at the entrance INPUT4 appears logical “1″. Motor M2 starts to rotate.

The change from state 1 and state 2 will give the robot to follow along the border of white and black.
In this scheme can be applied to logic chips or SN7404N.
Described by the robot can be implemented without the use of pull-up resistor. In this case, the emitter of the phototransistor can be connected to “earth” and to use two elements of the “NOT” gate.
It should be noted that the gate in addition to its direct purpose, may be a signal amplifier. Therefore, it is a variant of the scheme is often used in creating robots to sports competitions “Racing on the line.”

This is the application report from Texas Instruments about distance measurement using ultrasonic and MSP430 microcontroller. The report is provided in PDF file, you may download the application report at the end of this post.

This application report describes a distance-measuring system determined by ultrasonic sound using the MSP430F413 ultralow-power microcontroller. The system transmits a burst of ultrasonic sound waves towards the subject point and after that receives the corresponding echo.

This application is primarily based upon the reflection of sound waves. Sound waves are defined as longitudinal pressure waves in the medium in which they’re travelling. Subjects whose dimensions are greater than the wavelength of the impinging sound waves reflect them; the reflected waves are known as the echo. In the event the speed of sound in the medium is recognized and the time taken for the sound waves to travel the distance from the source towards the subject point and back to the source is measured, the distance from the source to the subject point will be computed accurately.

The devices applied to transmit and receive the ultrasonic sound waves within this application are 40-kHz ceramic ultrasonic transducers. The MSP430 drives the transmitter transducer using a 12-cycle burst of 40-kHz square-wave signal derived from the crystal oscillator, and therefore the receiver transducer receives the echo. The Timer_A in the MSP430 is configured to count the 40-kHz crystal frequency such that the time measurement resolution is 25 µs, that is more than enough for this application. The measurement time base is extremely stable because it is derived from a quartz-crystal oscillator. The echo received by the receiver transducer is boosted by an operational amplifier and the amplified output is fed towards the Comparator_A input. The Comparator_A senses the presence of the echo signal at its input and triggers a capture of Timer_A count value to capture compare register CCR1.

The capture is accomplished exactly at the immediate the echo arrives at the system. The captured count will be the measure of the time taken for the ultrasonic burst to travel the distance from the system to the subject point and back to the system. The distance in inches from the system towards the subject point is computed by the MSP430 implementing this measured time and displayed on a two-digit static LCD. Instantly right after updating the display screen, the MSP430 goes to LPM3 sleep mode to keep electrical power. The Basic Timer1 is programmed to interrupt the MSP430 every 205 milliseconds. The interrupt signal from the Basic Timer1 wakes up the MSP430 to repeat the measurement cycle and update the display screen.

Download the application report of distance measurement using ultrasonic and MSP430 microcontroller
» Download Link 1 (direct download from Texas Instruments)
» Download Link 1 (mirror download)

Arduino Tutorial: Use a Piezo Element to Detect Vibration. This tutorial shows you how to use a Piezo element to detect vibration, in this case, a knock on a door, table, or other solid surface.

A piezo is an electronic device that generates a voltage when it’s physically deformed by a vibration, sound wave, or mechanical strain. Similarly, when you put a voltage across a piezo, it vibrates and creates a tone. Piezos can be used both to play tones and to detect tones.

The sketch reads the piezos output using the analogRead() command, encoding the voltage range from 0 to 5 volts to a numerical range from 0 to 1023 in a process referred to as analog-to-digital conversion, or ADC.

If the sensors output is stronger than a certain threshold, your Arduino will send the string “Knock!” to the computer over the serial port.

Open the serial monitor to see this text.

Hardware Required

• Arduino Board
• (1) Piezo electric disc
• (1) Megohm resistor
• solid surface

Piezos are polarized, meaning that voltage passes through them (or out of them) in a specific direction. Connect the black wire (the lower voltage) to ground and the red wire (the higher voltage) to analog pin 0. Additionally, connect a 1-megohm resistor in parallel to the Piezo element to limit the voltage and current produced by the piezo and to protect the analog input.

It is possible to acquire piezo elements without a plastic housing. These will look like a metallic disc, and are easier to use as input sensors. PIezo sensors work best when firmly pressed against, taped, or glued their sensing surface.

Schematic Diagram:

A Piezo to attached to analog pin 0 with a 1-Megohm resistor

Code

In the code below, the incoming piezo data is compared to a threshold value set by the user. Try raising or lowering this value to increase your sensor’s overall sensitivity.

/* Knock Sensor
This sketch reads a piezo element to detect a knocking sound.
It reads an analog pin and compares the result to a set threshold.
If the result is greater than the threshold, it writes
“knock” to the serial port, and toggles the LED on pin 13.
The circuit:
* + connection of the piezo attached to analog in 0
* – connection of the piezo attached to ground
* 1-megohm resistor attached from analog in 0 to ground

http://www.arduino.cc/en/Tutorial/Knock

created 25 Mar 2007
by David Cuartielles
modified 4 Sep 2010
by Tom Igoe
This example code is in the public domain.
*/
// these constants won’t change:
const int ledPin = 13; // led connected to digital pin 13
const int knockSensor = A0; // the piezo is connected to analog pin 0
const int threshold = 100; // threshold value to decide when the detected sound is a knock
or not
// these variables will change:
int sensorReading = 0; // variable to store the value read from the sensor pin
int ledState = LOW; // variable used to store the last LED status, to toggle the light
void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
Serial.begin(9600); // use the serial port
}
void loop()
// read the sensor and store it in the variable sensorReading:
sensorReading = analogRead(knockSensor);
// if the sensor reading is greater than the threshold:
if (sensorReading >= threshold) {
// toggle the status of the ledPin:
ledState = !ledState;
// update the LED pin itself:
digitalWrite(ledPin, ledState);
// send the string “Knock!” back to the computer, followed by newline
Serial.println(“Knock!”);
}
delay(100); // delay to avoid overloading the serial port buffer
}

Download the Arduino Tutorial: Use a Piezo Element to Detect Vibration in PDF document:
» Download Link

This is the tutorial of DC motor control system for robot application. The tutorial provided in powerpoint presentation sheet which is converted in PDF file. The tutorial contains information about motor control system especially for PID Closed loop control system: PID control system diagram, PID implementation, PID calculation, PID tuning and more.

You will also find the sample of simple PWM circuit, H-Bridge motor driver circuit and Optical encoder circuit in the document provided.

This Robot Tutorial of DC Motor Control System can be accessed at dprg.org or you can download the presentation file here

In this article I do not open anything new, I just took the robot scheme, as described on many sites but all the actions I take pictures.

Step 1

So … our job is to make BEAM-robot. What do we need?

• L293D (engine driver)
• Resistor 100 ohms not less (I used 180 ohms)
• Phototransistor

These are the basic details that we need. But we also need a robot chassis, power supply, motor and wheels.

I did not want to reinvent the wheel, and therefore took the body from old toys, two electric motors and 203:1 tracked chassis. And this is the design.

But I do not think you have the same toy. Therefore, an alternative would be a case of … wood. Yes – made of wood. Do not worry. Of course, you can do and made of plastic, but not everyone has it. But the tree can be found everywhere.

Housing our BEAM robot will consist of a rectangle with sides of 100 mm by 60 mm (width may be greater if you use large electric motors).

Step 2

Well … you have made the case and now you can start soldering.

I’m not going to talk about all sorts of options L293D: this you can read on other sites. I’ll show you the photos, which you clearly see what and where to connect.

To begin with we take L293D and unbend inputs and outputs.

Step 3

The two electric motors solder the four wires.

Step 4

Take the battery holder and solder two wires to negative.

Step 5

Now take five wires, and connect them like this.

Now we connect to this construction, the resistor and phototransistor. It is very important to solder the resistor on the phototransistor shorter legs, and solder the blue wire to the other one.

Step 6

Now we’ll all be connected to the motor driver.
For a start – four wires to ENABLE1 and Vss, Vs and ENABLE2.

Now connecting to the phototransistors INPUT 1 and INPUT4.

Step 7

And now we join the resulting design with two engines.
In the figure: the upper motor and solder to OUTPUT1 OUTPUT2, and the lower to OUTPUT4 and OUTPUT3.

Step 8

That’s almost all: you only connect it all with the power supply. I used three AA batteries at 1.5 V.

First connect the negative (black wire that is connected to two blue – GND and GND, GND and GND)

Well, the red wire (positive) – the holder of the batteries by the end of the left resistor.

As you can see, I soldered the red wire not directly to the resistor, but through the switch.

Here we are with you and have a simple BEAM robot that reacts to light rays.

Robotic voice generator does not need the variety of complex chips. You can assemble using only ISD2500 ChipCorder® family and few components.The family of chip-coders ISD2500 firm Winbond contains almost everything you need to record and play back voice messages. As chips have mic preamps with AGC, working with the cheapest electret microphones, the output amplifier that runs on the speaker, memory, oscillator, ADC and DAC.

In a family of four basic models: 2560, 2575, 2590 and 25 120. The number following the numerals 25 denotes a maximum recording time in seconds. The amount of memory chips all the same, and long duration recording is achieved by a lower sampling rate. Ie, the chip with the lowest recording time provides the best sound quality.

Steps to follow when writing

First of all, set switch S3 to the recording mode (low level at pin 27). When you press S2 recording mode, which will end after pressing S2. With the third click again to start recording, etc. So you can continue for as long as the record will be nothing, or until the LED D2, indicating that the memory is full.

Steps to follow when playing

Playback can be started immediately, including the S1 and S3 in the switching mode “play”. Now, with every touch of S2, will consistently play the recorded messages. To record a new message over the old, turn S1, S3 switched to “record”, and pressing the S2, start recording again.

Some flexibility in the organization of the play mode allows you to connect together fragments of messages. Each piece ends with the flag of EOM (End Of Message – End of Posts), which is stored in the memory chip. So, instead of storing entire phrases, such as the “obstacle in front,” is much more efficient to keep an “obstacle”, “front”, “right”, “left”, “rear”. Similarly, for the numbers: from individual elements of the “one” “two”, “hundred”, “point”, etc. You can collect any number.

The Robotic voice generator scheme, managed by a microcontroller, is shown in the figure. Signals A0, PD, / CE and / EOM connected to a microcontroller that controls the robot.

To play you must first set to “0″ signal PD. To play the first message, the input / CE must submit a negative pulse. If this level of input A0 “0″, the playback will occur at normal speed, and if “1″ – a rate 800 times greater – a sort of “fast forward”. If you want after the first report was made, for example, the third, the microcontroller must set the “1″ to A0 and submit a negative pulse / CE, to “squander” the second message with great speed. Then, after waiting for the installation of the flag / EOM at a low level, A0 must be reset to “0″ and pulse / CE start playing the third message.

Due to the fact that the pulse duration / EOM may be less than 10 ms, it is better to use it to interrupt the processor, but do not check status / EOM interviews.