Arduino.ru

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

Тема изжована и пережована многократно, если вдруг появились проблемы в выражениях, приводите результат к нужному типу, например:

Serial.println((unsigned long)(millis() - previousMillis));

Аналогично в сравнении:

if((unsigned long)(millis() - previousMillis) < 0) { Serial.println("Never"); }

и вопросы отпадут сами собой. Тему читал по диагонали, потому что не интересна.

Как это? Вы его и задали, оно у вас и отрисовывается соответствующим выводом .. где ещё у вас "не получилось"? :)

пока не зальете не увидите, при объявлении глобальной переменной задаю

unsigned long previousMillis = 10000;

а он в мониторе выдает 1, пока не уберешь условие if (millis() - previousMillis > interval)

У вас на скриншоте иное поведение. Заливать и запускать всяческую фгиню .. увольте. Есть чем заняться. :)

а на скриншоте это с изъебом unsigned long previousMillis = -1000;

То что в мониторе кролика нет, это не значит что его точно нет .. может вы "не того кролика" выводите .. так бывает, особенно когда функция вывода сильно перегружена по типам .. или не в тот момент выводите, когда значение УЖЕ снова изменено .. так тоже бывает, когда оно меняется там, где вы этого предположить не смогли. В общем, я не телепат, а какой у вас тут код смотреть не очень внимал.

2 код в #40 посте, но вам же ведь не интересно :)

С какого это перепугу? Кому это бедняга компилятор так задолжал?

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

Этот код ничем не отличается от кода на скриншоте. Начальное присвоение отрицательного числа там наглядно видно из монитора, о чем я вам уже написал. Что-то есть интересней? :)

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

(это вам не моторы останавливать меняя полярность, или закорачивая обмотку) :)

Беззнаковое целочисленное значение, чего тут не понятно? Дальше что, будем обсуждать почему 2*2 = 4?

bad_user, ничего пояснять не нужно, если не желате вникать в суть - верьте на слове и если Вы объявляете беззнаковую переменную, то инициализировать её получится только положительным числом. Можно отрицательным, как продемонстрировали выше, но получится только >= 0, точка.

Простите, Архат, но Вы ... не обижайтесь .. бредите.

Не надо только рассказывать мне о "системах где имеют место иные ...". Давайте говорить о языке С++, ладно. А у языка С++ есть стандарт ISO/IEC 14882:2011 и он как-то не зависит от Ваших представлений о  "системах где имеют место иные ..."

Нет никакого вопроса "способа кодирования целого числа" в зависимости от того, знаковое оно или беззнаковое. Это Ваша выдумка. Раздел 3.9.1 стандарта явно говорит, что знаковые и беззнаковые типы кодируются одинаково: "each signed integer type has the same object representation as its corresponding unsigned integer type". Ну, а раз одинаково, то какие вопросы?

По поводу, правил преобразования, читайте раздел 4.7, а по поводу преобразований типов в деклараторах раздел 8.5. Там всё написано и в этой ситуации компилятор повёл себя абсолютно адекватно - в полном соответсвии со стандартом. Просто читайте стандарт, и не пишите сюда безграмотную отсебятину. Не ожидал от Вас.

В таком разе, предлагаю вам в unsigned char сохранить -300. Или даже -150 дабы за диапазон не вылазить. :)

Вы прочитали стандарт, как я Вам советовал? Видимо, нет.

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

Итак, -50 в unsigned char сохраняется безо всяких ошибок и предупреждений (также, как в и в пршлом случае).

-150 - это другой случай. Здесь саму константу компилятор справедливо посчитает за int, т.к. в signed char она не лезет. А поскольку он считает её int'ом, он выдаст warning насчёт преобразования к более короткому типу, но не более того. warning warning'ом а преобразует он её и запишет абсолютно  правильно.

Так что, как видите, сохраняю я их в char легко и непринуждённо (надеюсь, Вам скетч не нужен? Захотите проверить, сами напишете?). 

И всё это в полном соответсвии со стандартом. Просто перечитайте его.

Блин, да я в курсе что компилятор запихнет, куда и как и даже согласно стандарту. :)

