Arduino.ru

 Для ориентации в заданном пространстве/помещении очень рекомендую посмотреть в сторону алгоритма particle fiter algorithm. Очень компактно кодится и очень элегантный алгорим.

 Дайте ссылку пожалуйста, это надеюсь Fuzzy logic (или что то другое ?), Да у меня еще будет на платформе 3D компас (еще не приехал)

 Прошил плату, оказалось не хватало питания, хотя запитывал по паспорту от 6 пальчиковых аккумуляторов, заменил на щелочные элементы - все прошло успешно!

Двигаемся дальше!

Вот хорошая лекция по этой теме (англ), там еще очень понятная демонстрация.

http://www.youtube.com/watch?v=H0G1yslM5rc

Bigul Kак я рад что именно сейчас у вас очень похожий проект! :) Только мой знание C++ и arduino языка очень маленькие:( и поэтому моя первая цель проекта - Охрана периметра.
Что касается платформ - Wild Thumper 6WD конечно круто! И я задумывался о его покупки, но его цена.. и на мой взгляд трудность установления датчиков поворота колеса, склонила меня к альтернативе. И для начала заказал вот такой (http://i40.tinypic.com/tz9kl.jpg). 2 колесный с датчиками которые считают поворот колес. Думаю для начала он мне очень как раз.
Что касается железа, купил:
1. Ардуино мега 2650 и UNO
2, ультразвуковой датчик расстояния. 4 штуки
3, инфракрасный датчик расстояния. 3 штуки
4, датчик вибрации
5. датчик движения
6, датчик громкости, пока что один, в будущем нужно будет еще 3 купить для установления эпицентра звука.
7, (WI-FI) IP камера. Которой можно управлять через интернет.
8,SD карты модуль
9, Xbee модуль
10. Ethernet модуль.
И т.д...
Что касается самого проекта:
1,Применить Adaptive mapping. Для ориентации и патрулирования.
2,На самом работе будет стоять Ардуино мега с Xbee. А Ардуино UNО с Ethernet и Xbee модулем в электрощите где стоит роутер. И между ними будет связь, с помощью которой можно будет управлять роботом и камерой с любой точки земли где есть интернет:)

В данный момент борюсь c Adaptive mapping..
Если есть варианты - пишите!
 

 Bigul

Очень тема "приятная" и вот почему?

Есть однорукий робот РМ-01 Советский

подобие АВВ или NOKIA

несколько лет лежит мертвым грузом система управления "СФЕРА" кажется Белорусская устарела и т.д.

6 моторов.

Подскажите пож. Можно ли на системе Ардуино заставить его работать, и что для этого нужно.

Очень буду благодарен.

 Bigul Очень тема "приятная"
Bigul

Очень тема "приятная" и вот почему?

Есть однорукий робот РМ-01 Советский

подобие АВВ или NOKIA

несколько лет лежит мертвым грузом система управления "СФЕРА" кажется Белорусская устарела и т.д.

6 моторов.

Подскажите пож. Можно ли на системе Ардуино заставить его работать, и что для этого нужно.

Очень буду благодарен.

Mastino

 Пойду по порядку:

1. На моей платформе собственно колеса и не поварачиваются, управляется как гусиничная техника, путем разной скорости вращения левого и правого привода. Для ориентации в пространстве заказал цифровой компас, еще не приехал пока.

2. То что Вы купили - самое то чтобы обеспечить необходимый уровень оснащения, у меня только вопрос - как это все уместится на такой маленькой платформе ?

3. По поводу алгоритмов адаптивного меппинга - я еще и не дошел до этого, пока пишу базовую библиотеку классов на с++, например написал класс для обработки сигнала с аналогового датчика, масштабирование, перевод в инженерные единицы, демпфирование чтобы избавиться от шумов, алгоритмы калибровки датчика, сохранение калибровочных коэффициентов для каждого калиброванного датчика в eeprom и т.д.  Все отладил и оттестил на инфракрасном дальномере, датчике освещенности и микрофоне - работает.

Написал класс для обработки сигнала с ультразвукового дальномера (там данные собираются через последовательный порт) - ну и еще кое что. Пока готовлю базу алгоритмов для того чтобы в нормальном формате снимать данные и управлять исполнительными механизмами. 

Могу поделиться  исходниками

Николай

 Заставить работать можно, вопрос только в том, что если Ваши двигатели не стандартные в смысле питания и не удастся подобрать готовые силовые модули управления, то придется их тогда паять и сочинять самому, а это может занять много времени. Пришлите характеристики двигателей, я посмотрю что можно сделать.

Bigul

Цифровой компас (HMC5883L) у меня тоже есть вещь хорошая но и с глюками:
1. он очень чувствительный, если не далеко от него находится какой либо мeтал он начинает глючить. но не так что показание прыгают, а они меняются например с 90 градусов на 170.. и если не видишь компас своими глазами а смотришь только на показание то точно не поймешь правильные ли показание..
2. при наклоне компаса показание меняются - кардинально!

Все же не понимаю как вы будете знать какое расстояние вы проехали без щитания оборотов колес..?

если честно я об этом не подумал..:) может как нибудь засуну..:)

