консультация по ардуино

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

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

 

По поломке на скажу. А по работе скажу так. Настройки и прочие ритуалы выполнять отдельно, а измерение отдельно. Если речь идет о микросекундах, важно помнить, что на одну микросекунду у обычной дуньки всего 16 тактов и всякие дополнительные задачи в этот момент могут запросто пропускать что то важное. Я бы вообще на STM32 сделал, если нужна точность.

 

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

Почитал про STM32 впал в депрессию. Зачем столько времени потерял на всякие Ардуины. Наверно закажу себе парочку. Жалко что программируются по другому. я уже привык к ардуино иде, надо потихоньку переучиваться STM32 намного перспективнее)

 

Пульки не каждую микросекунду пролетают. Так что времени на фоновые процессы полно остается.

Ардуина легко фиксирует время с точностью до такта.

 

Есть способ писать для STM32 под IDE. Костыли конечно, но работают неплохо. Все равно раз в 8 быстрее дуни.

 

Вечер добрый. Запасайтесь попкорном, описание будет долгим. Отлично если кто нибудь вникнет в суть вопроса ( т.к описание ситуации не мой конек))ю
В общем история такая. Пока идут нормальные транзисторы, запустил схему на китайских транзисторах. Худо бедно но работает. Сама схема работает очень четко.







Выходы компаратора подключены на пины 2 и 3. Питание раздельное Ардуино от USB копараторы и датчики от своего стабилизированного питания 5 вольт. . Когда нет затенения на выходе компаратора +5 как попадает тень на датчики, на выходе 0.
Схема очень хорошо. проверял простым чтением пинов

скетч проверки

Код (C++):

[code]
#define in2 2
#define in3 3



void setup() {
  pinMode (in2, INPUT);
  pinMode (in3, INPUT);
Serial.begin(9600);
}

void loop() {
int IN2 = digitalRead(in2);
int  IN3 = digitalRead(in3);
  Serial.print("IN2"); //вход
Serial.print("\t");
Serial.print(IN2);
Serial.print("\t");
Serial.print("IN3"); //вход
Serial.print("\t");
Serial.print(IN3);
Serial.println("");
if (IN3 == 0 && IN2 == 0)
{
   Serial.print("PIPEC");
Serial.println("");
delay(2000);
}
}
 

[/code]

Но как только дело доходит до рабочего скетча то начается фигня. Он ловит какуют помеху и не могу ни как в коде ее отфильтровать. Прет и все дальше не смотря ни на какае условия. Перед тем как написать сюда, долго пытался найти в чем фикус но так и не понял. помеха микроскопическая 8 -23 микросекунды. но никак не могу от нее избавиться.


сам рабочий кот

Код (C++):

uint32_t preSpeed = 0;
uint32_t InPort_mcs = 0;  //время срабатывания датчиков входного порта
uint32_t OutPort_mcs = 0 ; // время срабатывания датчиков выходного порта в микросекундах
bool InPort_stat = false;  // флаг срабатывания входа
bool OutPort_stat = false; // флаг срабатывания выхода
int Speed ; // скорость
void InPort_meter(); // функция измерения входного датчика. фигня но без объвления функции в этом месте отказывается работать компилятор
void OutPort_meter(); // обработка выходных датчиков

void setup() {
  Serial.begin(9600);
attachInterrupt (0, InPort_meter, FALLING);
attachInterrupt (1, OutPort_meter, FALLING);                                                                                                    
}
void loop() {
/* int InPort = digitalRead(2);
int OutPort = digitalRead(3);
  Serial.print("InPort"); //вход
Serial.print("\t");
Serial.print(InPort);
Serial.print("\t");
Serial.print("OutPort"); //вход
Serial.print("\t");
Serial.print(OutPort);
Serial.println("");*/
if (InPort_stat == true && OutPort_stat == true &&OutPort_mcs > InPort_mcs && preSpeed > 100  )
// если появлись флажки срабатывания обоих портов и они укладываются в нужные рамки, знаяит это не помехи и измеряем данные с датчиков


Serial.print("InPort_mcs"); //вход
Serial.print("\t");
Serial.print(InPort_mcs);
Serial.print("\t");
Serial.print("OutPort_mcs"); //вход
Serial.print("\t");
Serial.print(OutPort_mcs);
Serial.println("");
uint32_t preSpeed = OutPort_mcs - InPort_mcs;
Serial.print("preSpeed"); //вход
Serial.print("\t");
Serial.print(preSpeed);
Serial.println("");
{
Speed = (220 /(OutPort_mcs - InPort_mcs)) ; // вычисление скорости
InPort_stat = false; // обнуление флажков
OutPort_stat = false; //
Serial.print("Speed"); //вход
Serial.print("\t");
Serial.print(Speed);
Serial.println("");
delay(2000);
}
}
void InPort_meter() // описание функций
{
InPort_mcs = micros();
  InPort_stat = true;
}
void OutPort_meter()
{
OutPort_mcs = micros();
  OutPort_stat = true;
uint32_t preSpeed = OutPort_mcs - InPort_mcs;

}

 