В данном случае наблюдаем банальное out of range, несмотря на то что запихнет. Ибо, как Вы совершенно верно заметили -150 и есть выход за диапазон знакового байта (-128 .. 127). Константу в данном случае он конечно же МОЖЕТ (согласно стандарту жеж) считать интом. Но вот выполнить присваивание её без обрезания нивазможна, об чем он и отпишет варнинг, верно.

.. вместо того, чтобы сгенерить банальный out of range. Об чем и написал.

А то, что Вы назвали "бредом" .. вполне штатная ситуация для 4-х битных ЦПУ, реализованных на 155 серии (были такие). Хранить и считать на таких проще и шустрее в двоично-десятичной арифметике. И знаковые и беззнаковые. Только вот под знак надо отводить тетраду .. а её нету. :)

Понятно. Говорили про unsigned long - быстро меняем тему на char и добавляем "я всё равно прав в 4-битных CPU".

Когда мы будем говорить о 4-битных CPU, то гда о них и поговорим. Сейчас мы говорим о стандарте С++, которого Вы не знаете и о котором несли бред.

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

Евгений, если бы вы спросили за стандарт в мае-июне, то да соглашусь .. сложно знать досконально после 17 лет перерыва, когда язык "в глаза не видел" всё это время, даже если ты с него сам писал компилятор .. для той самой 4-х битной ЭВМ (почему и пришло первое на ум). :)

А так, уже успел и прочесть и похожие несуразности в нем отметить .. в данном случае переход на байт - просто для наглядности. Можете сами пободрать значение в long-ах точно также: дабы оно было отрицательным и ЗА разрядной сеткой signed long, но ещё влезало в unsigned long. Согласно стандарту - "влезет" с тем же самым варнингом. Только что это меняет? Присвоение неотрицательному числу отрицательного значения - по любому это выход за диапазон неотрицательного числа. И, в данном простом присваивании литеральной константы - куда как правильнее (имхо) генерить ошибку выхода за диапазон, чем впихивать невпихуемое. :)

P.S. Да, и если вы ещё не заметили, мне глубоко начхать (лет так с 5) на наличие или отсутствие ко мне уважения с чьей-либо стороны. Платон конечно мне друг, но истина - дороже. :)

Ну, я понял. Язык неправильный, стандарт - неправильный и несуразный, - правильно только Ваше мнение. Я в курсе такой позиции. Не удивляет.

Только надо было так с самого начала и писать, что мол компилятор ведёт себя правильно - по стандарту, просто стандарт - неграмотный. Вы же зачем-то стали об ошибках компилятроа говорить и даже теорию приплели насчёт "выбора представления". Зачем? Это вводило людей в заблуждение. Можно было подумать что стандарт-то ничего, просто компилятор плохой.

А теперь-то всё понятно. Мы и раньше знали, что единственный грамотный человек - это Вы :)

Присоединяюсь к вопросу. Основания для этого есть, и самые веские. Каждые ~50 суток при переполнении unsigned long миллисекунд счётчик таймера сбрасывается. Соотвественно при вычислении разницы
 

unsigned long beginTime = millis()
//...........................
...( millis() - beginTime )

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

разница не может быть отрицательна, потому что тип этого значения - unsigned.

При переполнении millis() данное выражение ошибоу не дает. Прежде чем спорить и задавть вопросы - почитайте что-нибудь про целочисленную арифметику.

К какому именно? "Как сбросить millis"? Вообще-то, как два пальца. Опишите внешнюю переменную

extern volatile unsigned long timer0_millis;

и присвойте ей 0 или что Вашей душе угодно.

Другой вопрос "нафига?". Я, например, не вижу ни одной ситуации, где это было бы нужно.

То, что Вы тут пишете:

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

И никаких оснований сбрасывать миллис (тем более "самых веских") нет в природе.

Эта музыка будет вечной!

1) Через секунду после значения 2147483645 в счётчике будет значение 998.
998 - 2147483645 = <положительное значение>
гениально! значение либо приведётся к положительному значению, посчитав знаковый бит за бит значения, либо выбьет рантайм.
2) Про целочисленную арифметику начитан достаточно.

3)Ни одного аргумента или пояснения в посте. Зачем писать вообще?

Простите, а откуда у unsigned знаковый бит?

