roboforum.ru

В обсчем, я собрал схему в протеусе и она работает абсолютно так как я и хотел, но почему-то миня мучают сомнения, что если собрать это в реале, то не заработает, насколько прав или не прав могет быть протеус?

ты бы схемку чтоли привёл...

а вобще у протеуса есть такой минус, если в реале у тя кондёры тсопы нафиг повзрывались от перенапряжения и тя убило взрывной волной
то протеус скорей всего об этом не знает, и будет думать что схема работает...

В общем-то частично я уверен в правильности этого, но я не уверен в правильном подключении блока l293d с фотоэлементами и еще я не уверен с количеством тактов за секунду, я примерно экспериментально мерял, дак получаетсо что за 2,5 секунды МК делает в районе 6500 тактов... а как будет в реале хз

А еще меандр через трансформатор черт знает как передается. На первичку даю размах от -10 до 10 вольт, а со вторички почему-то от 0 до 20 получается. (обмотки 1:1). А синус передает нормально...

Добавлено спустя 7 минут 14 секунд:

AsonD писал(а):В общем-то частично я уверен в правильности этого, но я не уверен в правильном подключении блока l293d с фотоэлементами и еще я не уверен с количеством тактов за секунду, я примерно экспериментально мерял, дак получаетсо что за 2,5 секунды МК делает в районе 6500 тактов... а как будет в реале хз

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

Так как у тебя нарисовано может работать только фотоэлемент, который создает ЭДС, а у тебя простое сопротивление.

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

Схема просто нелепая. Фоторезисторы подключить к входам драйвера двигателя, а с выходов подавать на контроллер - это еще додуматься надо Есть же АЦП в контроллере - туда и надо фоторезисторы подключать.

Но все-таки, у миня в программе организован свободный поиск, робот меняет направление как только переменная станет равной 6500 (каждый такт прибавляетсо единица), в протеусе это происходит примерно за 2,5 секунд (значение переменной брал на вскидку), как по вашему, в реальности как сильно может измениться время прохода 6500 тактов?

А как ты узнал, что увеличивается именно на каждом такте?

Простите канечна, но как врубить фотоэлементы напрямую к МК я не в курсах, компараторы юзать тож не умею, а так все проверено и в принципе работает, если что-то не нравитсо подскажи пожалста

Добавлено спустя 48 секунд:
Потому что я сам писал программу, и написал "++Q", логично?)))

Абсолютно нелогично. Давай уже показывай свою программу.

Ну смотри) Компилятор - CV AVR
Там правдо лишнего наверное будет многа (прога пока в разработке)

Код: Выделить всё • Развернуть

/*****************************************************************************************************************
// Программа для мобильного робота (пока только ездит на свет; свободный поиск в разработке)
// Компилятор: CodeVision AVR
// (с) ASAR.my1.ru 2008
******************************************************************************************************************/

#include "mega16.h"
#include "delay.h"

// обьявляем переменные
int p;
long int g;
int x = 0;
int y = 6;
int Q = 0;

/****************
Таблица вероятностей
*******************/
int ai[5][6] = {
 { 1, 5, 2, 4, 3, 2 },
 { 5, 3, 6, 2, 3, 1 },
 { 2, 4, 3, 1, 1, 2 },
 { 3, 2, 1, 5, 3, 4 },
 { 1, 1, 5, 3, 2, 6 }
 }; 

/*********************************************************************************************************
  Варианты выбора направления
*********************************************************************************************/   
void F() // Forward - движение вперед
{ 
 PORTD.0 = 1;
 PORTD.1 = 0;
 PORTD.2 = 0;
 PORTD.3 = 0;
 
 PORTD.5 = 0;
 PORTD.6 = 1;
} 

void B() // Backward - движение назад
{ 
 PORTD.0 = 0;
 PORTD.1 = 1;
 PORTD.2 = 0;
 PORTD.3 = 0;
 
 PORTD.6 = 0;
 PORTD.5 = 1;
}  

void L() // движение просто влево и вправо  - запасные(просто так их использовать не получится), вдруг пригодятся))
{
 PORTD.0 = 0;
 PORTD.1 = 0;
 PORTD.2 = 1;
 PORTD.3 = 0;
}

void R()
{ 
 PORTD.0 = 0;
 PORTD.1 = 0;
 PORTD.2 = 0;
 PORTD.3 = 1;
}

void FL() // Forward-Left - движение вперед-влево
{ 
 PORTD.0 = 1;
 PORTD.1 = 0;
 PORTD.2 = 1;
 PORTD.3 = 0;
 
 PORTD.5 = 0;
 PORTD.6 = 1;
}

void FR() // Forward-Right - движение вперед-вправо
{ 
 PORTD.0 = 1;
 PORTD.1 = 0;
 PORTD.2 = 0;
 PORTD.3 = 1;
 
 PORTD.5 = 0;
 PORTD.6 = 1;
}

void BL() // Backward-Left - движение назад-влево
{ 
 PORTD.0 = 0;
 PORTD.1 = 1;
 PORTD.2 = 1;
 PORTD.3 = 0;
 
 PORTD.5 = 1;
 PORTD.6 = 0;
}

void BR() // Backward-Right - движение назад-вправо
{ 
 PORTD.0 = 0;
 PORTD.1 = 1;
 PORTD.2 = 0;
 PORTD.3 = 1;
 
 PORTD.5 = 1;
 PORTD.6 = 0;
}   

void STOP() // стоп
{ 
PORTD = 0x00;
}  