Понимаю что изъясняюсь не как Сократ но суть в следующей строке

Код (C++):

if (InPort_stat == true && OutPort_stat == true &&OutPort_mcs > InPort_mcs && preSpeed > 100  )

программе пифигу на все условия, прет себе и ошибка и все тут. Глаз замылен уже, возможно причина проста но я ее не замечаю. Буду благодарен за помощь. С уважением

 

потому что у вас коТ рабочий )))

Напишите,
1. что и где вы ожидаете. Например, ТУТ должно быть 100 мкс.
2. что получается фактически.Например, ТУТ получаем 108 мкс.
3. что вас не устраивает. Например, в ТУТ, фактически на 8 мкс больше.

Или... скорость всегда одинаковая, поэтому тут и тут должно быть 100мкс, а получается ТУТ 108мкс, а тут 100мкс. 108 это ошибка, должно буть 100мкс.

Переменные, которые изменяются в прерываниях нужно объявлять с модификатором volatile. Иначе оптимизатор C++ может решить, что в процедуре переменная не изменяется, и построить не тот код, который вы ожидаете.

Код (C++):

volatile uint32_t preSpeed = 0;
volatile uint32_t InPort_mcs = 0;  //время срабатывания датчиков входного порта
volatile uint32_t OutPort_mcs = 0 ; // время срабатывания датчиков выходного порта в микросекундах
volatile bool InPort_stat = false;  // флаг срабатывания входа
volatile bool OutPort_stat = false; // флаг срабатывания выхода

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

 

Зачем тут объявлять вычислять локальную переменную preSpeed которая нигде не используется?

Код (C++):

void OutPort_meter()
{
OutPort_mcs = micros();
  OutPort_stat = true;
uint32_t preSpeed = OutPort_mcs - InPort_mcs;

}
 

Видимо uint32_t не надо писать.

 

Код (C++):

if (InPort_stat == true && OutPort_stat == true &&OutPort_mcs > InPort_mcs && preSpeed > 100  )
// фигурные скобки пропущены???
Serial.print("InPort_mcs"); // эта строка выполнится при условии if.
Serial.print("\t"); // эта строка выполнится при любом условии

 

доброй ночи! Большое спасибо! Точно VOLATILE!!! Результат ночных бдений над игрушкой, дает о себе знать). Мне уже все равно, откуда эта помеха берется, теперь думаю ее смогу отфильтровать. стало ясно, почему так переменные себя вели.. Спасибо за свежий взгляд,) я до дыр скетч проглядел, а слона и не заметил))). Завтра проверю. А сегдня всем спать! завтра на выпускной!
(скобки не туда действительно всунул, когда отлаживал)

 

Я не понял что за помеха.

Могу заметить, что micros() имеет разрешение 4 мкс. Для измерений с разрешением до такта нужен другой подход.

В принципе, помеха в пределах допуска некритична. Ну есть она, и ладно. Если вы хотите выжать из МК каждый такт, придется программировать на уровне регистров. Если есть желание погрузится в тему могу подкинуть скетч.

 

Спасибо за помощь. частично дело было действительно в volatile. На помеху уже плюнул. Некогда разбираться. сейчас другая печаль . не вычисляется скорость.

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

Код (C++):

 uint32_t preSpeed = 0;
volatile uint32_t InPort_mcs = 0;  //время срабатывания датчиков входного порта
volatile uint32_t OutPort_mcs = 0 ; // время срабатывания датчиков выходного порта в микросекундах
volatile bool InPort_stat = false;  // флаг срабатывания входа
volatile bool OutPort_stat = false; // флаг срабатывания выхода
float  Speed = 0 ; // скорость
void InPort_meter(); // функция измерения входного датчика. фигня но без объвления функции в этом месте отказывается работать компилятор
void OutPort_meter(); // обработка выходных датчиков