Было бы очень желательно..:)

Узнавать какое расстояние проехал робот, зачем? Тем более по вращению колес. Не, ну можно ему курвиметр приделать, пусть путь в мм меряет :)

Видел проекты arduino + робот-пылесос (типа roomba), очень забавно. Уже реализована ходовая часть и система распознования препятствий, если удастся купить б/у румбу - вообще круто :)

Есть продвинутые роботы-пылесосы, которые составляют план помещения и катаются по оптимальному маршруту и мониторят пространство не только ик-датчиками, но и камерой...

Если на такую базу добавить систему распознавания предметов типа www.youtube.com/watch или в этом видео :) будет почти полноценный робот, сможет узнавать хозяина, можно будет на кухню за пивом отправлять :))

Вот она, рыба моей мечты :)

Интересно, можно их софт использовать не покупая у них железо? Или залочили?

чтобы составлять план помещения и кататся по оптимальному маршруту, как это делает Румба ;)

 Bigul
Характеристики двигателей:
Двигатели постоянного тока +- 36 В
Тормоза 27 В
Питания приводов двигателей +40 В
Потребляемый ток:
3 двигателя - 7,5 А;
3 двигателя - 3,8 А;
На двигателях установлены енкодеры
(фотоимпульсные датчики), и
потенциометрические датчики положения.
Силовые модули управления отсутствуют необходимо подобрать или спаять.
Если кратко то все.
Спасибо

Mastino

 даю исходник:

Файл ai_unit.h

//класс для считывания, нормализации и перевода в инженерные единицы аналогового сигнала

#ifndef ai_unit
#define ai_unit

class ai {
public:
ai();
//если хотим привязать к адресу во флэш памяти для сохранения и загрузки калибровочных данных, то mem_addr должен быть больше нуля, в противном случае сохранения не будет
void attach(int pin, int mem_addr);//прикрепляет юнит к входу контроллера
bool attached();//возвращает состояние юнита (прикреплен или нет к входу)
int value();//возвращает значение в инженерных единицах
bool calibrate();//функция ручной калибровки сенсора через терминал
void save_to_flash();//записывает калибровочные значения в еппром
void setfilter(int f);// устанавливает использование фильтрования (осреднения) - для сенсоров с шумами, чем больше значение - тем больше осреднение
int last_epprom_addr();//возвращает адрес последнего байта занимаемого в ЕППРОМ
int first_epprom_addr();//возвращает адрес первого байта занимаемого в ЕППРОМ
void set_cal_data(int fmin,int fmax,int frawmin,int frawmax);//устанавливает калибровочные коэффициенты из программы скетча
protected:
int _min;//минимум шкалы
int _rawmin;//код АЦП для минимума шкалы
int _max, _rawmax;// максимум шкалы и код АЦП
int _mem_addr;//адрес в ЕЕПРОМ для хранения калибровочных констант
int _pin;//номер входа к которому привязывается модуль
int _value;//хранит последнее измеренное значение
int _filter;//если true то фильтруем помехи (осредняем значение)
int _last_addr;//значение для возвращения функцией last_epprom_addr
virtual int get_raw_val();//возвращает код с АЦП датчика
};