/**********************************
Выбор случайного направления
*********************************/
 void snum()
 {

  Q++;  // каждый цикл этой переменной будет добавляться единица 
 
 if (Q == 6500)  // 6 500 взято на вскидку экспериментально в протеусе; примерно за 2,5 секунды программа сделает 6 500 циклов
 {
  Q = 0; //после проделывания 6500 циклов переменная обнуляется и отчет начинается сначала (и так до бесконечности)
 
  ++x; //каждые 6500 циклов или 2,5 секунды добавляем переменной единицу  
  
  
  
  if (x == 6) //каждый раз как x будет набирать число 6 по единицам, от у будет вычитаться единица
  {
  x = 0;//обнуляем переменную
  --y; // вычитаем 1 (каждый цикл при х = 6)
  }
  
  if (y == -1) // если у становится меньше нуля - возвращаем переменной первоначальное значение, а тоесть 6
  {y = 6;}
  
  } 

p = ai[x][y]; //переменная будет равна такому числу в таблице вероятностей, где x -номер числа по горизонтали, а у - по вертикали 

}
 
/*******************************************
Обработка информации с контактных датчиков
***********************************************/
 void contact()
 {
 //*********************************************************
 if ((PINB.4 == 1)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0))
 {
 BL();
 delay_ms(150);
 FR();
 delay_ms(150);
 F();
 delay_ms(50);
 
 } 
 //********************************************************* 
  if ((PINB.5 == 1)&&(PINB.4 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0))
 {
 FR();
 delay_ms(150);
 F();
 delay_ms(50);
 }
  //*********************************************************
  if ((PINB.6 == 1)&&(PINB.5 == 0)&&(PINB.4 == 0)&&(PINB.7 == 0))
 {
 FL();
 delay_ms(150);
 F();
 delay_ms(50);
 
 }
  //*********************************************************
  if ((PINB.7 == 1)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.4 == 0))
 {
 BR();
 delay_ms(150);
 FL();
 delay_ms(150);
 F();
 delay_ms(50);

 }
  //*********************************************************
 
 }

/******************************
Обработка информации с фотоэлементов
*********************************/
void photo()
{
if ((PINB.0 == 0)&&(PINB.1 == 1)&&(PINB.2 == 1)&&(PINB.3 == 1)&&(PINB.4 == 0)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0)) 
{
STOP();
FR();

delay_ms(25);
STOP();
}
////////////////////////////////////////////////////////////*
  
if ((PINB.1 == 0)&&(PINB.0 == 1)&&(PINB.2 == 1)&&(PINB.3 == 1)&&(PINB.4 == 0)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0)) 
{
STOP();
FL();


delay_ms(25);
STOP();} 
////////////////////////////////////////////////////////////*

if ((PINB.2 == 0)&&(PINB.1 == 1)&&(PINB.0 == 1)&&(PINB.3 == 1)&&(PINB.4 == 0)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0)) 
{
STOP();
BR();

delay_ms(100);
FL();
delay_ms(100);
STOP();} 
////////////////////////////////////////////////////////////*

if ((PINB.3 == 0)&&(PINB.1 == 1)&&(PINB.2 == 1)&&(PINB.0 == 1)&&(PINB.4 == 0)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0)) 
{
STOP();
BL();

delay_ms(100);
FR();
delay_ms(100);
STOP();}  
////////////////////////////////////////////////////////////*

if ((PINB.0 == 0) && (PINB.1 == 0)&&(PINB.2 == 1) && (PINB.3 == 1)&&(PINB.4 == 0)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0)) 
{
STOP();
F();

delay_ms(25);
STOP();}  
////////////////////////////////////////////////////////////*

if ((PINB.2 == 0) && (PINB.3 == 0) && (PINB.0 == 1) && (PINB.1 == 1)&&(PINB.4 == 0)&&(PINB.5 == 0)&&(PINB.6 == 0)&&(PINB.7 == 0)) 
{
STOP();
B(); 

delay_ms(25);
STOP();}
////////////////////////////////////////////////////////////*
}

 /***************************
 варианты "случайного" направления
 ************************/ 
void direction()
{ 

snum(); //выбираем значение случайного направления (р)  


//-----
//Дальше выбираем направление по ранее найденому значению 
if (p == 1)
{F();}

if (p == 2)
{FR();}

if (p == 3)
{BL();}

if (p == 4)
{FL();}

if (p == 5)
{BR();}

if (p == 6)
{B();}

}

/********************************************************
Главная программа
**********************************************************/
void main(void)
{ 
DDRD = 0xff; // назначаем все линии порта B на выход
PORTD = 0x00;

DDRB = 0x00; // назначаем все линии порта D на вход
PORTB = 0x00;


while(1) //бесконечный цикл
{

photo(); //запускаем фототранзисторное "зрение"
contact(); //запускаем контактные датчики

/****************************************
Свободный поиск
*******************************/

if (PORTB == 0) // Если с датчиков не поступает информация, включить свободный поиск
{
 direction();
}
     
} 
}   

Под тактом обычно понимают период тактовой частоты процессора.

В твоей программе период вызова snum() будет зависеть от состояния датчиков, потому что есть задержки, выполняемые при определенных условиях.

Не.. ну это-то понятно, он выполняетсо тока если не идет информации ни с одного из датчиков, просто мне то нужно узнать, как сильно отличаютсо данные протеуса от реальности, просто если примерно также будет работать то меня все устраивает, в протеусе все работает так как я и планировал

Можешь дергать какой-нибудь ногой в цикле, и добавить график, по которому сможешь точно замерять время.

как ты должен был уже заметить я не спец в программировании и электроникой занялсо не так давно, поэтому не мог бы ты пояснить что еще за график, по которому можно следить за временем?