void setup() {
  Serial.begin(9600);
attachInterrupt (0, InPort_meter, LOW); //FALLING
attachInterrupt (1, OutPort_meter, LOW);                                                                                                      
}
void loop() {
/* int InPort = digitalRead(2);  
int OutPort = digitalRead(3);
  Serial.print("InPort"); //вход
Serial.print("\t");
Serial.print(InPort);
Serial.print("\t");
Serial.print("OutPort"); //вход
Serial.print("\t");
Serial.print(OutPort);
Serial.println("");*/

if (InPort_stat == true && OutPort_stat == false || InPort_stat == false && OutPort_stat == true && OutPort_mcs - InPort_mcs > 100000 || OutPort_mcs - InPort_mcs < 30 ) // OutPort_mcs - InPort_mcs < 100000
{
  InPort_stat = false; // обнуление флажков
OutPort_stat = false;
//attachInterrupt (0, InPort_meter, FALLING); //FALLING
//attachInterrupt (1, OutPort_meter, FALLING);
}
if (InPort_stat == true && OutPort_stat == true &&OutPort_mcs > InPort_mcs && OutPort_mcs - InPort_mcs > 200 && OutPort_mcs - InPort_mcs < 100000)
// если появлись флажки срабатывания обоих портов и они укладываются в нужные рамки, знаяит это не помехи и измеряем данные с датчиков
// 50000 мкс скорость 4,4 м/с 100000 2,2 м/с, 200 мкс скорость 1100

{
// detachInterrupt(0);
// detachInterrupt(1);
// unsigned long IN = InPort_mcs;
//unsigned long OUT = OutPort_mcs;
  Serial.print("InPort_mcs"); //вход
Serial.print("\t");
Serial.print(InPort_mcs);
Serial.print("\t");
Serial.print("OutPort_mcs"); //вход
Serial.print("\t");
Serial.print(OutPort_mcs);
Serial.println("");
/* Serial.print("preSpeed"); //вход
Serial.print("\t");
Serial.print(preSpeed);
Serial.println("");*/
preSpeed = OutPort_mcs - InPort_mcs;
Speed = 220 / (OutPort_mcs - InPort_mcs)  ; // вычисление скорости* 1000
float  Speed1 = Speed;


InPort_stat = false; // обнуление флажков
OutPort_stat = false; //

//int InPort = digitalRead(2);  
//int OutPort = digitalRead(3);


Serial.print("preSpeed");
Serial.print("\t");
Serial.print(preSpeed);
Serial.print("\t");



Serial.print("Speed1"); //вход
Serial.print("\t");
Serial.print(Speed1);
Serial.println("");
delay(2000);
//attachInterrupt (0, InPort_meter, FALLING); //FALLING
//attachInterrupt (1, OutPort_meter, FALLING);
}
}
void InPort_meter() // описание функций
{
InPort_mcs = micros();
  InPort_stat = true;
//detachInterrupt(0);
}
void OutPort_meter()
{
OutPort_mcs = micros();
  OutPort_stat = true;
//detachInterrupt(1);
//preSpeed = OutPort_mcs - InPort_mcs;
 
}

 

в коде много ненужного. но править некогда. не дается во эта строка

Код (C++):

Speed = 220 / (OutPort_mcs - InPort_mcs)  

элементарно проще некуда, но не считает и все тут. пробовал все виды переменных нефига. Не делится и все тут. при чем исходные данные с датчиков InPort_mcs и OutPort_mcs, в полном порядке. Мистика . Видно каких то тайных знаний про язык Ардуино не хватает)))

 

