Роботът вече си има и име, казва се ATDV-I : All Terrain Discovery Vehicle. Сред последните обновления вече имаме PC-терминал за управление.
Снимка на терминала в действие:

Не пазят обикновенно си влачат задницата или предницата При всеки случай има още една опорна точка.
И все пак това е за BEAM-овете иначе има роботи които пазят равновесие и обикновенно това се постига благодарение на акселерометри(ускорителометри) или жироскопи или и двете.
Eто този приятел тук се стреми да запази равновесие, като усещайки, че се е навел напред или назад (вероятно с ускорителометър ) тръгва в тази посока, стремейки се да преудолее дисбаланса в тежестта

Общо взето имената на библиотеките говорят сами за себе си.
iostream.h - I/O stream или input/output stream - служи за боравене с входящи и изходящи потоци
stdio.h - std=standard, io=I/O, тоест стандартна входно изходна библиотека
math.h - за математически функции и т.н.
studio.h няма за подробно описани всички функции може да погледнеш на http://www.cppreference.com/

Защото човеко такъв мисли да ползва  

Хах, и за да си направиш кутия за елементи трябва да изпушиш 30 кутии  :lol:

#include <stdio.h>
#include <dos.h>

enum note {C, Cis, D, Dis, E, F, Fis, G, Gis, A, Ais, B};
short freq[12][10] = { {16, 33, 65, 131, 267, 523, 1047, 2093, 4186, 8372},
{17, 35, 69, 139, 277, 554, 1109, 2218, 4435, 8870},
{18, 37, 73, 147, 294, 587, 1175, 2349, 4699, 9397},
{19, 39, 78, 156, 311, 622, 1245, 2489, 4978, 9956},
{21, 41, 82, 165, 327, 659, 1319, 2637, 5274, 10548},
{22, 44, 87, 175, 349, 698, 1397, 2799, 5588, 11175},
{23, 46, 92, 185, 370, 740, 1480, 2960, 5920, 11840},
{25, 49, 98, 196, 392, 784, 1568, 3136, 6272, 12544},
{26, 52, 104, 208, 415, 831, 1661, 3322, 6645, 13290},
{28, 55, 110, 220, 440, 880, 1760, 3520, 7040, 14080},
{29, 58, 117, 233, 466, 932, 1865, 3729, 7459, 14917},
{31, 62, 123, 247, 494, 988, 1976, 3951, 7902, 15804}};

void _sound(enum note n, short octave, short period) {
sound(freq[n][octave]);
delay(period);
nosound();
}

