Arduino.ru

класс титановый велосипед для delay без delay().

понял спасибо.

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

у меня две перемменные А и Б, у каждой "новое значение и старое".

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

я смогу по править ваш пример под две переменных, мой уровень в программирование "начинающий"....

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

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

теперь сижу разбираю... наверное я сильно загнул что уровень мой "начинающий", скорей всего после этих строк уровень -1....

"Классы позволяют программисту создавать новые типы объектов. Они состоят из свойств и методов.  Свойства – это данные, которыми можно характеризовать объект класса. Методы – это функции, которые могут выполнять действия над свойствами класса"

"Хороший стиль объектно-ориентированного программирования предполагает, что все переменные должны быть закрытыми" 

я не прошу что то делать, направьте где я могу почитать. 

я посижу,  что то напишу и потом покажу что получилось. 

по прошу ткнуть носом что я делаю не так.

ну как то так....

хороший стиль учебника предполагает отсутсвие логических ошибок в рекомендациях:

как ты будешь использовать переменные класса, если ВСЕ закрыты?

какие переменные нужно закрывать, а какие - нет? кто это решает?

ок. опубликуй код, который у тебя УЖЕ написан - посмотрим, что там нужно допилить...

выкладывать страшно.... дабы в бубен не получить..... переменная Х, сравниваю старое значение и новое. таким же образом хотел Y переменную сравнивать. в setup все стоит current, looptime,  

void Position(){
  int newPos; 
  int oldPos;

    
  currentTime = millis();
  oldPos = X; {    
 if(currentTime >= (loopTime + 70))   // проверяем каждые 5мс 
    newPos = oldPos ;
   
  if(newPos > oldPos){    // если состояние изменилось  
      Pos = 1;          
      }   
    else if (newPos <  oldPos){
      Pos = -1;            
      }
      else  {
        Pos=0;
      } 
       //oldPos = 0; 
  }
  loopTime = currentTime; 
  
 }// end Position

я решаю конечно :-) с этим я разобрался.... наверное...

void Position(){
  int newPos; 
  int oldPos;

    
  currentTime = millis();
  oldPos = X; {    
 if(currentTime >= (loopTime + 70))   // проверяем каждые 5мс 
    newPos = oldPos ;
   
  if(newPos > oldPos){    // если состояние изменилось  
      Pos = 1;          
      }   
    else if (newPos <  oldPos){
      Pos = -1;            
      }
      else  {
        Pos=0;
      } 
       //oldPos = 0; 
  }
  loopTime = currentTime; 
  
 }// end Position

не попытку проверки каждые 5 миллисекунд переменных мне давай, а код, где предыдущая переменная отличается от настоящей и сравнение их.

так это, как его, это оно и есть.

переменная Х меняется от -1000 до 1000

я пытаюсь каждые 5 милисекунд сравнивать значение.

это джойстик,

если Х (новое) > X(старого)  то это = 1 (ускорение)

если Х (новое) < Х(старое)  то это = -1 (замедление)

если (Х==Х) = 0  (нет ускорения и нет замедления)

я не высчитываю скорость, только ускорение - замедление.

получается что я не могу присвоить значения "новой переменной Х" и "старой переменной Х" .  я не понимаю как это сделать... 

если я правильно по времени сравниваю старое и новое, тогда подскажите как правильно присвоить - указать "старое и новое" значение. 

записывать в память? епром и потом сравнивать?

void Position(){
  int newPos; 
  int oldPos;

    
  currentTime = millis();
  oldPos = X; {    
 if(currentTime >= (loopTime + 70))   // проверяем каждые 5мс 
    newPos = oldPos ;
   
  if(newPos > oldPos){    // если состояние изменилось  
      Pos = 1;          
      }   
    else if (newPos <  oldPos){
      Pos = -1;            
      }
      else  {
        Pos=0;
      } 
       //oldPos = 0; 
  }
  loopTime = currentTime; 
  
 }// end Position