//класс для работы с ультразвуковым сенсором-дальномером URM37 V3.2
class urm37 : public ai
{
public:
urm37();//конструктор
bool wait_for_ansver();//процедура ождает ответа от датика, после получения ответа возвращает true, при выходе по таймауту возвращает false
bool data_is_ready();//возвращает true если в буфере от датчика есть данные
void request_data();//запрашивает данные измерения сенсора (посылает запрос в порт)
bool is_waiting_mode();//возвращает true если подан запрос в порт и ожидаются данные
private:
virtual int get_raw_val();//возвращает код с АЦП датчика
bool _is_waiting_mode;//true если был направлен запрос в порт и ждем ответа от датчика
};

#endif

Файл ai_unit.cpp

#include "ai_unit.h"
#include "Arduino.h"
#include <EEPROM.h>
#include <avr/pgmspace.h>

//считывает целое число из EEPROM памяти
int read_eeprom(int addr)
{
return makeWord(EEPROM.read(addr),EEPROM.read(addr+1));
}
//записывает целое число в EEPROM по указанному адресу
void write_eeprom(int addr, int val)
{
byte b, b1;
b=((val>>8) & 0x00ff);
EEPROM.write(addr,b);
b1=(val & 0x00ff);
EEPROM.write(addr+1,b1);
}
//########################################################################################
// class ai
//#######################################################################################
//конструктор
ai::ai()
{
_min=0;
_max=100;
_rawmin=0;
_rawmax=1023;
_mem_addr=-1;
_pin=-1;
_filter=1;

}
//инициализация модуля к агналоговому входу контроллера и адресу EEPROM для сохранения калибровочных коэффициентов
void ai::attach(int pin, int mem_addr)
{
_mem_addr=mem_addr;
_last_addr=-1;
if (pin>=0)
{
_pin=pin;
//если адрес указан, то считываем из EEPROM калибровочные коэффициенты
if (_mem_addr>=0)
{
_min=read_eeprom(_mem_addr);
_last_addr = _mem_addr+2;
_max=read_eeprom(_last_addr);
_last_addr = _last_addr+2;
_rawmin=read_eeprom(_last_addr);
_last_addr = _last_addr+2;
_rawmax=read_eeprom(_last_addr);
}
}
}

bool ai::attached()
{
return (_pin>=0);
}

int ai::value()
{
int val, result;
val=get_raw_val();
if (val<0) return val;
result = map(val,_rawmin,_rawmax,_min,_max);
if (result <_min) return -1;
if (result >_max) return -1;
if (_filter>1)
{
_value = _value + (result - _value)/_filter;
result = _value;
}
_value = result;
return result;
}

int ai::get_raw_val()
{
return analogRead(_pin);
}

// процедура калибровки сенсора через терминал в диалоговом режиме, возвращает True если успешно завершена
bool ai::calibrate()
{
bool result=false;
int val,i=0;
String s="";
Serial.println();
Serial.println("CAL MOD");
Serial.println("Settings for MIN value, when value is MIN - enter value");
delay(1000);
//ожидаем ввода
//тут постоянно выводим считанное с аналогового порта значение, при этом предполагается что пользователь выставляет минимум шкалы
// (т.е. например для дальномера устанавливает препятствие на минимальном расстоянии) и вводит собственно само это значение (например 15 сантиметров)
while (not Serial.available())
{
val=get_raw_val();
Serial.println(val);
delay(500);
}
s = "";
while (Serial.available() > 0) {
int inChar = Serial.read();
if (isDigit(inChar)) {
s += (char)inChar; }
}
if (s!="")
{
_min=s.toInt();
Serial.println(s);
_rawmin=val;
Serial.print("MIN cal const is set to ");Serial.print(_rawmin);//выводим установленные при калибровке значения кода АЦП и инженерной единицы
Serial.print(" at val ");Serial.println(_min);
result= true;
delay(1000);
} else
{
Serial.println("Invalid value");
}
//то же самое для максимума шкалы
Serial.println("Settings for MAX, when value in MAX - enter value");
delay(1000);
while (not Serial.available())
{
val=get_raw_val();
Serial.println(val);
delay(500);
}
s = "";
while (Serial.available() > 0) {
int inChar = Serial.read();
if (isDigit(inChar)) {
s += (char)inChar; }
}
if (s!="")
{
_max=s.toInt();
Serial.println(s);
_rawmax=val;
Serial.print("MAX cal const is set to ");Serial.print(_rawmax);
Serial.print(" at val ");Serial.println(_max);
result= true;
}else
{
Serial.println("Invalid value");
}

Serial.println("CAL END");
return result;
}

