>>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.

• ruler
• marker
• PVC foam
• office knife
• glue
• A set of tracks Timiya
• Twin-engine gearbox Timiya
• Drill (3 mm) and then what are we going to drill holes

All sizes shown in the picture. Plan without a cap, if desired can be done, as in the picture.

Another view of Robot Platform for crawlers.

Here is the pcb layout :

Details :

L293D chip 
socket for the chip to 16 feet 
capacitor C6 to 1000 uF 25 volt 
capacitors C1-C5 0.1 uF 
Resistors R1-R6 100 ohm 
resistors R7-R12 at 220 ohms

On the Internet there are many examples of code for AVR-GCC , written using functions and macros that are no longer supported in newer versions of the compiler. To use these examples and understand them with the essence of the ports of the microcontroller, you need to rewrite code or use special macros.

For starters, learn programming AVR microcontrollers, this approach can be difficult. As a result, many go to other compilers and never use a cult which has become for many a development environment WinAVR. Although there is a simple way to solve all the problems and return again rejected by the developers of the functions in AVR-GCC. You can use a specially crafted AVR-GCC myROBOT PATCH for WinAVR .

Before we proceed to the description of the patch, let’s see what kind of function it returns. The latest versions of libraries avr-libc, which is part of the compiler AVR-GCC, uses a WinAVR, more functions are not supported inp , outp , sbi and CBI . Made it to the best interpretation of the source code when it is compiled and determine how to handle the port – how to register or to memory. Support for these functions is not starting from WinAVR-20050214 version. This includes no support for such a popular and convenient for many of the former bit_is_set and bit_is_clear .

Of course, nobody calls using only the “old” functions return the patch is backward-compatible programs on the AVR -GCC. Using the patch, you will not lose the ability to work with the new notation, and only return the use of excluded functions. For example, checking the work of any one found on the Internet example, you can practice by rewriting it with the new syntax.
In conclusion, let us consider some examples of possible replacements.

Please note that _BV () is preferable because in this case, the compiler performs a bitwise shift and inserts the result in the compiled code. This ensures that no time spent during direct execution of code in the microcontroller.
As you can see, the possibilities of syntax in the AVR-GCC wide enough to consider him one of the most convenient and flexible means of programming microcontrollers Atmel AVR.