в троке 9 непонятно что делается. отсюда ВСЕГДА попадаем в строку 18

игде получение данных в newPos ?

да я понимаю. 

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

и, я не понимаю - где переменные, если они постоянные?

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

void Position(){
  int newPos; 
  int oldPos;

    
  currentTime = millis();
  oldPos = X; {    
 if(currentTime >= (loopTime + 70))   // проверяем каждые 5мс 
    newPos = oldPos ;
   
  if(newPos > oldPos){    // если состояние изменилось  
      Pos = 1;          
      }   
    else if (newPos <  oldPos){
      Pos = -1;            
      }
      else  {
        Pos=0;
      } 
       //oldPos = 0; 
  }
  loopTime = currentTime; 
  
 }// end Position

9 строкой я считал новое значение (как я думал). понимаю что не правильно. 

Вы пальцем покажите откуда и как (с какого датчика ) получаете новые переменные

вот

void READ_PINS () {
  long sThrottle = 0;
 
  analogRead(ThrottlePin);
  for (byte I = 0 ; I < Damping ; I++) {
    sThrottle = sThrottle + analogRead(ThrottlePin);
    }
  
  x = sThrottle/Damping;
  x = map(x , 0, 1024, -1000, 1000); 

 Position();
 }

я и спрашиваю, правильно я считываю новое значение через милисекунды 

Какой, фунцией, хоть убейте не вижу.

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

analogRead(ThrottlePin);

void loop () {

READ_PINS ();
}

void READ_PINS () {
  long sThrottle = 0;
 
  analogRead(ThrottlePin);
  for (byte I = 0 ; I < Damping ; I++) {
    sThrottle = sThrottle + analogRead(ThrottlePin);
    }
  
  x = sThrottle/Damping;
  x = map(x , 0, 1024, -1000, 1000); 

 Position();
 }

void Position(){
  int newPos; 
  int oldPos;

    
  currentTime = millis();
  oldPos = X; {    
 if(currentTime >= (loopTime + 70))   // проверяем каждые 5мс 
    newPos = oldPos ;
   
  if(newPos > oldPos){    // если состояние изменилось  
      Pos = 1;          
      }   
    else if (newPos <  oldPos){
      Pos = -1;            
      }
      else  {
        Pos=0;
      } 
       //oldPos = 0; 
  }
  loopTime = currentTime; 
  
 }// end Position

без setup думаю понятно от куда я беру (х)?