Утро доброе если оно боброе(. дописал нормально рабочий код. Работает очень стабильно. за все врем проверки не было ни одного ложно срабатывания ни одного пропуска измерений. осталось допилить часть тестирования и сохранения данных.(если настроение будет). а так в принципе хронаграф на ардуине в макетном варианте готов. Где там топикстартеры? сбылась их мечта да и моя тоже. хронограф очень чуткий реагирует на затенение 1 мм проволоки. единственно что откажусь от зеркал. т.к. днем они ловят много света и датчки выходят из режима. надо корпус делать а мне лень, проще светодиоды излучающие вниз переставить. ну и сам кот

Код (C++):

// код немного сложнее, но работает идеально))) пофиксил все баги с ложными срабатываниями
#define pinIN  2    // входные пины
#define pinOUT  3

bool InPort_stat = false; // переменные для фиксации события срабатывания датчкиов
bool OutPort_stat = false;
byte InPort =0;
byte OutPort =0;
bool flagIN = 0;
bool flagOUT = 0;
unsigned long InPort_mcs = 0;  // время срабатывания входного портала
unsigned long OutPort_mcs = 0 ; //выходной портал
unsigned long  RaznicaVremeni;
//float Speed = 0 ;  //когда эту перменную  скорости  объявляешь здесь получается фигня с результатами
#define Rasstojanie 0.22 // расстояни в метрах чтобы в коде было что умножать

uint32_t mcs, mcs1 = 0;  // переменные для замера времени простоя

void setup() {
pinMode (pinIN, INPUT);  //объявляем пины как вход
pinMode (pinOUT, INPUT);

 
  Serial.begin(9600);
                                                                                                     
}
void loop()

{
InPort = digitalRead(pinIN);  //начинаем все с чтения входного пина
mcs = micros();  // и записи начального времени
if (InPort == 0)  //если сработал входной датчик
{
  InPort_stat = true; // ставим флаг срабатывания
  if (InPort_stat == true)   // такую загогулину сделал для того что бы измерилось время только в одном проходе
  {
    InPort_mcs = micros(); // так как датчики успевают 2 3 раза сработать особенно на медленных скоростях и получается каша
    flagIN = 1;
   InPort_stat = false; //сброс флага что бы было зафиксировано веремя 1 цикла
  }
 
  while(flagOUT == 0) // если сработал первый датчик входим в цикл и опрашиваем только выходной датчик
//ту я не уверен, возможно надо было этот цикл вставить в пределах предидущего куска кода
  {
    OutPort = digitalRead(pinOUT); // читаем только выходной пин
if (OutPort == 0) если он срабатывает
{
OutPort_stat = true;
if (OutPort_stat == true)
{
OutPort_mcs = micros();//фиксируем время пролета, так  же в одном проходе
OutPort_stat = false;
flagOUT = 1; // выходим из цикла
}
}
   
  }

if (flagIN == 0 && flagOUT == 1)// дальше проверяем если случилось что то непонятное и сработал выходной датчик а входной нет                                  
{
  flagIN = 0; // то значит это сбой и возвращаем все флажки на мест0
  flagOUT = 0;
  }
 
  else if (flagIN == 1 && flagOUT == 0 &&  ( mcs - mcs1 ) > 100000 || mcs < mcs1 ) // если сработал входной датчик и прошло 100000 мкс и не сработал выходной
  {
       mcs1 = mcs; // значит прооизошло ложное срабатывание и делаем то же самое
  flagIN = 0;
  flagOUT = 0;
  }

// если все в норме то считаем скорость

if (flagIN == 1 && flagOUT == 1 && OutPort_mcs - InPort_mcs > 150 ) // && OutPort_mcs - InPort_mcs > 150 && OutPort_mcs - InPort_mcs < 100000
{
/* вот тут самое интересное без float перед разницей и без умножения
перед делением, выдает 0, почему не знаю, а так после шаманизма получается все правильно */
  int Speed =  Rasstojanie*1000000 /float(OutPort_mcs - InPort_mcs) ; // Speed = (Rasstojanie/float(OutPort_mcs - InPort_mcs));
Serial.print("Speed");
Serial.print("\t");
Serial.print(Speed);
  Serial.print("\t");
Serial.print("RAZNICA");
Serial.print("\t");
Serial.print(OutPort_mcs - InPort_mcs);
Serial.print("\t");
Serial.println("");
  flagIN = 0;
  flagOUT = 0;
//InPort_stat = false;
//OutPort_stat = false;
InPort_mcs = 0;
  OutPort_mcs = 0;
  delay(2000);
}

 
}
}

/*работает идеально!!! точность измерения 0,25 м/с я даже округлил результат поставив int,
хотя один знак после запятой можно оставить) боюсь дальше на прерывания переводить
Радости полные штаны, что смог сам такое сотворить. Теперь бы осилить классы и массивы и запись в память.
а так в принципе копируйте код собирайте схему и у вас будет рамочный хронограф
*/

ну и вопрос с бодуна. сможет ли кто нибудь обяснить. почему

Код (C++):

Speed = 220 / (OutPort_mcs - InPort_mcs)

в результате получаем 0.
и более замудреный вариант с умножением и float перед результатом вычитания

Код (C++):

int Speed =  Rasstojanie*1000000 /float(OutPort_mcs - InPort_mcs)

Это решение я нашел у одного человека который тоже бился над тем что если в среде ардуино делить на результат разности получается 0. Таких случаев нашел несколько примеров. НО почему блин когда добавляешь float идействие умножения перед делением получается правильный результат????????
что это за шаманизм? это глюк IDE или самой ардуины? Всем доброго дня пошел за напитком из хмеля и баиньки

 

220 это целое число. Поэтому примееяется целочисленное деление.

Пишите
220.0 / ...

 

спасибо за ответ. Но все же не понял цимеса. Надо специально посидеть над этим. во втором примере и точка есть, но все равно, убираем умножение или float результат получается 0.

пока что то не программируется решил изучением портов занятся

Код (C++):

#define INPORT   B00000100 // пин 2 входной порт
#define OUTPORT  B00001000 // пин 3 выходной порт

#define In_HIGH_Out_LOW  B00000100  //маски возможных состояний пинов
#define In_LOW_Out_HIGH  B00001000
#define In_HIGH_Out_HIGH B00001100
#define In_LOW_Out_LOW   B00000000
void setup() {
DDRD = B00000000; // назначаем все пины на вход
}

void loop() {
byte A =1;
byte B = 1;


  int IN_stat = PIND;
if (IN_stat == In_HIGH_Out_LOW) A =10; // если совпадает маска  до что то делаем
else if (IN_stat == In_LOW_Out_HIGH) B = 10;

}

Подход правильный? как я понял PIND показывает состояние всех 8 пинов. а если мне нужны данные только от от одного?
#define _BV(bit) (1 << (bit)) использовать и обращаться по имени пина? сложноватая тема и примеров мало что б понять. Но очень интересно и нужно

Кстати в последнем коде хронографа добавил еще одни цикл на вход и туда же проверку переместил, так вроде правильнее будет.

 

потому что в C++ есть грубо говоря два оператора деления.

T operator/(const T &a, const T2 &b);

Один делит вещественные числа, типа float или double. Другой делит целые числа, типа char и int (как в начальной школе - деление с остатком и остаток отбрасывается). Какой оператор использовать C++ определяет по типу аргументов.

http://en.cppreference.com/w/cpp/language/operator_arithmetic
http://ru.cppreference.com/w/cpp/language/operator_arithmetic

 

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

пытаюсь вникнуть в работу с портами. Литературы мало и усваивается нелегко. пока что усвоил, только что команда считать с цифрового пина 2 будет выглядеть примерно так bitRead(PIND,2);интересно эта команда даст какой нибудь выигрыш в скорости?)
при использовании этой команды, нужно в установках писать DDRD = B00000000? или достаточно простого pinMode (2, INPUT); если есть какая нибудь литература на эту тему поделитесь пожалуйста. а то то что я нашел в интернете очень разрознено и только в общих чертах, описывает работу с портами.