int main () {
_sound(G, 4, 500);
_sound(G, 4, 500);
_sound(G, 4, 500);

_sound(E, 4, 250);
_sound(B, 4, 250);
_sound(G, 4, 500);
_sound(E, 4, 250);
_sound(B, 4, 250);
_sound(G, 4, 1000);
delay(500);

_sound(D, 5, 500);
_sound(D, 5, 500);
_sound(D, 5, 500);

_sound(E, 5, 250);
_sound(A, 4, 250);
_sound(F, 4, 500);
_sound(E, 4, 250);
_sound(B, 4, 250);
_sound(G, 4, 1000);

return 0;
}Ето програмата с Дарт Вейдъра дето я искаше днеска Работи за комп. Ако искаш да заработи и за пиезо зумера трябва да смениш _sound функцията с тази:_sound(enum note n, short octave, long period) {
long delay = 500000 / freq[n][octave];
period *= 1000;
for (long i = 0; (i << 1) * delay < period; ++i) {
output_high (PIN_B1);
delay_us (delay);
output_low (PIN_B1);
delay_us (delay);
} И dos.h става излишен. Have Fun!

Типове
C е функционален език, тоест език базиран на функции. Грубо казано програмите на него вървят, като последователно се извикват въведени от програмиста функции. Функиите приемат аргументи, които може да са променливи или константи и връщат стойности. Константите, променливите и върнатите стойности имат тип, който може да е сред няколко основни типа. Това са int, short,  long, char, float, double.

int (идва от integer / цяло число)
Типът int се използва за цели числа. В по-новите компилатори неговата големина е 4B (байта) или 32bit (бита). Това означава че може да приема 2^32 или 4294967296 различни стойности. По подразбиране int има знак (+ или -) и съответно може да приема стойности от -2147483648 до +2147483647 (защо не до +2147483648 ще ми кажете вие ).
Върху променливи от тип int могат да се използват следните аритметични операции: +, -, *, /, %. При +, - и * няма нищо странно, извършват се както очаквате. / в случая се нарича целочислено делене. Когато разделим две променливи от тип int a и b резултатът е цялата част на a/b, например 5/2 = 2.5, 8/3 = 2.(6). % се нарича сравняване по модул или остатък при деление. Тоест 11/3 = 3(2) (3 и остатък 2, защото 3*3 + 2 = 11) => 11%3 = 2 (остатъка).

short (идва от short (да не повярва човек), което значи къс)
short също е целочислен тип. С тази разлика че паметта която заема е 2B или 16bit. Тоест може да приема 65536 различни стойности, и ако има знак това значи от -32768 до +32767. Аритеметичните операции, които могат да се прилагат са същите, като при int.

long (идва от long/ дълъг)
long е третият целочислен тип в C, макар че заедно с short могат да се смятат за разновидности на int. Има големина 4B и е напълно идентичен с int. Смъсъла от него е, че ако не сте сигурни дали компилатора ви е 16 битов или 32 битов (т.е. дали подразбиращата се големина на int е 2B или 4B) така се подсигурявате .

char (идва от character / писмен знак)
char е по-интересен тип. Големината му е само 1B или 8bit което значи че може да приема само 256 стойности, и ако има знак това са целочислените стойности от -128 до +127. На всяка стойност обаче отговаря определен знак, според известната ASCII таблица (тя е 7 битова, което значи че имаме още 128 стойности който липсват в нея. Те за жалост са различни на различните машини.) Първите 31 символа са контролни знаци. Останалите са printable или визуални знаци. Знаците които лично аз си правя труда да помня са 32 = 'празно място', 48-57 = 0-9, 97-122 = a-z, но не е наложително, понеже винаги може да се погледне в таблицата . Повече за нея тук или на английската версия (по-подробна е) ето тук.

float (идва от floating point / плаваща точка)
float е тип който се използва за десетични дроби. Неговата големина е 4B. Десетичните дроби във float са представени с мантиса и експонента. Манисата се мени от 0 до 1, а експонентата е степен на която се вдига 10 и се умножава по мантисата. Например 12.5 има мантиса 0.125 и експонента 2 (0.125 * 10^2 = 12.5) и 0.03 има мантиса 0.3 и експонента -1 (0.3 * 10^(-1) = 0.3 * 0.1 = 0.03). Когато ги използвате обаче, това не трябва да ви интересува, защото могат да се използват и както сме свикнали, (0.03 не е грешно, но може да бъде записано и като 0.3е+1). Точността на float обикновенно е прибилизтелно 3 знака след десетичната точка. Приблизително, защото понякога се получават малки отклонения, като например вместо 3.0 получите 2.999.
Върху променливи от тип float могат да се използват следните операции: +, -, *, /. Всички те са еквивалентни на това, което очакваме. 2.0 + 3.2 = 5.2. 4.1 - 1.4 = 2.7. 3.1 * 0.3 = 0.93. 5.0/2.0 = 2.5.

double (идва от double / двоен)
double също е тип за десетични дроби. Неговата големина е 8B или 64bit, и точността му е 2 пъти по-голяма от тази на float. Аритметичните операции са същите, като при float.

Как се декларират променливи от определен тип?
Пише се името на типа, и след него името на променливите, които искаме да декларираме от този тип. (декларирането е нужно, ако искаме да ползваме някоя променлива). Ето пример:short age, height;
double weight;
char gender;
Могат да се добавят и допълнителни запазени думи пред променливите, които ги променят. Например запазената дума unsigned променя диапазона на стойности които може да приема променливата, като го прави такъв че да съдържа само положителни стойности. Например променлива от тип unsigned short ще приема стойности от 0 до 65535 вместо от -32768 до +32767.
Запазената дума const превръща променливата в константа. Това означава, че програмата не може да я променя. Ако искате да създадете константа е нужно при декларирането и да я ициализирате, което става с операторът =.const double PI = 3.14169265;Можете ако желаете да инициализирате и променливи, което става по идентичен начин. Запазената дума long служи за 'разширяване на типа'. Можете да я ползвате само с double и long. long long e целочислен тип с големина 8B или 64bit, а long double е десетична дроб, заемаща памет 12B или 96bit.

Инициализацията
Ако пишете по-големи и сложни програми е хубаво винаги да си инициализирате променливите, защото ако се опитате да ги променяте преди да сте ги инициализирате ще се получат безсмислици и програмата няма да върви както се очаква.

Операции върху променливите
Операциите се извършват както обичайно. ако искате да съберете две променливи и да запишете резултата в трета трябва да направите следното:
int a = 3,b,c;//декларирате a, b и c и инициализирате а със стойност 3
b = 6; //присвоявате на b стойността 6.
c = a + b; //присвоявате на c стойността на a + b.
Освен аритметичните, можете да извършвате още булеви/логически или побитови операции. Булевите/логическите оператори, които можете да прилагате върху променливи са грубо казано сравнения. Булевите оператори са < (по-малко), > (по-голямо), <=(по-малко или равно), >=(по-голямо или равно), ==(логическо равно (да не се бърка с =)), !=(различно от или не-равно). Логическите оператори се използват като обикновенни и връщат стойност 0 или 1 съответно 1 при вярно и 0 при невярно. Напримерint a, b = 3, c = 4;
a = b > c; //тук на а се присвоява стойност 0, защото b не е по голямо от c
a = b <=c; //а = 1, защото b е по-малко или равно на c;
a = b == c; //a = 0, защото b не е равно на c;
a = b != c; //a = 1, по същата причинаОще две логически операции са || и &&. За разлика от останалите те могат да се използват върху булеви изрази или това което правехме преди 2 реда. || или логическо OR връща 1 ако един от двата израза е 1, а другия 0 или ако и двата са 1 и 0 ако и двата са 0. && или логическото AND връща 1 ако и двата израза са 1 и 0 ако поне един от тях е 0. Пример: int a, b = 3, c = 3;
a = b >= c && b <= c; //един изватен начин да проверите дали b е равно на c, ако b e по-голямо или равно на c и същевременно е по-малко или равно на c то b = c :)
a = b < c || b > c; //това пък е изватен начин да проверите дали b e различно от c

Побитовите операции, могат да ви се сторят странни и излшни в началото.Те са <<, >>, &, |, ^, ~.
<< премества битовете на променливата от лявата му страна на ляво с толкова колкото е променливата от дясната страна.
>> e идентично, само че надясно. Пример:
int a = 7;
a = a << 1; // вече а е 14. 7 в двоична бройна система е 111. Като изместим битовете на ляво с 1 се получава 1110, което е 14.
а = а >> 2; // вече а е 3. досега е било 1110, като преместим битовете на дясно с 2 се получава 11, което е 3.Ако сте внимавали може да сте забелязали че с това преместване на битовете всъщност умножаваме или делим едно число със степен на 2. Това всъщност е много по-бързо от колкото ако използваме операторът *, поради простата причина че "компютеро работи с еденици и нули', както всички знаят .
| побитовото OR (не трябва да се бърка с логическото || OR)
скужи за OR-ване на две числа по-лесно се обяснява с пример.
Имаме 00001111 и 0111100, като ги OR-нем, там където има 1 поне при едното число получаваме 1 в резултата. А ако и 2-те са 0-и се получава 0.
Та OR-ваме и получаваме
00001111
 0111100

00111111
& побитовото AND (и то не трябва да се бърка с логическото && AND) служи за AND-ване на 2 числа. Там където има 0 поне при едното число получаваме 0 в резултата, иначе 1. Ако AND-нем пак същите числа ще получим:
00001111
 0111100

00001100
^ побитово XOR, него за жалост няма с какво да го сбъркате
служи за (познайте) XOR-ване на 2 числа. Там където има 0 и 1 или 1 и 0 резултатът е 1, а където има 0 и 0 или 1 и 1 е 0. XOR-ваме:
00001111
 0111100

00110011
~ тилда, обръща битовете на 1 число. ~111100 = 11..11000011. Единиците в началото са обърнатите 'невидими' нули на 111100. общо 1-ците и обърнатата 'видима' част от числото са толкова на брой, колкото е и големината на типа в битове. Тоест ако 111100 е от тип int (32 bit) -> 111111111111111111111111111111000011.

Толкова за типовете, променливите и другите такива работи
Ето една примерна програмка, която можете да си реализирате:#include <stdio.h>
const double PI = 3.14169265;
int main () {
   int r;
   scanf ("%d", &r);
   double S = PI * r * r;
   printf ("%lf", S);
   return 0;
} 'Програмата' чете от клавиатурата радиуса на една окръжност и пресмята лицето й. Новото тук е функцията scanf, за нея в следващия пост.

Поупражнявайте се с наученото и ако имате въпроси да питате.
Модератор: Темата беше разчистена с цел да се запази четливостта.

Ето ти цяла страница
http://www.pololu.com/products/gearbox.html

мисля че това
 е подходящо за твоето начинание, но сирьеньето е с пари дет се вика