нет не понятно ! в одном случае у вас x в другом X, и как объявлен Pos и еще { в 26 строке...

Полностью скетч.

ошибся с х когда сейчас перенабирал. х выводится в монитор, все считывается

26 это я уже экспиременты ставил. чтоб новое значение получить через 5 милисекунд. Pot это ускорение. глобально  int Pot=0; 

смысл такой,

считал значение с джойстика, получил (х) //я его получил

далее (х) это старое значение oldPot

двигаем джойстик

5 милли

новое значение newPot

if newPot > oldPot

то pot=1  ну как то так. 

х уменя считывается! 

/*
#1
джойстик -> A0 (joystick_pin)
*/
//#1
const int joystick_pin = A0;
int joystick, joystick_old; // новое и старое значение джойстика
int var = 0; // -1 замедление / 0 ничего не изменилось/ 1 ускорение
void setup() {
  //#1 
  joystick = analogRead(joystick_pin);


}
void loop() {
  //#1 5 миллисекунд вычислит. поток 1
  static uint32_t past_1 = 0 ;
  if (millis() - past_1 >= 5) { // если прошло 5 миллисек
    past_1 = millis();
    joystick_old = joystick;
    joystick = analogRead(joystick_pin);
    if (joystick == joystick_old) var = 0;
    else if (joystick > joystick_old) var = 1;
    else var = -1;
  }
}

спасибо я понял этот вариант. после 5 мили я считываю опять джойстик, дальше сравнение. 

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

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

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

студент фигли,

еще раз спасибо.

/*
#1
джойстик -> A0 (joystick_pin)
*/
//#1
const int joystick_pin = A0;
int joystick, joystick_old; // новое и старое значение джойстика
int var = 0; // -1 замедление / 0 ничего не изменилось/ 1 ускорение
void setup() {
  //#1 
  joystick = analogRead(joystick_pin);


}
void loop() {
  //#1 5 миллисекунд вычислит. поток 1
  static uint32_t past_1 = 0 ;
  if (millis() - past_1 >= 5) { // если прошло 5 миллисек
    past_1 = millis();
    joystick_old = joystick;
    joystick = analogRead(joystick_pin);
    if (joystick == joystick_old) var = 0;
    else if (joystick > joystick_old) var = 1;
    else var = -1;
  }
}

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

Вы наверно знаете что такое ООП(объектно орентированое программирование). Но я не об этом. Следствием ООП есть избыток переменных (и констант, которые выглядят переменными). Вот что бы в них не запутаться. А запутаться в них легко их стараются разделять на группы и называть в определеном стиле. Из-за этого я пришел к метками #1 #2 . Но ладно все это предисловие.

static uint32_t  past_1 = 0 ;

Плюс static в том что на эту переменную не надо обращать внимание. Она ну очень локальная, хотя передается из цикла в цикл.  А то что past_1. Так в этом месте всегда у меня переменная с названием past . А 1 так поток то 1. Я и путаться не буду. А вот past_2 в потоке 1 это уже моя описка, а значит и к дальнейшим глюкам в программе.

static uint32_t  past_1 = 0 ;

простите а можно два слова об этом #1 #2

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

/*
#1
#2
#3
*/
//#1
//#2
//#3
void setup() {
  //#1
  //#2
  //#3
}
void loop() {
  static uint32_t MILLIS ;
  MILLIS = millis() ;
  //#1 1000 миллисекунд вычислит. поток 1
  static uint32_t past_1 = 0 ;
  if (MILLIS - past_1 >= 1000) { // если прошло 1000 миллисек
    past_1 = MILLIS ;
    // сам код
    MILLIS = millis() ;
  }
  //#2  200 миллисекунд вычислит. поток 2
  static uint32_t past_2 = 0 ;
  if (MILLIS - past_2 >= 200) { // если прошло 200 миллисек
    past_2 = MILLIS ;
    // сам код
    MILLIS = millis() ;
  }
  //#3  100 миллисекунд вычислит. поток 3
  static uint32_t past_3 = 0 ;
  if (MILLIS - past_3 >= 100) { // если прошло 100 миллисек
    past_3 = MILLIS ;
    // сам код
  }
}

Вот шаблон. Ну это принцип (превдо-)многопоточного проектирования программ в среде Ардуино. Одна из самых сложных вещей это совмещение разных скетчей. Так вот если есть несколько рабочих скетчей написаных в этом стиле, то их можно просто совместить в одной Ардуине и они будут работать. Разумеется если они пользуются различными аппаратными устройствами процессора. Хотя и в этом случае переделки будут минимальны.

Ну как вам сказать. Си как раз создавался как кроссплатформенный ассемблер. Поищите про Объектный Си. И да эта среда его тоже поддерживает. Так что stаtic от туда вылазит. Языки высокого уровня вертят абстрактными переменными. А Си с его указателями опускают его на уровень ассемблера.

...ассемблера...в интел к примеру мощнейшая  команда XLAT (работал на 8 битном) выполняется за один такт, мне не пришлось видеть скомпилированный в СИ код в котором она бы применялась )))

Ну-ну. Когда рисовался Си было господство интерплетаторов и языков на них. Так что язык Си был быстр. А программировать на ассембелере было очень трудоемко.

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

Элементарно, Ватсон, - через методы.

Ничего решать не надо, выше уже было сказано - ВСЕ!

филОсОф, ты не умничай, а пиши скетч, безрукому неофиту.

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