//записывает настроечные калибровочные коэффициенты в память EEPROM
void ai::save_to_flash()
{
write_eeprom(_mem_addr,_min);
_last_addr = _mem_addr+2;
write_eeprom(_last_addr,_max);
_last_addr = _last_addr+2;
write_eeprom(_last_addr,_rawmin);
_last_addr = _last_addr+2;
write_eeprom(_last_addr,_rawmax);
}

void ai::setfilter(int f)// цстанавливает константу для фильтрования
{
if (f>0) _filter = f;
}

int ai::last_epprom_addr()//возвращает адрес последнего байта в EEPROM куда сохранялись калибровочные коэффициенты для того, чтобы в следующем объекте можно было установить адрес для хранения
return _last_addr;
}

int ai::first_epprom_addr()//возвращает адрес первого занятого в EEPROM байта
{
return _mem_addr;
}

void ai::set_cal_data(int fmin,int fmax,int frawmin,int frawmax)//устанавливает калибровочные коэффициенты напрямую из скетча (для случаев когда они известны заранее или высчитаны теоритически
{
_min=fmin;
_max=fmax;
_rawmin=frawmin;
_rawmax=frawmax;
}

//#########################################################################################
// class urm37
//#########################################################################################
const uint8_t DMcmd[4] = { 0x22, 0x00, 0x00, 0x22};// последовательность байт отправляемая в порт (команда на чтение расстояния) из даташита сенсора
//для получения температуры воздуха необходимо направить другую команду

int urm37::get_raw_val()
{
int val = -1;
//request_data();
//wait_for_ansver();
if (!_is_waiting_mode) return val;
if (data_is_ready())
{
int header=Serial3.read(); //0x22
int highbyte=Serial3.read();
int lowbyte=Serial3.read();
int sum=Serial3.read();//sum
Serial3.flush();
_is_waiting_mode = false;

if(highbyte==255)
{
val=65525; //if highbyte =255 , the reading is invalid.
}
else
{
val = highbyte*255+lowbyte;
}
}

return val;
}

bool urm37::wait_for_ansver()
{
if (!_is_waiting_mode) return false;
unsigned long ms = millis();
while (!(Serial3.available()==4))
{
if ((millis()-ms)>500){return false;}
}
return true;
}

bool urm37::data_is_ready()
{
return (Serial3.available()==4);
}

void urm37::request_data()
{
if (!_is_waiting_mode)
{
Serial3.flush();
for(int i=0;i<4;i++)
{
Serial3.write(DMcmd[i]);
}
_is_waiting_mode = true;
}

}

bool urm37::is_waiting_mode()
{
return _is_waiting_mode;
}

urm37::urm37()
{
Serial3.begin(9600);
_value = -1;
_is_waiting_mode = false;
request_data();

}
 

Для использования в скетче необходимо:

объявить переменную типа ai, сначала в настроечном (калибровочном ) скетче вызвать if (ai1.calibrate()){ai1.save_to_flash()}

чтобы откалибровать сенсор и сохранить в EEPROM памяти калибровочные значения коэффициентов, потом просто для считывания значения в инженерных единицах в основном скетче вызывайте просто ai1.value();

При перепрошивке скетча не бойтесь, EEPROM не затирается, там все сохраняется.

Единственное замечание, класс для ультразвукового дальномера сделан отдельно, потому что подключается сенсор по последовательному порту, но чтобы не портить принцип его класс унаследован от ai, однако он еще сыроват и я не предусмотрел программной возможности выбора интерфейса а привязал жестко к Serial3 (для Меги), но в будущем переделаю чтобы можно было и на софтварный порт пристыковать. Там по этому юниту есть несоторые особенности, т.к. данные на нем появляются не сразу, а через некоторое время (зависит от измеряемого расстояния от 3 до 40 миллисекунд как показали мои эксперименты) то нужно сначала запросить данные, дождаться ответа - и для этого предусмотрены возможности (смотрите коменты)

 Вам повезло Николай, посмотрите вот эти платки: http://www.pololu.com/catalog/product/708