Вот и я о том, что результат (отрицательное значение) либо интерпретируется как положительное, либо будет несовместимость типов. После 4 294 967 295 следующее значение счётчика 0, так ведь?

4 294 965 295, через секунду 4 294 966 295, через секунду 0. Вот такая целочисленная арифметика. Счётчик то цикличный. Или я чего то не понимаю?

Зачем зря шум поднимать? Нет ничего проще, чем поставить эксперимент.

Возьмите две переменные типа unsigned long,

x1 = 4 294 967 290;

x2 = x1 +100;

А потом посчитайте, сколько будет x2 - x1

В процессоре нет положительных или отрицательных чисел. Есть нолики и единички собранные в рядочки. Как интерпретировать эти рядочки это ваша прерогатива. Что скажете программе, то она будет интерпретировать. А если смотреть на операцию 4 294 967 295 + 1 то в регистре результата действительно будет 0. Интереснее что будет в результате 500 - 4 294 967 295. Ответте себе на этот вопрос и закройте тему.

Согласен, тему можно закрывать, никакого конструктива.

то есть решить примерчик 500 - 4 294 967 295 - никак? тогда зачем вам "конструктив", вы его все равно не поймете.

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

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

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

+1

Как, еще один? Если 072 это год рождения, то ведь это еще наше, нормальное обрзование?

Да еще и тезка... кошмар! Они, походу на свет лезут!.

----------------

Для ТС: Долбо...б! Тебе сказали: проведи эксперимент. Вставь это себе в.... скетч. А потом напиши сюда и извинись, недоросль х..ева!
 

uint32_t a,b;
b = 4294967000;
for (uint32_t i = 0; i<1000; i++)
  {  
  a = i + 4294967000;

  Serial.print("a=");
  Serial.print(a);
  Serial.print("b=");
  Serial.print(b);
  Serial.print("a-b=");
  Serial.println(a-b);
  }

в колонки!

Чего чего? И как это будет выглядеть? Вспоминается страшное слово АВОСТ!

ЕГОГ

EASILY!

#define time_reload 45821  //обнуление millis

void(* resetFunc) (void) = 0; 

if (millis()>time_reload)
  {
    resetFunc();
  }

#define time_reload 45821  //обнуление millis

void(* resetFunc) (void) = 0; 

if (millis()>time_reload)
  {
    resetFunc();
  }

Фу!!! Богомерзкий извращенец! Вот нет, чтобы замутить робопалец на паре сервомоторов и аккуратненько так на ресет нажимать - всё норовят парой строк кода обойтись! Лодыри!

Сброс микрос/милис 
#include "wiring.c"
void setup(){
Serial.begin(115200);
}
void loop(){
 Serial.println(millis());
 delay(1000);
 cli(); 
  timer0_millis=0; //millis
  timer0_overflow_count = 0; //micros
  sei();
}

Сброс микрос/милис 
#include "wiring.c"
void setup(){
Serial.begin(115200);
}
void loop(){
 Serial.println(millis());
 delay(1000);
 cli(); 
  timer0_millis=0; //millis
  timer0_overflow_count = 0; //micros
  sei();
}

Зачем?

Людям свойственно хотеть странного...

"...что б не сказать большего!" Это ж надо, wiring.c даже заради этого припендюрить.)

Сброс микрос/милис 
#include "wiring.c"
void setup(){
Serial.begin(115200);
}
void loop(){
 Serial.println(millis());
 delay(1000);
 cli(); 
  timer0_millis=0; //millis
  timer0_overflow_count = 0; //micros
  sei();
}

Вторая строчка ... говонокодометр зашкаливает :(

Для сброса millis(). Вопрос темы именно так поставлен.
В теме была только полная перезагрузка.
Есть другие варианты?
Можно конечно ещё адрес в памяти узнать счётчика и затирать там.

есть - не сбрасывать миллис.

Вопрос темы отдает идиотией и бросаться решать его совсем не обязательно.

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

В общем респект.

Сказал "А", говори "Б".

timer0_millis=0; << это и есть затирание в памяти.

А так, как сделали Вы, здесь на форуме предлагали делать ещё ВОСЕМЬ лет назад.

Надо ввести статус на форуме - "Сбрасыватель millis"