Arduino is a tool for making computers that can sense and control the physical world through your computer. It is a development platform open-source physical computing, based on a simple microcontroller board and a development environment for creating software (programs) for the board.

Arduino can use to create interactive objects, reading data from a variety of switches and sensors and control many types of lights, motors and other physical actuators. Arduino projects can be stand alone or communicate with a program (software) running on your computer (eg Flash, Processing, MaxMSP). Board can be mounted alone or buy a ready to use software development and you can download it for free. The Arduino programming language is an implementation of Wiring, a similar physical computing platform, which in turn is based on Processing, multimedia programming environment.

Why should Arduino?
There are many other microcontrollers and microcontroller platforms available for physical computing. Parallax Basic Stamp, BX-24 from Netmedia, Phidgets, MIT Handyboard, and many others offer similar functionality. All these tools organize the complicated work of programming a microcontroller-friendly packages. Arduino can simplify the work with a microcontroller, offering several advantages over other systems for teacher, student and amateur. Here are some advantages of Arduino:

• Affordable – The Arduino boards are more affordable compared to other microcontroller platforms. The most expensive version of an The Arduino module can be mounted by hand, and even mounted and costs much less than 60 €
• Multi-Platform – The The Arduino software runs on Windows operating systems, Macintosh OSX and Linux. Most environments for microcontrollers are limited to Windows.
• The programming environment simple - Arduino is easy to use  programming environment for beginners and flexible enough for advanced users. Teacher thinking is based on the Arduino programming environment Procesing with students to learn to program in this environment will feel familiar with the Arduino development environment.
• Software upgradeable and open-source - The Arduino software is published under a free license and ready to be extended by experienced programmers. The language can be extended through C + + libraries, and if you are interested in learning more about the technical details, you can jump into the programming language C in which AVR is based. Similarly can be added directly in AVR C code in your programs if you wish.
• Scalable hardware and open source – Arduino is based on ATMEGA168 microcontrollers, ATMega328 and ATmega1280. The planes of the modules are published under Creative Commons license, so experienced circuit designers can make their own version of the module, expanding or optimizing. Even relatively inexperienced users can build the development board version to understand how it works and save some money.

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

Ports of the microcontroller – this I / O devices, allowing the microcontroller to send or receive data. The default port of the AVR microcontroller has eight bits of data that can be transmitted or received simultaneously. Each grade (or bit) corresponds to the output (pin) microcontroller. The legs of the microcontroller is also called pins. To designate ports use letters A, B, C, etc. Number of I / O ports varies depending on the model of the microcontroller. Any port of the microcontroller can be configured as input or output.

To do this, you should write to the corresponding port register DDRx desired value. In addition, as an input or output can be configured separately, any output (pin) port. In any case, if  you want to configure all port or a single output, you will need to work with DDRx register.

DDRx – direction data register. This register determines whether one or the other output port of input or output. If a discharge register DDRx contains a logical unit, the corresponding port pin is configured as an output, otherwise – as an input. The letter x in this case should designate a port name with which you work. Thus, for this will be port A register DDRA, Port B – DDRB register, etc.

Using the AVR GCC , written in the appropriate register a certain value can be one of the following methods.

For all the ports at once.

DDRD = 0xFF;

All D port pins are configured as outputs.

0xFF – hexadecimal representation of ff, where 0x is the prefix used to write hexadecimal numbers. In decimal representation this will be number 255, and in binary it would look like 11111111. That is, all bits of DDRD register will be written to logic one.

In AVR GCC to represent binary numbers use the prefix 0b. Thus, the number 11111111 to be presented in the program as 0b11111111. We can write the previous command for better readability.

DDRD = 0b11111111;

While such a record and is more obvious when you configure the ports made ​​to use the hex representation of numbers.

In order to configure all port pins as inputs D, you should write down all the bits in the register DDRD logical zeros.

DDRD = 0×00;

in DDRD register can be written and the other numbers.  For example:

DDRD = 0xb3;

0xb3 – hexadecimal representation of the number 179. In binary it would look like 10,110,011. That is part of the output port D is configured as outputs, and some – as inputs.

PD0 – 1 (out)
PD1 – 1 (out)
PD2 – 0 (input)
PD3 – 0 (input)
PD4 – 1 (out)
PD5 – 1 (output)
PD6 – 0 (input)
PD7 – 1 (out)

Each bit registers DDRx can be installed separately. For example, to configure a separate output PD2 as output, we need a corresponding bit in DDRD register to record 1. To do this, use the following construction.

DDRD | = 1 <<2;

1 <<2 – performs the shift left 2 bits, that is to the right added two zero bits, and turns 100, and the sign “|”, standing in front of the sign of the assignment “= “performs bitwise logical operation of addition.

With the addition of a logical 0 +0 = 0, 0 +1 = 1 1 +1 = 1 . The logical addition in another operation called OR

Thus, the bits stored in register DDRD, added to a binary 100, presented at the 8-bit microcontroller register as 00,000,100, and the result is written back to register DDRD.

To configure the output PD2 separately as an input, we need a corresponding bit in DDRD register write 0. To do this, use the following construction.

DDRD & = ~ (1 <<2);

In this case, the result of shifting units at two positions to the left is inverted by inverting the bit-operations, denoted by a ” ~ . ”

When we get the inversion instead of zeros, but instead of ones – are zero. This logical operation is also called the operation NOT.

Thus, when one bit inversion 00,000,100 11,111,011 we get. (For information about working with numbers in the microcontroller, see the sidebar below.)

The resulting number by performing a bitwise logical multiplication is multiplied by k number stored in the register DDRD, and the result is written into the register DDRD.

When the logical multiplication of 0 * 0 = 0, 0 * 1 = 0, 1 * 1 = 1 . The operation of logical multiplication operation is also called AND.

So we shifted to the left by two positions ones transformed with inversion at zero and multiplied by the corresponding bit which stored in register DDRD. When multiplied by zero, we get zero. Thus, the PD2 bit is zero.

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