VNH3SP30 and VNH2SP30 Comparison
                                                   VNH3SP30                                 VNH2SP30
Operating supply voltage (Vcc)        5.5 – 36 V*                              5.5 – 16 V
Maximum current rating                 30 A                                         30 A
MOSFET on-resistance (per leg)       34 mΩ                                     19 mΩ
Maximum PWM frequency               10 kHz                                     20 kHz
Current sense none approximately 0.13 V/A
Over-voltage shutoff                       36 V*                                       16 V minimum (19 V typical)
Time to overheat at  20 A**           8 seconds                                  35 seconds
Time to overheat at 15 A**            30 seconds                                150 seconds
Current for infinite run time**        9 A                                            14 A
Платки двухканальные, каждая на 2 двигателя

Все остальное дело техники, силовая часть попрет, берите Ардуинку, и вперед!

 Коллеги, я подумал что для четкого определения движения работа считывать данные с датчиков вращения колес не совсем то что мне надо (колеса ведь могут и пробуксовывать), я хочу на днище платформы разместить сенсор от оптической мышки, только нужно перефокусировать сенсор на большее расстояние и как то подключить к Ардуино!

Кто нибудь знает как ?

Bigul - сразу видно что вы работаете в этой сфере.. Респект! Так как я новичок с ардуино и программированием вообще мне не всё понятно в этом коде и думаю мне понадобится много времени чтобы понять..:) поэтому думаю не смогу поддержать или чем-нибудь помочь:)
а так я использую как базу вот эти коды:

для IR

char GP2D12;
char a,b;
void setup()
{
  Serial.begin(9600); //
}
void loop()
{
  int val;
  GP2D12=read_gp2d12_range(0);
  a=GP2D12/10;
  b=GP2D12%10;
  val=a*10+b;
  if(val>10&&val<80)
  {
    Serial.print(a,DEC);//
    Serial.print(b,DEC);//
    Serial.println("cm");//
  }
  else Serial.println("over");//
  delay(50);
}
float read_gp2d12_range(byte pin)
{
  int tmp;
  tmp = analogRead(pin);
  if (tmp < 3)return -1;
  return (6787.0 /((float)tmp - 3.0)) - 4.0;
}

для PING`a

const int pingPin = 7;

void setup() {
  // initialize serial communication:
  Serial.begin(9600);
}

void loop()
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, inches, cm;

  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
  cm = microsecondsToCentimeters(duration);
 
  Serial.print(inches);
  Serial.print("in, ");
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();
 
  delay(100);
}

long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

Вот что вам нужно:
http://store.diydrones.com/Optical_Flow_Sensor_p/br-0016-01.htm

все что хорошо - дорого:(, за то хорошо и правильно работает..

 Да уж, но пока еще поищу решение по мышам, может чего нарою!

В любом случае спасибо за участие

И вот еще эта вещь нужна - http://www.pololu.com/catalog/product/701

 Да, это наверное для обнаружения док-станции и автоматической парковки на зарядку аккумулятора. 

Пока до этого руки не доходят. Классная штука, спасибо за ссылку

да именно для этого, ну и для калибровки показаний место находимости робота. и опять 28 x 2 + shipping.. но может в будущем купим..
Bigul - не мог бы посмотреть на эту тему - http://arduino.ru/forum/programmirovanie/adaptivnaya-karta-adaptive-mapping
может быть дашь умный совет

 Bigul
Большое спасибо, буду собирать запчасти
а по вопросу программирования, если позволите,
обращусь позже.

Для создания реального ИИ необходимо использовать как нечеткую логику так и алгоритмы адаптации, например генетические алгоримты. Я так понимаю необходимо создать некого сервисного робота. Очевидно, что робот будет агент передающий данные о своем место положении и т.д. а основные вычисления будут производится за счет ресурса компьютера соедененного удаленно с агентом. скорее всего как то так. 

Вот хорошая книжка, где описанны технологии для создания ИИ на основе нечеткой логики, ГА и т.п.

http://www.books.ru/books/intellektualnoe-robastnoe-upravlenie-tekhnologii-myagkikh-vychislenii-1046/?customer_product=1