Уважаемый mcureenab Вы здесь на форуме как на работе! пусть у вас будет много щедрых заказчиков и удачных работ!
С уважением

 

В сравнении с digitalRead и digitalWrite прямое чтение/запись портов в разы быстрее выполняется. Но программа получается привязанной к определенной платформе и необходимо вкурить соответствующий раздел даташита на МК.
Например для Leonardo:

http://www.atmel.com/Images/Atmel-7766-8-bit-AVR-ATmega16U4-32U4_Datasheet.pdf

Её будет не просто портировать на другой МК. В общем без острой необходимости не стоит опускаться до уровня портов.

Литература имеется исчерпывающая. Вот например про битовые операции:

http://www.atmel.com/webdoc/avrlibcreferencemanual/group__avr__sfr.html

Думаю часть ответов вы найдете.

Про DDRD = B00000000? - После включения или сброса все биты DDRD содержат Initial Value = 0. Т.е. это лишнее.

pinMode выставляет не только направление INPUT/OUTPUT, но и может подключать подтягивающий резистор INPUT_PULLUP.

Про другие платы смотрите тут https://www.arduino.cc/en/Main/Products на каждую есть коммерческое описание со ссылками на даташит МК, и т.д.

 

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

 

В циклах 1,2,3 нет условия выхода в режим настройки. Я так понимаю, как только нажата кнопка, нужно выйти в режим чтения кнопок.
После цикла 3 должен быть цикл 4. Т.е. демонстрация результата не должна тупо висеть на delay. Нужно крутить цикл опроса кнопок и истечения времени показа.
В циклы 2 и 3 тоже нужно добавить опрос кнопок, чтобы не надо было ждать, когда пулька пролетит и появится результат.